AI Studio用户名：翩若惊鸿影2016

作业1-1

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

（2）学习使用PaddleNLP下面的LAC模型或Jieba分词
LAC模型地址：https://github.com/PaddlePaddle/models/tree/release/1.6/PaddleNLP/lexical_analysis
Jieba模型：https://github.com/fxsjy/jieba

（3）对人民日报语料完成切词，并通过统计每个词出现的概率，计算信息熵
语料地址：https://github.com/fangj/rmrb/tree/master/example/1946%E5%B9%B405%E6%9C%88

作业1-2

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

最大向前匹配复杂度：N*M^2
（2）给定一个句子，如何计算里面有多少种分词候选，你能给出代码实现吗？

import jieba

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

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

1：基于词典：

       前向最大匹配法（FMM）

       后向最大匹配法（BMM）

       双向最大匹配法

2：基于统计

              n-gram语言模型

              基于统计机器学习——序列标注

                     隐马尔可夫模型（HMM）

                     条件随机场（CRF）

3：基于神经网络

       LSTM（长短时记忆网络+超链接到历史推文）

       BERT

     ERNIE

XLNet

作业1-1

（1）提交班主任

（2）学习分词模型

（3）jieba分词（对 发刊词.md）

计算信息熵

参考：

https://blog.csdn.net/livingbody/article/details/104521409

作业1-2

（1）

计算复杂度 O（NM^2）

（2）

Paddle模式  全模式  精确模式 搜索模式

（3）

基于规则

后向匹配算法：与前向最大匹配算法类似，只是方向相反，即从后向前寻找词典中存在的词并输出

双向最大匹配算法：将正向最大匹配算法和逆向最大匹配算法进行比较，从而确定正确的分词方法。

基于统计：

基于隐马尔可夫模型

基于条件随机场模型

AI Studio用户名：Jesus丶cia

作业1-1

（1）下载飞桨本地并安装成功

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

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

作业1-2

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

一个词表里面由N个词，输入一个长度为M的句子，那么使用最大前向匹配算法的话，假设最坏的情况，每次匹配只能匹配到一个词，并且每一次尝试都要和此表中的N个词进行比对，因此，我们可以得到：

第一轮：N * M

第二轮：N * M-1

…

最后一轮： N * 1

所以总共为： N * M + N* (M-1) + … + N * 1 = N * (M + M-1 + M-2 +…+ 1) = N * M^2

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

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

最大反向匹配

AI Studio用户名：jet_435129

作业1-1：

(1)已发班主任

(2)

import jieba

w_cut = jieba.lcut('武汉马拉松组委会官网29日发布公告称,原定于4月举办的2020东风雷诺武汉马拉松延期至下半年举行')
print(' '.join(w_cut))

(3)

from glob import glob
import jieba
import os
import math
from collections import Counter

def get_datas():
f_paths = [f for f in glob.glob('data/1946年05月/*.md')]
datas = []
for file_path in f_paths:
sents = open(file_path,'r',encoding='utf-8').read()
datas.append(jieba.lcut(sents))
return datas

datas = get_datas()
word_counter = Counter(datas)
total_num = len(datas)

def cmp_entropy():
entropy = 0
for w,c in word_counter.items():
freq = float(c) / total_num
entropy += freq * math.log(freq, 2)
return -entropy

print('信息熵：{}'.format(cmp_entropy()))

作业1-2：

（1）O(MM)

（2）向大佬学习

（3）还有后向最大匹配法，综合前向最大匹配及后向最大匹配的双向最大匹配法，HMM(jieba可以设置)，以及通过深度学习方法训练出来的方法

AI Studio用户名：蓝灵静紫

作业1-1：

（1）参照paddlepaddle官网介绍，因本机之前已安装tensorflow，避免框架之间各种包依赖版本问题，新建paddle虚拟环境管理，使用conda安装。已发班主任

（2）

（3）

作业1-2：

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

         对于长度为N的词典，长度为M的句子，最坏情况下每个词都需要切分，一般用字典树存储词典，查找一个词的时间复杂度为O(该词的长度)，复杂度是O(N*M), 由于词最大的长度是整个句子的长度，所以计算复杂度是O(M^2)。
（2）给定一个句子，如何计算里面有多少种分词候选，你能给出代码实现吗？

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

