nlp长文本分类方法需要多大的训练集文本分类 nlp

转载

mob64ca13fb1f2e 2024-01-18 22:58:24

文章标签 nlp长文本分类方法需要多大的训练集 python 机器学习人工智能结点 文章分类 NLP 人工智能

分类的目的和分类的方法

目标

能够说出项目中进行文本的目的
能够说出意图识别的方法
能够说出常见的分类的方法

1. 文本分类的目的

回顾之前的流程，我们可以发现文本分类的目的就是为了进行意图识别

在当前我们的项目的下，我们只有两种意图需要被识别出来，所以对应的是2分类的问题

可以想象，如果我们的聊天机器人有多个功能，那么我们需要分类的类别就有多个，这样就是一个多分类的问题。例如，如果希望聊天机器人能够播报当前的时间，那么我们就需要准备关于询问时间的语料，同时其目标值就是一个新的类别。在训练后，通过这个新的模型，判断出用户询问的是当前的时间这个类别，那么就返回当前的时间。

同理，如果还希望聊天机器人能够播报未来某一天的天气，那么这个机器人就还需要增加一个新的进行分类的意图，重新进行训练

2. 机器学习中常见的分类方法

在前面的机器学习的课程中我们学习了朴素贝叶斯，决策树等方法都能够帮助我们进行文本的分类，那么我们具体该怎么做呢？

2.1 步骤

特征工程：对文本进行处理，转化为能够被计算的向量来表示。我们可以考虑使用所有词语的出现次数，也可以考虑使用tfidf这种方法来处理
对模型进行训练
对模型进行评估

2.2 优化

使用机器学习的方法进行文本分类的时候，为了让结果更好，我们经常从两个角度出发

特征工程的过程中处理的更加细致，比如文本中类似你，我，他这种词语可以把它剔除；某些词语出现的次数太少，可能并不具有代表意义；某些词语出现的次数太多，可能导致影响的程度过大等等都是我们可以考虑的地方
使用不同的算法进行训练，获取不同算法的结果，选择最好的，或者是使用集成学习方法

3. 深度学习实现文本分类

前面我们简单回顾了使用机器学习如何来进行文本分类，那么使用深度学习该如何实现呢？

在深度学习中我们常见的操作就是：

对文本进行embedding的操作，转化为向量
之后再通过多层的神经网络进行线性和非线性的变化得到结果
变换后的结果和目标值进行计算得到损失函数，比如对数似然损失等
通过最小化损失函数，去更新原来模型中的参数

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

fastText实现文本分类

目标

知道fastext是什么
能够应用fasttext进行文本分类
能够完成项目中意图识别的代码

1. fastText的介绍

文档地址：https://fasttext.cc/docs/en/support.html

fastText is a library for efficient learning of word representations and sentence classification.

fastText是一个单词表示学习和文本分类的库

优点：在标准的多核CPU上，在10分钟之内能够训练10亿词级别语料库的词向量，能够在1分钟之内给30万多类别的50多万句子进行分类。

fastText 模型输入一个词的序列（一段文本或者一句话)，输出这个词序列属于不同类别的概率。

2. 安装和基本使用

2.1 安装步骤：

下载 git clone https://github.com/facebookresearch/fastText.git
cd cd fastText
安装 python setup.py install

2.2 基本使用

把数据准备为需要的格式
进行模型的训练、保存和加载、预测

#1. 训练
model = fastText.train_supervised("./data/text_classify.txt",wordNgrams=1,epoch=20)
#2. 保存
model.save_model("./data/ft_classify.model")
#3. 加载
model = fastText.load_model("./data/ft_classify.model")

textlist = [句子1，句子2]
#4. 预测，传入句子列表
ret = model.predict(textlist)

3. 意图识别实现

3.1 数据准备

数据准备最终需要的形式如下：

nlp长文本分类方法需要多大的训练集文本分类 nlp_人工智能

nlp长文本分类方法需要多大的训练集文本分类 nlp_人工智能_02

以上格式是fastText要求的格式，其中chat、QA字段可以自定义，就是目标值，__label__之前的为特征值，需要使用\t进行分隔，特征值需要进行分词，__label__后面的是目标值

3.1.1 准备特征文本

使用之前通过模板构造的样本和通过爬虫抓取的百度上的相似问题，

3.1.2 准备闲聊文本

使用小黄鸡的语料，地址：dgk_lost_conv/results at master · aceimnorstuvwxz/dgk_lost_conv · GitHub

3.1.3 把文本转化为需要的格式

对两部分文本进行分词、合并，转化为需要的格式

def prepar_data():
    #小黄鸡 作为闲聊
    xiaohaungji = "./corpus/recall/小黄鸡未分词.conv"
    handle_chat_corpus(xiaohaungji)
    # mongodb中的数据，问题和相似问题作为 问答
    handle_mongodb_corpus()

