大纲：1. 任务描述
2.一些理论
3. 隐马尔科夫模型
4. HMM应用之——隐序列解码(词性标注)
5. 附录
6. 完整代码
1. 任务描述
标注英文句子中每个单词的词性,属于HMM任务中的预测过问题(已知参数和x,求z)。
场景：给定一个英文句子X=’I like …’其中每个单词由
 表示， 
 表示那个单词对应的词性。
目标：给定一个句子
 .可以得出每个单词对应的词性
2.一些理论
(1)概率图模型
利用图来表示与模型有关的变量的联合概率分布
(2) 贝叶斯网络
将随机变量作为结点，若两个随机变量相关或者不独立，则将二者连接一条边；若给定若干随机变量，则形成一个有向图，即构成一个网络。
如果该网络是有向无环图，则这个网络称为贝叶斯网络。
(3)马尔科夫模型
若贝叶斯网络退化成线性链，则得到马尔科夫模型。
已知 n个有序随机变量，根据贝叶斯定理，其联合分布可写成条件分布的连乘。
马尔科夫模型是指，假设序列中的任一随机变量只与它的前 1个变量有关，与更早的变量条件独立：
在此假设下，其联合分布可简化为：
为了表达当前变量与更早的变量之间的关系，可引入高阶马尔科夫性，指当前随机变量与它的前 m 个变量有关：
3. 隐马尔科夫模型
对于离散型随机变量，隐状态：
可观测变量：
X 已知，求解最大概率的 Z，即是最大化
根据马尔科夫假设，任一随机变量只与它的前 1个变量有关
因此：
模型简化为3个部分：
发射概率矩阵：
初始概率：
转移概率矩阵：
因此首先需计算HMM模型参数
 ，再利用已知的x加上参数，求y(HMM的预测问题)
简化：
对应到代码中：
# trans_p是转移概率矩阵A   emit_p是发射概率矩阵B
dp[i,j]=max(dp[i -1][k]+ trans_p[k][j]+ emit_p[j][obs[i]] for k in range(T))
dp[i][j], path[i][j] = max(
(dp[i - 1][k] + trans_p[k][j] + emit_p[j][obs[i]], k)
for k in range(T))
----------------------------
不懂就看下面简单版
dp=[4,5,6]
T=3
a=max(dp[k] for k in range(T))
print(a)  #6
dp=[4,5,6]
T=3
a,b=max((dp[k],k) for k in range(T))
print(a,b)  #6 2
----------------------
4. HMM应用之——隐序列解码(词性标注)
import numpy as np, pandas as pd
(1)数据预处理
START = 'start'  # 句始tag
END = 'end'  # 句末tag
NOUN = 'subj'  # 名词
ADV = 'adv'  # 副词
ADJ = 'adj'  # 形容词
corpus = np.array([
('我', NOUN), ('很', ADV), ('菜', ADJ), ('。', END),
('我', NOUN), ('好', ADV), ('菜', ADJ), ('。', END),
('我', NOUN), ('很', ADV), ('好', ADJ), ('。', END),
('他', NOUN), ('很', ADV), ('菜', ADJ), ('。', END),
('他', NOUN), ('好', ADV), ('菜', ADJ), ('。', END),
('他', NOUN), ('很', ADV), ('好', ADJ), ('。', END),
('菜', NOUN), ('很', ADV), ('好', ADJ), ('。', END),
('我', NOUN), ('菜', ADJ), ('。', END),
('我', NOUN), ('好', ADJ), ('。', END),
('他', NOUN), ('菜', ADJ), ('。', END),
('他', NOUN), ('好', ADJ), ('。', END),
('菜', NOUN), ('好', ADJ), ('。', END),
('我', NOUN), ('好', ADV), ('好', ADJ), ('。', END),
('他', NOUN), ('好', ADV), ('好', ADJ), ('。', END),
], dtype=str)
words = sorted(set(corpus[:, 0]))  # 单词
tags = sorted(set(corpus[:, 1]))  # 词性
W = len(words)  # 词汇量
T = len(tags)   # 词性数
word2id = {words[i]: i for i in range(W)}  # 单词-id词典
tag2id = {tags[i]: i for i in range(T)}    # 词性-id词典
id2tag = {i: tags[i] for i in range(T)}    # id-词性词典
(2)HMM参数训练
SMOOTHNESS = 1e-8  # 平滑参数
emit_p = np.zeros((T, W)) + SMOOTHNESS  # 发射概率 B
start_p = np.zeros(T) + SMOOTHNESS  # π
trans_p = np.zeros((T, T)) + SMOOTHNESS  # 转移概率 A
prev_tag = START  # 前一个tag
for word, tag in corpus: # 每一个单词 每一个词性
wid, tid = word2id[word], tag2id[tag] # 单词转id，词性转id
emit_p[tid][wid] += 1  # # 无论如何都要更新B  词性到单词
if prev_tag == START: # 句首
start_p[tid] += 1 # 更新π
else:  # 不是句首，更新A  词性到词性
trans_p[tag2id[prev_tag]][tid] += 1
# 如果句子结束了 prev_tag = START 否则prev_tag=tag
prev_tag = START if tag == END else tag
(3)频数 --> 概率对数
取对数，防止下溢，乘法运算转换成更简单的加法运算
start_p = np.log(start_p / sum(start_p))
for i in range(T):
emit_p[i] = np.log(emit_p[i] / sum(emit_p[i]))
trans_p[i] = np.log(trans_p[i] / sum(trans_p[i]))
发射矩阵B
pd.DataFrame(emit_p, tags, words)
初始概率
pd.DataFrame(start_p.reshape(1, T),['START'], tags)
状态转移矩阵A
pd.DataFrame(trans_p, tags, tags)
(4)维特比算法
sentence =list('菜好好。')
obs = [word2id[w] for w in sentence]  # 观测序列
le = len(obs)  # 序列长度   4
# 动态规划矩阵
dp = np.array([[-1e99] * T] * le)  # 节点最大概率
path = np.zeros((le, T), dtype=int)  # 节点转移记录
for j in range(T):
dp[0][j] = start_p[j] + emit_p[j][obs[0]]
    path[0][j] = -1