查找了下，参考了其他同学的答案，了解到下面两个算法。

      1、逆向最大匹配算法RMM：该算法是正向最大匹配的逆向思维，匹配不成功，将匹配字段的最前一个字去掉，实验表明，逆向最大匹配算法要优于正向最大匹配算法。

      2、双向最大匹配法：是将正向最大匹配法得到的分词结果和逆向最大匹配法的到的结果进行比较，从而决定正确的分词方法。

AI Studio用户名：吖小吞

2月25日第一次作业

作业1-1：

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

（2） 学习使用PaddleNLP下面的L AC模型或jieba分词

LAC模型：

jieba分词:

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

代码参考71楼的大佬：

作业1-2：

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

总的比较次数=N*(M-1+2)*(M-1)/2=N*(M^2-1)/2，复杂度为O(N*M^2)

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

参照 77楼大佬：

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

1.基于词典的分词

最大匹配分词算法

最短路径分词算法

基于n-gram model的分词算法

2.基于字的分词

生成式模型分词算法（n-gram模型、HMM隐马尔可夫模型、朴素贝叶斯分类等）

判别式模型分词算法（感知机、SVM支持向量机、CRF条件随机场、最大熵模型等）

神经网络分词算法

AI Studio用户名：丶简丨

作业1-1：

（1）已截图发送；

  (2-3)词频统计、出现概率

作业1-2

（1）表内含N个词，句子长度M，使用最大向前匹配，即难度最大形式，每次匹配均要与表内对比，可得复杂度为O(NM^2)

（2）分词候选，

import jieba

seg_list = jieba.cut_for_search("给定一个句子.")
print(" ".join(seg_list))

(3)分词发展到目前有很多不同方式

3.1基于规则和词典：

   向前最大匹配，向后最大匹配，双向匹配

3.2统计语言处理：

   N-gram，HMM，CRF

3.3基于机器学习深度学习

  LSTM、BERT、ERNIE  国内外比较著名的分词有Jieba、SnowNLP、PKUSeg、THULAC、HanLP、FoolNLTK、LTP、CoreNLP、BaiduLac等等

LSTM常用的是解决了序列的长短依赖，并以此叠加双向多层的方法居于常见。BERT提出预训练的方式，ERNIE则在BERT基础上延申而来，HMM等利用预定假设彼此之间独立来寻求一个句子中词组成概率最大的性质来进行分词，神经网络将分词问题转化成为序列标注或者序列预测等问题进行求解。

AI Studio 用户名：儒雅的sagapo
作业1-1
（1） 下载飞桨本地并安装成功

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

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

import os
import paddlehub as hub
import numpy as np

def parse_md_file(lac, md_file_path):
    with open(md_file_path, 'r', encoding='utf8') as fr:
        text = fr.read()
    inputs = {"text": [text]}
    result = lac.lexical_analysis(data=inputs)
    return result[0]['word']

def cal_entropy(words_list):
    dic = {}
    nums = len(words_list)
    for word in words_list:
        if word not in dic:
            dic[word] = 1
        else:
            dic[word] = dic[word] + 1
    entropy = 0
    for value in dic.values():
        entropy += (value / nums) * np.log2(value / nums)
    print('entropy', -entropy)

def main(files_path='./1946rmrb/'):
    files = os.listdir(files_path)
    files_nums = len(files)
    result = []
    lac = hub.Module(name="lac")
    for idx, filename in enumerate(files):
        md_file_path = os.path.join(files_path, filename)
        r = parse_md_file(lac, md_file_path)
        result.extend(r)
        print('Read file {:3d} / {} : {}'.format(idx + 1, files_nums, filename))
    cal_entropy(result)

if __name__ == '__main__':
    main(files_path='./1946rmrb/')

作业1-2

（1）假设输入一个词表里面含有N个词，输入一个长度为M的句子，那么最大前向匹配的计算复杂度是
假设词表中词的最大长度为1（最坏的情况），此时得到第一个分词需要计算M*N次，得到第二个需要（M-1）*N，依次类推得到最后一个为 1*N次，合计M*N+ （M-1）*N
+ ... 1*N = N* M*(M+1)/2 算法的复杂为O(NM^2)
（2）给定一个句子，如何计算里面有多少种分词候选，代码实现

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

（3）分词算法
正向最大匹配法（由左到右的方向）
逆向最大匹配法（由右到左的方向）
双向最大匹配法（将正向最大匹配法得到的分词结果和逆向最大匹配法得到的结果进行比较，然后按照最大匹配原则，选取词数切分最少的作为结果）
逐字匹配算法（基于TRIE索引树的逐字匹配算法,是建立在树型词典机制上，匹配的过程是从索引树的根结点依次同步匹配待查词中的每个字，可以看成是对树 某一分枝的遍历。）
神经网络分词算法
联想—回溯法(Association－Backtracking Method，简称 AB 法)

