52phm社区,工业互联网人的技术交流社区

2021-12-04 12:13:55    博客笔记    538    当前专栏:未分组    分类:算法开发    本站官网:www.52phm.cn   

扫码进群 ...

  • 日期:2019.05.10
  • 作者:小知
  • 课题:中文分词,各种分类算法的使用和性能比较

本文源码和数据集获取
https://pan.baidu.com/s/1apCigMQBPQiVmCnUtah1kw
提取码: cw1h

前言

本篇文本分类实战训练是以完整的文本分类项目流程来写的,比较适合进阶和提高
《获取数据》——《数据分析和处理》——《特征工程与选择》——《算法模型》——《性能评估/参数调优》

这一篇训练比较重视批量读取和处理文本数据集;

其中也比较重视函数的使用以提高代码的复用率。

在分类算法这一块,本篇项目总共使用了 《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.算法之间性能比较

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

数据集介绍

获取数据

1 目录情况

——text_classification  

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

        ——校园
            ——.txt  ...
    ——stopword.txt  

2 数据集介绍

           样本数/.txt文件数           标签

训练集:         3305         [女性,体育,文学,校园]

测试集           200          [女性,体育,文学,校园]

3 数据来源

https://github.com/cystanford/text_classification

目标定义

目标需求1:批量读取文档文件.txt
目标需求2:文本向量化使用词袋法或者TFIDF
目标需求3:比较各个算法的性能优劣,包括模型消耗用时、模型准确率

导入所需模块

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
from sklearn import svm
from sklearn import metrics
from sklearn.neural_network import MLPClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
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
from sklearn.feature_extraction.text import TfidfVectorizer 

warnings.filterwarnings('ignore')
    /opt/conda/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88
      return f(*args, **kwds)
    /opt/conda/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88
      return f(*args, **kwds)
    Using TensorFlow backend.

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

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

# -------------------------------------------
# 路径
filepath   = '/home/kesci/work/xiaozhi/text_classification.zip'
savepath   = '/home/kesci/work/xiaozhi/'
delectpath = '/home/kesci/work/xiaozhi/text_classification'

# -----------------------------------------
# 检索并删除文件夹
if os.path.exists(delectpath):
    print('\n存在该文件夹,正在进行删除,防止解压重命名失败......\n')
    shutil.rmtree(delectpath)
else:
    print('\n不存在该文件夹, 请放心处理......\n')

