NLP及推荐课程总结

AI Studio用户名：FutureSI

• NLP课程中，我学习了如何使用CBOW算法和skip-gram算法把word给embedding成vector，即把词嵌入成特定维度的向量。开始自己手写的模型始终运行不是很理想（当时真的不开心），与用ERNIE预训练模型的效果差太多了（也很正常）。后来我甚至想抽取小规模（比如十来个常用词）的高频词组成小批语料在“可控、可理解”的场景下测试调整手写模型。但后来，我觉得要理解模型，还是应该从弄清每一个理论细节着手，然后由简入繁进行试验。这是深度学习课，不是编程课。即使每行代码都能读明白，不了解理论的话还是睁眼瞎。当然，只要理论理解透彻，数据分布没有问题，结果是一定能复现的。至此我才觉得云开雾散，前路豁然开朗。在实现CBOW算法时，我做余弦相似度计算的过程走了一些弯路。开始我用scikit-learn库算计算两个向量的余弦相似度时，程序执行两、三个batch就会报错。然后，我又直接用python按公式手写函数计算余弦相似度，程序可以执行，但是速度超级慢。后来听推荐课时，我发现原来paddle自带余弦相似度计算函数。以后要用什么函数，我还是先查paddle手册吧，能节省不少时间。（后来我在文档上查kmeans聚类功能，没有找到，还是用的scikit-learn库。要是paddle把这些机器学习中常用的基本算法都集成就更美好了。）
• 这次的标题文本分类比赛，由于nlp初学，我主要熟悉了下paddle hub的使用，了解了下联合训练，而且头一次发现用大量的数据训练一轮就得半天，跑模型一天也就训练两轮。这时就用得让paddle slim帮忙了。因为忙于写作业、学习理论细节，比赛我就站在场内捧着油瓶给大佬们加油了。在此要向吕坤大佬致敬，赞赏他在上次“AI识虫”比赛的出色表现和开源精神。
• 在个性化推荐课程里，我发现毕老师讲课更风趣了。尤其是课程中毕老师津津乐道的万物embedding的思想（把各种feature给embedding到模型中，然后为所欲为）让我大开脑回路，yy了好多有趣的玩法。而且，原来在cv课上学习yolo v3目标检测模型时，我对将图片的分类feature和选择锚框的回归的feature给拼接在一起的操作感到很突兀。尤其是，loss也被这样“硬给”加和在了一起用来优化模型更是让我满头问号，觉得：“这也能行？为啥能行？”学了毕老师的推荐课我领会到，原来这个是老司机们玩儿深度学习的标准操作——把一切问题“翻译”成标准的向量，然后再让模型去解决这些标准向量的分类、回归等问题。
• 总体感觉这次的NLP及推荐课程是作业多多（可能是个人初学，所以作业写得慢）、收获满满。NLP和推荐系统几个作业程序写下来，我感觉自己炼丹大法的修为又精进了一重——进入了embedding境界。其实CV和NLP没有我原来想象的那么不同。现在，我理解CV使用的卷积网络本质上也就是一种把图像、视频信息给转换为向量的Embedding操作。所以无论CV问题还是NLP或是其他问题，我们都是将数据embedding到向量，然后就通过标准的分类、回归算法训练网络参数了。通过这期课程，我也进一步熟悉了paddle hub以及ERNIE预训练模型的使用。如果越用越上手，希望自己不会越来越懒哈。我还是希望能像吕坤大佬那样开心的玩耍模型。
• 最后诚挚感谢各位老师们、班主任、运维等伙伴们，还有我自己（是的，自己也要感谢一下）的辛苦努力。希望paddle框架闪闪发光，AI Studio平台、社区越来越强。

AI Studio用户名：寂寞你快进去

作业1-1：

（1）截图已发给班主任

（2）

import paddlehub as hub
import jieba
jieba.enable_paddle()

lac = hub.Module(name="lac")
test_text = [您将创建一个数组，它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例]

for str in test_text:

    result = lac.lexical_analysis(data={"text": [str]})
    print('/'.join(list(result[0]['word'])))

    seg_list = jieba.cut(str,use_paddle=True) # 使用paddle模式
    print('/'.join(list(seg_list)))
    
    seg_list = jieba.cut(str)
    print('/'.join(list(seg_list)))  # 默认是精确模式