AIStudio名称：枫叶又落地

1.提交班主任

2jieba切词

3.人民日报切词

import os
import jieba
import re
import numpy as np

def read_file(dictory):
    word_list = []
    path = os.listdir(dictory)
    for p in path:
        fp = os.path.join(dictory,p)
        with open(fp, 'r', encoding='utf-8') as f:
            text = f.read()
            text = text.strip().replace('\n','').replace(' ','').replace('， ','').replace('  ','')
            punc = ',,、：。？“”；#()'
            text = re.sub(r'[%s]+' %punc, "", text)
        seg_list = jieba.cut(text)
        word_list += seg_list
    return word_list

def get_counter(word_list):
    word_freq ={}
    for word in word_list:
        if word not in word_freq:
            word_freq[word] = 0
        word_freq[word] += 1
    return word_freq

def get_entropy(word_freq):
    count_result = list(word_freq.values())
    cr = np.array(count_result)
    p = cr/cr.sum()
    entropy = np.sum(-p*np.log2(p))
    return entropy

if __name__ == '__main__':
    dic = 'D:\pycharm\百度NLP\\rmrb-master\\7z\\1946年05月'
    word_list = read_file(dic)
    word_freq = get_counter(word_list)
    entroy = get_entropy(word_freq)
    print(entroy)

信息熵：11.096820472978939

1-2

（1）假设词典中词的最大长度也为M，从句子M开始匹配，匹配N次，未找到，从[0,M-1]开始匹配，匹配N次，最坏情况下，单字匹配，（M+(M-1)+(M-2),……3+2+1）N=M(M+1)N/2,复杂度为O(NM^2)

（2）

sentence ='长江是真的很长的长桥'
worddict = ['长', '长江','是', '真', '真的', '的', '很', '很长','长桥','桥']
def list_segment(result, sentence, worddict):
  '''result:分词时的中间列表
  sentence: 待分词句子
  worddict:分词词典
  '''
  cnt = 0
  if len(sentence) == 0:
      print("/".join(result))
      return 1
  for i in range(1, len(sentence)+1):
      if sentence[:i] in worddict:
          cnt += list_segment(result+[sentence[:i]], sentence[i:], worddict)
  return cnt
cnt =list_segment([],sentence,worddict)
print('候选分词可能数目:%d' % cnt)

结果

长江/是/真/的/很/长/的/长/桥
长江/是/真/的/很/长/的/长桥
长江/是/真/的/很长/的/长/桥
长江/是/真/的/很长/的/长桥
长江/是/真的/很/长/的/长/桥
长江/是/真的/很/长/的/长桥
长江/是/真的/很长/的/长/桥
长江/是/真的/很长/的/长桥
候选分词可能数目:8

(3)

正向最大匹配法
逆向最大匹配法
N-最短路径方法
基于统计模型的分词方法
基于N-gram语言模型的分词方法
基于序列标注的分词方法
基于HMM的分词方法
基于CRF的分词方法
基于词感知机的分词方法
基于深度学习的端到端的分词方法

用户名：雾丶茫茫

作业1-1-1：

作业1-1-2：

通过jieba分词

作业1-1-3：计算1946年5月人民日报数据的信息熵

作业1-2-1

一共需要计算N*M*(M-1)次，时间复杂度为O(NM^2)。（PS:我有点感觉M^2可以忽略，O（N））

作业1-2-2

作业1-2-3

（1）最大逆向匹配算法，从后往前匹配。

（2）双向最大匹配：将最大前向匹配和最大后向匹配的结果结合起来。

AI Studio用户名： a372983526

作业1-1：

(1) 截图已发送

(2) 

（3） 8.038373285989232

作业1-2

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

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

(3):
# 1.LSTM
# 2.BERT
# 3.n-gram语言模型
# 4.隐马尔可夫模型（HMM）

AI Studio用户名：根亥寅

作业1-1：

（1）截图已发给班主任

（3）使用jieba分词全模式

#! /home/work/tools/python27/bin python
# -*- coding: utf-8 -*-
# @Time : 2020-03-02 00:07
# @Author : luolvgen@baidu.com
# @Site :
# @File : code1_1.py
# @Software: PyCharm

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))
信息熵：7.55530908768

