宝迪沃怎么用？我来告诉你答案14种分类算法进行文本分类实战

前言

这个文本分类实战训练是以完整的文本分类项目流程编写的，更适合高级和增强

《获取数据》 3354 《数据分析和处理》 —— 《特征工程与选择》 —— 《算法模型》 —— 《性能评估/参数调优》 —— 010-30000

本培训更侧重于文本数据集的大量阅读和处理。

另外，为了提高代码重用率，更加重视函数的使用。

在分类算法这一块，本篇项目总共使用了 《14》 种分类算法来进行文本分类，
涵盖《sklearn》中的常规分类算法和集成学习算法;
竞赛和工业界比较得宠的集成学习算法《xgboost》和《lightgbm》;
深度学习框架《Keras》中的前馈神经网络和《LSTM》算法。

PS：需要本文项目的代码以及数据集的朋友，关注我之后，在评论区私信小编即可分享给你，希望对读者有所帮助！

本篇目录

数据集介绍

1.解压文件并处理中文乱码

2.批量读取和合并文本数据集

3.中文文本分词

4.停止词使用

5.编码器处理文本标签

6.算法模型

• * 常规算法——方法1——k近邻算法
• * 常规算法——方法2——决策树
• * 常规算法——方法3——多层感知器
• * 常规算法——方法4——伯努力贝叶斯
• * 常规算法——方法5——高斯贝叶斯
• * 常规算法——方法6——多项式贝叶斯
• * 常规算法——方法7——逻辑回归
• * 常规算法——方法8——支持向量机
• * 集成学习算法——方法1——随机森林算法
• * 集成学习算法——方法2——自适应增强算法
• * 集成学习算法——方法3——lightgbm算法
• * 集成学习算法——方法4——xgboost算法
• * 深度学习框架keras算法——方法1——前馈神经网络
• * 深度学习框架keras算法——方法2——LSTM 神经网络

7.算法之间性能比较

数据集介绍

获取数据

1 目录情况

```
——text_classification
——train
——女性
——.txt ...
——体育
——.txt ...
——文学
——.txt ...
——校园
——.txt ...
——test
——女性
——.txt ...
——体育
——.txt ...
——文学
——.txt ...

——校园
——.txt ...
——
```

2 数据集介绍

```
样本数/.txt文件数 标签

训练集： 3305 [女性，体育，文学，校园]
测试集 200 [女性，体育，文学，校园]
```

3 数据来源

目标定义

目标需求1：批量读取文档文件.txt

目标需求2：文本向量化使用词袋法或者TFIDF

目标需求3：比较各个算法的性能优劣，包括模型消耗用时、模型准确率

### 1.导入所需模块

import os
import shutil
import zipfile
import jieba
import time
import warnings
import xgboost
import lightgbm
import numpy as np
import pandas as pd
from keras import models
from keras import layers
from keras.u import to_categorical
from keras. import Tokenizer
from sklearn import svm
from sklearn import metrics
from import MLPClassifier
from import DecisionTreeClassifier
from import KNeighborsClassifier
from import BernoulliNB
from import GaussianNB
from import MultinomialNB
from import LogisticRegression
from import RandomForestClassifier
from import AdaBoostClassifier
from import LabelEncoder
from import CountVectorizer
from import TfidfVectorizer
warnings.filterwarnings('ignore')


/opt/conda/lib: RuntimeWarning: num size changed, may indicate binary incompatibility. Expected 96, got 88

return f(*args, **kwds)

/opt/conda/lib: RuntimeWarning: num size changed, may indicate binary incompatibility. Expected 96, got 88

return f(*args, **kwds)

Using TensorFlow backend.

1. 解压文件并处理中文乱码

>解压压缩包

解决目录或文件中文名字乱码的问题

# -------------------------------------------
# 路径
filepath = '/home/kesci/work/xiaozhi;
savepath = '/home/kesci/work/xiaozhi/'
delectpath = '/home/kesci/work/xiaozhi/text_classification'
# -----------------------------------------
# 检索并删除文件夹
if os.(delectpath):
print('n存在该文件夹，正在进行删除，防止解压重命名失败......n')
(delectpath)
else:
print('n不存在该文件夹, 请放心处理......n')

# -----------------------------------------
# 解压并处理中文名字乱码的问题
z = zi(filepath, 'r')
for file in z.namelist():
# 中文乱码需处理
filename = ('cp437').decode('gbk') # 先使用 cp437 编码，然后再使用 gbk 解码
z.extract(file, savepath) # 解压 ZIP 文件
# 解决乱码问题
os.chdir(savepath) # 切换到目标目录
os.rename(file, filename) # 将乱码重命名文件


存在该文件夹，正在进行删除，防止解压重命名失败……

### 2. 批量读取和合并文本数据集

>本案例注重编写函数来批量读取所有文档的文本数据，提高代码复用率

本案例注重函数格式的要求，添加参数注释，提高代码阅读率

def read_text(path, text_list):
'''
path: 必选参数，文件夹路径
text_list: 必选参数，文件夹 path 下的所有 .txt 文件名列表
return: 返回值
features 文本(特征)数据，以列表形式返回;
labels 分类标签，以列表形式返回
'''

features, labels = [], []
for text in text_list:
if ('.')[-1] == 'txt':
try:
with open(path + text, encoding='gbk') as fp:
()) # 特征
labels.append('/')[-2]) # 标签
except Exception as erro:
print('n>>>发现错误, 正在输出错误信息...n', erro)

return features, labels

def merge_text(train_or_test, label_name):
'''
train_or_test: 必选参数，train 训练数据集 or test 测试数据集
label_name: 必选参数，分类标签的名字
return: 返回值
merge_features 合并好的所有特征数据，以列表形式返回;
merge_labels 合并好的所有分类标签数据，以列表形式返回
'''

print('n>>>文本读取和合并程序已经启动, 请稍候...')

merge_features, merge_labels = [], [] # 函数全局变量
for name in label_name:
path = '/home/kesci/work/xiaozhi/text_classification/'+ train_or_test +'/'+ name +'/'
text_list = os.listdir(path)
features, labels = read_text(path=path, text_list=text_list) # 调用函数
merge_features += features # 特征
merge_labels += labels # 标签