# -----------------------------------------
# 解压并处理中文名字乱码的问题
z = zipfile.ZipFile(filepath, 'r')    
for file in z.namelist():
    # 中文乱码需处理
    filename = file.encode('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 text.split('.')[-1] == 'txt':
            try:
                with open(path  text, encoding='gbk') as fp:
                    features.append(fp.read())          # 特征 
                    labels.append(path.split('/')[-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 /tmp/jieba.cache
Loading model cost 0.837 seconds.
Prefix dict has been built succesfully.





['冬季 饮食 减肥 小窍门 吃 , 我 所欲 也 ; 瘦 , 亦 我 所欲 也 。 难道 吃 和 瘦 真的 不可 兼得 吗 ? 没这回事 宝迪沃 告诉 你 冬天 怎样才能 吃 好吃 饱 不 发胖 吧 1 、 烧烤 后 吃 根 香蕉 2 、 吃火锅 后 喝点 酸奶 3 、 饭后 喝 大麦茶 或 橘皮 水 4 、 吃 方便面 后 吃水果 5 、 吃 蟹 后 , 喝 生姜 红糖 水 6 、 润肺 止咳 , 饭后 吃个 柿子 7 、 吃 得 太 油腻 喝杯 芹菜 汁 <img src="https://latex.codecogs.com/svg.latex?LOTOzf">',
 '优惠 信息 今日 拍拍网 母君宝康 母婴 专营店 乳钙 软胶囊 惊爆价 : 39 元 含泪 上架 ( 优惠 还有 升级版 : 今日 购买 一盒 该 软胶囊 任意 一件 产品 送 48 元水润 透感 美手 霜 一支 ) 另有 多多 产品 供 您 试用 体验 , 惊喜 有木有 实惠 有 不 有 : 3',
 '老年斑 形成 的 原因 华美 段跃 民主 任 介绍 说 , 人到 一定 年纪 后 , 体内 细胞 功能 的 衰退 在 逐年 加速 , 血液循环 也 趋向 缓慢 , 加上 饮食结构 上 的 变化 和 动植物 脂肪 摄入量 的 比例失调 等 原因 , 容易 在 人体 表面 形成 老年斑 。 目前 使用 6 激光 去 老年斑 是 目前 很 理想 的 老年斑 的 治疗 方法 , 而且 无副作用 : 8',
 '  | |   时尚 美人团 :   各种 眼线 的 画法 ~ 转给 想画 出 漂亮 眼线 的 姐妹 们 吧 ~ <img src="https://latex.codecogs.com/svg.latex?LOTOzf">             女人 天生 爱美丽 : 各种 眼线 的 画法 ~ 转给 想画 出 漂亮 眼线 的 姐妹 们 吧 ~ 想 学 穿衣 就 收听 → 潮女学 穿衣',
 '打造 小腰 精 : 直立 , 一臂 上举 , 一臂 伸向 背后 。 左臂 后伸 , 右臂 向上 伸 , 身体 左转 , 下肢 保持 不 动 , 停 20 秒 , 换 另一边 。 做 扭转 时要 感觉 腰部 肌肉 的 绷紧 , 脚跟 不能 移开 。 其实 瘦身 不 需要 太 大 运动量 的 , 减脂 的 关键在于 多 做 有氧 运动 , 也就是说 多 次数 小 重量 的 活动 。 只要 能 天天 坚持 , 不 出 一二个 月 , 效果 就 能 看到 了 。 <img src="https://latex.codecogs.com/svg.latex?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 <img src="https://latex.codecogs.com/svg.latex?LOTOzf">',
     '【 12 星座 思春 表现 】 白羊 ( 发呆 沉思 ) 、 金牛 ( 闷 着 长毛 ) 、 双子 ( 狂过 嘴瘾 ) 、 巨蟹 ( 有心 没胆 ) 、 狮子 ( 电话费 暴涨 ) 、 处女 ( 调戏 网友 ) 、 天秤 ( 穿衣 扮靓 ) 、 天蝎 ( 狂看 情色电影 ) 、 射手 ( 四处 约会 ) 、 魔羯 ( 执着 着 闷骚 ) 、 水瓶 ( 借口 闲聊 ) 、 双鱼 ( 眉来眼去 装 可怜 ) 。 <img src="https://latex.codecogs.com/svg.latex?LOTOzf">',
     '冬天 真是 万恶 的 季节 , 食欲 越来越 大 , 控制 不住 。 胖友 介绍 “ 瘦身 之颠 ” 这 款 减肥 产品 , 连续 看 了 十几页 的 评价 , 看 的 我 好 心动 , 立即 下单 , 服用 了 半个 月 瘦 了 8 斤 。 好开心 啊 , 吼吼 ... 好 姐妹 都 过来 要 秘诀 , 刚 看到 店家 在 做 活动 , 又 买 了 2 瓶 储备 , 分享 下 产品 地址 : http : url . cn / 1xd9ka <img src="https://latex.codecogs.com/svg.latex?LOTOzf">',
     '美丽 微 课堂 光子 嫩肤 项目 是 近 5 年 发展 起来 的 一种 带有 美容 性 治疗 的 一种 技术 。 可以 说 是 脱毛 的 孪生兄弟 。 真正 的 光子 嫩肤 是 让 肌肤 变得 细腻 、 有 弹性 、 有 光泽 , 对于 色素 沉着 、 雀斑 、 妊娠 纹 、 浅表 皱纹 、 黄褐斑 、 面部 红血丝 、 痤疮 浅表 疤痕 、 皮肤 粗糙 、 肤色 发黄 等 效果 还是 相当 不错 的 。 \t \t \t \t <img src="https://latex.codecogs.com/svg.latex?LOTOzf">',
     '    | |   樱花 草 丶 忧伤 :   【 事业 婚姻 两 得意 的 星座 女 】 第三名 : 天蝎座 <img src="https://latex.codecogs.com/svg.latex?LOTOzf">             星座 宝典 : 【 事业 婚姻 两 得意 的 星座 女 】 第一名 : 水瓶座 ; 第二名 : 巨蟹座 ; 第三名 : 天蝎座 ; 第四名 : 白羊座 ; 第五名 : 双鱼座 。 【 花心 男 最 斗不过 的 星座 女 】 第一名 : 射手 女 ; 第二名 : 水瓶 女 ; 第三名 : 魔羯 女 ; 第四名 : 双 子女 ; 第五名 : 天秤 女 。']

4. 停止词使用

1 停止词是为了过滤掉已经确认对训练模型没有实际价值的分词
2 停止词作用:提高模型的精确度和稳定性

# 加载停止词语料

stoplist = [word.strip() for word in open('/home/kesci/work/xiaozhi/text_classification/stopword.txt', \
                                           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_train_count.toarray()
X_test_count  = X_test_count.toarray()

print(X_train_count.shape, X_test_count.shape)
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 = 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

常规算法——方法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])
    >>>算法正在启动,请稍候...

    >>>算法正在进行训练,请稍候...
    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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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.7971396446228027 秒



    (None, None, None)

常规算法——方法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])
    >>>算法正在启动,请稍候...

    >>>算法正在进行训练,请稍候...
    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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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)