for i in range(1, le):
for j in range(T):
dp[i][j], path[i][j] = max(
(dp[i - 1][k] + trans_p[k][j] + emit_p[j][obs[i]], k)
for k in range(T))
节点最大概率矩阵
pd.DataFrame(dp.T, tags, sentence)
节点转移记录矩阵
pd.DataFrame(path.T, tags, sentence)
隐态序列标号
states = [np.argmax(dp[le - 1])]  # [2]
# 从后到前的循环来依次求出每个单词的词性
for i in range(le - 2, -1, -1):
    states.insert(0, path[i + 1][states[0]])  # path[3][3] path[2][0] path[1][1]
注意states会动态变化
(5)标注结果打印
for word, tid inzip(sentence, states):
print(word, id2tag[tid])
菜 subj
好 adv
好 adj
。 end
5. 附录
语料地址：
GitHub地址：
6. 完整代码：
import numpy as np
"""配置"""
SMOOTHNESS = 1e-8
START = 'start'  # 句始tag
END = 'end'  # 句末tag
NOUN = 'subj'  # 名词
ADV = 'adv'  # 副词
ADJ = 'adj'  # 形容词
"""数据预处理"""
corpus = np.array([
('我', NOUN), ('很', ADV), ('菜', ADJ), ('。', END),
('我', NOUN), ('好', ADV), ('菜', ADJ), ('。', END),
('我', NOUN), ('很', ADV), ('好', ADJ), ('。', END),
('他', NOUN), ('很', ADV), ('菜', ADJ), ('。', END),
('他', NOUN), ('好', ADV), ('菜', ADJ), ('。', END),
('他', NOUN), ('很', ADV), ('好', ADJ), ('。', END),
('菜', NOUN), ('很', ADV), ('好', ADJ), ('。', END),
('我', NOUN), ('菜', ADJ), ('。', END),
('我', NOUN), ('好', ADJ), ('。', END),
('他', NOUN), ('菜', ADJ), ('。', END),
('他', NOUN), ('好', ADJ), ('。', END),
('菜', NOUN), ('好', ADJ), ('。', END),
('我', NOUN), ('好', ADV), ('好', ADJ), ('。', END),
('他', NOUN), ('好', ADV), ('好', ADJ), ('。', END),
], dtype=str)
words = sorted(set(corpus[:, 0]))
tags = sorted(set(corpus[:, 1]))
W = len(words)  # 词汇量
T = len(tags)  # 词性种类数
word2id = {words[i]: i for i in range(W)}
tag2id = {tags[i]: i for i in range(T)}
id2tag = {i: tags[i] for i in range(T)}
"""HMM训练"""
emit_p = np.zeros((T, W)) + SMOOTHNESS  # emission_probability
start_p = np.zeros(T) + SMOOTHNESS  # start_probability
trans_p = np.zeros((T, T)) + SMOOTHNESS  # transition_probability
prev_tag = START  # 前一个tag
for word, tag in corpus:
wid, tid = word2id[word], tag2id[tag]
emit_p[tid][wid] += 1
if prev_tag == START:
start_p[tid] += 1
else:
trans_p[tag2id[prev_tag]][tid] += 1
prev_tag = START if tag == END else tag  # 句尾判断
# 频数 --> 概率对数
start_p = np.log(start_p / sum(start_p))
for i in range(T):
emit_p[i] = np.log(emit_p[i] / sum(emit_p[i]))
trans_p[i] = np.log(trans_p[i] / sum(trans_p[i]))
def viterbi(sentence):
"""维特比算法"""
obs = [word2id[w] for w in sentence.strip()]  # 观测序列
le = len(obs)  # 序列长度
# 动态规划矩阵
dp = np.zeros((le, T))  # 记录节点最大概率对数
path = np.zeros((le, T), dtype=int)  # 记录上个转移节点
for j in range(T):
dp[0][j] = start_p[j] + emit_p[j][obs[0]]
for i in range(1, le):
for j in range(T):
dp[i][j], path[i][j] = max(
(dp[i - 1][k] + trans_p[k][j] + emit_p[j][obs[i]], k)
for k in range(T))
# 隐序列
states = [np.argmax(dp[le - 1])]
# 从后到前的循环来依次求出每个单词的词性
for i in range(le - 2, -1, -1):
states.insert(0, path[i + 1][states[0]])
# 打印
for word, tid in zip(sentence, states):
print(word, id2tag[tid])
"""测试"""
x = '菜好好。'
viterbi(x)
补充：马尔科夫网络、马尔科夫模型、马尔科夫过程、贝叶斯网络的区别将随机变量作为结点，若两个随机变量相关或者不独立，则将二者连接一条边；若给定若干随机变量，则形成一个有向图，即构成一个网络。
如果该网络是有向无环图，则这个网络称为贝叶斯网络。
如果这个图退化成线性链的方式，则得到马尔科夫模型；因为每个结点都是随机变量，将其看成各个时刻(或空间)的相关变化，以随机过程的视角，则可以看成是马尔科夫过程。
若上述网络是无向的，则是无向图模型，又称马尔科夫随机场。
如果在给定某些条件的前提下，研究这个马尔科夫随机场，则得到条件随机场。
如果使用条件随机场解决标注问题，并且进一步将条件随机场中的网络拓扑变成线性的，则得到线性链条件随机场
总结：
先利用训练集训练模型参数
 ，此时已知x和模型参数，利用维特比算法，求z