# 可以自定义添加一些想要知道的信息
print('n>>>你正在处理的数据类型是...n', train_or_test)
print('n>>>[', train_or_test ,']数据具体情况如下...')
print('样本数量t', len(merge_features), 't类别名称t', set(merge_labels))
print('n>>>文本读取和合并工作已经处理完毕...n')

return merge_features, merge_labels

# 获取训练集
train_or_test = 'train'
label_name = ['女性', '体育', '校园', '文学']
X_train, y_train = merge_text(train_or_test, label_name)


>>>文本读取和合并程序已经启动, 请稍候…

>>>发现错误, 正在输出错误信息…

'gbk' codec can't decode byte 0xaa in position 87: illegal multibyte sequence

>>>你正在处理的数据类型是…

train

>>>[ train ]数据具体情况如下…

样本数量 3305 类别名称 {'女性', '文学', '体育', '校园'}

>>>文本读取和合并工作已经处理完毕…

# 获取测试集
train_or_test = 'test'
label_name = ['女性', '体育', '校园', '文学']
X_test, y_test = merge_text(train_or_test, label_name)


>>>文本读取和合并程序已经启动, 请稍候…

>>>你正在处理的数据类型是…

test

>>>[ test ]数据具体情况如下…

样本数量 200 类别名称 {'女性', '文学', '体育', '校园'}

>>>文本读取和合并工作已经处理完毕…

### 3. 中文文本分词

# 训练集
X_train_word = [jieba.cut(words) for words in X_train]
X_train_cut = [' '.join(word) for word in X_train_word]
X_train_cut[:5]

Building prefix dict from the default dictionary …

Loading model from cache /tm

Loading model cost 0.837 seconds.

Prefix dict has been built succesfully.

['冬季 饮食 减肥 小窍门 吃 ， 我 所欲 也 ； 瘦 ， 亦 我 所欲 也 。 难道 吃 和 瘦 真的 不可 兼得 吗 ？ 没这回事 宝迪沃 告诉 你 冬天 怎样才能 吃 好吃 饱 不 发胖 吧 1 、 烧烤 后 吃 根 香蕉 2 、 吃火锅 后 喝点 酸奶 3 、 饭后 喝 大麦茶 或 橘皮 水 4 、 吃 方便面 后 吃水果 5 、 吃 蟹 后 ， 喝 生姜 红糖 水 6 、 润肺 止咳 ， 饭后 吃个 柿子 7 、 吃 得 太 油腻 喝杯 芹菜 汁 $ LOTOzf $',

'优惠 信息 今日 拍拍网 母君宝康 母婴 专营店 乳钙 软胶囊 惊爆价 ： 39 元 含泪 上架 （ 优惠 还有 升级版 ： 今日 购买 一盒 该 软胶囊 任意 一件 产品 送 48 元水润 透感 美手 霜 一支 ） 另有 多多 产品 供 您 试用 体验 ， 惊喜 有木有 实惠 有 不 有 : 3',

'老年斑 形成 的 原因 华美 段跃 民主 任 介绍 说 ， 人到 一定 年纪 后 ， 体内 细胞 功能 的 衰退 在 逐年 加速 ， 血液循环 也 趋向 缓慢 ， 加上 饮食结构 上 的 变化 和 动植物 脂肪 摄入量 的 比例失调 等 原因 ， 容易 在 人体 表面 形成 老年斑 。 目前 使用 6 激光 去 老年斑 是 目前 很 理想 的 老年斑 的 治疗 方法 ， 而且 无副作用 : 8',

' | | 时尚 美人团 : 各种 眼线 的 画法 ~ 转给 想画 出 漂亮 眼线 的 姐妹 们 吧 ~ $ LOTOzf $ 女人 天生 爱美丽 : 各种 眼线 的 画法 ~ 转给 想画 出 漂亮 眼线 的 姐妹 们 吧 ~ 想 学 穿衣 就 收听 → 潮女学 穿衣',

'打造 小腰 精 ： 直立 ， 一臂 上举 ， 一臂 伸向 背后 。 左臂 后伸 ， 右臂 向上 伸 ， 身体 左转 ， 下肢 保持 不 动 ， 停 20 秒 ， 换 另一边 。 做 扭转 时要 感觉 腰部 肌肉 的 绷紧 ， 脚跟 不能 移开 。 其实 瘦身 不 需要 太 大 运动量 的 ， 减脂 的 关键在于 多 做 有氧 运动 ， 也就是说 多 次数 小 重量 的 活动 。 只要 能 天天 坚持 ， 不 出 一二个 月 ， 效果 就 能 看到 了 。 $ LOTOzf $']

# 测试集
X_test_word = [jieba.cut(words) for words in X_test]
X_test_cut = [' '.join(word) for word in X_test_word]
X_test_cut[:5]

