机器学习实战（1）-文本分类

参考链接：14种分类算法进行文本分类实战：https://blog.csdn.net/qq_41731978/article/details/109459234（这个博主写的很详细，受益匪浅）
本文暂时不涉及深度学习，还没学会（哭.jpg）

1介绍

主要是在自己实习的时候接触到的文本分类，主要是中文文本的单标签分类(one vs one)，多标签分类(one vs rest)，用python实现，需要先学习一下机器学习方面的内容，还有就是pandas科学计算库，sklearn等。

2导包

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.utils.np_utils import to_categorical
from keras.preprocessing.text import Tokenizer
# sklearn提供的一些模型
from sklearn import svm # 支持向量机
from sklearn import metrics # 用于预测准确度等
from sklearn.neural_network import MLPClassifier
from sklearn.tree import DecisionTreeClassifier # 决策树
from sklearn.neighbors import KNeighborsClassifier # K 近邻
from sklearn.naive_bayes import BernoulliNB # 伯努利朴素贝叶斯
from sklearn.naive_bayes import GaussianNB # 高斯贝朴素叶斯
from sklearn.naive_bayes import MultinomialNB # 多项式朴素贝叶斯
from sklearn.linear_model import LogisticRegression # 逻辑回归
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import AdaBoostClassifier
# 标签化
from sklearn.preprocessing import LabelEncoder
# 特征提取
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
# 训练集、测试集的划分
from sklearn.model_selection import train_test_split

warnings.filterwarnings('ignore')

3读取数据并进行分词处理等

从数据库中读取数据

# 导入pymysql模块
import pymysql

# 连接database
conn = pymysql.connect(
    host="localhost",
    user="root",
    password="123",
    database="kss",
    charset="utf8")
 
# 得到一个可以执行SQL语句的光标对象
cursor = conn.cursor()  # 执行完毕返回的结果集默认以元组显示
 # 定义要执行的SQL语句
sql = 'SELECT item_description, item_catalog_name FROM item'

加载停用词

stoplist = [word.strip() for word in open('D:CodePythonCodeproject01project_01dbstopwords.txt', encoding='utf-8').readlines()]

逐条读取并处理

labels, texts = [], []
sentences = []
try:
   # 执行SQL语句
   cursor.execute(sql)
   # 获取所有记录列表
   results = cursor.fetchall()
   for row in results: # 逐行处理
      segs=jieba.lcut(row[0]) 
      segs = filter(lambda x:len(x)>1, segs) # 去除长度小于1的词
      segs = filter(lambda x:x not in stoplist, segs) # 去掉停用词
      #  labels.append(row[1])
      #  texts.append( " ".join(list(jieba.cut(row[0]))))
      sentences.append((" ".join(segs),row[1])) # 一定用join()把分词连接起来，row[1]是标签
       # 打印结果
      #  print(row)
   # for row in results[-500:]:
   #    #  labels.append(row[1])
   #    #  texts.append( " ".join(list(jieba.cut(row[0]))))
   #     sentences.append((" ".join(list(jieba.cut(row[0]))),row[1]))
except:
   print ("Error: unable to fecth data")

扩展：

4划分训练集、测试集

可以学习一下train_test_split这个函数（之后单独我再学习一下sklearn的API吧）

import random
random.shuffle(sentences) # 打乱顺序生成有效训练集
# 将数据集划分为训练集和测试集
train_x, test_x, train_y, test_y = train_test_split(x, y, train_size=0.7, random_state=0)

5标签化

我这一步，给省略了，遇到点问题，还不太清楚

le = LabelEncoder()
# 为什么编码之后的准确率低很多
# y_train_le = le.fit_transform(train_y)
# y_test_le  = le.fit_transform(test_y)
y_train_le = train_y
y_test_le  = test_y

6特征提取

这个需要学一下TfidfVectorizer这个函数的使用

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

# tfidf_vectorizer = TfidfVectorizer(stop_words=stoplist)
tfidf_vectorizer = TfidfVectorizer(analyzer='word', ngram_range=(1,4), max_features=10000)

'''注意：
这里要先 count.fit() 训练所有训练和测试集，保证特征数一致，
这样在算法建模时才不会报错
'''
# count.fit(list(train_x) + list(test_x))
tfidf_vectorizer.fit(train_x)
X_train_count = tfidf_vectorizer.transform(train_x)
X_test_count  = tfidf_vectorizer.transform(test_x)

# 这里会内存不够
# X_train_count = X_train_count.torarray()
# X_test_count  = X_test_count.toaray()
# X_train_count.toarray()

# print(X_train_count.shape, X_test_count.shape)
# X_train_count, X_test_count

7统一的处理函数

这个是直接用那个大佬的代码，一个字，赞！

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 = 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

8常规算法
8.1常规算法——方法1——k 近邻算法

knc = KNeighborsClassifier()
result = get_text_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——决策树

dtc = DecisionTreeClassifier()
result = get_text_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])

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

mlpc = MLPClassifier()
result = get_text_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])

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

bnb = BernoulliNB()
result = get_text_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])

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

这个出了点错，未解决
gnb = GaussianNB()
result = get_text_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])

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

mnb = MultinomialNB()
result = get_text_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])
看一下预测结果：

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

lgr = LogisticRegression()
result = get_text_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])

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

svc = svm.SVC()
result = get_text_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])

9集成学习

这都没学，但是听说xgboost很好用，准确度高，运行比较慢，之后有时间接着学

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

rfc = RandomForestClassifier()
result = get_text_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——自增强算法

abc = AdaBoostClassifier()
result = get_text_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])

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

gbm = lightgbm.LGBMClassifier()
result = get_text_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])

集成学习算法——方法4——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])

10深度学习

先到这，下面实在看不懂

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

1 算法流程：
创建神经网络——添加神经层——编译神经网络——训练神经网络——预测——性能评估——保存模型

2 添加神经层
至少要有两层神经层，第一层必须是输入神经层，最后一层必须是输出层；
输入神经层主要设置输入的维度，而最后一层主要是设置激活函数的类型来指明是分类还是回归问题

3 编译神经网络
分类问题的 metrics，一般以 accuracy 准确率来衡量
回归问题的 metrics, 一般以 mae 平均绝对误差来衡量