（3）使用jieba分词全模式

import os
import math
import jieba


dir_path = "/Users/luolvgen/project/nlp_course/datas/rmrb"

word_dict = dict()
total = 0

for exapmle_file in os.listdir(dir_path):
with open(os.path.join(dir_path, exapmle_file), "r") as file:
content = file.read()
seg_list = jieba.cut(content, cut_all=True)
for word in seg_list:
if len(word) == 0:
continue
if word not in word_dict:
word_dict[word] = 0
word_dict[word] += 1
total += 1


def cal_entropy(words_p, total):
entropy = 0
for word, p in words_p.iteritems():
p = p * 1.0 / total
entropy -= p * math.log(p)
return entropy


print("信息熵: %s" % cal_entropy(word_dict, total))

 信息熵：8.038373285989232

作业1-2：

（1）时间复杂度为O（N*M^2）

（2）

import jieba

seg_list = jieba.cut_for_search("在 C 中，您可以逐个初始化数组，也可以使用一个初始化语句") 

print(", ".join(seg_list))

（3）
  1.LSTM
  2.隐马尔可夫模型
  3.Bert
  4.ERNIE

1-1   .1  已发截图

1-1 .2

1-1.3

1-2.1  计算复杂度为O(NM^2)

1-2   .2 给定一个句子，如何计算里面有多少种分词候选，你能给出代码实现吗？

窃取：

str = '中国人民万岁'
dict=['中','国','人','民','万','岁','中国','国民','中国人','万岁','中国人民']
def text_count(text, word, dict):
    if len(word) == 0:
        print('/'.join(text))
        return 1
    count = 0
   
    for i in range(1, len(word) + 1):
        if word[:i] not in dict:
            continue
        count += text_count(text + [word[:i]], word[i:], dict)
    return count

candidate = text_count([], str, dict)

print("候选:", candidate)

1-2 .3 HMM，朴素贝叶斯、SVM支持向量机、CRF条件随机场

1-1   .1  已发截图

1-1 .2

1-1.3

1-2.1  计算复杂度为O(NM^2)

1-2   .2 给定一个句子，如何计算里面有多少种分词候选，你能给出代码实现吗？

窃取：

str = '中国人民万岁'
dict=['中','国','人','民','万','岁','中国','国民','中国人','万岁','中国人民']
def text_count(text, word, dict):
    if len(word) == 0:
        print('/'.join(text))
        return 1
    count = 0
   
    for i in range(1, len(word) + 1):
        if word[:i] not in dict:
            continue
        count += text_count(text + [word[:i]], word[i:], dict)
    return count

candidate = text_count([], str, dict)

print("候选:", candidate)

1-2 .3 HMM，朴素贝叶斯、SVM支持向量机、CRF条件随机场

Ai Studio 用户名: DevF

1-1

1

2

3

1-2

1

O(N×M2)

2

3

HMM方法

端到端的方法

AI Studio用户名：东南林美

作业1-1

（1）已发班主任

（2）

（3）

作业1-2：
（1）以完成一次词表遍历为单位时间，则t=O(N*(M+M-1+M-2+…+1))=O(N*M^2) 。
（2）参照其他同学的思想，关键在于找出这个句子有多少种拆分方法。
（3）基于词典的方法除了前向最大匹配算法MM还有:逆向最大匹配算法RMM和双向最大匹配法BMM。
基于统计的方法除了N-gram还有HMM。
RMM：该算法是正向最大匹配的逆向思维，匹配不成功，将匹配字段的最前一个字去掉，实验表明，逆向最大匹配算法要优于正向最大匹配算法。
BMM：双向最大匹配法是将正向最大匹配法得到的分词结果和逆向最大匹配法的到的结果进行比较，从而决定正确的分词方法。
HMM：是关于时序的概率模型， 描述由一个隐藏的马尔可夫链随机生成不可观察的状态序列，再有状态序列生成一个观测序列的过程。

AI Studio用户名：夕岚

作业1-1

（1）

（2）

（3）

作业1-2：