参考：Python词性标注HMM+viterbi实现_ArYe-CSDN博客_hmm_viterbi python3​blog.csdn.net

1. DefaultTagger标注器
DefaultTagger可以将所有token标记为同一个标签（tag）。
sent = "Thanks for your reading!"
tokens = nltk.word_tokenize(sent)

default_tagger = nltk.DefaultTagger('NN')
tagged_words = default_tagger.tag(tokens)
print(tagged_words)
result:
[('Thanks', 'NN'), ('for', 'NN'), ('your', 'NN'), ('reading', 'NN'), ('!', 'NN')]
evaluate函数可以测试这种标记方法的准确率。这里使用brown语料库提供的标记好词性的tagged_sents进行测试：
brown_tagged_sents = brown.tagged_sents(categories='news')
default_tagger = nltk.DefaultTagger('NN')
print(default_tagger.evaluate(brown_tagged_sents))
result:
0.13089484257215028
输入结果说明将所有单词标记为名词（NN）的方法只有13%的准确率，这也说明brown_tagged_sents里名词占13%。

2. N-gram标注器
将brown_tagged_sents前90%的数据作为训练数据，后10%的数据作为测试数据。
以UnigramTagger(train_data,backoff = default_tagger) 为例，对于UnigramTagger不能标记train_data中的一些单词，使用 backoff 对应的default_tagger标记。
from nltk.tag import UnigramTagger
from nltk.tag import DefaultTagger
from nltk.tag import BigramTagger
from nltk.tag import TrigramTagger