['【 祛痘 饮食 三多两 忌 】 一 ： 多吃含 锌 含钙 食物 。 锌 可 加速 蛋白质 合成 及 细胞 再生 ， 并 促进 伤口 愈合 ， 而 钙 能 安抚 神经 。 二 ： 多 吃 维生素 含量 多 的 食品 。 特别 要 注意 补充 维生素 A 、 B2 、 B6 、 C 、 E 。 三 ： 多 吃 粗纤维 食品 。 可 促进 肠胃 蠕动 加快 代谢 ， 使 多余 的 油脂 尽早 排出 体外 。 一忌 ： 忌肥 腻味 。 二忌 ： 忌 辛辣 温热 。 t t t t $ LOTOzf $',

'【 12 星座 思春 表现 】 白羊 （ 发呆 沉思 ） 、 金牛 （ 闷 着 长毛 ） 、 双子 （ 狂过 嘴瘾 ） 、 巨蟹 （ 有心 没胆 ） 、 狮子 （ 电话费 暴涨 ） 、 处女 （ 调戏 网友 ） 、 天秤 （ 穿衣 扮靓 ） 、 天蝎 （ 狂看 情色电影 ） 、 射手 （ 四处 约会 ） 、 魔羯 （ 执着 着 闷骚 ） 、 水瓶 （ 借口 闲聊 ） 、 双鱼 （ 眉来眼去 装 可怜 ） 。 $ LOTOzf $',

'冬天 真是 万恶 的 季节 ， 食欲 越来越 大 ， 控制 不住 。 胖友 介绍 “ 瘦身 之颠 ” 这 款 减肥 产品 ， 连续 看 了 十几页 的 评价 ， 看 的 我 好 心动 ， 立即 下单 ， 服用 了 半个 月 瘦 了 8 斤 。 好开心 啊 ， 吼吼 … 好 姐妹 都 过来 要 秘诀 ， 刚 看到 店家 在 做 活动 ， 又 买 了 2 瓶 储备 ， 分享 下 产品 地址 ： http : url . cn / 1xd9ka $ LOTOzf $',

'美丽 微 课堂 光子 嫩肤 项目 是 近 5 年 发展 起来 的 一种 带有 美容 性 治疗 的 一种 技术 。 可以 说 是 脱毛 的 孪生兄弟 。 真正 的 光子 嫩肤 是 让 肌肤 变得 细腻 、 有 弹性 、 有 光泽 ， 对于 色素 沉着 、 雀斑 、 妊娠 纹 、 浅表 皱纹 、 黄褐斑 、 面部 红血丝 、 痤疮 浅表 疤痕 、 皮肤 粗糙 、 肤色 发黄 等 效果 还是 相当 不错 的 。 t t t t $ LOTOzf $',

' | | 樱花 草 丶 忧伤 : 【 事业 婚姻 两 得意 的 星座 女 】 第三名 : 天蝎座 $ LOTOzf $ 星座 宝典 : 【 事业 婚姻 两 得意 的 星座 女 】 第一名 : 水瓶座 ； 第二名 : 巨蟹座 ； 第三名 : 天蝎座 ； 第四名 : 白羊座 ； 第五名 : 双鱼座 。 【 花心 男 最 斗不过 的 星座 女 】 第一名 : 射手 女 ； 第二名 : 水瓶 女 ； 第三名 : 魔羯 女 ； 第四名 : 双 子女 ； 第五名 : 天秤 女 。']

### 4. 停止词使用

1 停止词是为了过滤掉已经确认对训练模型没有实际价值的分词

2 停止词作用：提高模型的精确度和稳定性

# 加载停止词语料
stoplist = [word.strip() for word in open('/home/kesci/work/xiaozhi/text_classification/',
encoding='utf-8').readlines()]
stoplist[:10]

['ufeff,', '?', '、', '。', '“', '”', '《', '》', '！', '，']

### 5. 编码器处理文本标签

le = LabelEncoder()
y_train_le = le.fit_transform(y_train)
y_test_le = le.fit_transform(y_test)
y_train_le, y_test_le

(array([1, 1, 1, …, 2, 2, 2]),

array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,

3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2]))

### 文本数据转换成数据值数据矩阵

count = CountVectorizer(stop_words=stoplist)
'''注意：
这里要先 count.fit() 训练所有训练和测试集，保证特征数一致，
这样在算法建模时才不会报错
'''
count.fit(list(X_train_cut) + list(X_test_cut))
X_train_count = count.transform(X_train_cut)
X_test_count = count.transform(X_test_cut)
X_train_count = X_()
X_test_count = X_()
prin, X_)
X_train_count, X_test_count

(3305, 23732) (200, 23732)

(array([[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0],

…,

[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0]]), array([[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0],

…,

[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0],

[0, 0, 0, …, 0, 0, 0]]))

### 6. 算法模型

封装一个函数，提高复用率，使用时只需调用函数即可

# 用于存储所有算法的名字，准确率和所消耗的时间

estimator_list, score_list, time_list = [], [], []

def get_text_classification(estimator, X, y, X_test, y_test):
'''
estimator: 分类器，必选参数
X: 特征训练数据，必选参数
y: 标签训练数据，必选参数
X_test: 特征测试数据，必选参数
y_tes: 标签测试数据，必选参数
return: 返回值
y_pred_model: 预测值
classifier: 分类器名字
score: 准确率
t: 消耗的时间
matrix: 混淆矩阵
report: 分类评价函数

'''
start = ()

print('n>>>算法正在启动，请稍候...')
model = estimator

print('n>>>算法正在进行训练，请稍候...')
model.fit(X, y)
print(model)

print('n>>>算法正在进行预测，请稍候...')
y_pred_model = model.predict(X_test)
print(y_pred_model)

print('n>>>算法正在进行性能评估，请稍候...')
score = me(y_test, y_pred_model)
matrix = me(y_test, y_pred_model)
report = me(y_test, y_pred_model)
print('>>>准确率n', score)
print('n>>>混淆矩阵n', matrix)
print('n>>>召回率n', report)
print('>>>算法程序已经结束...')

end = ()
t = end - start
print('n>>>算法消耗时间为：', t, '秒n')
classifier = str(model).split('(')[0]

return y_pred_model, classifier, score, round(t, 2), matrix, report


#### 常规算法——方法1——k 近邻算法

knc = KNeighborsClassifier()
result = get_text_classification(knc, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])

>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',

metric_params=None, n_jobs=None, n_neighbors=5, p=2,

weights='uniform')

>>>算法正在进行预测，请稍候…