（1）O(MaxLen(word) * N)

每次从词表的最长词长开始，最大前向匹配最坏的情况：句子分词结果为单个字，并且每个字都需要遍历词表全部。

（2）
import jieba
seg = jieba.cut("干一行行一行，一行不行行行不行", cut_all=True)
seg_list = list(seg)
print('分词个数： ', len(seg_list), '\n候选分词： ', seg_list)分词个数： 13
候选分词： ['干一行', '一行', '一行行', '行行', '一行', '，', '一行', '行不行', '不行', '行行', '行行', '行不行', '不行']

（3）

1 隐马尔可夫模型：HMM模型认为在解决序列标注问题时存在两种序列，一种是观测序列，即人们显性观察到的句子，而序列标签是隐状态序列，即观测序列为X，隐状态序列是Y，因果关系为Y->X。因此要得到标注结果Y，必须对X的概率、Y的概率、P(X|Y)进行计算，即建立P(X,Y)的概率分布模型。

2. CRF算法: 对语料采用BIO/BI/BIOE任意一种标注，作为训练语料，一些分词器在早些时候采用这种方式和规则训练分词模型

AI Studio  用户名：zhangyabkun

作业1-1：（1）（2）如图片所示，使用LAC分词

（3）

import jieba
import math
string=''
fin=open('report','rt')
while True:
     line=fin.readline()
     if not line:
         break
     string+=line
fin.close()
word_fre=dict()
jieba.enable_paddle()# 启动paddle模式。 0.40版之后开始支持，早期版本不支持
seg_list=jieba.cut(string,use_paddle=True)
for word in seg_list:#对每个词的数量进行统计
     if word not in word_fre:
         word_fre[word]=0
     word_fre[word]+=1
word_num=len(word_fre)
entropy=0
for i in word_fre:
     p=word_fre[i]/word_num#统计概率
     entropy+=-p*math.log(p,2)
print(entropy)

对1946-05-15进行分词得到其信息熵为11.650444730765923

作业1-2：

（1）假设最大匹配的词的长度为max，则算法复杂度为O（max*M）

（2）str='南京市长江大桥'

l=jieba.lcut(str,cut_all=True)

num=len(l)

(3)基于HMM的分词  基于CRF的分词  基于深度学习的分词

可以通过音箱的连续对话模式，诱导幼儿对某一特定话题进行对话，从而考察期词汇量。

AI Studio用户名：FutureSI
作业2 附加题 打开脑洞，尝试各种embedding花样玩法

• 家里有小度智能音箱.孩子平时挺喜欢玩.我也写技能给孩子用.dueros能将语音信息转换为文本资料.我想能不能用word2vector的模型做评价幼儿词汇丰富程度的技能,甚至可以进而评价幼儿的语言能力.

AI Studio用户名：FutureSI
作业2 附加题 打开脑洞，尝试各种embedding花样玩法

• 记得上学时玩过一个叫colorgenics的网页应用,其通过让用户点击屏幕上8个不同颜色的立方体,根据用户点击的顺序判断用户当时的心理状态.准不准的反正当时觉得挺好玩,毕竟做这个网站的是个在米国职业的心理医师.我就想词向量模型可不可以做类似的好玩儿的应用.比如通过输入一个人的微信或博客的文本资料,统计个人的口头禅,并进一步通过公开的数据集或模型进行迁移学习,分析个人的性格倾向,如乐观程度、积极程度、文明用语水平等。当然应用背后有心理学模型支撑才称得上“科学”，这个应用主要是好玩。

• AI Studio用户名：FutureSI
  作业2
  请尝试用飞桨实现一个CBOW模型，并使用text8语料进行训练（或尝试提高skip-gram的训练速度）
• CBOW的代码在原来skip-gram代码基础上主要做了两处修改:
  1.build_data()函数返回的dataset从（中心词，上下文词正/负的样本，label）的三元组改为（上下文词，中心词正/负样本，label）的三元组。

