本篇重视使用函数来提高代码复用率，同时使用高达14种涵盖sklearn、xgboost、lightgbm和Keras框架的分类算法进行文本分类，适合进阶和提高。
前言
本篇文本分类实战训练是以完整的文本分类项目流程来写的，比较适合进阶和提高
《获取数据》——《数据分析和处理》——《特征工程与选择》——《算法模型》——《性能评估/参数调优》
这一篇训练比较重视批量读取和处理文本数据集；
其中也比较重视函数的使用以提高代码的复用率。
在分类算法这一块，本篇项目总共使用了 《14》 种分类算法来进行文本分类，
涵盖《sklearn》中的常规分类算法和集成学习算法;
竞赛和工业界比较得宠的集成学习算法《xgboost》和《lightgbm》;
深度学习框架《Keras》中的前馈神经网络和《LSTM》算法。
本篇目录：
数据集介绍
- 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.导入的包
#xgboost
import xgboost
#lightgbm
import lightgbm
#keras MLP多层感知机
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
#svm支持向量机
from sklearn import svm
#sklearn MLP
from sklearn.neural_network import MLPClassifier
#DecisionTree决策树
from sklearn.tree import DecisionTreeClassifier
#KNN
from sklearn.neighbors import KNeighborsClassifier
#Bernoulli NB贝努力贝叶斯
from sklearn.naive_bayes import BernoulliNB
#GaussianNB高斯贝叶斯
from sklearn.naive_bayes import GaussianNB
#朴素贝叶斯
from sklearn.naive_bayes import MultinomialNB
#logistic回归
from sklearn.linear_model import LogisticRegression
#RFC随机森林
from sklearn.ensemble import RandomForestClassifier
#AdaBoost
from sklearn.ensemble import AdaBoostClassifier
2. 算法模型
封装一个函数，提高复用率，使用时只需调用函数即可
# 用于存储所有算法的名字，准确率和所消耗的时间
estimator_list, score_list, time_list = [], [], []
def get_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 = time.time()
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 = metrics.accuracy_score(y_test, y_pred_model)
matrix = metrics.confusion_matrix(y_test, y_pred_model)
report = metrics.classification_report(y_test, y_pred_model)
print('>>>准确率\n', score)
print('\n>>>混淆矩阵\n', matrix)
print('\n>>>召回率\n', report)
print('>>>算法程序已经结束...')
end = time.time()
t = end - start
print('\n>>>算法消耗时间为：', t, '秒\n')
classifier = str(model).split('(')[0]
return y_pred_model, classifier, score, round(t, 2), matrix, report
2.1 常规算法—k 近邻算法-KNN
knc = KNeighborsClassifier()
result = get_classification(knc, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.2 常规算法—决策树
dtc = DecisionTreeClassifier()
result = get_classification(dtc, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.3 常规算法—多层感知器
mlpc = MLPClassifier()
result = get_classification(mlpc, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.4 常规算法—伯努力贝叶斯算法
bnb = BernoulliNB()
result = get_classification(bnb, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.5 常规算法—高斯贝叶斯
gnb = GaussianNB()
result = get_classification(gnb, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.6 常规算法—多项式朴素贝叶斯
mnb = MultinomialNB()
result = get_classification(mnb, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.7 常规算法—逻辑回归
lgr = LogisticRegression()
result = get_classification(lgr, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.8 常规算法—支持向量机
svc = svm.SVC()
result = get_classification(svc, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.9 集成学习算法—随机森林算法
rfc = RandomForestClassifier()
result = get_classification(rfc, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.10 集成学习算法—随机森林算法
2.10 集成学习算法—自适应增强算法
abc = AdaBoostClassifier()
result = get_classification(abc, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.11 集成学习算法—lightgbm算法
gbm = lightgbm.LGBMClassifier()
result = get_classification(gbm, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.12 集成学习算法—xgboost算法
xgb = xgboost.XGBClassifier()
result = get_text_classification(xgb, X_train_count, y_train_le, X_test_count, y_test_le)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(result[3])
2.13 深度学习算法—多分类前馈神经网络
虽然 Keras 也是一个高级封装的接口，但对初学者来说也会很容易混淆一些地方，所以小知同学来说一些概念。
1 算法流程：
创建神经网络——添加神经层——编译神经网络——训练神经网络——预测——性能评估——保存模型
2 添加神经层
至少要有两层神经层，第一层必须是输入神经层，最后一层必须是输出层；
输入神经层主要设置输入的维度，而最后一层主要是设置激活函数的类型来指明是分类还是回归问题
3 编译神经网络
分类问题的 metrics，一般以 accuracy 准确率来衡量
回归问题的 metrics, 一般以 mae 平均绝对误差来衡量
# ----------------------------------------------------
# 1 创建神经网络
network = models.Sequential()
# ----------------------------------------------------
# 2 添加神经连接层
# 第一层必须有并且一定是 [输入层], 必选
network.add(layers.Dense( # 添加带有 relu 激活函数的全连接层
units=100,
activation='relu',
input_shape=(feature_num, )
))
# 介于第一层和最后一层之间的称为 [隐藏层]，可选
network.add(layers.Dense( # 添加带有 relu 激活函数的全连接层
units=100,
activation='relu'
))
# 最后一层必须有并且一定是 [输出层], 必选
network.add(layers.Dense( # 添加带有 softmax 激活函数的全连接层
units=4,
activation='softmax'
))
# -----------------------------------------------------
# 3 编译神经网络
network.compile(loss='categorical_crossentropy', # 分类交叉熵损失函数
optimizer='rmsprop',
metrics=['accuracy'] # 准确率度量
)
# -----------------------------------------------------
# 4 开始训练神经网络
network.fit(X_train_count, # 训练集特征
y_train_cate, # 训练集标签
epochs=5, # 迭代次数
batch_size=100, # 每个批量的观测数
validation_data=(X_test_count, y_test_cate) # 验证测试集数据
)
# 5 模型预测
y_pred_keras = network.predict(X_test_count)
y_pred_keras[:20]
# 6 性能评估
print('>>>多分类前馈神经网络性能评估如下...\n')
score = network.evaluate(X_test_count,
y_test_cate,
batch_size=32)
print('\n>>>评分\n', score)
print()
end = time.time()
estimator_list.append('前馈网络')
score_list.append(score[1])
time_list.append(round(end-start, 2))
# ----------------------------------------------------
# 7 保存/加载模型
# 保存
print('\n>>>你正在进行保存模型操作, 请稍候...\n')
network.save('/home/kesci/work/xiaozhi/my_network_model.h5')
print('>>>保存工作已完成...\n')
# 加载和使用
print('>>>你正在加载已经训练好的模型, 请稍候...\n')
my_load_model = models.load_model('/home/kesci/work/xiaozhi/my_network_model.h5')
print('>>>你正在使用加载的现成模型进行预测, 请稍候...\n')
print('>>>预测部分结果如下...')
my_load_model.predict(X_test_count)[:20]
2.14 深度学习算法—LSTM 神经网络
# ----------------------------------------------
# 1 创建神经网络
lstm_network = models.Sequential()
# ----------------------------------------------
# 2 添加神经层
lstm_network.add(layers.Embedding(input_dim=feature_num, # 添加嵌入层
output_dim=28))
lstm_network.add(layers.LSTM(units=28)) # 添加 128 个单元的 LSTM 神经层
lstm_network.add(layers.Dense(units=4,
activation='sigmoid')) # 添加 sigmoid 分类激活函数的全连接层
# ----------------------------------------------
# 3 编译神经网络
lstm_network.compile(loss='binary_crossentropy',
optimizer='Adam',
metrics=['accuracy']
)
# ----------------------------------------------
# 4 开始训练模型
lstm_network.fit(X_train_count,
y_train_cate,
epochs=5,
batch_size=128,
validation_data=(X_test_count, y_test_cate)
)
算法之间性能比较
（基于其他项目）
在同一训练集和测试集、分类器默认参数设置（都未进行调参）的情况下：
- 综合效果最好的是:
MultinomialNB多项式朴素贝叶斯分类算法：
其准确率达到了 90.5% 并且所消耗的的时间才 0.55 s - 综合效果最差的是：
SVC支持向量机
其准确率才 0.575 并且消耗时间高达 380.72s - 准确率最低的是：0.570
AdaBoostClassifier自适应增强集成学习算法 - 消耗时间最高的是：566.59s
XGBClassifier集成学习算法
参考链接：https://www.kesci.com/home/project/5cbbe1668c90d7002c810f79
扫一扫
513
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