[0 0 2 0 1 0 0 0 0 1 0 1 0 1 0 0 2 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1

1 0 2 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 2 0 2 0 0 0 0 0 0 0 0 0 2 0 2 0 0 0

0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 2 0 2 0 0 0 0 0 0 0 0 0 2 2 2 0 0 0 0 0 0 0

2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 2 0 2 2 2 2 3 0 0 2 0 3 0 0 0 2 0 2 2 0 2 2 2 2 2 2 2 2 2 2 0 0 2 1

2 0 2 2 2 2 2 2 0 2 0 0 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.67

>>>混淆矩阵

[[99 0 16 0]

[26 10 2 0]

[ 7 1 23 0]

[ 7 0 7 2]]

>>>召回率

precision recall f1-score support

0 0.71 0.86 0.78 115

1 0.91 0.26 0.41 38

2 0.48 0.74 0.58 31

3 1.00 0.12 0.22 16

micro avg 0.67 0.67 0.67 200

macro avg 0.78 0.50 0.50 200

weighted avg 0.74 0.67 0.63 200

>>>算法程序已经结束…

>>>算法消耗时间为： 32.66772508621216 秒

(None, None, None)

#### 常规算法——方法2——决策树

dtc = DecisionTreeClassifier()
result = get_text_classification(dtc, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])


>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,

max_features=None, max_leaf_nodes=None,

min_impurity_decrease=0.0, min_impurity_split=None,

min_samples_leaf=1, min_samples_split=2,

min_weight_fraction_leaf=0.0, presort=False, random_state=None,

splitter='best')

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1

1 0 0 0 0 1 0 3 0 0 0 1 0 0 0 0 2 0 1 0 0 1 0 0 0 0 0 0 0 0 1 2 0 0 0 0 0

1 0 0 0 1 2 0 0 1 1 0 0 0 0 0 2 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0

2 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 1 0 1 0 3 0 0 0 0 0 0 1 0 0 0 0 1 0 0

0 1 0 1 0 2 3 3 3 3 3 3 2 1 3 3 0 3 2 1 2 2 1 2 1 2 2 2 2 3 2 1 3 2 3 2 1

2 3 2 2 2 2 2 2 2 2 1 2 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.76

>>>混淆矩阵

[[87 21 5 2]

[ 1 34 2 1]

[ 0 5 22 4]

[ 1 2 4 9]]

>>>召回率

precision recall f1-score support

0 0.98 0.76 0.85 115

1 0.55 0.89 0.68 38

2 0.67 0.71 0.69 31

3 0.56 0.56 0.56 16

micro avg 0.76 0.76 0.76 200

macro avg 0.69 0.73 0.70 200

weighted avg 0.81 0.76 0.77 200

>>>算法程序已经结束…

>>>算法消耗时间为： 38.00881791114807 秒

(None, None, None)

#### 常规算法——方法3——多层感知器

mlpc = MLPClassifier()
result = get_text_classification(mlpc, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])

>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,

beta_2=0.999, early_stopping=False, epsilon=1e-08,

hidden_layer_sizes=(100,), learning_rate='constant',

learning_rate_init=0.001, max_iter=200, momentum=0.9,

n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,

random_state=None, shuffle=True, solver='adam', tol=0.0001,

validation_fraction=0.1, verbose=False, warm_start=False)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 2 1 1 1 1 1 1 1

1 0 0 0 0 1 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0

0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 3 0 0 0 0 0 0 2 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 1 0 0 0 0 0 0 0

0 0 0 0 0 2 3 3 3 3 3 1 2 2 3 3 0 3 2 0 2 2 2 2 2 2 2 2 2 2 2 2 2 0 2 2 1

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.89

>>>混淆矩阵

[[105 2 7 1]

[ 1 36 1 0]

[ 1 1 29 0]

[ 2 1 5 8]]

>>>召回率

precision recall f1-score support

0 0.96 0.91 0.94 115

1 0.90 0.95 0.92 38

2 0.69 0.94 0.79 31

3 0.89 0.50 0.64 16

micro avg 0.89 0.89 0.89 200

macro avg 0.86 0.82 0.82 200

weighted avg 0.90 0.89 0.89 200

>>>算法程序已经结束…

>>>算法消耗时间为： 213.85095739364624 秒

(None, None, None)

#### 常规算法——方法4——伯努力贝叶斯算法

bnb = BernoulliNB()
result = get_text_classification(bnb, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])

>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 0 1 0 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 0 1 1 1 1 1 1 1

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 2 2 0 0 2 0 0 2 0 2 0 0 0 0 0

0 2 0 0 0 0 0 2 2 2 0 2 2 2 0]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.785

>>>混淆矩阵

[[113 0 2 0]

[ 6 32 0 0]

[ 19 0 12 0]

[ 15 0 1 0]]

>>>召回率

precision recall f1-score support

0 0.74 0.98 0.84 115

1 1.00 0.84 0.91 38

2 0.80 0.39 0.52 31

3 0.00 0.00 0.00 16

micro avg 0.79 0.79 0.79 200

macro avg 0.63 0.55 0.57 200

weighted avg 0.74 0.79 0.74 200

>>>算法程序已经结束…

>>>算法消耗时间为： 1.267916202545166 秒

(None, None, None)

#### 常规算法——方法5——高斯贝叶斯

gnb = GaussianNB()
result = get_text_classification(gnb, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])


>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

GaussianNB(priors=None, var_smoothing=1e-09)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1

1 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0

2 0 0 0 2 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 3 0 0 0 0 0 0 2 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 3 3 3 3 3 3 1 3 1 3 3 2 2 3 0 3 0 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 3 2 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.89

>>>混淆矩阵

[[105 1 8 1]

[ 2 34 2 0]

[ 1 1 28 1]

[ 1 2 2 11]]

>>>召回率

precision recall f1-score support

0 0.96 0.91 0.94 115

1 0.89 0.89 0.89 38

2 0.70 0.90 0.79 31

3 0.85 0.69 0.76 16

micro avg 0.89 0.89 0.89 200

macro avg 0.85 0.85 0.84 200

weighted avg 0.90 0.89 0.89 200

>>>算法程序已经结束…

>>>算法消耗时间为： 2.20556640625 秒

(None, None, None)

#### 常规算法——方法6——多项式朴素贝叶斯

mnb = MultinomialNB()
result = get_text_classification(mnb, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])

>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 2 3 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 3 1 1 1 1 2 1 1 1 1 1 1 1

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0

3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 3 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 2 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0

0 0 0 0 0 0 3 3 3 3 3 2 0 2 3 3 3 3 0 3 0 2 2 2 2 0 2 2 2 2 2 2 2 2 2 2 2