作业1-2：

（1）在没有设置最大长度的前提下，最大前向匹配的计算复杂度是 O(N + M^2)，查某个词是否在单词表中的复杂度是O(1)，设置最大长度L后，匹配的复杂度是O(N + M*L)

(2) 

word_dict = {'架构', '架构师', '手把手', '手', '把手', '教', '深度', '学习', '架', '构', '师', '把', '深', '度', '学', '习', '深度学习'}

def candidate_cnt(sentence, tmp_res):
global word_dict
if len(sentence) == 0:
print tmp_res
return 1
cnt = 0
for i in range(1, len(sentence) + 1):
if sentence[:i] in word_dict:
cnt += candidate_cnt(sentence[i:], tmp_res + sentence[:i] + "/")
return cnt

sentence = '架构师手把手教深度学习'
cnt = candidate_cnt(sentence, "")
print('total count: %d' % cnt)
result: 

(3) 其他分词方法

基于字符串匹配的方法：

1. 最少切分（使每一句中切出的词数最小)
2. 双向最大匹配法（进行由左到右、由右到左两次扫描的前后向最大匹配）

基于统计的分词方法（在给定大量已经分词的文本的前提下，利用统计机器学习模型学习词语切分的规律（称为训练），从而实现对未知文本的切分）：

隐马尔可夫模型（HMM）
最大熵模型（ME）
条件随机场模型（CRF）
上述方法都是按照  1.找出句子的所有分词结果；2.在所有的分词结果中找到最好的那一个的步骤进行的。

本条格式有点问题，重新发一下

AI Studio用户名：根亥寅

作业1-1：

（1）截图已发给班主任

（3）使用jieba分词全模式

#! /home/work/tools/python27/bin python
#  -*- coding: utf-8 -*-
#  @Time    : 2020-03-02 00:07
#  @Author  : luolvgen@baidu.com
#  @Site    :
#  @File    : code1_1.py
#  @Software: PyCharm

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

信息熵：7.55530908768

作业1-2：

（1）在没有设置最大长度的前提下，最大前向匹配的计算复杂度是 O(N + M^2)，查某个词是否在单词表中的复杂度是O(1)，设置最大长度L后，匹配的复杂度是O(N + M*L)

(2) 

word_dict = {'架构', '架构师', '手把手', '手', '把手', '教', '深度', '学习', '架', '构', '师', '把', '深', '度', '学', '习', '深度学习'}


def candidate_cnt(sentence, tmp_res):
    global word_dict
    if len(sentence) == 0:
        print tmp_res
        return 1
    cnt = 0
    for i in range(1, len(sentence) + 1):
        if sentence[:i] in word_dict:
            cnt += candidate_cnt(sentence[i:], tmp_res + sentence[:i] + "/")
    return cnt


sentence = '架构师手把手教深度学习'
cnt = candidate_cnt(sentence, "")
print('total count: %d' % cnt)

(3) 其他分词方法

基于字符串匹配的方法：

1. 最少切分（使每一句中切出的词数最小)
2. 双向最大匹配法（进行由左到右、由右到左两次扫描的前后向最大匹配）

基于统计的分词方法（在给定大量已经分词的文本的前提下，利用统计机器学习模型学习词语切分的规律（称为训练），从而实现对未知文本的切分）：

隐马尔可夫模型（HMM）
最大熵模型（ME）
条件随机场模型（CRF）
上述方法都是按照  1.找出句子的所有分词结果；2.在所有的分词结果中找到最好的那一个的步骤进行的。

AI Studio用户名：comer_zhang76

作业1-1：

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

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

Jieba模型：

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

作业1-2：

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

N*(M+M-1+M-2+…..+3+2+1)=N*(M*(M+1)/2)

计算复杂度为O(N*(M^2))

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

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

最短路径分词算法：最短路径分词算法首先将一句话中的所有词匹配出来，构成词图（有向无环图DAG），之后寻找从起始点到终点的最短路径作为最佳组合方式，
判别式模型分词算法：判别式模型主要有感知机，SVM支持向量机、CRF条件随机场、最大熵模型等。
神经网络分词算法：在NLP中，最常用的神经网络为循环神经网络（RNN，Recurrent Neural Network），它在处理变长输入和序列输入问题中有着巨大的优势。LSTM为RNN变种的一种，在一定程度上解决了RNN在训练过程中梯度消失和梯度爆炸的问题。双向（Bidirectional）循环神经网络分别从句子的开头和结尾开始对输入进行处理，将上下文信息进行编码，提升预测效果。