estimator_list.append(result[1]), score_list.append(result[2]), time_list.append(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 = 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])
    >>>算法正在启动,请稍候...

    >>>算法正在进行训练,请稍候...
    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 = 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])
    >>>算法正在启动,请稍候...

    >>>算法正在进行训练,请稍候...
    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 = time.time()
# --------------------------------
# np.random.seed(0)     # 设置随机数种子
feature_num = X_train_count.shape[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 添加神经连接层
# 第一层必须有并且一定是 [输入层], 必选
network.add(layers.Dense(     # 添加带有 relu 激活函数的全连接层
                         units=128, 
                         activation='relu', 
                         input_shape=(feature_num, )
                         ))

# 介于第一层和最后一层之间的称为 [隐藏层],可选
network.add(layers.Dense(     # 添加带有 relu 激活函数的全连接层
                         units=128, 
                         activation='relu'
                         ))
network.add(layers.Dropout(0.8))
# 最后一层必须有并且一定是 [输出层], 必选                         
network.add(layers.Dense(     # 添加带有 softmax 激活函数的全连接层
                         units=4,
                         activation='sigmoid'
                         ))

# -----------------------------------------------------
# 3 编译神经网络
network.compile(loss='categorical_crossentropy',  # 分类交叉熵损失函数    
                optimizer='rmsprop',  
                metrics=['accuracy']              # 准确率度量
                )

# -----------------------------------------------------
# 4 开始训练神经网络
history = network.fit(X_train_count,     # 训练集特征
            y_train_cate,        # 训练集标签
            epochs=20,          # 迭代次数
            batch_size=300,    # 每个批量的观测数  可做优化
            validation_data=(X_test_count, y_test_cate)  # 验证测试集数据
            )
network.summary()
    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 = 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))
    >>>多分类前馈神经网络性能评估如下...

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

    >>>评分
     [0.27604406617581845, 0.9]
# 损失函数情况
import matplotlib.pyplot as plt
%matplotlib inline

train_loss = history.history["loss"]
valid_loss = history.history["val_loss"]
epochs = [i for i in range(len(train_loss))]
plt.plot(epochs, train_loss,linewidth=3.0)
plt.plot(epochs, valid_loss,linewidth=3.0)

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