2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.905

>>>混淆矩阵

[[108 1 2 4]

[ 0 33 3 2]

[ 1 0 30 0]

[ 4 0 2 10]]

>>>召回率

precision recall f1-score support

0 0.96 0.94 0.95 115

1 0.97 0.87 0.92 38

2 0.81 0.97 0.88 31

3 0.62 0.62 0.62 16

micro avg 0.91 0.91 0.91 200

macro avg 0.84 0.85 0.84 200

weighted avg 0.91 0.91 0.91 200

>>>算法程序已经结束…

>>>算法消耗时间为： 0.6552143096923828 秒

(None, None, None)

#### 常规算法——方法7——逻辑回归算法

lgr = LogisticRegression()
result = get_text_classification(lgr, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])


>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,

intercept_scaling=1, max_iter=100, multi_class='warn',

n_jobs=None, penalty='l2', random_state=None, solver='warn',

tol=0.0001, verbose=0, warm_start=False)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 3 1 1 1 1 2 1 1 1 1 1 1 1

1 0 0 0 0 1 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0

1 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

2 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 1 0 0 0 0 0 0 0

0 0 0 0 0 0 3 3 3 3 3 3 2 2 3 3 0 3 0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 1

2 2 2 2 2 2 2 2 2 2 2 1 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.89

>>>混淆矩阵

[[105 3 7 0]

[ 0 36 1 1]

[ 1 2 28 0]

[ 5 0 2 9]]

>>>召回率

precision recall f1-score support

0 0.95 0.91 0.93 115

1 0.88 0.95 0.91 38

2 0.74 0.90 0.81 31

3 0.90 0.56 0.69 16

micro avg 0.89 0.89 0.89 200

macro avg 0.87 0.83 0.84 200

weighted avg 0.90 0.89 0.89 200

>>>算法程序已经结束…

>>>算法消耗时间为： 0.79727 秒

(None, None, None)

#### 常规算法——方法8——支持向量机算法

svc = ()
result = get_text_classification(svc, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])

>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,

decision_function_shape='ovr', degree=3, gamma='auto_deprecated',

kernel='rbf', max_iter=-1, probability=False, random_state=None,

shrinking=True, tol=0.001, verbose=False)

>>>算法正在进行预测，请稍候…

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.575

>>>混淆矩阵

[[115 0 0 0]

[ 38 0 0 0]

[ 31 0 0 0]

[ 16 0 0 0]]

>>>召回率

precision recall f1-score support

0 0.57 1.00 0.73 115

1 0.00 0.00 0.00 38

2 0.00 0.00 0.00 31

3 0.00 0.00 0.00 16

micro avg 0.57 0.57 0.57 200

macro avg 0.14 0.25 0.18 200

weighted avg 0.33 0.57 0.42 200

>>>算法程序已经结束…

>>>算法消耗时间为： 398.7027745246887 秒

(None, None, None)

#### 集成学习算法——方法1——随机森林算法

rfc = RandomForestClassifier()
result = get_text_classification(rfc, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])


>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',

max_depth=None, max_features='auto', max_leaf_nodes=None,

min_impurity_decrease=0.0, min_impurity_split=None,

min_samples_leaf=1, min_samples_split=2,

min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=None,

oob_score=False, random_state=None, verbose=0,

warm_start=False)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 2 3 1 1 1 0 0 1 0 1 1 1 1 0 1 1 1 1 1 1 1

1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 2 0 0 0 0 2 0 0 0 0 2 0 0 0 0 0

0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 2 0 3 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 2 0 0 0

0 0 0 0 0 2 3 2 2 3 3 1 2 0 3 3 0 3 2 0 2 0 0 2 2 2 2 2 2 2 2 2 2 0 0 2 3

2 3 2 2 2 2 2 2 2 2 2 1 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.82

>>>混淆矩阵

[[103 3 8 1]

[ 5 31 1 1]

[ 4 1 24 2]

[ 3 1 6 6]]

>>>召回率

precision recall f1-score support

0 0.90 0.90 0.90 115

1 0.86 0.82 0.84 38

2 0.62 0.77 0.69 31

3 0.60 0.38 0.46 16

micro avg 0.82 0.82 0.82 200

macro avg 0.74 0.72 0.72 200

weighted avg 0.82 0.82 0.82 200

>>>算法程序已经结束…

>>>算法消耗时间为： 6.421279668807983 秒

(None, None, None)

#### 集成学习算法——方法2——自增强算法

abc = AdaBoostClassifier()
result = get_text_classification(abc, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])

>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

AdaBoostClassifier(algorithm='SAMME.R', base_estimator=None,

learning_rate=1.0, n_estimators=50, random_state=None)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1

1 0 1 0 0 1 0 1 0 0 0 1 0 0 0 0 1 0 1 0 1 1 1 0 0 0 0 1 0 0 1 1 0 1 0 0 0

1 0 1 1 1 1 1 0 1 1 0 0 1 1 0 1 0 1 0 0 1 0 1 1 0 1 0 1 0 0 0 1 0 0 1 1 0

1 1 0 0 1 0 1 0 0 0 1 0 1 1 1 0 1 0 1 0 1 0 1 1 1 1 0 1 0 1 1 0 1 0 1 0 1

1 0 0 1 0 1 3 3 3 3 3 3 1 1 3 3 1 3 1 1 1 0 1 2 1 1 1 1 2 3 2 1 3 1 0 1 1

1 3 2 2 1 2 1 1 2 2 1 1 2 1 1]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.57

>>>混淆矩阵

[[59 56 0 0]

[ 1 37 0 0]

[ 2 17 9 3]

[ 0 7 0 9]]

>>>召回率

precision recall f1-score support

0 0.95 0.51 0.67 115

1 0.32 0.97 0.48 38

2 1.00 0.29 0.45 31

3 0.75 0.56 0.64 16

micro avg 0.57 0.57 0.57 200

macro avg 0.75 0.58 0.56 200

weighted avg 0.82 0.57 0.60 200

