实验二代码摘自知乎，其他实验代码修改自课本。
 实验一，基于规则的分词算法
 
from pyhanlp import *

def load_dictionary():
    IOUtil = JClass('com.hankcs.hanlp.corpus.io.IOUtil')
    path = HanLP.Config.CoreDictionaryPath.replace('.txt', 'mini.txt')
    dic = IOUtil.loadDictionary([path])
    return set(dic.keySet())

def fully_segment(text, dic):
    word_list = []
    for i in range(len(text)):
        for j in range(len(text)):
            word = text[i:j]
            if word in dic:
                word_list.append(word)
    return word_list

def forward_segment(text, dic):
    word_list = []
    i = 0
    while i < len(text):
        longest_word = text[i]
        for j in range(i+1, len(text) + 1):
            word = text[i:j]
            if word in dic:
                if len(word) > len(longest_word):
                    longest_word = word
        word_list.append(longest_word)
        i += len(longest_word)
    
    return word_list

def backward_segment(text, dic):
    word_list = []
    i = len(text) - 1
    while i >= 0:
        longest_word = text[i]
        for j in range(0, i):
            word = text[j: i+1]
            if word in dic:
                if len(word) > len(longest_word):
                    longest_word = word
                    break
        word_list.insert(0, longest_word)
        i -= len(longest_word)
    return word_list

def count_single_char(word_list:list):
    return sum(1 for word in word_list if len(word) == 1)

def bidirectional_segment(text, dic):
    f = forward_segment(text, dic)
    b = backward_segment(text, dic)
    if len(f) < len(b):
        return f
    elif len(f) > len(b):
        return b
    else:
        if count_single_char(f) < count_single_char(b):
            return f
        else:
            return b
 
dic = load_dictionary()
text = ['项目的研究', '商品和服务', '研究生命起源', '当下雨天地面积水', '结婚的和尚未结婚的', '欢迎新老师生前来就餐']

for i in text:
    print('正向最长匹配：' + str(forward_segment(i, dic)))
    print('逆向最长匹配：' + str(backward_segment(i, dic)))
    print('双向最长匹配：' + str(bidirectional_segment(i, dic)))
    print('---------------------------------------------')
 
 
实验二，隐马尔可夫求πAB
 
import numpy as np

def train(fileName):

    # HMM模型由三要素决定 lambda=（A，B，pi）
    # A为状态转移矩阵
    # B为观测概率矩阵
    # pi为初始状态概率向量

    # 在该函数中，我们需要通过给定的训练数据（包含S个长度相同的观测序列【每一句话】和对应的状态序列【每一句话中每个词的词性】

    # 在中文分词中，包含一下集中状态（词性）
    # B：词语的开头（单词的头一个字）
    # M：中间词（即在一个词语的开头和结尾之中）
    # E：单词的结尾（即单词的最后一个字）
    # S：单个字

    # 定义一个状态映射字典。方便我们定位状态在列表中对应位置
    status2num={'B':0,'M':1,'E':2,'S':3}

    # 定义状态转移矩阵。总共4个状态，所以4x4
    A=np.zeros((4,4))

    #定义观测概率矩阵
    #在ord中，中文编码大小为65536，总共4个状态
    #所以B矩阵4x65536
    #就代表每一种状态（词性）得到观测状态（字）
    B=np.zeros((4,65536))

    # 初始状态，每一个句子的开头只有4中状态（词性）
    PI=np.zeros(4)

    with open(fileName,encoding='utf-8') as file:

        for line in file.readlines():
            wordStatus=[]#用于保存该行所有单词的状态
            words=line.strip().split() #除去前后空格，然后依照中间空格切分为单词

            for i,word in enumerate(words):

                # 根据长度判断状态
                if len(word)==1:
                    status='S'# 保存每一个单词状态
                    code=ord(word)
                    B[status2num[status[0]]][code]+=1

                else:
                    # 当长度为2，M*0。这样可以一起更新
                    status='B'+(len(word)-2)*'M'+'E'
                    for s in range(len(word)):
                        code=ord(word[s])
                        B[status2num[status[s]]][code]+=1

                # i==0意味着这是句首。我们需要更新PI中每种状态出现次数
                if i==0:
                    PI[status2num[status[0]]]+=1

                # 使用extend，将status中每一个元素家在列表之中。而不是append直接将整个status放在后面
                wordStatus.extend(status)

            for i in range(1,len(wordStatus)):
                # wordStatus获得状态，使用status2num来映射到正确位置
                A[status2num[wordStatus[i-1]]][status2num[wordStatus[i]]]+=1

    # 计算PI向量
    total=sum(PI)
    for i in range(len(PI)):
        if PI[i]==0:
            PI[i]=-3.14e+100
        else:
            # 别忘了去取对数
            PI[i]=np.log(PI[i]/total)

    # 计算A矩阵
    for i in range(len(A)):
        total=sum(A[i])
        for j in range(len(A[i])):
            if A[i][j]==0:
                A[i][j]=-3.14e+100
            else:
                A[i][j]=np.log(A[i][j]/total)
    # 更新B矩阵

    for i in range(len(B)):
        total=sum(B[i])
        for j in range(len(B[i])):
            if B[i][j]==0:
                B[i][j]=-3.14e+100
            else:
                B[i][j]=np.log(B[i][j]/total)

    # 返回三个参数
    return (PI,A,B)

