NLP学习笔记-FastText文本分类（四）

分类的目的和分类的方法

1. 文本分类的目的

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

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

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

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

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

朴素贝叶斯，决策树等方法都能够帮助进行文本的分类

2.1 步骤

机器学习

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

2.2 优化

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

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

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

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

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

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 安装步骤：

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

2.2 基本使用

1. 把数据准备为需要的格式

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 数据准备

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

word word \t __label__QA

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

3.1.1 准备特征文本

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

3.1.2 准备闲聊文本

使用小黄鸡的语料，地址：
https://github.com/fateleak/dgk_lost_conv/tree/master/results

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", encoding='utf-8') 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(str(word).strip() for word in line_cuted) + '\t' + '__label__chat'
                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")

build.py 实现模型的训练和加载

import fasttext
import config

def build_classify_model():
    model = fasttext.train_supervised(config.classify_corpus_path, epoch = 20,wordNgrams = 1, minCount = 5)
    model.save_model(config.classify_model_path)


def get_classify_model():
    """加载模型"""
    model = fasttext.load_model(config.classify_model_path)
    return 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)

test_classify.py 进行模型测试

"""测试分类相关API"""
from classify.build_model import build_classify_model, get_classify_model
from pprint import pprint


if __name__ == '__main__':
    # build_classify_model()
    model = get_classify_model()
    test = [
        '你 吃饭 了 么',
        '今天 天气 非常 好',
        'python',
        'python 好 学 么'
    ]
    ret = model.predict(test)
    pprint(ret)

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

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

build_classify_corpus.py 实现文本划分，训练集和测试集按4:1划分

from lib import cut
import config
from tqdm import tqdm
import json
import random

# 闲聊语料
xiaohuangji_path = r'E:\chatservice\corpus\classify\小黄鸡未分词.conv'
# QA语料
shoudong_path = r'E:\chatservice\corpus\classify\手动构造的问题.json'
spider_path = r'E:\chatservice\corpus\classify\爬虫抓取的问题.csv'

flags = [0, 0, 0, 0, 1]  # 切分数据集标签，切分为4:1,即1/5的数据作为测试集


# 判断line中是否存在不符合要求的词
def keywords_in_line(line):
    keywords_list = ["传智播客","传智","黑马程序员","黑马","python"
    "人工智能","c语言","c++","java","javaee","前端","移动开发","ui",
    "ue","大数据","软件测试","php","h5","产品经理","linux","运维","go语言",
    "区块链","影视制作","pmp","项目管理","新媒体","小程序","前端"]
    for keyword in line:
        if keyword in keywords_list:
            return True
    return False


def process_xiaohuangji(file_train, file_test):
    num_train = 0  # 统计训练集
    num_test = 0  # 统计测试集
    for line in tqdm(open(xiaohuangji_path, encoding='utf-8').readlines(),ascii = True, desc= '小黄鸡语料'):
        if line.startswith('E'):
            flag = 0  # 标记是否为第一个
            continue
        elif line.startswith('M'):
            if flag == 0:  # 第一个M出现
                line = line[1:].strip()
                flag = 1
            else:
                continue  # 不需要第二个M开头的句子
        # 构造fasttext格式  word word \t __label__chat
        line_cuted = cut(line)
        if not keywords_in_line(line_cuted):
            line_cuted = ' '.join(line_cuted) + '\t' + '__label__chat'
            # 进行数据集划分
            if random.choice(flags) == 0:
                num_train += 1
                file_test.write(str(line_cuted) + '\n')
            else:
                num_test += 1
                file_train.write(str(line_cuted) + '\n')
    return num_train, num_test