AI Studio用户名：Shona1021

作业1-1

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

截图如下（已发班主任）：

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

下载数据集和预训练模型，并使用提供的预训练模型对测试集进行验证：

[test] P: 0.89211, R: 0.89442, F1: 0.89326, elapsed time: 0.987 s

使用LAC模型对数据集进行预测：

对LAC模型的理解：

LAC是一个集合中文分词、词性标注、专有名词识别任务的词法分析模型。其主要工作原理如下图所示：

整体流程为：

id      ->      one-hot方式       ->     字向量序列   ->      两层双向GRU    ->      CRF   ->      带有词性标注的分词结果。

1.     每个用一个数字id来表示，每句话（即每个序列）被表示为one-hot方式；one-hot表示的每个序列通过字表最终转换为每句话的embedding，作为第一个双向GRU层的输入；

2.     双向的GRU从输入，即序列的embedding，学习该序列的features，通过叠加多一层双向GRU增强特征学习能力；

3.     双层双向GRU得到的序列的features通过全连接层得到CRF的输入；

4.     通过最后一层CRF解码得到序列的分词结果及各分词的标注。

学习jieba分词：

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

entropy: 9.287

作业1-2

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

设定最大长度限制为L：复杂度为O(N + M*L)；

若无最大长度限制：复杂度为O(N+M^2)；

其中，构造HashMap存储词表，每次查找的复杂度为O(1)。

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

根据词表递归匹配即可：

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

1.     生成式模型分词算法：HMM隐马尔可夫模型、朴素贝叶斯分类等。

HMM模型较为常用，jieba分词使用了HMM。

2.     判别式模型分词算法：平均感知机模型、最大熵模型、CRF条件随机场等。

感知机是一种简单的二分类线性模型，CRF条件随机场可看作无向图模型，是目前最常用的分词、序列标注算法，对未登录词识别能力强。

3.     神经网络分词算法：BiLSTM+CRF、BiGRU+CRF等。

作业中学习的LAC模型属于第三类神经网络分词算法，使用的是双层双向gru+CRF模型实现。

AI Studio用户名：wk_mike

作业1-1：

（1）截图已经发给班主任

（2）使用PaddleNLP下面的LAC模型，以及使用Jieba分词模型：

import paddlehub as hub
import jieba
jieba.enable_paddle()# 启动paddle模式。 0.40版之后开始支持，早期版本不支持

lac = hub.Module(name="lac")
test_text = ["百度深度学习集训营第二阶段的NLP+推荐系统内容开讲啦，每个阶段的作业都将有各自的奖励，欢迎大家学习",
            "如遇帖子过期、审核不通过的情况，请先复制内容保存在word文档，然后根据提示，完成个人实名验证，刷新后重新粘贴复制的内容，即可提交",
            "作业奖励：3月2日中午12点之前完成，会从中挑选10位回答优秀的同学获得飞桨定制的数据线",
            "请大家按照作业格式将作业回帖在下面，并备注自己的AI Studio用户名"
            ]

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)))  # 默认是精确模式

输出

