NLP算法-关键词提取之Gensim算法库_gensim 抽取关键词

引入

书接上回，我们讲到关键词提取常用的Jieba算法库
我们接着讲基于主题模型的关键词提取(LDA)，为啥我要用两个博客来讲述这个关键词提取呢？

因为我打算换一个库来讲讲这个模型，之前TF-IDF算法我们采取的是jieba库，这篇博客我们介绍一下Gensim这个算法库

Gensim简介

Gensim 是一款开源的第三方 Python 工具包，用于对原始的非结构化的文本进行无监督地学习，从而得到文本隐层的主题向量表达。它支持包括 $TF-IDF$，$LSA$，$LDA$ 和 $word2vec$ 在内的多种主题模型算法，支持流式训练，并提供了诸如相似度计算，信息检索等一些常用任务的接口。

Gensim 包含有以下特征：

• 内存独立；
• 有效实现了许多流行的向量空间算法；
• 对流行的数据格式进行了 IO 封装和转换；
• 在其语义表达中，可以相似查询

一些基础概念

• 语料（ Corpus ）：一组原始文本的集合，用于无监督地训练文本主题的隐层结构。语料中不需要人工标注的附加信息。在 Gensim 中，Corpus 通常是一个可迭代的对象（比如列表）。每一次迭代返回一个可用于表达文本对象的稀疏向量；
• 向量（ Vector ）：由一组文本特征构成的列表。是一段文本在 Gensim 中的内部表达；
• 稀疏向量（ Sparse Vector ）：通常，我们可以略去向量中多余的 0 元素。此时，向量中的每一个元素是一个( key, value )的 tuple；
• 模型（ Model ）：是一个抽象的术语。定义了两个向量空间的变换（即从文本的一种向量表达变换为另一种向量表达）。

Gensim的使用方式

1、 训练语料的预处理

**训练语料的预处理指的是将文档中原始的字符文本转换成 Gensim 模型所能理解的稀疏向量的过程。**通常，我们要处理的原生语料是一堆文档的集合，每一篇文档又是一些原生字符的集合。

在交给 Gensim 的模型训练之前，我们需要将这些原生字符解析成 Gensim 能处理的稀疏向量的格式，然后，可以调用 Gensim 提供的 API 建立语料特征的索引字典，并将文本特征的原始表达转化成词袋模型对应的稀疏向量的表达。

示例：构建词袋模型

from gensim import corpora # 导入词袋
dictionary = corpora.Dictionary(texts) # 构建词袋模型
corpus = [dictionary.doc2bow(text) for text in texts]
print corpus[0] 
1
2
3
4

2、主题向量的变换

对文本向量的变换是 Gensim 的核心
通过挖掘语料中隐藏的语义结构特征，最终可以变换出一个简洁高效的文本向量。在 Gensim 中，每一个向量变换的操作都对应着一个主题模型，每一个模型又都是一个标准的 Python 对象。

首先是模型对象的初始化。通常，Gensim 模型都接受一段训练语料（在 Gensim 中，语料对应着一个稀疏向量的迭代器）作为初始化的参数。显然，越复杂的模型需要配置的参数越多。

示例1：TF-IDF 模型

from gensim import models
tfidf = models.TfidfModel(corpus)
1
2

其中，corpus 是一个返回 bow 向量的迭代器。这两行代码将完成对 corpus 中出现的每一个特征的 IDF 值的统计工作。

示例2：LSI 模型

model = lsimodel.LsiModel(tfidf_corpus, id2word=dictionary, num_topics=300)
1

函数中各个参数的具体含义为：
tfidf_corpus 参数代表 tf-idf 模型生成的统计量；
id2word 参数代表词袋向量；
num_topics 表示选取的主题词个数。

LSI 训练的独特之处是能够继续“训练”，仅需提供更多的训练文本，这是通过对底层模型进行增量更新实现的，这个过程称为“在线训练”。

示例3：LDA 模型

model = ldamodel.LdaModel(bow_corpus, id2word=dictionary, num_topics=100)
1

函数中各个参数的具体含义为：
bow_corpus 参数代表模型生成的统计量；
id2word 参数代表词袋向量；
num_topics 表示选取的主题词个数。

LDA 是 LSA 的概率扩展，因此 LDA 的主题可以被解释为词语的概率分布。这些分布式从训练语料库中自动推断的，就像 LSA 一样。

LDA模型 demo

from gensim import corpora, models
import jieba.posseg as jp, jieba
from basic import get_stopword_list