train_data= brown_tagged_sents[:int(len(brown_tagged_sents) * 0.9)]
test_data= brown_tagged_sents[int(len(brown_tagged_sents) * 0.9):]

unigram_tagger = UnigramTagger(train_data,backoff = default_tagger)
print(unigram_tagger.evaluate(test_data))

bigram_tagger= BigramTagger(train_data, backoff = unigram_tagger)
print(bigram_tagger.evaluate(test_data))

trigram_tagger=TrigramTagger(train_data,backoff = bigram_tagger)
print(trigram_tagger.evaluate(test_data))
result:
0.8361407355726104
0.8452108043456593
0.843317053722715
3. 正则表达式标注器
举例来说，以able结尾的单词一般是形容词，以ly结尾的一般是副词等，根据这种构词规则，可以使用正则表达式表示一类单词的通用形式，进而统一进行标注。

from nltk.tag.sequential import RegexpTagger
regexp_tagger = RegexpTagger(
         [( r'^-?[0-9]+(.[0-9]+)?$', 'CD'),   # cardinal numbers
          ( r'(The|the|A|a|An|an)$', 'AT'),   # articles
          ( r'.*able$', 'JJ'),                # adjectives
          ( r'.*ness$', 'NN'),         # nouns formed from adj
          ( r'.*ly$', 'RB'),           # adverbs
          ( r'.*s$', 'NNS'),           # plural nouns
          ( r'.*ing$', 'VBG'),         # gerunds
          (r'.*ed$', 'VBD'),           # past tense verbs
          (r'.*', 'NN')                # nouns (default)
          ])                           # 前缀r用于防止转义，常用于正则表达式
print((regexp_tagger.evaluate(test_data)))
result:
0.31306687929831556
用正则表示式标注器标注日期和$字符：
date_tagger = RegexpTagger([
    (r'(\d{2})[/.-](\d{2})[/.-](\d{4})$','DATE'),
    (r'\$','MONEY')
    ])
test = 'I will be coming on sat 10-02-2014 with around 10 $ '.split()
date_tagger.tag(test)
result:
[('I', None),
 ('will', None),
 ('be', None),
 ('coming', None),
 ('on', None),
 ('sat', None),
 ('10-02-2014', 'DATE'),
 ('with', None),
 ('around', None),
 ('10', None),
 ('$', 'MONEY')]
用正则表达式标注器替代2中的default_tagger，改善性能。
unigram_tagger = UnigramTagger(train_data,backoff = regexp_tagger)
print(unigram_tagger.evaluate(test_data))

bigram_tagger= BigramTagger(train_data, backoff = unigram_tagger)
print(bigram_tagger.evaluate(test_data))

trigram_tagger=TrigramTagger(train_data,backoff = bigram_tagger)
print(trigram_tagger.evaluate(test_data))
result:
0.8657430479417921
0.8755108143127679
0.8730190371773149