# 定义手动处理数据方法
def process_byhand_dada(file_train, file_test):
    # {key,[[a,b,c],[d,e,f,],....]}
    total_lines = json.loads(open(shoudong_path, encoding='utf-8').read())
    num_train = 0  # 统计训练集
    num_test = 0  # 统计测试集
    for key in tqdm(total_lines,desc='手动获取数据：'):
        for lines in total_lines[key]:
            for line in lines:
                # 构造fasttext格式  word word \t __label__chat
                line_cuted = cut(line)
                if '校区' in line:
                    continue
                line_cuted = ' '.join(line_cuted) + '\t' + '__label__QA'
                if random.choice(flags) == 0:
                    num_train += 1
                    file_test.write(str(line_cuted) + '\n')
                else:
                    num_test += 1
                    file_train.write(str(line_cuted) + '\n')
    return num_train, num_test

# 定义爬虫爬取数据处理方法
def process_crawed_data(file_train, file_test):
    num_train = 0  # 统计训练集
    num_test = 0  # 统计测试集
    for line in tqdm(open(spider_path,encoding='utf-8').readlines(), desc = '爬虫爬取：'):
        # 构造fasttext格式  word word \t __label__chat
        line_cuted = cut(line)
        line_cuted = ' '.join(line_cuted) + '\t' + '__label__chat'
        if random.choice(flags) == 0:
            num_train += 1
            file_test.write(str(line_cuted) + '\n')
        else:
            num_test += 1
            file_train.write(str(line_cuted) + '\n')
    return num_train, num_test


# 调用
def process():
    # with open(config.classify_corpus_path, 'a', encoding='utf-8') as f:
    f_train = open(config.classify_corpus_train_path, 'a', encoding = 'utf-8')
    f_test = open(config.classify_corpus_test_path, 'a', encoding = 'utf-8')

    # 1.处理小黄鸡
    num_chat_train, num_chat_test = process_xiaohuangji(f_train, f_test)
    # 2.处理手动构造的句子
    num_qa_hd_train, num_qa_hd_test = process_byhand_dada(f_train, f_test)
    # 3.处理爬虫抓取的句子
    num_qa_sp_train, num_qa_sp_test = process_crawed_data(f_train, f_test)

    f_train.close()
    f_test.close()
    # 统计语料数量
    print('小黄鸡语料中：num_chat = %d, num_chat_train = %d, num_chat_test = %d' % (num_chat_train+num_chat_test,num_chat_train, num_chat_test))
    print('手动处理中：num_qa_hd = %d, num_qa_hd_train = %d, num_qa_hd_test = %d' % (num_qa_hd_train+num_qa_hd_train,num_qa_hd_train,num_qa_hd_test))
    print('爬虫获取中：num_qa_sp = %d, num_qa_sp_train = %d, num_qa_sp_test = %d' % (num_qa_sp_train + num_qa_sp_train, num_qa_sp_train, num_qa_sp_test))
    print('QA_train = %d, QA_test = %d' % (num_qa_hd_train + num_qa_sp_train, num_qa_hd_train + num_qa_sp_train))
    print('训练集 %d , 测试集 %d ' % (num_qa_hd_train + num_qa_sp_train + num_chat_train, num_qa_hd_train + num_qa_sp_train + num_chat_test))

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

"""
意图识别模型的封装
"""
import config
import fasttext