Paddle enabled successfully......
2020-03-02 01:24:03,365-DEBUG: Paddle enabled successfully......
[2020-03-02 01:24:03,367] [    INFO] - Installing lac module
[2020-03-02 01:24:03,388] [    INFO] - Module lac already installed in C:\Users\kali\.paddlehub\modules\lac
[2020-03-02 01:24:03,479] [    INFO] - 20 pretrained paramaters loaded by PaddleHub
百度/深度/学习/集训/营/第二/阶段/的/NLP/+/推荐/系统/内容/开讲/啦/，/每个/阶段/的/作业/都/将/有/各自/的/奖励/，/欢迎/大家/学习
百度/深度/学习/集训营/第二/阶段/的/NLP/+/推荐/系统/内容/开讲/啦/，/每个/阶段/的/作业/都/将/有/各自/的/奖励/，/欢迎/大家/学习
百度/深度/学习/集训营/第二阶段/的/NLP/+/推荐/系统/内容/开讲/啦/，/每个/阶段/的/作业/都/将/有/各自/的/奖励/，/欢迎/大家/学习
如/遇/帖子/过期/、/审核/不/通过/的/情况/，/请/先/复制/内容/保存/在/word/文档/，/然后/根据/提示/，/完成/个人/实名/验证/，/刷新/后/重新/粘贴/复制/的/内容/，/即可/提交
如/遇/帖子/过期/、/审核/不/通过/的/情况/，/请/先/复制/内容/保存/在/word/文档/，/然后/根据/提示/，/完成/个人/实名/验证/，/刷新/后/重新/粘贴/复制/的/内容/，/即可/提交
如遇/帖子/过期/、/审核/不/通过/的/情况/，/请/先/复制/内容/保存/在/word/文档/，/然后/根据/提示/，/完成/个人/实名/验证/，/刷新/后/重新/粘贴/复制/的/内容/，/即可/提交
作业/奖励/：/3月2日中午12点/之前/完成/，/会/从中/挑选/10位/回答/优秀/的/同学/获得/飞/桨/定制/的/数据线
作业/奖励/：/3月2日中午12点/之前/完成/，/会/从中/挑选/10位/回答/优秀/的/同学/获得/飞/桨/定制/的/数据线
作业/奖励/：/3/月/2/日/中午/12/点/之前/完成/，/会/从中/挑选/10/位/回答/优秀/的/同学/获得/飞桨/定制/的/数据线
请/大家/按照/作业/格式/将/作业/回帖/在/下面/，/并/备注/自己/的/AI Studio/用户名
请/大家/按照/作业/格式/将/作业/回帖/在/下面/，/并/备注/自己/的/AI Studio/用户名
请/大家/按照/作业/格式/将/作业/回帖/在/下面/，/并/备注/自己/的/AI/ /Studio/用户名

（3） 对人民日报语料完成切词，计算信息熵

import os
import sys
import re
import tqdm
from collections import Counter
import paddlehub as hub
import jieba
import numpy as np
from wordcloud import WordCloud

def search_file(path):
    if not os.path.exists(path):
        print("path 不存在，没有这个文件夹")
        sys.exit(1)

    # 遍历文件夹 单层
    file_list = os.listdir(path)
    file_list=[os.path.join(path,i) for i in file_list]

    return file_list

def get_sentence(file_list):
    text=[]
    for filename in file_list:
        # print(filename)
        data=open(filename, "r",encoding = 'utf-8').read()

        # 除去中文 数字外的所有字符
        data = re.sub(r'[^\u4e00-\u9fa50-9]', " ",data) 
        data = data.strip() #去掉开头结尾的空格
        data = re.sub(r' +', " ",data) #去掉中间多余的空格
        data = data.split(' ')
        # print(data)
        text=text+data
        # break

    return  text

def Entropy(word):
    word_rate = Counter(word)
    p=np.array(list(word_rate.values()))
    p=p/len(word)
    return -(p*np.log2(p)).sum()

def get_stopword(filename):
    data=open(filename, "r",encoding = 'utf-8').read()
    return data.split('\n')



# 人民日报位置
path = "rmrb_article"

# 获取句子
file_list=search_file(path)
print("文章数量：",len(file_list))
data=get_sentence(file_list)
print("句子数量：",len(data))

#获取停用词
stopword=get_stopword('stopwords/中文停用词表.txt')

# 词云
w = WordCloud(font_path="msyh.ttc",
      width=1000, height=700, background_color="white",
      collocations=False
      )

# lac 分词
lac = hub.Module(name="lac")
result_list = lac.lexical_analysis(data={"text": data})
word=[]
for result in result_list:
    word=word+result['word']
print('LAC分词之后总共单词数量：',len(Counter(word)))
print("LAC分词之后信息熵: ", Entropy(word))
word = [w for w in word if w not in stopword and len(w)>2 and not re.match('^[a-z|A-Z|0-9|.]*$',w)]
print('LAC分词+stopword之后总共单词数量：',len(Counter(word)))
print("LAC分词+stopword之后信息熵: ", Entropy(word))
print(Counter(word).most_common(10))
w.generate(" ".join(word))
w.to_file("LAC分词+stopword之后.png")

# jieba 分词，使用paddle模式
jieba.enable_paddle()# 启动paddle模式。 0.40版之后开始支持，早期版本不支持
word=[]
for s in tqdm.tqdm(data):
    result = jieba.lcut(s,use_paddle=True) # 使用paddle模式
    word=word+result