Python NLTK学习5(词性标注)
发表于: 2017年1月3日  阅读: 12925
除特别注明外，本站所有文章均为小杰Code原创
本系列博客为学习《用Python进行自然语言处理》一书的学习笔记。
词性标注器
一个词性标注器处理一个词序列，为每个词附加一个词性标记，我们先看一个示例：
import nltk
words = nltk.word_tokenize('And now for something completely different')
print(words)
word_tag = nltk.pos_tag(words)
print(word_tag)
结果为：
['And', 'now', 'for', 'something', 'completely', 'different']
[('And', 'CC'), ('now', 'RB'), ('for', 'IN'), ('something', 'NN'), ('completely', 'RB'), ('different', 'JJ')]
nltk.word_tokenize(text)：对指定的句子进行分词，返回单词列表。
nltk.pos_tag(words)：对指定的单词列表进行词性标记，返回标记列表。
从结果我们可以看到something是NN，NN代表名词。
为什么nltk.pos_tag()方法可以对单词进行词性标记？这是因为NLTK预先使用一些语料库训练出了一个词性标注器，这个词性标注器可以对单词列表进行标记。
标注语料库
NLTK中的很多语料库都已经标注了词性，我们之前学习过的布朗语料库就是一个被标注了词性的语料库，每个语料库使用的标记符号可以有所不同。
from nltk.corpus import brown
words_tag = brown.tagged_words(categories='news')
print(words_tag[:10])
结果为：
[('The', 'AT'), ('Fulton', 'NP-TL'), ('County', 'NN-TL'), ('Grand', 'JJ-TL'), ('Jury', 'NN-TL'), ('said', 'VBD'), ('Friday', 'NR'), ('an', 'AT'), ('investigation', 'NN'), ('of', 'IN')]
brown可以看作是一个CategorizedTaggedCorpusReader实例对象。
CategorizedTaggedCorpusReader::tagged_words(fileids, categories)：该方法接受文本标识或者类别标识作为参数，返回这些文本被标注词性后的单词列表。
CategorizedTaggedCorpusReader::tagged_sents(fileids, categories)：该方法接受文本标识或者类别标识作为参数，返回这些文本被标注词性后的句子列表，句子为单词列表。
tagged_sents = brown.tagged_sents(categories='news')
print(tagged_sents)
结果为：
[[('The', 'AT'), ('Fulton', 'NP-TL'), ('County', 'NN-TL'), ('Grand', 'JJ-TL'), ('Jury', 'NN-TL'), ('said', 'VBD'), ('Friday', 'NR'), ('an', 'AT'), ('investigation', 'NN'), ('of', 'IN'), ("Atlanta's", 'NP$'), ('recent', 'JJ'), ('primary', 'NN'), ('election', 'NN'), ('produced', 'VBD'), ('``', '``'), ('no', 'AT'), ('evidence', 'NN'), ("''", "''"), ('that', 'CS'), ('any', 'DTI'), ('irregularities', 'NNS'), ('took', 'VBD'), ('place', 'NN'), ('.', '.')], [('The', 'AT'), ('jury', 'NN'), ('further', 'RBR'), ('said', 'VBD'), ('in', 'IN'), ('term-end', 'NN'), ('presentments', 'NNS'), ('that', 'CS'), ('the', 'AT'), ('City', 'NN-TL'), ('Executive', 'JJ-TL'), ('Committee', 'NN-TL'), (',', ','), ('which', 'WDT'), ('had', 'HVD'), ('over-all', 'JJ'), ('charge', 'NN'), ('of', 'IN'), ('the', 'AT'), ('election', 'NN'), (',', ','), ('``', '``'), ('deserves', 'VBZ'), ('the', 'AT'), ('praise', 'NN'), ('and', 'CC'), ('thanks', 'NNS'), ('of', 'IN'), ('the', 'AT'), ('City', 'NN-TL'), ('of', 'IN-TL'), ('Atlanta', 'NP-TL'), ("''", "''"), ('for', 'IN'), ('the', 'AT'), ('manner', 'NN'), ('in', 'IN'), ('which', 'WDT'), ('the', 'AT'), ('election', 'NN'), ('was', 'BEDZ'), ('conducted', 'VBN'), ('.', '.')], ...]
NLTK中还包含一个中文语料库sinica_treebank，该库使用繁体中文，该库也被标注了词性，我们来看看该库。
from nltk.corpus import sinica_treebank
print(sinica_treebank.fileids())
结果为：
['parsed']
sinica_treebank可以看做是一个SinicaTreebankCorpusReader实例对象。
SinicaTreebankCorpusReader::words(fileids)：该方法接受文本标识作为参数，返回文本的单词列表。
SinicaTreebankCorpusReader::tagged_words(fileids)：该方法接受文本标识作为参数，返回文本被标注词性后的单词列表。
words = sinica_treebank.words('parsed')
print(words[:40])
words_tag = sinica_treebank.tagged_words('parsed')
print(words_tag[:40])
结果为：
['一', '友情', '嘉珍', '和', '我', '住在', '同一條', '巷子', '我們', '是', '鄰居', '也', '是', '同班', '同學', '我們', '常常', '一起', '上學', '一起', '回家', '有一天', '上學', '時', '我', '到', '她', '家', '等候', '按', '了', '門鈴', '卻', '沒有', '任何', '動靜', '正當', '我', '想', '離開']
[('一', 'Neu'), ('友情', 'Nad'), ('嘉珍', 'Nba'), ('和', 'Caa'), ('我', 'Nhaa'), ('住在', 'VC1'), ('同一條', 'DM'), ('巷子', 'Nab'), ('我們', 'Nhaa'), ('是', 'V_11'), ('鄰居', 'Nab'), ('也', 'Dbb'), ('是', 'V_11'), ('同班', 'Nv3'), ('同學', 'Nab'), ('我們', 'Nhaa'), ('常常', 'Dd'), ('一起', 'Dh'), ('上學', 'VA4'), ('一起', 'Dh'), ('回家', 'VA13'), ('有一天', 'DM'), ('上學', 'VA4'), ('時', 'Ng'), ('我', 'Nhaa'), ('到', 'P61'), ('她', 'Nhaa'), ('家', 'Ncb'), ('等候', 'VK2'), ('按', 'VC2'), ('了', 'Di'), ('門鈴', 'Nab'), ('卻', 'Dbb'), ('沒有', 'VJ3'), ('任何', 'Neqa'), ('動靜', 'Nad'), ('正當', 'P16'), ('我', 'Nhaa'), ('想', 'VE2'), ('離開', 'VC2')]
我们来看看哪些标记是sinica_treebank库中最常见的。
words_tag = sinica_treebank.tagged_words('parsed')
tag_fd = nltk.FreqDist(tag for (word, tag) in words_tag)
tag_fd.tabulate(5)
结果为:
Nab   DE  Nac  Nad VH11
9520 7095 4478 3873 3722
我们可以看到Nab标记出现了9520次。
总结
nltk.word_tokenize(text)：对指定的句子进行分词，返回单词列表
nltk.pos_tag(words)：对指定的单词列表进行词性标记，返回标记列表
CategorizedTaggedCorpusReader::tagged_words(fileids, categories)：该方法接受文本标识或者类别标识作为参数，返回这些文本被标注词性后的单词列表
CategorizedTaggedCorpusReader::tagged_sents(fileids, categories)：该方法接受文本标识或者类别标识作为参数，返回这些文本被标注词性后的句子列表，句子为单词列表
SinicaTreebankCorpusReader::tagged_words(fileids)：该方法接受文本标识作为参数，返回文本被标注词性后的单词列表
SinicaTreebankCorpusReader::tagged_sents(fileids)：该方法接受文本标识作为参数，返回文本被标注词性后的句子列表，句子为单词列表
其他章节链接
Python NLTK学习5(词性标注)