>>>算法程序已经结束…

>>>算法消耗时间为： 149.1696276664734 秒

(None, None, None)

#### 集成学习算法——方法3——lightgbm算法

gbm = lig()
result = get_text_classification(gbm, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])


>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

LGBMClassifier(boosting_type='gbdt', class_weight=None, colsample_bytree=1.0,

learning_rate=0.1, max_depth=-1, min_child_samples=20,

min_child_weight=0.001, min_split_gain=0.0, n_estimators=100,

n_jobs=-1, num_leaves=31, objective=None, random_state=None,

reg_alpha=0.0, reg_lambda=0.0, silent=True, subsample=1.0,

subsample_for_bin=200000, subsample_freq=1)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 3 1 1 1 1 1 1 3 1 1 1 1 1 1 1 1 1 1 1 1

1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 2 0 2 0 0 2 0 0 0 0 2 0 0 0 2 0 0 0 0 0 0

1 0 0 0 2 2 0 0 3 0 0 0 0 0 0 2 0 2 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 2 0

2 0 0 0 0 0 0 0 0 0 1 0 2 0 3 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0

0 0 0 1 0 2 3 2 2 3 3 3 2 2 3 3 0 3 2 1 2 0 2 2 2 2 2 2 2 2 2 2 3 3 2 0 1

2 3 2 2 2 2 2 1 2 2 2 1 2 2 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.795

>>>混淆矩阵

[[94 6 13 2]

[ 0 35 1 2]

[ 2 3 23 3]

[ 1 1 7 7]]

>>>召回率

precision recall f1-score support

0 0.97 0.82 0.89 115

1 0.78 0.92 0.84 38

2 0.52 0.74 0.61 31

3 0.50 0.44 0.47 16

micro avg 0.80 0.80 0.80 200

macro avg 0.69 0.73 0.70 200

weighted avg 0.83 0.80 0.80 200

>>>算法程序已经结束…

>>>算法消耗时间为： 2.091001510620117 秒

(None, None, None)

#### 集成学习算法——方法4——xgboost算法

xgboost 模型运行有点慢，这里需要等待一阵子

xgb = xgboo()
result = get_text_classification(xgb, X_train_count, y_train_le, X_test_count, y_test_le)
e(result[1]), (result[2]), (result[3])


>>>算法正在启动，请稍候…

>>>算法正在进行训练，请稍候…

XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,

colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,

max_depth=3, min_child_weight=1, missing=None, n_estimators=100,

n_jobs=1, nthread=None, objective='multi:softprob', random_state=0,

reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,

silent=True, subsample=1)

>>>算法正在进行预测，请稍候…

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0

1 0 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 0 1 1 0

0 0 0 0 1 0 0 0 0 0 1 0 1 1 1 0 0 0 1 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0

0 1 0 1 0 1 3 3 3 3 3 3 0 1 3 3 0 3 1 1 1 2 1 2 1 1 2 2 2 3 2 1 1 0 2 1 1

1 3 2 2 2 2 2 1 2 2 2 1 2 1 2]

>>>算法正在进行性能评估，请稍候…

>>>准确率

0.735

>>>混淆矩阵

[[83 32 0 0]

[ 0 38 0 0]

[ 1 11 17 2]

[ 2 5 0 9]]

>>>召回率

precision recall f1-score support

0 0.97 0.72 0.83 115

1 0.44 1.00 0.61 38

2 1.00 0.55 0.71 31

3 0.82 0.56 0.67 16

micro avg 0.73 0.73 0.73 200

macro avg 0.81 0.71 0.70 200

weighted avg 0.86 0.73 0.75 200

>>>算法程序已经结束…

>>>算法消耗时间为： 602.9425418376923 秒

(None, None, None)

#### 深度学习算法——方法1——多分类前馈神经网络

虽然 Keras 也是一个高级封装的接口，但对初学者来说也会很容易混淆一些地方，所以小知同学来说一些概念。

```
1 算法流程：
创建神经网络——添加神经层——编译神经网络——训练神经网络——预测——性能评估——保存模型
2 添加神经层
至少要有两层神经层，第一层必须是输入神经层，最后一层必须是输出层；
输入神经层主要设置输入的维度，而最后一层主要是设置激活函数的类型来指明是分类还是回归问题
3 编译神经网络
分类问题的 metrics，一般以 accuracy 准确率来衡量
回归问题的 metrics, 一般以 mae 平均绝对误差来衡量
```

暂时就说这些比较容易混淆的知识点

start = ()
# --------------------------------
# np.random.seed(0) # 设置随机数种子
feature_num = X_[1] # 设置所希望的特征数量
# ---------------------------------
# 独热编码目标向量来创建目标矩阵
y_train_cate = to_categorical(y_train_le)
y_test_cate = to_categorical(y_test_le)
print(y_train_cate)

[[0. 1. 0. 0.]

[0. 1. 0. 0.]

[0. 1. 0. 0.]

…

[0. 0. 1. 0.]

[0. 0. 1. 0.]

[0. 0. 1. 0.]]

# ----------------------------------------------------
# 1 创建神经网络
network = models.Sequential()
# ----------------------------------------------------
# 2 添加神经连接层
# 第一层必须有并且一定是 [输入层], 必选
ne( # 添加带有 relu 激活函数的全连接层
units=128,
activation='relu',
input_shape=(feature_num, )
))
# 介于第一层和最后一层之间的称为 [隐藏层]，可选
ne( # 添加带有 relu 激活函数的全连接层
units=128,
activation='relu'
))
ne))
# 最后一层必须有并且一定是 [输出层], 必选
ne( # 添加带有 softmax 激活函数的全连接层
units=4,
activation='sigmoid'
))
# -----------------------------------------------------
# 3 编译神经网络
ne(loss='categorical_crossentropy', # 分类交叉熵损失函数
optimizer='rmsprop',
metrics=['accuracy'] # 准确率度量
)
# -----------------------------------------------------
# 4 开始训练神经网络
history = ne(X_train_count, # 训练集特征
y_train_cate, # 训练集标签
epochs=20, # 迭代次数
batch_size=300, # 每个批量的观测数 可做优化
validation_data=(X_test_count, y_test_cate) # 验证测试集数据
)
ne()