def keywords_in_line(line):
    """相似问题中去除关键字不在其中的句子
    """
    keywords_list = ["传智播客","传智","黑马程序员","黑马","python"
    "人工智能","c语言","c++","java","javaee","前端","移动开发","ui",
    "ue","大数据","软件测试","php","h5","产品经理","linux","运维","go语言",
    "区块链","影视制作","pmp","项目管理","新媒体","小程序","前端"]
    for keyword in keywords_list:
        if keyword in line:
            return True
    return False


def handle_chat_corpus(path):
    chat_num = 0
    with open("./corpus/recall/text_classify.txt","a") as f:
        for line in open(path,"r"):
            if line.strip() == "E" or len(line.strip())<1:
                continue
            elif keywords_in_line(line):
                continue
            elif line.startswith("M"):
                line = line[2:]
                line = re.sub("\s+"," ",line)
                line_cuted = " ".join(jieba_cut(line.strip())).strip()
                lable = "\t__label__{}\n".format("chat")
                f.write(line_cuted+lable)
                chat_num +=1
    print(chat_num)
    
def handle_QA_corpus():
  
    by_hand_data_path = "./corpus/recall/手动构造的问题.json" #手动构造的数据
    by_hand_data = json.load(open(by_hand_data_path))

    qa_num = 0

    f = open("./corpus/recall/text_classify.txt","a")
    for i in by_hand_data:
        for j in by_hand_data[i]:
            for x in j:
                x = re.sub("\s+", " ", x)
                line_cuted = " ".join(jieba_cut(x.strip())).strip()
                lable = "\t__label__{}\n".format("QA")
                f.write(line_cuted + lable)
                qa_num+=1

    #mogodb导出的数据
    for line in open("./corpus/recall/爬虫抓取的问题.csv"):
        line = re.sub("\s+", " ", line)
        line_cuted = " ".join(jieba_cut(line.strip()))
        lable = "\t__label__{}\n".format("QA")
        f.write(line_cuted + lable)
        qa_num += 1

    f.close()
    print(qa_num)

3.1.4 思考：

是否可以把文本分割为单个字作为特征呢？

修改上述代码，准备一份以单个字作为特征的符合要求的文本

3.2 模型的训练

import logging
import fastText
import pickle

logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.DEBUG)


ft_model = fastText.train_supervised("./data/text_classify.txt",wordNgrams=1,epoch=20)
ft_model.save_model("./data/ft_classify.model")

训练完成后看看测试的结果

ft_model = fastText.load_model("./data/ft_classify.model")

textlist = [
    # "人工智能 和 人工智障 有 啥 区别", #QA
    # "我 来 学 python 是不是 脑袋 有 问题 哦", #QA
    # "什么 是 python", #QA
    # "人工智能 和 python 有 什么 区别",  #QA
    # "为什么 要 学 python", #QA
    # "python 该 怎么 学",  #CHAT
    # "python", #QA
    "jave", #CHAT
    "php", #QA
    "理想 很 骨感 ，现实 很 丰满",
    "今天 天气 真好 啊",
    "你 怎么 可以 这样 呢",
    "哎呀 ， 我 错 了",
]
ret = ft_model.predict(textlist)
print(ret)

3.2.2 模型的准确率该如何观察呢？

观察准备去，首先需要对文本进行划分，分为训练集和测试集，之后再使用测试集观察模型的准确率

3.3 模型的封装

为了在项目中更好的使用模型，需要对模型进行简单的封装，输入文本，返回结果

这里我们可以使用把单个字作为特征和把词语作为特征的手段结合起来实现

"""
构造模型进行预测
"""
import fastText
import config
from lib import cut


class Classify:
    def __init__(self):
        self.ft_word_model = fastText.load_model(config.fasttext_word_model_path)
        self.ft_model = fastText.load_model(config.fasttext_model_path)

    def is_qa(self,sentence_info):
        python_qs_list = [" ".join(sentence_info["cuted_sentence"])]
        result = self.ft_mode.predict(python_qs_list)

        python_qs_list = [" ".join(cut(sentence_info["sentence"],by_word=True))]
        words_result = self.ft_word_mode.predict(python_qs_list)

        acc,word_acc = self.get_qa_prob(result,words_result)
        if acc>0.95 or word_acc>0.95:
            #是QA
            return True
        else:
            return False

    def get_qa_prob(self,result,words_result):
        label, acc, word_label, word_acc = zip(*result, *words_result)
        label = label[0]
        acc = acc[0]
        word_label = word_label[0]
        word_acc = word_acc[0]
        if label == "__label__chat":
            acc = 1 - acc
        if word_label == "__label__chat":
            word_acc = 1 - word_acc
        return acc,word_acc

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

fastText的原理剖析

目标

能够说出fasttext的架构
能够说出fasttext速度快的原因
能够说出fastText中层次化的softmax是如何实现的

1. fastText的模型架构

fastText的架构非常简单，有三层：输入层、隐含层、输出层（Hierarchical Softmax）

输入层：是对文档embedding之后的向量，包含有N-garm特征