texts=[]
# 构建语料库
for i in range(5):
    s=input()
    texts.append(s)

flags = ('n', 'nr', 'ns', 'nt', 'eng', 'v', 'd')  # 词性
stopwords = get_stopword_list()
words_ls = []
for text in texts:
    words = [word.word for word in jp.cut(text) if word.flag in flags and word.word not in stopwords]
    words_ls.append(words)

# 去重，存到字典
dictionary = corpora.Dictionary(words_ls)
corpus = [dictionary.doc2bow(words) for words in words_ls]

# 任务:基于 gensim 的models构建一个lda模型，主题数为1个
lda = models.LdaModel(corpus,id2word=dictionary, num_topics=1)
for topic in lda.print_topics(num_words=1):
    print(topic[1].split('*')[1],end="")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

测试输入：
实录|疫情下的美院师生书信:网课、绘本、互动与写作
美国学生怎么上网课?
网课开展这么久后:为何大家想回到教室了?
“洋学生”网课记:跨越万水千山 携手漫步“云端”
高校优质网课怎么打造?河南高校教师探索创新“线上教学”模式

输出：
网课

LSA/LSI 算法

LSA 即潜在语义分析，也被称为 LSI
是 Scott Deerwester，Susan T. Dumais 等人在1990年提出来的一种新的索引和检索方法。该方法和传统向量空间模型一样使用向量来表示词和文档，并通过向量间的关系（如夹角）来判断词及文档间的关系；不同的是，LSA 将词和文档映射到潜在语义空间，从而去除了原始向量空间中的一些“噪音”，提高了信息检索的精确度。

LSA 潜在语义分析的目的，就是要找出在文档和查询中的真正含义，也就是潜在语义。
我们希望找到一个模型，能够获取单词之间的相似性。如果两个单词之间有很强的相关性，那么当一个单词出现时，往往意味着另一个单词也应该出现（ 同义词 ）；反之，如果查询语句或者文档中的某个单词和其他单词的相关性都不大，那么这个单词可能表达的就是另外一个意思。

LSA 的核心思想是将词和文档映射到潜在语义空间，再比较其相似性。

LSA/LSI算法原理

LSA（ LSI ）使用 SVD（ 奇异值分解 ）对单词文档矩阵进行分解。SVD 可以看作是从单词-文档矩阵中发现部相关的索引变量（ 因子 ），将原来的数据映射到语义空间内。在单词-文档矩阵中不相似的两个文档，可能在语义空间内比较相似。

SVD，是对矩阵进行分解的一种方法，假设是一个$t\ast d$维的矩阵（单词-文档矩阵） X ，可以将其分解成$T\ast S\ast DT$，其中 T 为t*n维矩阵， S 为$n\ast n$维对角矩阵，每个值为奇异值， D 为$d\ast n$维矩阵。在对单词文档矩阵做 SVD 分解之后，我们只保存 S 中最大的 K 个奇异值，以及 T 和 D 中对应的 k 个奇异向量， k 个奇异值构成新的对角矩阵 S’ ，则$X^{\prime }=T^{\prime }\ast S^{\prime }\ast D^{\prime }T$形成了一个新的$t\ast d$矩阵。

如图所示，在算法模型中，第一个矩阵 U 中的每一行表示意思相关的一类词，其中的每个非零元素表示这类词中每个词的重要性（ 或者说相关性 ），数值越大越相关。最后一个矩阵 V 中的每一列表示同一主题的一类文章，其中每个元素表示这类文章中每篇文章的相关性。中间的矩阵 D 则表示类词和文章类之间的相关性。

因此，我们只要对关联矩阵 X 进行一次奇异值分解，我们就可以同时完成了近义词分类和文章的分类，同时得到每类文章和每类词的相关性。

LSA/LSI 算法步骤

1. 使用 BOW 模型将每个文档表示为向量；
2. 将所有的文档词向量拼接构成词-文档矩阵（m*n）；
3. 对词-文档矩阵进行 SVD 操作；
4. 根据 SVD 的结果，将词-文档矩阵进行奇异值分解到更低维度的近似 SVD 结果中，每个词和文档均可表示为k个主题构成的空间中的一个点，通过计算每个词和文档的相似度（ 余弦相似度或KL相似度 ），然后得到每个文档中对每个词的相似度结果，取相似度最高的一个词即为文档关键词。

LSA/:SI优缺点

LSA 的优点包括：

• 低维空间表示可以刻画同义词，同义词会对应着相同或相似的主题；
• 降维可去除部分噪声，是特征会更明显；
• 充分利用冗余数据；
• 无监督/完全自动化；
• 与语言无关。