class Classify(object):
    def __init__(self):
        """
        加载训练好的模型
        """
        self.model = fasttext.load_model(config.classify_model_final_path)  # 词特征模型
        self.model_by_word = fasttext.load_model(config.classify_model_final_by_word_path)  # 单字特征模型

    def predict(self, sentence_cuted):
        """
        预测输入数据结果,准确率
        :param sentence_cuted: {'cut_by_word':str, 'cut':str}
        :return: (label, acc)
        """

        # label, acc = self.model.predict(sentence_cuted)
        # label_by_word, acc_by_word = self.model_by_word.predict(sentence_cuted)
        result1 = self.model.predict(sentence_cuted['cut'])
        result2 = self.model_by_word.predict(sentence_cuted['cut_by_word'])
        # *(), 拆包
        for label, acc, label_by_word, acc_by_word in zip(*result1, *result2):
            # 将所有label 和 acc 转换到chat上比较其准确率
            if  label == '__label__chat':
                label = '__label__QA'
                acc = 1 - acc
            if label_by_word == '__label__chat':
                label_by_word = '__label__QA'
                acc_by_word = 1 - acc_by_word

            # 判断准确率--意图判别
            if acc > 0.95 and acc_by_word > 0.95:  # 设置阈值
                return ('QA', max(acc, acc_by_word))
            else:
                return ('chat', 1 - min(acc, acc_by_word))

            # # 假设有3个类别
            # if label == label_by_word:
            #     if acc > 0.95 or acc_by_word > 0.95:
            #         return label, max(acc, acc_by_word)
            #     else:
            #         return None, 0  # 无法获取其分类意图,或不符合阈值要求
            # else:
            #     if acc_by_word > 0.99:  # 返回单字模型预测结果
            #         return label_by_word, acc_by_word
            #     elif acc > 0.98:  # 返回词语模型返回的结果
            #         return  label, acc
            #     else:
            #         return None, 0

fastText的原理剖析

1. fastText的模型架构

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

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

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

输出层：是文档对应标签

如下图所示：

1.1 N-garm的理解

1.1.1 bag of word

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 哈夫曼树和哈夫曼编码

2.1.1 哈夫曼树的定义

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

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

2.1.2 哈夫曼树的相关概念

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

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

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

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

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

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

2.1.3 哈夫曼树的构造算法

1. 把 { W 1 , W 2 , W 3 … W n } ​ \{W_1,W_2,W_3 \dots W_n\}​ {W1​,W2​,W3​…Wn​}​看成n棵树的森林
2. 在森林中选择两个根节点权值最小的树进行合并，作为一颗新树的左右子树，新树的根节点权值为左右子树的和
3. 删除之前选择出的子树，把新树加入森林
4. 重复2-3步骤，直到森林只有一棵树为止，概树就是所求的哈夫曼树

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

可见：

1. 权重越大，距离根节点越近
2. 叶子的个数为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进行编码发送

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

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

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

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

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

2.3 梯度计算

上图中，红色为哈夫曼编码，即label5的哈夫曼编码为1001，那么此时如何定义条件概率$P(Label5|contex)$呢？

以Label5为例，从根节点到Label5中间经历了4次分支，每次分支都可以认为是进行了一次2分类，根据哈夫曼编码，可以把路径中的每个非叶子节点0认为是负类，1认为是正类（也可以把0认为是正类）

由机器学习课程中逻辑回归使用sigmoid函数进行2分类的过程中，一个节点被分为正类的概率是$\delta (X^T\theta )=\frac{1}{1+e^{-X^T\theta }}$,被分类负类的概率是：$1-\delta (X^T\theta )$，其中$\theta$就是图中非叶子节点对应的参数$\theta$。

对于从根节点出发，到达Label5一共经历4次2分类，将每次分类结果的概率写出来就是：

1. 第一次：
   $$P(1|X,{\theta }_1)=\delta (X^T{\theta }_1)$$
   即从根节点到23节点的概率是在知道X和${\theta }_1$的情况下取值为1的概率
2. 第二次：$$P(0|X,{\theta }_2)=1-\delta (X^T{\theta }_2)$$
3. 第三次：$$P(0|X,{\theta }_3)=1-\delta (X^T{\theta }_4)$$
4. 第四次：$$P(1|X,{\theta }_4)=\delta (X^T{\theta }_4)$$

但是我们需要求的是$P(Label|contex)$, 他等于前4词的概率的乘积，公式如下（$d_j^w$是第j个节点的哈夫曼编码）
$$P(Label|context)=\prod _{j=2}^{5}P(d_j|X,{\theta }_{j-1})$$