print('jieba分词+paddle模式之后总共单词数量：',len(Counter(word)))
print("jieba分词+paddle模式之后信息熵: ", Entropy(word))
word = [w for w in word if w not in stopword and len(w)>2 and not re.match('^[a-z|A-Z|0-9|.]*$',w)]
print('jieba分词+paddle模式+stopword之后总共单词数量：',len(Counter(word)))
print("jieba分词+paddle模式+stopword之后信息熵: ", Entropy(word))
print(Counter(word).most_common(10))
w.generate(" ".join(word))
w.to_file("jieba分词+paddle模式+stopword之后.png")

# jieba 分词，使用默认模式
word=[]
for s in tqdm.tqdm(data):
    result = jieba.lcut(s) # 使用默认模式
    word=word+result
print('jieba分词+默认模式之后总共单词数量：',len(Counter(word)))
print("jieba分词+默认模式之后信息熵: ", Entropy(word))
word = [w for w in word if w not in stopword and len(w)>2 and not re.match('^[a-z|A-Z|0-9|.]*$',w)]
print('jieba分词+默认模式+stopword之后总共单词数量：',len(Counter(word)))
print("jieba分词+默认模式+stopword之后信息熵: ", Entropy(word))
print(Counter(word).most_common(10))
w.generate(" ".join(word))
w.to_file("jieba分词+默认模式+stopword之后.png")

输出

文章数量：447
句子数量：29918
[2020-03-02 01:24:07,894] [    INFO] - Installing lac module
[2020-03-02 01:24:07,909] [    INFO] - Module lac already installed in C:\Users\kali\.paddlehub\modules\lac
[2020-03-02 01:24:08,059] [    INFO] - 20 pretrained paramaters loaded by PaddleHub
LAC分词之后总共单词数量：22232
LAC分词之后信息熵:11.768764799116218
LAC分词+stopword之后总共单词数量：8445
LAC分词+stopword之后信息熵:11.833236623380314
[('国民党', 640), ('解放区', 256), ('新华社', 229), ('第2版', 225), ('四平街', 112), ('民主政府', 102), ('反动派', 83), ('八路军', 80), ('老百姓', 64), ('共产党', 61)]
Paddle enabled successfully......
2020-03-02 01:27:30,528-DEBUG: Paddle enabled successfully......
100%|██████████| 29918/29918 [00:46<00:00, 645.55it/s]
jieba分词+paddle模式之后总共单词数量：21822
jieba分词+paddle模式之后信息熵:11.733316066602764
jieba分词+paddle模式+stopword之后总共单词数量：7965
jieba分词+paddle模式+stopword之后信息熵:11.549378460118193
[('国民党', 687), ('新华社', 407), ('第2版', 225), ('解放区', 215), ('第1版', 207), ('反动派', 139), ('四平街', 112), ('八路军', 88), ('民主政府', 86), ('共产党', 66)]
100%|██████████| 29918/29918 [00:31<00:00, 956.07it/s]
jieba分词+默认模式之后总共单词数量：21694
jieba分词+默认模式之后信息熵:11.817539624577861
jieba分词+默认模式+stopword之后总共单词数量：5362
jieba分词+默认模式+stopword之后信息熵:10.733158652255831
[('国民党', 885), ('新华社', 435), ('解放区', 299), ('反动派', 214), ('冀鲁豫', 104), ('八路军', 104), ('委员会', 101), ('法西斯', 84), ('十五日', 80), ('十六日', 79)]

LAC分词+stopword之后.png

jieba分词+paddle模式+stopword之后.png

jieba分词+默认模式+stopword之后.png

作业1-2：

（1）N个词，输入一个长度为M的句子，最大前向匹配的计算复杂度为O(N*M(M+1)/2)=O(N*M^2)

（2）计算给定的句子有多少种分词候选

import jieba

data = '武汉市长江大桥'
word_dict= list(jieba.cut(data,cut_all=True))

dic=list(data)+word_dict
print("句子中的单词包括：",dic)

def pref_cut(pre,data,dic,ans=[]):
    if len(data)==0:
        # print(pre)
        ans.append(pre)
        return 0
    for i in range(len(data)):
        if data[:i+1] in dic:
            pref_cut(pre+[data[:i+1]],data[i+1:],dic,ans)
    return ans

word=pref_cut([],data,dic)
print("分词候选个数",len(word))
word

输出