PI, A, B = train('D:/自然语言/HMMTrainSet.txt')

print('    初始矩阵π的维度：' + str(PI.shape))
print('状态转移矩阵A的维度：' + str(A.shape))
print('状态发射矩阵B的维度: ' + str(B.shape))
print('----------------------------------')
print('π的值为：')
print(PI)
print('A的值为：')
print(str(A))
print('B维度过大不予展示')

 
 
实验三，隐马尔可夫维特比算法分词
 
from pyhanlp import *
import os
import zipfile
from pyhanlp.static import download, remove_file, HANLP_DATA_PATH
CWSEvaluator = SafeJClass('com.hankcs.hanlp.seg.common.CWSEvaluator')

def test_data_path():
    """
    获取测试数据路径，位于$root/data/test，根目录由配置文件指定。
    :return:
    """
    data_path = os.path.join(HANLP_DATA_PATH, 'test')
    if not os.path.isdir(data_path):
        os.mkdir(data_path)
    return data_path

def ensure_data(data_name, data_url):
    root_path = test_data_path()
    dest_path = os.path.join(root_path, data_name)
    if os.path.exists(dest_path):
        return dest_path
    if data_url.endswith('.zip'):
        dest_path += '.zip'
    download(data_url, dest_path)
    if data_url.endswith('.zip'):
        with zipfile.ZipFile(dest_path, "r") as archive:
            archive.extractall(root_path)
        remove_file(dest_path)
        dest_path = dest_path[:-len('.zip')]
    return dest_path

sighan05 = ensure_data('icwb2-data', 'http://sighan.cs.uchicago.edu/bakeoff2005/data/icwb2-data.zip')
msr_dict = os.path.join(sighan05, 'gold', 'msr_training_words.utf8')
msr_train = os.path.join(sighan05, 'training', 'msr_training.utf8')
msr_model = os.path.join(test_data_path(), 'msr_cws')
msr_test = os.path.join(sighan05, 'testing', 'msr_test.utf8')
msr_output = os.path.join(sighan05, 'testing', 'msr_bigram_output.txt')
msr_gold = os.path.join(sighan05, 'gold', 'msr_test_gold.utf8')
FirstOrderHiddenMarkovModel = JClass('com.hankcs.hanlp.model.hmm.FirstOrderHiddenMarkovModel')
HMMSegmenter = JClass('com.hankcs.hanlp.model.hmm.HMMSegmenter')



def train(corpus, model):
    segmenter = HMMSegmenter(model)
    segmenter.train(corpus)
    print(segmenter.segment('商品和货币'))
    return segmenter.toSegment()


def evaluate(segment):
    result = CWSEvaluator.evaluate(segment, msr_test, msr_output, msr_gold, msr_dict)
    print(result)


if __name__ == '__main__':
    segment = train(msr_train, FirstOrderHiddenMarkovModel())
    evaluate(segment)
    
 
 
实验四，K-means文本聚类
 
from pyhanlp import *

ClusterAnalyzer = JClass('com.hankcs.hanlp.mining.cluster.ClusterAnalyzer')