其中：
$$P(d_j|X,{\theta }_{j-1})=\{\begin{array}{rlr}& \delta (X^T{\theta }_{j-1}),& d_j=1;\\ & 1-\delta (X^T{\theta }_{j-1})& d_j=0;\end{array}$$

或者也可以写成一个整体,把目标值作为指数，之后取log之后会前置：
$$P(d_j|X,{\theta }_{j-1})=[\delta (X^T{\theta }_{j-1}){]}^{d_j}\cdot [1-\delta (X^T{\theta }_{j-1}){]}^{1-d_j}$$

在机器学习中的逻辑回归中，我们经常把二分类的损失函数(目标函数)定义为对数似然损失，即
$$l=-\frac{1}{M}\sum _{label\in labels}logP(label|context)$$

式子中，求和符号表示的是使用样本的过程中，每一个label对应的概率取对数后的和，之后求取均值。

带入前面对$P(label|context)$的定义得到：

有了损失函数之后，接下来就是对其中的$X,\theta$进行求导，并更新，最终还需要更新最开始的每个词语词向量

层次化softmax的好处：传统的softmax的时间复杂度为L（Labels的数量），但是使用层次化softmax之后时间复杂度的log(L) （二叉树高度和宽度的近似），从而在多分类的场景提高了效率

3. fastText中的negative sampling(负采样)-对传统softmax的优化方法2

negative sampling，即每次从除当前label外的其他label中，随机的选择几个作为负样本。

具体的采样方法：

如果所有的label为$V$,那么我们就将一段长度为1的线段分成$V$份，每份对应所有label中的一类label。当然每个词对应的线段长度是不一样的，高频label对应的线段长，低频label对应的线段短。每个label的线段长度由下式决定：
$$len(w)=\frac{count(label{)}^{\alpha }}{{\sum }_{w\in labels}count(labels{)}^{\alpha }}$$a在fasttext中为0.75，即负采样的数量和原来词频的平方根成正比

在采样前，我们将这段长度为1的线段划分成$M$等份，这里$M>>V$，这样可以保证每个label对应的线段都会划分成对应的小块。而M份中的每一份都会落在某一个label对应的线段上。在采样的时候，我们只需要从$M$个位置中采样出neg个位置就行，此时采样到的每一个位置对应到的线段所属的词就是我们的负例。

简单的理解就是，从原来所有的样本中，等比例的选择neg个负样本作（遇到自己则跳过），作为训练样本，添加到训练数据中，和正例样本一起来进行训练。

Negative Sampling也是采用了二元逻辑回归来求解模型参数，通过负采样，我们得到了neg个负例，将正例定义为$labe{l}_0$,负例定义为$labe{l}_i,i=1,2,3...neg$

定义正例的概率为$P\left(labe{l}_0|\text{context}\right)=\sigma \left(x_{\mathrm{k}}^T\theta \right),y_i=1$

则负例的概率为：$P\left(labe{l}_i|\text{context}\right)=1-\sigma \left(x_{\mathrm{k}}^T\theta \right),y_i=0,i=1,2,3..neg$

此时对应的对数似然函数为：
$$L=\sum _{i=0}^{neg}{y}_i\log \left(\sigma \left(x_{labe{l}_0}^T\theta \right)\right)+\left(1-y_i\right)\log \left(1-\sigma \left(x_{labe{l}_0}^T\theta \right)\right)$$
具体的训练时候损失的计算过程(源代码已经更新)：

可以看出：一个neg+1个样本进行了训练，得到了总的损失。

之后会使用梯度上升的方法进行梯度计算和参数更新，仅仅每次只用一波样本(一个正例和neg个反例)更新梯度，来进行迭代更新

具体的更新伪代码如下:

其中内部大括号部分为w相关参数的梯度计算过程，e为w的梯度和学习率的乘积
具体参考

好处：

1. 提高训练速度，选择了部分数据进行计算损失，同时整个对每一个label而言都是一个二分类，损失计算更加简单，只需要让当前label的值的概率尽可能大，其他label的都为反例，概率会尽可能小
2. 改进效果，增加部分负样本，能够模拟真实场景下的噪声情况，能够让模型的稳健性更强