我是一个新的python，正在处理一个文本分类问题。我用不同的在线资源开发了一个代码。但是这个代码并没有做词性标注。有人能帮我找出我的代码中我真正出错的那一行吗。我在代码中做词性标记，但结果中没有显示。我也试过用nltk做词性标注，但这对我也不起作用。如有任何帮助，我们将不胜感激。谢谢。在# Add the Data using pandas
Corpus = pd.read_csv(r"U:\FAHAD UL HASSAN\Python Code\projectdatacor.csv",encoding='latin-1')
# Data Pre-processing - This will help in getting better results through the classification algorithms
# Remove blank rows if any.
Corpus['description'].dropna(inplace=True)
# Change all the text to lower case. This is required as python interprets 'design' and 'DESIGN' differently
Corpus['description'] = [entry.lower() for entry in Corpus['description']]
# Punctuation Removal
Corpus['description'] = Corpus.description.str.replace('[^\w\s]', '')
# Tokenization : In this each entry in the corpus will be broken into set of words
Corpus['description']= [word_tokenize(entry) for entry in Corpus['description']]
# Remove Stop words, Non-Numeric and perfom Word Stemming/Lemmenting.
# WordNetLemmatizer requires Pos tags to understand if the word is noun or verb or adjective etc. By default it is set to Noun
STOPWORDS = set(stopwords.words('english'))
tag_map = defaultdict(lambda : wn.NOUN)
tag_map['J'] = wn.ADJ
tag_map['V'] = wn.VERB
tag_map['R'] = wn.ADV
for index,entry in enumerate(Corpus['description']):
# Declaring Empty List to store the words that follow the rules for this step
Final_words = []
# Initializing WordNetLemmatizer()
word_Lemmatized = WordNetLemmatizer()
# pos_tag function below will provide the 'tag' i.e if the word is Noun(N) or Verb(V) or something else.
for word, tag in pos_tag(entry):
# Below condition is to check for Stop words and consider only alphabets
if word not in STOPWORDS and word.isalpha():
word_Final = word_Lemmatized.lemmatize(word,tag_map[tag[0]])
Final_words.append(word_Final)
# The final processed set of words for each iteration will be stored in 'description_final'
Corpus.loc[index,'description_final'] = str(Final_words)
print(Corpus['description_final'].head())
这些就是我得到的结果。这段代码做了很多事情，比如标记化，删除了stopwords，但是它在我的结果中显示了pos标记。在
^{pr2}$