analyzer = ClusterAnalyzer()
analyzer.addDocument("赵一", "流行, 流行, 流行, 流行, 流行, 流行, 流行, 流行, 流行, 流行, 蓝调, 蓝调, 蓝调, 蓝调, 蓝调, 蓝调, 摇滚, 摇滚, 摇滚, 摇滚")
analyzer.addDocument("钱二", "爵士, 爵士, 爵士, 爵士, 爵士, 爵士, 爵士, 爵士, 舞曲, 舞曲, 舞曲, 舞曲, 舞曲, 舞曲, 舞曲, 舞曲, 舞曲")
analyzer.addDocument("张三", "古典, 古典, 古典, 古典, 民谣, 民谣, 民谣, 民谣")
analyzer.addDocument("李四", "爵士, 爵士, 爵士, 爵士, 爵士, 爵士, 爵士, 爵士, 爵士, 金属, 金属, 舞曲, 舞曲, 舞曲, 舞曲, 舞曲, 舞曲")
analyzer.addDocument("王五", "流行, 流行, 流行, 流行, 摇滚, 摇滚, 摇滚, 嘻哈, 嘻哈, 嘻哈")
analyzer.addDocument("马六", "古典, 古典, 古典, 古典, 古典, 古典, 古典, 古典, 摇滚")
print(analyzer.kmeans(3))
 

实现新闻分类的代码如下：
 
import tensorflow as tf
from keras.datasets import  reuters
import numpy as np
from keras import models
from keras import layers
from keras.preprocessing import sequence
from keras.layers import Embedding,LSTM,SimpleRNN
import matplotlib.pyplot as plt
(train_data,train_label),(test_data,test_labels)=reuters.load_data(num_words=10000)
def vectorize_sequences(sequences,dimension=10000):
    results=np.zeros((len(sequences),dimension))
    for i,sequence  in enumerate(sequences):
        results[i,sequence]=1.
    return results
x_train=vectorize_sequences(train_data)
x_test=vectorize_sequences(test_data)

def to_one_hot(labels,dimension=46):
    results=np.zeros((len(labels),dimension))
    for i,labels in enumerate(labels):
        results[i,labels]=1.
    return results