#构造数据，准备模型训练
#max_window_size代表了最大的window_size的大小，程序会根据max_window_size从左到右扫描整个语料
#negative_sample_num代表了对于每个正样本，我们需要随机采样多少负样本用于训练，
#一般来说，negative_sample_num的值越大，训练效果越稳定，但是训练速度越慢。 
def build_data(corpus, word2id_dict, max_window_size = 3, 
               negative_sample_num = 3):
    
    #使用一个list存储处理好的数据
    dataset = []
    
    #corpus = corpus[:1000000]
    #corpus = corpus[:1000]
    #从左到右，开始枚举每个中心点的位置
    for center_word_idx in range(len(corpus)):
        #以max_window_size为上限，随机采样一个window_size，这样会使得训练更加稳定
        #window_size = random.randint(1, max_window_size)
        window_size = max_window_size
        #当前的中心词就是center_word_idx所指向的词
        center_word = corpus[center_word_idx]

        #以当前中心词为中心，左右两侧在window_size内的词都可以看成是正样本
        positive_word_range = (max(0, center_word_idx - window_size), min(len(corpus) - 1, center_word_idx + window_size))
        positive_word_candidates = [corpus[idx] for idx in range(positive_word_range[0], positive_word_range[1]+1) if idx != center_word_idx]
        if center_word_idx % 100000 == 0:
            print(center_word_idx, window_size, center_word, positive_word_range, positive_word_candidates)
        #对于每个正样本来说，随机采样negative_sample_num个负样本，用于训练
        for positive_word in positive_word_candidates:
            #首先把（中心词，正样本，label=1）的三元组数据放入dataset中，
            #这里label=1表示这个样本是个正样本
            #dataset.append((center_word, positive_word, 1))
            dataset.append((positive_word, center_word, 1))

            #开始负采样
            i = 0
            while i < negative_sample_num:
                negative_word_candidate = random.randint(0, vocab_size-1)

                if negative_word_candidate not in positive_word_candidates:
                    #把（中心词，正样本，label=0）的三元组数据放入dataset中，
                    #这里label=0表示这个样本是个负样本
                    #dataset.append((center_word, negative_word_candidate, 0))
                    dataset.append((positive_word, negative_word_candidate, 0))
                    i += 1
    
    return dataset

dataset = build_data(corpus, word2id_dict)
for _, (center_word, target_word, label) in zip(range(100), dataset):
    #print("center_word %s, target %s, label %d" % (id2word_dict[center_word],id2word_dict[target_word], label))
    print("context_word %s, target %s, label %d" % (center_word,target_word, label))

• 2.修改forward()正向计算函数.其实因为输入数据的格式和skip-gram是一样的,所以模型的网络结构是无需改动的.在此处将两个词的点乘改为计算余弦相似度是为了增进模型的效率.

        word_sim = fluid.layers.elementwise_mul(center_words_emb, target_words_emb)
        word_sim = fluid.layers.reduce_sum(word_sim, dim = -1)
        a = fluid.layers.elementwise_mul(center_words_emb, center_words_emb)
        a = fluid.layers.reduce_sum(a, dim = -1)
        a = fluid.layers.sqrt(a)
        b = fluid.layers.elementwise_mul(target_words_emb, target_words_emb)
        b = fluid.layers.reduce_sum(b, dim = -1)
        b = fluid.layers.sqrt(b)
        word_sim = word_sim / a / b

补充作业内容，语料计算的信息熵为：8.3472

AIstudio 用户名：Hi_Boy022

作业1-1:

切词模型我选用LAC模型，选取的人民日报的第一个语料，

jieba切词的前20个结果：

'为', '七百万', '人民', '请命', '李庄', '一', '毁灭', '与', '新生', '四月', '九日', '五辆', '吉普车', '载', '着', '黄河', '勘察', '团', '从', '荷泽'

作业1-2:

（1）：按照句子中每一个词匹配的最坏情况，计算复杂度为O(N*M)

（3）：最短路径分词算法——最短路径分词算法首先将一句话中的所有词匹配出来，构成词图（有向无环图DAG），之后寻找从起始点到终点的最短路径作为最佳组合方式

参考来源：https://zhuanlan.zhihu.com/p/50444885

AI Studio用户名：蓝路白

作业1-1：

（1）下载飞桨本地并安装成功,将截图发给班主任