LSA 的缺点包括：

• LSA 可以处理向量空间模型无法解决的一义多词问题，但不能解决一词多义问题。因为 LSA 将每一个词映射为潜在语义空间中的一个点，也就是说一个词的多个意思在空间中对于的是同一个点，并没有被区分；
• 特征向量的方向没有对应的物理解释；
• SVD 的计算复杂度很高，而且当有新的文档来到时，若要更新模型需重新训练；
• 没有刻画 term 出现次数的概率模型。

LSA/LSI算法 demo

from gensim import corpora, models
import functools
from others import seg_to_list,load_data,word_filter,cmp
import math

class TopicModel(object):
    # 三个传入参数：处理后的数据集，关键词数量，具体模型（LSI、LDA），主题数量
    def __init__(self, doc_list, keyword_num, model='LSI', num_topics=4):
        # 使用gensim的接口，将文本转为向量化表示
        # 先构建词空间
        self.dictionary = corpora.Dictionary(doc_list)
        
        # 任务：使用BOW模型进行向量化，并保存到corpus变量中
        corpus = [self.dictionary.doc2bow(words) for words in doc_list]
        
        # 对每个词，根据tf-idf进行加权，得到加权后的向量表示
        self.tfidf_model = models.TfidfModel(corpus)
        self.corpus_tfidf = self.tfidf_model[corpus]
        self.keyword_num = keyword_num
        self.num_topics = num_topics
        # 选择加载的模型
        if model == 'LSI':
            self.model = self.train_lsi()
        else:
            self.model = self.train_lda()
        # 得到数据集的主题-词分布
        word_dic = self.word_dictionary(doc_list)
        self.wordtopic_dic = self.get_wordtopic(word_dic)
    def train_lsi(self):
        lsi = models.LsiModel(self.corpus_tfidf, id2word=self.dictionary, num_topics=self.num_topics)
        return lsi
    def train_lda(self):
        lda = models.LdaModel(self.corpus_tfidf, id2word=self.dictionary, num_topics=self.num_topics)
        return lda
    def get_wordtopic(self, word_dic):
        wordtopic_dic = {}
        for word in word_dic:
            single_list = [word]
            wordcorpus = self.tfidf_model[self.dictionary.doc2bow(single_list)]
            wordtopic = self.model[wordcorpus]
            wordtopic_dic[word] = wordtopic
        return wordtopic_dic
    # 计算词的分布和文档的分布的相似度，取相似度最高的keyword_num个词作为关键词
    def get_simword(self, word_list):
        sentcorpus = self.tfidf_model[self.dictionary.doc2bow(word_list)]
        senttopic = self.model[sentcorpus]
        # 余弦相似度计算
        def calsim(l1, l2):
            a, b, c = 0.0, 0.0, 0.0
            for t1, t2 in zip(l1, l2):
                x1 = t1[1]
                x2 = t2[1]
                a += x1 * x1
                b += x1 * x1
                c += x2 * x2
            sim = a / math.sqrt(b * c) if not (b * c) == 0.0 else 0.0
            return sim
        # 计算输入文本和每个词的主题分布相似度
        sim_dic = {}
        for k, v in self.wordtopic_dic.items():
            if k not in word_list:
                continue
            sim = calsim(v, senttopic)
            sim_dic[k] = sim
        for k, v in sorted(sim_dic.items(), key=functools.cmp_to_key(cmp), reverse=True)[:self.keyword_num]:
            print(k + "/ ", end='')
        print()
    # 词空间构建方法和向量化方法，在没有gensim接口时的一般处理方法
    def word_dictionary(self, doc_list):
        dictionary = []
        for doc in doc_list:
            dictionary.extend(doc)
        dictionary = list(set(dictionary))
        return dictionary
    def doc2bowvec(self, word_list):
        vec_list = [1 if word in word_list else 0 for word in self.dictionary]
        return vec_list
def topic_extract(word_list, model, pos=False, keyword_num=10):
    doc_list = load_data(pos)
    topic_model = TopicModel(doc_list, keyword_num, model=model)
    topic_model.get_simword(word_list)
if __name__ == '__main__':
    text = input()
    pos = True
    seg_list = seg_to_list(text, pos)
    filter_list = word_filter(seg_list, pos)
    topic_extract(filter_list, 'LSI', pos)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

注：这个demo的作用是提取出所输入文本中的关键词，并输出关键词提取结果（使用LSA/LSI算法）。其中文本内容通过 input 从后台获取。