one_hot_train_labels=to_one_hot(train_label) #将训练标签向量化
one_hot_test_labels=to_one_hot(test_labels)#将测试标签向量化
models=models.Sequential()
models.add(Embedding(10000,64))
models.add(SimpleRNN(64,return_sequences=True))
models.add(SimpleRNN(64,return_sequences=True))
models.add(SimpleRNN(64))
models.add(layers.Dense(46,activation='softmax'))
models.summary()
models.compile(optimizer='rmsprop',loss='categorical_crossentropy',metrics=['acc'])
x_val=x_train[:1000]
partial_x_train=x_train[1000:]
y_val=one_hot_train_labels[:1000]
partial_y_train=one_hot_train_labels[1000:]
history=models.fit(partial_x_train,partial_y_train,epochs=10,batch_size=128,validation_data=(x_val,y_val))
loss=history.history['loss']
val_loss=history.history['val_loss']
acc=history.history['acc']
val_acc=history.history['val_acc']
plt.subplot(1,2,1)
plt.plot(loss,label='Training loss')
plt.plot(val_loss,label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.subplot(1,2,2)
plt.plot(acc,label='Training acc')
plt.plot(val_acc,label='Validation acc')
plt.title('Training and validation acc')
plt.legend()
plt.show()

 
 新书《基于PyTorch的自然语言处理》的详细笔记！
 主要是对这本书的代码部分的理解和处理，整理了处理方法的过程，这样可以给刚刚步入NLP的学者提供一些帮助。
 
 
 博客的内容是按照文章章节的部分来整理的，大家可以选择部分内容进行学习。
 
 
 
欢迎转载，转载请注明出处：https://blog.csdn.net/qq_41709378/article/details/113354298
 
 
 


 
目录
 
第1章 概述
1.1 损失函数
    
第2章 自然语言处理
第3章 神经网络基础
第4章 用于自然语言处理的前馈网络
第5章 嵌入单词和类型
第6章 自然语言处理的序列建模
第7章 自然语言处理的中级序列建模
第8章 自然语言处理的高级序列建模
第9章 经典，前沿与下一步发展
  
 


  
 
第1章 概述
 
这部分主要是介绍了PyTorch中张量的基本概念，张量的类型大小，张量的基本操作，索引，切片和连接。
 
这里解决习题的代码：
 
import torch

# 1.随机创建一个二维张量，然后第0维插入1个维度
a = torch.rand(3, 3)
a.unsqueeze(0)
print(a)

# 2.去掉刚刚加入张量上的维度
a.squeeze(0)
print(a)

# 3.在区间[3, 7]中创建一个形状为5*3的随机向量
a = 3 + torch.rand(5, 3)*(7-3)
print(a)

# 4.创建一个具有正态分布（mean = 0, std = 1）值的张量
a = torch.rand(3,3)
a.normal_()
print(a)
print(a.normal_())

# 5.找到torch.Tensor([1,1,1,0,1])中所有非零元素的索引
a = torch.Tensor([1,1,1,0,1])
print(torch.nonzero(a))

# 6.创建一个大小为（3，1）的随机张量，水平扩展4个副本
a = torch.rand(3,1)
print(a.expand(3, 4))

# 7.返回两个3维矩阵的乘积（a=torch.rand(3,4,5), b=torch.rand(3,5,4)）
a = torch.rand(3,4,5)
b = torch.rand(3,5,4)
print(torch.bmm(a,b))

# 8.返回一个3维矩阵和一个2维矩阵的乘积（a=torch.rand(3,4,5), b=torch.rand(5,4)）
a = torch.rand(3,4,5)
b = torch.rand(5,4)
print(b.unsqueeze(0).expand(a.size(0), *b.size()))
print(torch.bmm(a, b.unsqueeze(0).expand(a.size(0), *b.size())))
 
 
 
这部分其他知识点的内容：
 
1.1 损失函数
 
损失函数用来评价模型的预测值和真实值不一样的程度，损失函数越好，通常模型的性能越好。不同的模型用的损失函数一般也不一样。
 
损失函数分为经验风险损失函数和结构风险损失函数。经验风险损失函数指预测结果和实际结果的差别，结构风险损失函数是指经验风险损失函数加上正则项。
 
（1）0-1损失函数(zero-one loss)
 　　　　　　　　　 
 
（2）log对数损失函数
 　　　　　　　　　 
 
（3）平均绝对误差损失函数
 　　　　　　　　　 
 　　　　　　　　　 
 
（4）均方差损失函数
 　　　　　　　　　 
 
假设模型预测与真实值之间的误差服从标准高斯分布，也就是说在模型输出与真实值的误差服从高斯分布的假设下，最小化均方差损失函数与极大似然估计本质上是一致的，因此在这个假设能被满足的场景中（比如回归），均方差损失是一个很好的损失函数选择；当这个假设没能被满足的场景中（比如分类），均方差损失不是一个好的选择。
 
（5）交叉熵损失函数
 　　　　　　　　　 
 
 
 
1.交叉熵函数与最大似然函数的联系和区别？
 区别： 交叉熵函数使用来描述模型预测值和真实值的差距大小，越大代表越不相近；似然函数的本质就是衡量在某个参数下，整体的估计和真实的情况一样的概率，越大代表越相近。
 联系： 交叉熵函数可以由最大似然函数在伯努利分布的条件下推导出来，或者说最小化交叉熵函数的本质就是对数似然函数的最大化。
 最小化交叉熵函数的本质就是对数似然函数的最大化。
 
 
 
 
交叉熵损失应该算作是log损失的一个特例，相当于将log损失应用在数据分布为伯努利分布的情况下，
 如果我们把数据分布换成高斯分布，那么log损失便会退化为均方损失，
 换成laplace分布，会退化为绝对值损失。
 
 
 
 
2.在用sigmoid作为激活函数的时候，为什么要用交叉熵损失函数，而不用均方误差损失函数？
 其实这个问题求个导，分析一下两个误差函数的参数更新过程就会发现原因了。
  
 由于激活函数sigmoid的特点，在z取大部分的时候，求导后的值会很小，使得模型参数更新的时间会很长，如果使用均方误差损失函数，在使用梯度下降更新参数时，可以看到参数更新中具有sigmoid函数求导这一项，
 
 而使用了交叉熵损失函数后，参数迭代的过程中是不含有这一项：
 
 可以看到参数更新公式中没有sigmoid求导这一项，权重的更新受sigmoid 影响，受到误差的影响，
 所以当误差大的时候，权重更新快；当误差小的时候，权重更新慢。这是一个很好的性质。
 所以当使用sigmoid作为激活函数的时候，常用交叉熵损失函数而不用均方误差损失函数。
 
 
参考文章：
 （1）https://zhuanlan.zhihu.com/p/58883095
 （2）https://zhuanlan.zhihu.com/p/77686118
 
 
  
 （2）one-hot编码
 
（3）梯度下降
 
（4）TF 和 TF-IDF
 
（1）TF-IDF算法介绍及实现：
 https://blog.csdn.net/asialee_bird/article/details/81486700
 https://www.cnblogs.com/lianyingteng/p/7755545.html
 
 
  
 
第2章 自然语言处理
 
 
 刚开始使用spacy包时，导入“en”.
 
import spacy
nlp = spacy.load("en")
text = "Mary, don't slap the green witch"
print([str(token) for token in nlp(text.lower())])
 
会出现以下问题：
 
 
OSError: [E050] Can’t find model ‘en’. 
It doesn’t seem to be a shortcut link, a Python package or a valid path to a data directory
 
 
 解决方法一：
 
 参考博客：https://blog.csdn.net/mr_muli/article/details/111592360
 
from spacy.lang.en import English
# 如下会报错：
#            import spacy
#            spacy_en = spacy.load('en')
#            return lambda s: [tok.text for tok in spacy_en.tokenizer(s)]
# 替换之后：

            from spacy.lang.en import English
            spacy_en = English()
            return lambda s: [tok.text for tok in spacy_en.tokenizer(s)]
 
 
 解决方法二：
 
 参考博客：https://github.com/hamelsmu/Seq2Seq_Tutorial/issues/1
 参考博客：https://www.cnblogs.com/zrdm/p/8667131.html（这个是解决方法）
 点击en_core_web_sm获得en_core_web_sm-2.2.0.tar
 
获得en_core_web_sm-2.2.0.tar后：
 参考这篇博客：https://www.cnblogs.com/xiaolan-Lin/p/13286885.html
 然后执行：
 
pip install en_core_web_sm-2.2.0.tar.gz
 
 
 最后，代码如下：
 
import spacy

nlp = spacy.load("en_core_web_sm")
# nlp = spacy.load('en')
text = "Mary, don't slap the green witch"
print([str(token) for token in nlp(text.lower())])
 
 
  
 这里第二章中的习题代码：
 

"""
第二章：自然语言处理
"""

# 例2-1：文本分词
"""
from spacy.lang.en import English
# 如下会报错：
#            import spacy
#            spacy_en = spacy.load('en')
#            return lambda s: [tok.text for tok in spacy_en.tokenizer(s)]
# 替换之后：

            from spacy.lang.en import English
            spacy_en = English()
            return lambda s: [tok.text for tok in spacy_en.tokenizer(s)]
"""
import spacy
nlp = spacy.load("en_core_web_sm")
# nlp = spacy.load('en')
text = "Mary, don't slap the green witch"
print([str(token) for token in nlp(text.lower())], '\n')

from nltk.tokenize import TweetTokenizer
tweet = u"Snow White and the Seven Degrees MakeAMovieCold@midnight:-)"
tokenizer = TweetTokenizer()
print(tokenizer.tokenize(tweet.lower()), "\n")


# 例2-2：从文本生成n元模型
def n_grams(text, n):
    return [text[i:i+n] for i in range(len(text)-n+1)]

cleand = ['mary', ',', "n't", 'slap', 'green', 'witch', '.']
print(n_grams(cleand, 3), "\n")


# 例2-3：词形还原：将单词还原为词根形式
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("he was running late")
for token in doc:
    print('{} --> {}'.format(token, token.lemma_))
print("\n")


# 例2-4：词性标注
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Mary slapped the green witch.")
for token in doc:
    print('{} --> {}'.format(token, token.pos_))
print("\n")


# 例2-5 名词短语（NP）分块
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Mary slapped the green witch.")
for chunk in doc.noun_chunks:
    print('{} --> {}'.format(chunk, chunk.label_))
print("\n")



 
 
  
 
第3章 神经网络基础
 
 
 在学习 例3-5 时，会报错：
 
TypeError: prelu() missing 1 required positional arguments: "weight"
 
解决方法：
 
 
这里我们，需要加入权重a，注意的是加入权重a的类型为：torch.FloatTensor
 
# 例3-5：PRelu激活函数
import torch
import matplotlib.pyplot as plt
import numpy as np

prelu = torch.nn.PReLU(num_parameters = 1)
x = torch.range(-5., 5., 0.1)
a = torch.tensor([0.25])  # a为torch.FloatTensor数据类型
# a = torch.from_numpy(np.array(0.25)).int()  # 运用form_numpy()可以实现类型转换
y = torch.prelu(x, a)

plt.plot(x.numpy(), y.numpy())
plt.show()
 
 
 
第4章 用于自然语言处理的前馈网络
 
 
 
第5章 嵌入单词和类型
 
（1）[NLP] 秒懂词向量Word2vec的本质：
 https://zhuanlan.zhihu.com/p/26306795
 
第6章 自然语言处理的序列建模
 
第7章 自然语言处理的中级序列建模
 
第8章 自然语言处理的高级序列建模
 
第9章 经典，前沿与下一步发展

自然语言处理，前面和大家说了
 
【新手上路常见问答】关于自然语言处理（NLP）
【实战技能】自然语言处理（NLP）的案例一：依赖解析
 
今天继续和大家聊聊我自己做的作业案例。作业来自Coursera上的Introduction to Natural Language Processing这门课，讲师是Dragomir R. Radev, Ph.D.，University of Michigan的教授。关于课程内容，虽然现在没有了，但是2016年的链接是https://www.coursera.org/learn/natural-language-processing/home/welcome
 
模型：HMM 隐式马尔科夫模型
 
这个案例我们会用到HMM (Hidden Markov Model，HMM) （隐式马尔科夫模型）
 
HMM的模型是一个五元组:
 
 
StatusSet: 状态值集合
 
 
ObservedSet: 观察值集合
 
 
TransProbMatrix: 转移概率矩阵
 
 
EmitProbMatrix: 发散概率矩阵
 
 
InitStatus: 初始状态分布
 
 
HMM模型用来解决以下三种问题：
 
 
在参数(StatusSet, TransProbMatrix, EmitRobMatrix,
 InitStatus)已知的情况下，求解观察值序列，这是Forward-backward算法。
 
 
在参数(ObservedSet, TransProbMatrix, EmitRobMatrix,
 InitStatus)已知的情况下，求解状态值序列，这是Viterbi算法， 可以用于中文分词、语音识别、新词发现和词性标注。
 
 
在参数(ObservedSet)已知的情况下，求解(TransProbMatrix, EmitRobMatrix,
 InitStatus)，这是Baum-Welch算法。
 
 
语言建模
 
如何预测下一个词呢？这是语言建模的一个任务。我们使用Brown Corpus布朗语料库来创建、训练和评估语言模型。关于语料库，请查看此链接http://icame.uib.no/brown/bcm.html
 
我们使用Python最流行的NLP库自然语言工具包（NLTK）来完成语言模型的相关任务。
 
步骤如下：
 1.计算Brown语料库未标注的训练集中的数据的一元，二元和三元对数概率。
 
2.使用模型来查找每个n元模型的布朗训练数据中每个句子的对数概率或得分。
 
如果发现任何n-gram不在训练句子里 ，将整个句子的log-probability设置为-1000。
 
3.在创建的三个n元模型中实现线性插值。
 
线性插值是一种旨在通过同时使用所有三个标注器，即一元、二元和三元语法标注器来导出更好的标注器的方法。 每个标注器被赋予由参数λ描述的权重。 有一些方法可以得出最好的一组λ，目前我们暂时设置所有三个λ相等。关于线性插值的具体内容，可以阅读Speech and Language Processing一书（http://web.stanford.edu/~jurafsky/slp3/）4.4.3节
 
词性标注
 
步骤如下
 
1.在已标记的数据集中分隔标记和单词。 在一个数据结构中存储没有标记的句子，而在另一个数据结构中存储这些标记， 确保将句子开始和停止符号添加到单词和标签的列表中。
 
2.计算标记的三元概率。
 
3.实现平滑方法。 使用标记“RARE”替换出现五次或少于五次的每个单词。创建在训练数据中出现超过五次的单词列表; 当标记时，不会出现在此列表中的任何单词应该被替换为标记“RARE”。
 
4.计算修改后的数据集的发散概率。
 
5.实现HMM (Hidden Markov Model，HMM) （隐式马尔科夫模型）标注器的Viterbi算法。Viterbi算法是一种具有许多应用的动态规划算法，也是用于找到给定句子的最高得分标签序列的相对有效的方法。关于算法的细节，可以阅读Speech and Language Processing一书（http://web.stanford.edu/~jurafsky/slp3/）第8.4和9.4节。
 
6.创建一个NLTK的三元标注器的实例，以回退到NLTK的二元标注器。 让二元标注器自己使用标记“NOUN”，以便回退到NLTK的默认标注器。
 
欢迎大家留言，和我一起交流自然语言处理。