（2）学习使用PaddleNLP下面的LAC模型或Jieba分词

# encoding=utf-8
import jieba

jieba.enable_paddle()  # 启动paddle模式。 0.40版之后开始支持，早期版本不支持
strs = ["我来到北京清华大学", "乒乓球拍卖完了", "中国科学技术大学"]
for str in strs:
    seg_list = jieba.cut(str, use_paddle=True)  # 使用paddle模式
    print("Paddle Mode: " + '/'.join(list(seg_list)))

seg_list = jieba.cut("我来到北京清华大学", cut_all=True)
print("Full Mode: " + "/ ".join(seg_list))  # 全模式

seg_list = jieba.cut("我来到北京清华大学", cut_all=False)
print("Default Mode: " + "/ ".join(seg_list))  # 精确模式

seg_list = jieba.cut("他来到了网易杭研大厦")  # 默认是精确模式
print(", ".join(seg_list))

seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所，后在日本京都大学深造")  # 搜索引擎模式
print(", ".join(seg_list))

Paddle Mode: 我/来到/北京清华大学

Paddle Mode: 乒乓球/拍卖/完/了

Paddle Mode: 中国科学技术大学

Full Mode: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学

Default Mode: 我/ 来到/ 北京/ 清华大学

他, 来到, 了, 网易, 杭研, 大厦

小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, ，, 后, 在, 日本, 京都, 大学, 日本京都大学, 深造

（3）对人民日报语料完成切词，并通过统计每个词出现的概率，计算信息熵

# encoding=utf-8
import jieba
import numpy as np


def load_data(file_name):
    with open(file_name, encoding='gbk') as f:
        content = f.read().strip('\n')
    f.close()
    return content


def calc_shannon_ent(data):
    numData = len(data)
    unique_data, counts = np.unique(np.array(data), return_counts=True)
    prob = counts / numData
    shannon_ent = -(np.sum(prob * np.log2(prob)))
    return shannon_ent


if __name__ == '__main__':
    content = load_data('rmrb19640515.txt')
    seg_list = jieba.cut(content, use_paddle=True)
    shannon_ent = calc_shannon_ent(list(seg_list))
    print(len(content))
    print("信息熵：", shannon_ent)

3305
信息熵： 8.094496950793541

作业1-2：

（1）思考一下，假设输入一个词表里面含有N个词，输入一个长度为M的句子，那么最大前向匹配的计算复杂度是多少？

最大前向匹配的计算复杂度是O(N*M*M)。假设单词的最大长度为M，首先将M整个取出与词表中的N个词匹配，匹配失败，每次去掉匹配字段最后面的一个字，继续匹配；匹配成功后，去掉匹配成功的字段，一轮计算复杂度为N*M；直到匹配字段长度为0，结束。在最坏情况下，需要匹配M轮，因此计算复杂度为O(N*M*M)。

（2）给定一个句子，如何计算里面有多少种分词候选，你能给出代码实现吗？

import jieba
seg = jieba.cut("乒乓球拍卖完了", cut_all=True)
seg_list = list(seg)
print('分词个数： ', len(seg_list), '\n候选分词： ', seg_list)

分词个数：  7

候选分词：  ['乒乓', '乒乓球', '乒乓球拍', '球拍', '拍卖', '卖完', '了']

（3）除了最大前向匹配和N-gram算法，你还知道其他分词算法吗，请给出一段小描述。

HMM隐马尔可夫算法：HMM模型认为在解决序列标注问题时存在两种序列，一种是观测序列，即人们显性观察到的句子，而序列标签是隐状态序列，即观测序列为X，隐状态序列是Y，因果关系为Y->X。因此要得到标注结果Y，必须对X的概率、Y的概率、P(X|Y)进行计算，即建立P(X,Y)的概率分布模型。

CRF条件随机场：CRF可以看作一个无向图模型，对于给定的标注序列Y和观测序列X，对条件概率P(Y|X)进行定义，而不是对联合概率建模。CRF可以说是目前最常用的分词、词性标注和实体识别算法，它对未登陆词有很好的识别能力，但开销较大。