# ----------------------------------------------------
# 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]
    >>>你正在进行保存模型操作, 请稍候...

    >>>保存工作已完成...

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

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

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

    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_train_count.shape[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 创建神经网络
# lstm_network = models.Sequential()

# # ----------------------------------------------
# # 2 添加神经层
# lstm_network.add(layers.Embedding(input_dim=feature_num,  # 添加嵌入层
#                                   output_dim=4))

# lstm_network.add(layers.LSTM(units=128))                 # 添加 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)
#                  )

7.算法之间性能比较

df = pd.DataFrame()
df['分类器'] = estimator_list
df['准确率'] = score_list
df['消耗时间/s'] = time_list
df
分类器 准确率 消耗时间/s
0 KNeighborsClassifier 0.670 32.67
1 DecisionTreeClassifier 0.760 38.01
2 MLPClassifier 0.890 213.85
3 BernoulliNB 0.785 1.27
4 GaussianNB 0.890 2.21
5 MultinomialNB 0.905 0.66
6 LogisticRegression 0.890 0.80
7 SVC 0.575 398.70
8 RandomForestClassifier 0.820 6.42
9 AdaBoostClassifier 0.570 149.17
10 LGBMClassifier 0.795 2.09
11 XGBClassifier 0.735 602.94
12 前馈网络 0.900 47.08

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

在同一训练集和测试集、分类器默认参数设置(都未进行调参)的情况下:
* 综合效果最好的是:

MultinomialNB 多项式朴素贝叶斯分类算法:
其准确率达到了 90.5% 并且所消耗的的时间才 0.55 s```

* 综合效果最差的是:

SVC 支持向量机 其准确率才 0.575 并且消耗时间高达 380.72s```

  • 准确率最低的是:0.570
AdaBoostClassifier 自适应增强集成学习算法```

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

XGBClassifier 集成学习算法```

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

免责声明:信息来源于互联网聚合整理或者作者原创,非原创文章标示"互联网",原创文章标示"作者昵称",本文仅代表文章作者的个人观点,且文中陈述文字和内容的时效性、真实性与本站无关,请读者仅作参考,如发现有害或侵权内容,请联系我们将在第一时间进行核实处理。


[推荐] 异常检测——常见方法分类

2021-12-19 14:43:14    互联网    294    分类:算法开发    专栏:工业异常检测   


[推荐] 时间序列分类算法之LPS论文翻译

2021-12-21 15:50:53    互联网    223    分类:论文速递    专栏:时间序列预测   


[推荐] 基于CNN实现细胞识别分类

2022-03-31 21:45:25    博客笔记    99    分类:算法开发    专栏:未分组   



转发此文章到社区


进群

让志同道合读者学习交流



一种基于CNN的数据驱动故障诊断方法

本文主要分为四个部分:目录本文主要分为四个部分:1.数据预处理2.使用的CNN框架3.性能评估4.总结

2021-12-09 14:46:03    互联网    418    分类:算法开发    专栏:故障诊断   


故障诊断期刊文献分析

看看故障诊断研究重点方向在哪?故障诊断总发文量统计如下:前20个主要主题词分布情况:前20个次要主题词分布情况:录用期刊分布:期刊类型:学科分布情况:发文机构分布:基金分布情况:...

2021-12-13 17:11:53    互联网    531    分类:算法开发    专栏:故障诊断   


随机振动信号分析方法总结(时域、频域、时频域分析)

随机振动信号分析方法总结信号处理(信号滤波、时频域分析、神经网络、寿命预测)一、时域分析时域分析特征包括均值、方差、峭度、峰峰值等;振动信号降噪结果分析:对于去噪效果好坏的评价,常用信号的信噪比(SNR)、估计信号同原信号的均方根误差(RMSE)来判断。SNR 越高则说明混在信号里的噪声越小,否则相反。RMSE的计算值越小则表示去噪效果越好。信噪比定义:均方根误差定义:二、频域分析三、 时频联合域分析(Joint Time-Frequency Analysis,JTFA)即时频分析,

2021-12-14 18:49:46    互联网    498    分类:算法开发    专栏:振动信号预处理   


频谱分析幅值单位_知否知否?常用振动诊断方法——包络分析和阶次分析

包络分析对于各个行业,尤其是水泥行业,存在很多低转速设备。低转速部件引起的振动集中在低频部分,且往往较为微弱,容易淹没在其他信号中,在频谱中不容易分辨出故障信号与噪声信号。但这种故障引起的冲击信号往往会激起高频固有频率,在频谱上表现为出现共振带,即低频故障信号作为某高频载波的边频出现。因此,对于这种出现调制现象的故障信号,往往需要通过包络进行分析诊断。图1 包络解调机理解调前需要对信号进行滤波处理...

2021-12-14 23:01:12    互联网    443    分类:算法开发    专栏:振动信号预处理   


时间序列预测算法总结

时间序列算法time series data mining 主要包括decompose(分析数据的各个成分,例如趋势,周期性),prediction(预测未来的值),classification(对有序数据序列的feature提取与分类),clustering(相似数列聚类)等。时间序列的预测常用的思路:1、计算平均值2、exponential smoothing指数衰减...

2021-12-25 19:42:49    互联网    231    分类:算法开发    专栏:时间序列预测   


时间序列预测的8种常用方法简介

时间序列预测8种常用方法简介,包括朴素预测法、简单平均法、移动平均法、简单指数平滑法、霍尔特(Holt)线性趋势法、Holt-Winter方法、AMRIA。

2021-12-25 19:46:21    互联网    287    分类:算法开发    专栏:时间序列预测   


使用2D卷积技术进行时间序列预测

本文将展示一种新的时间序列预测方法。目标数据集在这个项目中使用的数据是来自北卡罗来纳州夏洛特分校的全球能源预测竞赛的数据。您可以在这里找到更多信息:http://www.drhongtao.com/gefcom/2017你需要知道的是,这些数据是来自能源网络的各种读数。我们的目标是利用这些数据点预测电网的实时能源需求。数据点还包括露点和干球温度,因为空调是能源消耗的主力。我们的目标变量是RTDemand(Real Time energy demand):电网的实时能源需求。数据具有清晰的日周期特征。

2021-12-25 19:54:22    互联网    261    分类:算法开发    专栏:时间序列预测   


倒谱分析与倒谱求法

倒谱分析可检测频谱中的重复模式,使其对区分多个故障非常有用,该故障在不同的主要频谱(即FFT、阶次、包络和增强频谱)中很难看到。    最重要的行业应用与机械诊断相关,如齿轮箱分析,以及其他应用,如:1 回声检测和去除2 以及语音分析    在以下网站中:http://www.bksv.cn/Products/analysis-software/signal-a

2021-12-26 13:31:12    互联网    309    分类:算法开发    专栏:振动信号预处理   


算法人必备技能-SQL/MySQL基本操作

快速入门 SQL,基本语句+函数。四个核心内容:插入、选择、更新和删除

2022-03-31 21:56:59    博客笔记    126    分类:算法开发    专栏:数据库操作   


电机状态分类预测与研究

电机状态.txt数据集中最后一列是`电机状态`标签,其余列是特征。本数据集可以作为学习工业数据的分类算法使用,(1)分析不同电机状态的特征分布情况;(2)建立分类模型体验分类算法的应用。

2022-04-20 15:00:51    博客笔记    730    分类:算法开发    专栏:故障预测与健康管理