“`

Train on 3305 samples, validate on 200 samples

Epoch 1/20

3305/3305 [==============================] – 2s 587us/step – loss: 1.2444 – acc: 0.5425 – val_loss: 1.0093 – val_acc: 0.7450

Epoch 2/20

3305/3305 [==============================] – 2s 490us/step – loss: 0.8650 – acc: 0.7256 – val_loss: 0.6828 – val_acc: 0.8350

Epoch 3/20

3305/3305 [==============================] – 2s 489us/step – loss: 0.5740 – acc: 0.8551 – val_loss: 0.5079 – val_acc: 0.8650

Epoch 4/20

3305/3305 [==============================] – 2s 489us/step – loss: 0.3937 – acc: 0.9147 – val_loss: 0.3795 – val_acc: 0.9100

Epoch 5/20

3305/3305 [==============================] – 2s 494us/step – loss: 0.2743 – acc: 0.9467 – val_loss: 0.2993 – val_acc: 0.9150

Epoch 6/20

3305/3305 [==============================] – 2s 493us/step – loss: 0.1883 – acc: 0.9728 – val_loss: 0.2564 – val_acc: 0.9150

Epoch 7/20

3305/3305 [==============================] – 2s 491us/step – loss: 0.1326 – acc: 0.9770 – val_loss: 0.2308 – val_acc: 0.9100

Epoch 8/20

3305/3305 [==============================] – 2s 492us/step – loss: 0.0978 – acc: 0.9846 – val_loss: 0.2241 – val_acc: 0.9050

Epoch 9/20

3305/3305 [==============================] – 3s 932us/step – loss: 0.0788 – acc: 0.9879 – val_loss: 0.2210 – val_acc: 0.9100

Epoch 10/20

3305/3305 [==============================] – 3s 962us/step – loss: 0.0564 – acc: 0.9888 – val_loss: 0.2041 – val_acc: 0.9150

Epoch 11/20

3305/3305 [==============================] – 3s 981us/step – loss: 0.0479 – acc: 0.9906 – val_loss: 0.2118 – val_acc: 0.9150

Epoch 12/20

3305/3305 [==============================] – 3s 1ms/step – loss: 0.0376 – acc: 0.9936 – val_loss: 0.2109 – val_acc: 0.9150

Epoch 13/20

3305/3305 [==============================] – 3s 1ms/step – loss: 0.0363 – acc: 0.9930 – val_loss: 0.1821 – val_acc: 0.9200

Epoch 14/20

3305/3305 [==============================] – 3s 980us/step – loss: 0.0241 – acc: 0.9964 – val_loss: 0.2104 – val_acc: 0.9100

Epoch 15/20

3305/3305 [==============================] – 3s 996us/step – loss: 0.0225 – acc: 0.9958 – val_loss: 0.2092 – val_acc: 0.9050

Epoch 16/20

3305/3305 [==============================] – 3s 1ms/step – loss: 0.0236 – acc: 0.9955 – val_loss: 0.2074 – val_acc: 0.9100

Epoch 17/20

3305/3305 [==============================] – 2s 665us/step – loss: 0.0195 – acc: 0.9943 – val_loss: 0.1952 – val_acc: 0.9100

Epoch 18/20

3305/3305 [==============================] – 2s 492us/step – loss: 0.0156 – acc: 0.9976 – val_loss: 0.2131 – val_acc: 0.9100

Epoch 19/20

3305/3305 [==============================] – 2s 491us/step – loss: 0.0149 – acc: 0.9970 – val_loss: 0.2556 – val_acc: 0.9000

Epoch 20/20

3305/3305 [==============================] – 2s 487us/step – loss: 0.0128 – acc: 0.9970 – val_loss: 0.2760 – val_acc: 0.9000

_________________________________________________________________

Layer (type) Output Shape Param #

=================================================================

dense_1 (Dense) (None, 128) 3037824

_________________________________________________________________

dense_2 (Dense) (None, 128) 16512

_________________________________________________________________

dropout_1 (Dropout) (None, 128) 0

_________________________________________________________________

dense_3 (Dense) (None, 4) 516

=================================================================

Total params: 3,054,852

Trainable params: 3,054,852

Non-trainable params: 0

_________________________________________________________________

# -----------------------------------------------------
# 5 模型预测
y_pred_keras = ne(X_test_count)
# y_pred_keras[:20]

# -----------------------------------------------------
# 6 性能评估
print('>>>多分类前馈神经网络性能评估如下...n')
score = ne(X_test_count,
y_test_cate,
batch_size=32)
print('n>>>评分n', score)
print()
end = ()
e('前馈网络')
(score[1])
(round(end-start, 2))


>>>多分类前馈神经网络性能评估如下…

200/200 [==============================] – 0s 298us/step

>>>评分

[0.27604406617581845, 0.9]


# 损失函数情况
import ma as plt
%matplotlib inline
train_loss = ["loss"]
valid_loss = ["val_loss"]
epochs = [i for i in range(len(train_loss))]
(epochs, train_loss,linewidth=3.0)
(epochs, valid_loss,linewidth=3.0)


# 准确率情况
train_loss = ["acc"]
valid_loss = ["val_acc"]
epochs = [i for i in range(len(train_loss))]
(epochs, train_loss,linewidth=3.0)
(epochs, valid_loss,linewidth=3.0)

# ----------------------------------------------------
# 7 保存/加载模型
# 保存
print('n>>>你正在进行保存模型操作, 请稍候...n')
ne('/home/kesci/work/xiaozhi;)
print('>>>保存工作已完成...n')
# 加载和使用
print('>>>你正在加载已经训练好的模型, 请稍候...n')
my_load_model = models.load_model('/home/kesci/work/xiaozhi;)
print('>>>你正在使用加载的现成模型进行预测, 请稍候...n')
print('>>>预测部分结果如下...')
my_load_model.predict(X_test_count)[:20]

>>>你正在进行保存模型操作, 请稍候…

>>>保存工作已完成…

>>>你正在加载已经训练好的模型, 请稍候…

>>>你正在使用加载的现成模型进行预测, 请稍候…

>>>预测部分结果如下…

array([[5.1700755e-11, 9.9822301e-01, 5.9817724e-12, 1.0217827e-12],

[5.7793606e-08, 9.7230035e-01, 3.4339887e-08, 4.5136148e-09],

[9.5060422e-09, 5.1215082e-01, 8.4493550e-08, 9.5746200e-10],

[1.9871244e-13, 9.9930143e-01, 2.1562925e-12, 1.3205597e-14],

[1.8191915e-12, 9.9938619e-01, 2.1153847e-12, 4.9101162e-14],

[7.0857258e-11, 6.6743273e-01, 1.3755715e-10, 1.9664211e-13],

[1.4808219e-11, 2.6674886e-04, 1.9547663e-08, 2.4381385e-16],

[2.1480148e-04, 6.2760770e-02, 5.8339193e-04, 1.9946802e-04],

[1.0268595e-10, 9.2095643e-01, 5.2838917e-08, 1.5940900e-11],

[7.5692771e-11, 9.8575795e-01, 7.2382700e-10, 6.0663430e-10],

[3.5654655e-06, 2.7780209e-02, 6.7675983e-06, 6.2545593e-07],

[5.6649534e-15, 9.9979669e-01, 1.9059852e-14, 6.8455198e-17],

[2.3525736e-04, 1.1769304e-01, 2.6649828e-03, 2.0936482e-04],

[3.6169077e-08, 9.7102821e-01, 5.3637911e-10, 1.0601772e-10],

[1.1997248e-12, 9.8428184e-01, 6.2197027e-12, 1.8859871e-14],

[9.4651825e-14, 9.9954802e-01, 4.3595604e-13, 6.6097509e-15],

[4.8878224e-04, 4.5537679e-03, 1.2824073e-03, 1.9483171e-04],

[6.1444093e-06, 8.1935581e-03, 1.8014919e-03, 9.0278033e-04],

[4.6505798e-07, 2.8149030e-01, 1.4581896e-06, 4.8493359e-08],

[2.6251234e-07, 2.9730025e-01, 3.8841034e-05, 1.4241238e-07]],

dtype=float32)

#### 深度学习算法——方法2——LSTM 神经网络

本案例的数据使用 LSTM 跑模型

# ---------------------------------------------
# 设置所希望的特征数
feature_num = X_[1]
# 使用单热编码目标向量对标签进行处理
y_train_cate = to_categorical(y_train_le)
y_test_cate = to_categorical(y_test_le)
print(y_train_cate)

“`