LSTM长短期记忆网络：在NLP中，最常用的神经网络为循环神经网络（RNN，Recurrent Neural Network），它在处理变长输入和序列输入问题中有着巨大的优势。LSTM为RNN变种的一种，在一定程度上解决了RNN在训练过程中梯度消失和梯度爆炸的问题。使用LSTM模型可以更好的捕捉到较长距离的依赖关系。

BiLSTM双向长短期记忆网络：双向循环神经网络分别从句子的开头和结尾开始对输入进行处理，将上下文信息进行编码，提升预测效果。前向的LSTM与后向的LSTM结合成BiLSTM。BiLSTM可以更好的捕捉双向的语义依赖。

BiLSTM+CRF：双向长短期记忆网络和条件随机场的结合。

参考资料：

【1】https://www.jianshu.com/p/715fa597c6bc

【2】https://www.jiqizhixin.com/articles/2018-10-24-13

AI Studio用户名：余音竖图

作业1-1

（1）下载飞桨本地并安装成功,将截图发给班主任

（2）学习使用PaddleNLP下面的LAC模型或Jieba分词

# LAC 分词

import paddlehub as hub
module = hub.Module(name="lac")
test_text = ["今天是个好日子", "天气预报说今天要下雨", "下一班地铁马上就要到了"]
results = module.lexical_analysis(data={"text":test_text})
print(results)

{'word': ['今天', '是', '个', '好日子'], 'tag': ['TIME', 'v', 'q', 'n']},

{'word': ['天气预报', '说', '今天', '要', '下雨'], 'tag': ['n', 'v', 'TIME', 'v', 'v']},

{'word': ['下', '一班', '地铁', '马上', '就要', '到', '了'], 'tag': ['f', 'm', 'n', 'd', 'v', 'v', 'xc']}]

# 信息熵 

# 读取测试 语料
symbol = r'[a-zA-Z0-9’!"#$%&\'()*+,-./:;<=>?@：，。（）?＠★、…【】《》？“”‘’！^_`{|}~\s]+'
with open("./test100.txt", "r", encoding="utf-8") as D:
data = D.read()
data_unsymbol = re.sub(symbol, "", data)

data_jieba =jieba.lcut(data_unsymbol)
print(len(data_jieba))
data_list = collections.Counter(data_jieba)

data_num = np.array(list(data_list.values()))
p1 = data_num / data_num.sum()

jieba_entropy = np.sum(-p1*np.log2(p1))
print("分词的信息熵:", jieba_entropy)

112919
分词的信息熵: 10.341794453554972

AI Studio用户名：FutureSI

作业1-2 （1）思考一下，假设输入一个词表里面含有N个词，输入一个长度为M的句子，那么最大前向匹配的计算复杂度是多少？

• 匹配过程如下： 1.首先得到词表中最长词的长度MaxLen(word) 2.匹配句子中前MaxLen(word)个字的组合是否在词表中，如果在，匹配一词，如果不在，字的组合末尾去掉一位递归重复第2步。如果递归将所有字都从末尾一一去掉，则本次匹配得到本句子中第一个字单独成词。计算所需时间复杂度为O(MaxLen(word))。 3在最极端复杂的情况下，句子的每一个字都被单独切成一个词，则第2步骤需被重复M此，所以整个句子匹配需要MaxLen(word) * M(M为句子长度)次计算，则整个句子最大前向匹配的计算复杂度是O(MaxLen(word) * M) 如果字典不采用链表而是采用树状结构存储，则在每一轮切词时，前述第2步骤匹配从长度为MaxLen(word)，MaxLen(word) - 1, MaxLen(word) - 2, MaxLen(word) - 3,...3, 2, 1的词典中的词语时，只需一次遍历。 所以匹配所需时间复杂度为0(M)。

作业1-2 （2）给定一个句子，如何计算里面有多少种分词候选，你能给出代码实现吗？