隐藏层：是对输入数据的求和平均

输出层：是文档对应标签

如下图所示：

nlp长文本分类方法需要多大的训练集文本分类 nlp_nlp长文本分类方法需要多大的训练集_03

1.1 N-garm的理解

1.1.1 bag of word

nlp长文本分类方法需要多大的训练集文本分类 nlp_python_04

bag of word 又称为bow，称为词袋。是一种只统计词频的手段。

例如：在机器学习的课程中通过朴素贝叶斯来预测文本的类别，我们学习的countVectorizer和TfidfVectorizer都可以理解为一种bow模型。

1.1.2 N-gram模型

但是在很多情况下，词袋模型是不满足我们的需求的。

例如：我爱她 和她爱我在词袋模型下面，概率完全相同，但是其含义确实差别非常大。

为了解决这个问题，就有了N-gram模型，它不仅考虑词频，还会考虑当前词前面的词语，比如我爱，她爱。

N-gram模型的描述是：第n个词出现与前n-1个词相关，而与其他任何词不相关。（当然在很多场景下和前n-1个词也会相关，但是为了简化问题，经常会这样去计算）

例如：I love deep learning这个句子，在n=2的情况下，可以表示为{i love},{love deep},{deep learning}，n=3的情况下，可以表示为{I love deep},{love deep learning}。

在n=2的情况下，这个模型被称为Bi-garm（二元n-garm模型）

在n=3 的情况下，这个模型被称为Tri-garm（三元n-garm模型）

具体可以参考 ed3book chapter3

所以在fasttext的输入层，不仅有分词之后的词语，还有包含有N-gram的组合词语一起作为输入

2. fastText中的层次化的softmax-对传统softmax的优化方法1

为了提高效率，在fastText中计算分类标签的概率的时候，不再是使用传统的softmax来进行多分类的计算，而是使用的哈夫曼树(Huffman，也成为霍夫曼树),使用层次化的softmax（Hierarchial softmax）来进行概率的计算。

2.1 哈夫曼树和哈夫曼编码

nlp长文本分类方法需要多大的训练集文本分类 nlp_python_05

2.1.1 哈夫曼树的定义

哈夫曼树概念：给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。

哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

2.1.2 哈夫曼树的相关概念

二叉树：每个节点最多有2个子树的有序树，两个子树分别称为左子树、右子树。有序的意思是：树有左右之分，不能颠倒

叶子节点：一棵树当中没有子结点的结点称为叶子结点，简称“叶子”

路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。

结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。

树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和

树的高度：树中结点的最大层次。包含n个结点的二叉树的高度至少为log2 (n+1)。

2.1.3 哈夫曼树的构造算法

把看成n棵树的森林
在森林中选择两个根节点权值最小的树进行合并，作为一颗新树的左右子树，新树的根节点权值为左右子树的和
删除之前选择出的子树，把新树加入森林
重复2-3步骤，直到森林只有一棵树为止，概树就是所求的哈夫曼树

例如：圆圈中的表示每个词语出现的次数，以这些词语为叶子节点构造的哈夫曼树过程如下：

nlp长文本分类方法需要多大的训练集文本分类 nlp_机器学习_06

可见：

权重越大，距离根节点越近
叶子的个数为n，构造哈夫曼树中新增的节点的个数为n-1

2.2.1 哈夫曼编码

在数据通信中，需要将传送的文字转换成二进制的字符串，用0，1码的不同排列来表示字符。

例如，需传送的报文为AFTER DATA EAR ARE ART AREA，这里用到的字符集为A，E，R，T，F，D，各字母出现的次数为{8，4，5，3，1，1}。现要求为这些字母设计编码。要区别6个字母，最简单的二进制编码方式是等长编码，固定采用3位二进制，可分别用000、001、010、011、100、101对A，E，R，T，F，D进行编码发送

但是很明显，上述的编码的方式并不是最优的，即整理传送的字节数量并不是最少的。

为了提高数据传送的效率，同时为了保证任一字符的编码都不是另一个字符编码的前缀，这种编码称为前缀编码[前缀编码],可以使用哈夫曼树生成哈夫曼编码解决问题

可用字符集中的每个字符作为叶子结点生成一棵编码二叉树，为了获得传送报文的最短长度，可将每个字符的出现频率作为字符结点的权值赋予该结点上，显然字使用频率越小权值越小，权值越小叶子就越靠下，于是频率小编码长，频率高编码短，这样就保证了此树的最小带权路径长度效果上就是传送报文的最短长度

因此，求传送报文的最短长度问题转化为求由字符集中的所有字符作为叶子结点，由字符出现频率作为其权值所产生的哈夫曼树的问题。利用哈夫曼树来设计二进制的前缀编码，既满足前缀编码的条件，又保证报文编码总长最短。

下图中label1 .... label6分别表示A，E，R，T，F，D

nlp长文本分类方法需要多大的训练集文本分类 nlp_机器学习_07