[[0. 1. 0. 0.]

[0. 1. 0. 0.]

[0. 1. 0. 0.]

…

[0. 0. 1. 0.]

[0. 0. 1. 0.]

[0. 0. 1. 0.]]

### 7.算法之间性能比较

df = ()
df['分类器'] = estimator_list
df['准确率'] = score_list
df['消耗时间/s'] = time_list
df
<div>
<style scoped>
.dataframe tbody tr th:only-of-type {
vertical-align: middle;
}
.dataframe tbody tr th {
vertical-align: top;
}
.dataframe thead th {
text-align: right;
}
</style>
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th></th>
<th>分类器</th>
<th>准确率</th>
<th>消耗时间/s</th>
</tr>
</thead>
<tbody>
<tr>
<th>0</th>
<td>KNeighborsClassifier</td>
<td>0.670</td>
<td>32.67</td>
</tr>
<tr>
<th>1</th>
<td>DecisionTreeClassifier</td>
<td>0.760</td>
<td>38.01</td>
</tr>
<tr>
<th>2</th>
<td>MLPClassifier</td>
<td>0.890</td>
<td>213.85</td>
</tr>
<tr>
<th>3</th>
<td>BernoulliNB</td>
<td>0.785</td>
<td>1.27</td>
</tr>
<tr>
<th>4</th>
<td>GaussianNB</td>
<td>0.890</td>
<td>2.21</td>
</tr>
<tr>
<th>5</th>
<td>MultinomialNB</td>
<td>0.905</td>
<td>0.66</td>
</tr>
<tr>
<th>6</th>
<td>LogisticRegression</td>
<td>0.890</td>
<td>0.80</td>
</tr>
<tr>
<th>7</th>
<td>SVC</td>
<td>0.575</td>
<td>398.70</td>
</tr>
<tr>
<th>8</th>
<td>RandomForestClassifier</td>
<td>0.820</td>
<td>6.42</td>
</tr>
<tr>
<th>9</th>
<td>AdaBoostClassifier</td>
<td>0.570</td>
<td>149.17</td>
</tr>
<tr>
<th>10</th>
<td>LGBMClassifier</td>
<td>0.795</td>
<td>2.09</td>
</tr>
<tr>
<th>11</th>
<td>XGBClassifier</td>
<td>0.735</td>
<td>602.94</td>
</tr>
<tr>
<th>12</th>
<td>前馈网络</td>
<td>0.900</td>
<td>47.08</td>
</tr>
</tbody>
</table>
</div>

综上 DataFrame 展示，结合消耗时间和准确率来看，可以得出以下结论：

在同一训练集和测试集、分类器默认参数设置（都未进行调参）的情况下：

* 综合效果最好的是:

“`

MultinomialNB 多项式朴素贝叶斯分类算法：

其准确率达到了 90.5% 并且所消耗的的时间才 0.55 s“`

* 综合效果最差的是：

“`

SVC 支持向量机

其准确率才 0.575 并且消耗时间高达 380.72s“`

* 准确率最低的是：0.570

“`

AdaBoostClassifier 自适应增强集成学习算法“`

* 消耗时间最高的是：566.59s

“`

XGBClassifier 集成学习算法“`

PS：需要本文项目的代码以及数据集的朋友，关注我之后，在评论区私信小编即可分享给你，希望对读者有所帮助，觉得对你有帮助可以点个赞哦！