text = '今天中午不吃食堂'
dictionary = ['今', '天', '中', '午', '不', '吃', '食', '堂', '今天', '中午', '不吃', '吃食', '食堂']
availableList = list() #存储text中出现的dictionary中的词语，以待全部完成一遍切词后打印
def count_seg(avaList, rest, dic):
    #print(avaList) #打印已切分完成的词语列表
    #print(rest) #打印还未切词的句子的剩余部分
    if len(rest) == 0: #如果本次切词完成，打印切分方式
        print('/'.join(avaList))
        return 1 #每次成功切分返回一个1用以计数切分方式
    
    count = 0 #本分支初始化切分方式计数
    for i in range(1, len(rest)+1): #将rest中的所有字按从左到右的顺序逐一尝试切分
        #print(i)
        if rest[:i] not in dic: #如果rest中的前i个字符的组合不在dic中则跳过本次尝试。
            continue
        #如果rest中的前i个字符的组合在dic中,则递归调用本函数，尝试进行从rest中划入avaList一个字进行切分
        #本层以下分支切分数目全部加和
        count += count_seg(avaList + [rest[:i]], rest[i:], dic)
    return count #返回本分支递归共进行了多少种切分

print('候选分词数为', count_seg(availableList, text, dictionary))

输出结果：

• 今/天/中/午/不/吃/食/堂
  今/天/中/午/不/吃/食堂
  今/天/中/午/不/吃食/堂
  今/天/中/午/不吃/食/堂
  今/天/中/午/不吃/食堂
  今/天/中午/不/吃/食/堂
  今/天/中午/不/吃/食堂
  今/天/中午/不/吃食/堂
  今/天/中午/不吃/食/堂
  今/天/中午/不吃/食堂
  今天/中/午/不/吃/食/堂
  今天/中/午/不/吃/食堂
  今天/中/午/不/吃食/堂
  今天/中/午/不吃/食/堂
  今天/中/午/不吃/食堂
  今天/中午/不/吃/食/堂
  今天/中午/不/吃/食堂
  今天/中午/不/吃食/堂
  今天/中午/不吃/食/堂
  今天/中午/不吃/食堂
  候选分词数为 20

作业1-2 （3）除了最大前向匹配和N-gram算法，你还知道其他分词算法吗，请给出一段小描述。

• 还有序列标注算法、HMM隐形马尔科夫模型、CRF随机条件场、Structured SVM等。可以参考资料 https://www.hankcs.com/ml/comparison-of-sequence-labeling-models.html

感谢各位老师，各位同学，各位大神。我神往AI已久，现在终于有时间，系统学习。来得晚了点，还在学习前面的课；已略有心得，甚是欢喜。

AI Studio用户名：FutureSI
作业1-1 （1）下载飞桨本地并安装成功,将截图发给班主任

作业1-1 （2）学习使用PaddleNLP下面的LAC模型或Jieba分词

作业1-1 （3）对人民日报语料完成切词，并通过统计每个词出现的概率

#!unzip -d /home/aistudio/work /home/aistudio/data/data22678/1946年05月.zip
import os
import re
import paddlehub as hub
import numpy as np
from collections import Counter

def getData():
    fileList = os.listdir('/home/aistudio/work/194605')
    data = []
    for fileName in fileList:
        content = open('/home/aistudio/work/194605/'+fileName, "r",encoding = 'utf-8').read()
        #除去中文、数字外的所有字符
        content = re.sub(r'[^\u4e00-\u9fa50-9]', " ",content)
        content = content.strip()
        content = re.sub(r' +', " ", content)
        sentence = content.split(' ')
        data = data + sentence
    return data

def cut(sentences):
    module = hub.Module(name="lac")
    wordListTotal = []
    for sentence in sentences:
        wordList = []
        words = module.lexical_analysis(data={"text": [sentence]})
        for w in words:
            wordList.extend(w['word'])
        wordListTotal = wordListTotal + wordList
    return wordListTotal

def getEntropy(word):
    wordRate = Counter(word) #统计词频
    p = np.array(list(wordRate.values()))
    p = p / len(word)
    return -(p*np.log2(p)).sum()

def getStopWord():
    content = open('/home/aistudio/baidu_stopwords.txt', "r",encoding = 'utf-8').read()
    return content.split('\n')

sentences = getData()
words = cut(sentences)
entropy = getEntropy(words)
print("信息熵："+str(entropy))
entropy = getEntropy([w for w in words if w not in getStopWord()])
print("去掉停止词信息熵："+str(entropy))