句子中的单词包括：['武', '汉', '市', '长', '江', '大', '桥', '武汉', '武汉市', '市长', '长江', '长江大桥', '大桥']
分词候选个数19
[['武', '汉', '市', '长', '江', '大', '桥'],
 ['武', '汉', '市', '长', '江', '大桥'],
 ['武', '汉', '市', '长江', '大', '桥'],
 ['武', '汉', '市', '长江', '大桥'],
 ['武', '汉', '市', '长江大桥'],
 ['武', '汉', '市长', '江', '大', '桥'],
 ['武', '汉', '市长', '江', '大桥'],
 ['武汉', '市', '长', '江', '大', '桥'],
 ['武汉', '市', '长', '江', '大桥'],
 ['武汉', '市', '长江', '大', '桥'],
 ['武汉', '市', '长江', '大桥'],
 ['武汉', '市', '长江大桥'],
 ['武汉', '市长', '江', '大', '桥'],
 ['武汉', '市长', '江', '大桥'],
 ['武汉市', '长', '江', '大', '桥'],
 ['武汉市', '长', '江', '大桥'],
 ['武汉市', '长江', '大', '桥'],
 ['武汉市', '长江', '大桥'],
 ['武汉市', '长江大桥']]

（3）其他分词算法：

反向最大匹配：与前向最大匹配类似，根据词典中最长的序列长度，从最后面开始匹配，如果匹配到之后，就直接分割；如果没有匹配到的话就减少一个序列长度继续匹配。

基于Transformer的多标准中文分词： 能够针对不同语境采取不同的分词方法。 这种模型使用共享的全连接自注意力机制，从而能根据不同的标准进行分词。

AI Studio昵称：伊言

AI Studio用户名：a1104647683

-------------------------------------------------------------------------------

作业1-1解答如下：

（1）安装飞桨

注意事项：

要先确定显卡是否够用，不够就得老实选用CPU版本。GPU版本需要提前安装好对应的CUDA和CUDNN，甚至Python也有版本的对应要求。可以用whl包手动安装，这样版本对应更让人放心。

此外即使版本不对应，也不用卸载另一个版本的CUDA，无论大小版本。

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

注意：逗号这里没懂，标记住这个问题。

（3）对人民日报语料切词，并计算计算熵

实在是初学，水平就只有“只读”的级别。参考学习了大佬们的代码，结果大佬们都跨过了语料的解释，试了好几个就这一个改了一个小时才出来，一开始实在是不知道语料怎么用。虽然半懂不懂，但确实学到了很多。

-------------------------------------------------------------------------------

作业1-2解答如下：

（1）O(M(M+1)N/2) --> O(M^2N)

（2） 本来写的不是这个，但准备交的时候突然看到97楼大哥的，觉得大概是自己理解题目有点偏差，就直接用上了这位大哥的代码。

（3）其他分词算法：

最大匹配分词算法（寻找最优组合的方式是将匹配到的最长词组合在一起）

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

平均感知机分词算法（通过构造超平面，将特征空间（输入空间）中的样本分为正负两类）

CRF分词算法（对于给定的标注序列Y和观测序列X，对条件概率P(Y|X)进行定义）

双向循环神经网络分词算法（分别从句子的开头和结尾开始对输入进行处理，将上下文信息进行编码，提升预测效果）

2月27日第二次作业  附加题

AI Studio用户名：赵杭天

作业2-1附加题：

使用t-SNE可视化：

AI Studio用户名：根亥寅

作业二附加题：

利用开源工具：https://projector.tensorflow.org/

使用PCA进行可视化：

使用tsne进行可视化

补充code：

batch_size = 512
epoch_num = 3
embedding_size = 200
step = 0
learning_rate = 0.001

with fluid.dygraph.guard(fluid.CUDAPlace(0)):
    model, _ = fluid.load_dygraph("cbow_0.000")
    skip_gram_model = SkipGram("skip_gram_model", vocab_size, embedding_size, batch_size)
    skip_gram_model.set_dict(model)
    #get_similar_tokens('she', 5, skip_gram_model.embedding._w)
    vecs = skip_gram_model.embedding._w.numpy()

def get_tokens_vec(query_token, k):
    x = vecs[word2id_dict[query_token]]
    cos = np.dot(vecs, x) / np.sqrt(np.sum(vecs * vecs, axis=1) * np.sum(x * x) + 1e-9)
    flat = cos.flatten()
    indices = np.argpartition(flat, -k)[-k:]
    indices = indices[np.argsort(-flat[indices])]
    for i in indices:
        print("%s\t%s" % (str(id2word_dict[i]), ",".join(map(str, vecs[i]))))

strs = ['structure', 'deep', 'learn', 'teach', 'me']
for s in strs:
    get_tokens_vec(s, 5)