训练一个关键词提取算法需要以下几个步骤：
1）加载已有的文档数据集；
2）加载停用词表；
3）对数据集中的文档进行分词；
4）根据停用词表，过滤干扰词；
5）根据数据集训练算法；
根据训练好的关键词提取算法对新文档进行关键词提取要经过以下环节：
1）对新文档进行分词；
2）根据停用词表，过滤干扰词；
3）根据训练好的算法提取关键词；
1 加载模块
import math
import jieba
import jieba.posseg as psg
from gensim import corpora, models
from jieba import analyse
import functools
2 定义好停用词表的加载方法
def get_stopword_list():
    # 停用词表存储路径，每一行为一个词，按行读取进行加载
    # 进行编码转换确保匹配准确率
    stop_word_path = './stopword.txt'
    stopword_list = [sw.replace('/n', '') for sw in open(stop_word_path).readlines()]
    return stopword_list
3 定义一个分词方法
def seg_to_list(sentence, pos=False):
    ''' 分词方法，调用结巴接口。pos为判断是否采用词性标注 '''
    if not pos:
        # 不进行词性标注的分词方法
        seg_list = jieba.cut(sentence)
    else:
        # 进行词性标注的分词方法
        seg_list = psg.cut(sentence)
    return seg_list
4 定义干扰词过滤方法
def word_filter(seg_list, pos=False):
    ''' 
        1. 根据分词结果对干扰词进行过滤；
        2. 根据pos判断是否过滤除名词外的其他词性；
        3. 再判断是否在停用词表中，长度是否大于等于2等；
    '''
    stopword_list = get_stopword_list() # 获取停用词表
    filter_list = [] # 保存过滤后的结果
    #  下面代码： 根据pos参数选择是否词性过滤
    ## 下面代码： 如果不进行词性过滤，则将词性都标记为n，表示全部保留
    for seg in seg_list:
        if not pos:
            word = seg
            flag = 'n'
        else:
            word = seg.word # 单词
            flag = seg.flag # 词性
        if not flag.startswith('n'):
            continue
        # 过滤停用词表中的词，以及长度为<2的词
        if not word in stopword_list and len(word)>1:
            filter_list.append(word)
            
    return filter_list
5 加载数据集，并对数据集中的数据分词和过滤干扰词
def load_data(pos=False, corpus_path = './corpus.txt'):
    '''
        目的：
            调用上面方法对数据集进行处理，处理后的每条数据仅保留非干扰词
        参数：
            1. 数据加载
            2. pos: 是否词性标注的参数
            3. corpus_path: 数据集路径
    '''
    doc_list = [] # 结果
    for line in open(corpus_path, 'r'):
        content = line.strip() # 每行的数据
        seg_list = seg_to_list(content, pos) # 分词
        filter_list = word_filter(seg_list, pos) # 过滤停用词
        doc_list.append(filter_list) # 将处理后的结果保存到doc_list
    return doc_list
6 IDF 训练
# TF-IDF的训练主要是根据数据集生成对应的IDF值字典，后续计算每个词的TF-IDF时，直接从字典中读取。

def train_idf(doc_list):
    idf_dic = {} # idf对应的字典
    tt_count = len(doc_list) # 总文档数
    # 每个词出现的文档数
    for doc in doc_list: 
        for word in set(doc):
            idf_dic[word] = idf_dic.get(word, 0.0) + 1.0
    # 按公式转换为idf值，分母加1进行平滑处理
    for k, v in idf_dic.items():
        idf_dic[k] = math.log(tt_count/(1.0 + v))
    # 对于没有在字典中的词，默认其尽在一个文档出现，得到默认idf值
    default_idf = math.log(tt_count/(1.0))
    return idf_dic, default_idf
7 LSI 训练
# LSI的训练时根据现有的数据集生成文档-主题分布矩阵和主题-词分布矩阵，Gensim中有实现好的方法，可以直接调用。

def train_lsi(self):
    lsi = models.LsiModel(self.corpus_tfidf, id2word=self.dictionary, num_topics=self.num_topics)
    return lsi
8 LDA训练
# LDA的训练时根据现有的数据集生成文档-主题分布矩阵和主题-词分布矩阵，Gensim中有实现好的方法，可以直接调用。

def train_lda(self):
    lda = models.LdaModel(self.corpus_tfidf, id2word=self.dictionary, num_topics=self.num_topics)
    return lda
9 cmp函数
# 为了输出top关键词时，先按照关键词的计算分值排序，在得分相同时，根据关键词进行排序

def cmp(e1, e2):
    ''' 排序函数，用于topK关键词的按值排序 '''
    import numpy as np
    res = np.sign(e1[1] - e2[1])
    if res != 0:
        return res
    else:
        a = e1[0] + e2[0]
        b = e2[0] + e1[0]
        if a > b:
            return 1
        elif a == b:
            return 0
        else:
            return -1
10 TF-IDF实现方法
根据具体要处理的文本，计算每个词的TF值，并获取前面训练好的IDF数据，直接获取每个词的IDF值，综合计算每个词的TF-IDF。
class TfIdf(object):
    # 四个参数分别是：训练好的idf字典，默认idf字典，处理后的待提取文本， 关键词数量
    def __init__(self, idf_dic, default_idf, word_list, keyword_num):
        self.idf_dic, self.default_idf = idf_dic, default_idf
        self.word_list = word_list
        self.tf_dic = self.get_tf_dic() # 统计tf值
        self.keyword_num = keyword_num
    
    def get_tf_dic(self):
        # 统计tf值
        tf_dic = {}
        for word in self.word_list:
            tf_dic[word] = tf_dic.get(word, 0.0) + 1.0
        tt_count = len(self.word_list)
        for k, v in tf_dic.items():
            tf_dic[k] = float(v) / tt_count # 根据tf求值公式
        
        return tf_dic

    def get_tfidf(self):
        # 计算tf-idf值
        tfidf_dic = {}
        for word in self.word_list:
            idf = self.idf_dic.get(word, self.default_idf)
            tf  = self.tf_dic.get(word, 0)
            
            tfidf = tf * idf
            tfidf_dic[word] = tfidf
        
        tfidf_dic.items()
        # 根据tf-idf排序，去排名前keyword_num的词作为关键词
        for k, v in sorted(tfidf_dic.items(), key=functools.cmp_to_key(cmp), reverse=True)[:self.keyword_num]:
            print(k + '/', end='')
        print()
11 完整的主题模型实现方法
分别实现了LSI，LDA算法，根据传入参数model进行选择，几个参数如下：
doc_list 是前面数据集加载方法的返回结果
keyword_num同上，为关键词数量
model为本主题模型的具体算法，分别可以传入LSI，LDA，默认为LSI
num_topics为主题模型的主题数量
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 = [self.dictionary.doc2bow(doc) for doc 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)
        
    
    # LSI的训练时根据现有的数据集生成文档-主题分布矩阵和主题-词分布矩阵，Gensim中有实现好的方法，可以直接调用。
    def train_lsi(self):
        lsi = models.LsiModel(self.corpus_tfidf, id2word=self.dictionary, num_topics=self.num_topics)
        return lsi
    
    # LDA的训练时根据现有的数据集生成文档-主题分布矩阵和主题-词分布矩阵，Gensim中有实现好的方法，可以直接调用。
    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
    
    def get_simword(self, word_list):
        # 计算词的分布和文档的分布的相似度，去相似度最高的keyword_num个词作为关键词
        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()
        
    def word_dictionary(self, doc_list):
        # 词空间构建方法和向量化方法，在没有gensim接口时的一般处理方法
        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
12 对上面的各个方法进行封装，统一算法调用接口
def tfidf_extract(word_list, pos=False, keyword_num=10):
    doc_list = load_data(pos)
    idf_dic, default_idf = train_idf(doc_list)
    tfidf_model = TfIdf(idf_dic, default_idf, word_list, keyword_num)
    tfidf_model.get_tfidf()
    
def textrank_extract(text, pos=False, keyword_num=10):
    textrank = analyse.textrank
    keywords = textrank(text, keyword_num)
    # 输出抽取出的关键词
    for keyword in keywords:
        print(keyword + "/", end='')
    print()
    
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)
13 主函数调用
if __name__ == "__main__":
    
    text = '6月19日,《2012年度“中国爱心城市”公益活动新闻发布会》在京举行。' + 
           '中华社会救助基金会理事长许嘉璐到会讲话。基金会高级顾问朱发忠,全国老龄' + 
           '办副主任朱勇,民政部社会救助司助理巡视员周萍,中华社会救助基金会副理事长耿志远,' + 
           '重庆市民政局巡视员谭明政。晋江市人大常委会主任陈健倩,以及10余个省、市、自治区民政局' + 
           '领导及四十多家媒体参加了发布会。中华社会救助基金会秘书长时正新介绍本年度“中国爱心城' + 
           '市”公益活动将以“爱心城市宣传、孤老关爱救助项目及第二届中国爱心城市大会”为主要内容,重庆市' + 
           '、呼和浩特市、长沙市、太原市、蚌埠市、南昌市、汕头市、沧州市、晋江市及遵化市将会积极参加' + 
           '这一公益活动。中国雅虎副总编张银生和凤凰网城市频道总监赵耀分别以各自媒体优势介绍了活动' + 
           '的宣传方案。会上,中华社会救助基金会与“第二届中国爱心城市大会”承办方晋江市签约,许嘉璐理' + 
           '事长接受晋江市参与“百万孤老关爱行动”向国家重点扶贫地区捐赠的价值400万元的款物。晋江市人大' + 
           '常委会主任陈健倩介绍了大会的筹备情况。'
    pos = False
    seg_list = seg_to_list(text, pos)
    filter_list = word_filter(seg_list, pos)
    
    print("TF-IDF模型结果：")
    tfidf_extract(filter_list)
    print("TextRank模型结果：")
    textrank_extract(text)
    print("LSI模型结果：")
    topic_extract(filter_list, 'LSI', pos)
    print("LDA模型结果：")
    topic_extract(filter_list, 'LDA', pos)
14 输出结果：

目录

一、关键词提取概述

二、TF-IDF关键词提取算法及实现

三、TextRank关键词提取算法实现

四、LDA主题模型关键词提取算法及实现

五、Word2Vec词聚类的关键词提取算法及实现

六、信息增益关键词提取算法及实现

七、互信息关键词提取算法及实现

八、卡方检验关键词提取算法及实现

九、基于树模型的关键词提取算法及实现

十、总结

一、关键词提取概述

关键词是能够表达文档中心内容的词语，常用于计算机系统标引论文内容特征、信息检索、系统汇集以供读者检阅。关键词提取是文本挖掘领域的一个分支，是文本检索、文档比较、摘要生成、文档分类和聚类等文本挖掘研究的基础性工作。

从算法的角度来看，关键词提取算法主要有两类：无监督关键词提取方法和有监督关键词提取方法。

1、无监督关键词提取方法

不需要人工标注的语料，利用某些方法发现文本中比较重要的词作为关键词，进行关键词提取。该方法是先抽取出候选词，然后对各个候选词进行打分，然后输出topK个分值最高的候选词作为关键词。根据打分的策略不同，有不同的算法，例如TF-IDF，TextRank，LDA等算法。

无监督关键词提取方法主要有三类：基于统计特征的关键词提取（TF,TF-IDF）；基于词图模型的关键词提取(PageRank,TextRank)；基于主题模型的关键词提取(LDA)

基于统计特征的关键词提取算法的思想是利用文档中词语的统计信息抽取文档的关键词；
	
基于词图模型的关键词提取首先要构建文档的语言网络图，然后对语言进行网络图分析，在这个图上寻找具有重要作用的词或者短语，这些短语就是文档的关键词；
	
基于主题关键词提取算法主要利用的是主题模型中关于主题分布的性质进行关键词提取；
2、有监督关键词提取方法

将关键词抽取过程视为二分类问题，先提取出候选词，然后对于每个候选词划定标签，要么是关键词，要么不是关键词，然后训练关键词抽取分类器。当新来一篇文档时，提取出所有的候选词，然后利用训练好的关键词提取分类器，对各个候选词进行分类，最终将标签为关键词的候选词作为关键词。

3、无监督方法和有监督方法优的缺点

无监督方法不需要人工标注训练集合的过程，因此更加快捷，但由于无法有效综合利用多种信息 对候选关键词排序，所以效果无法与有监督方法媲美；而有监督方法可以通过训练学习调节多种信息对于判断关键词的影响程度，因此效果更优，有监督的文本关键词提取算法需要高昂的人工成本，因此现有的文本关键词提取主要采用适用性较强的无监督关键词提取。

4、关键词提取常用工具包

jieba
	
Textrank4zh （TextRank算法工具）
	
SnowNLP  （中文分析）简体中文文本处理
	
TextBlob （英文分析）
二、TF-IDF关键词提取算法及实现

TF-IDF算法的详细介绍及实现方法总结参看博客：TF-IDF算法介绍及实现

三、TextRank关键词提取算法实现

TextRank算法的详细介绍及实现方法总结参看博客：TextRank算法介绍及实现

四、LDA主题模型关键词提取算法及实现

1、LDA（Latent Dirichlet Allocation）文档主题生成模型

主题模型是一种统计模型用于发现文档集合中出现的抽象“主题”。主题建模是一种常用的文本挖掘工具，用于在文本体中发现隐藏的语义结构。

LDA也称三层贝叶斯概率模型，包含词、主题和文档三层结构；利用文档中单词的共现关系来对单词按主题聚类，得到“文档-主题”和“主题-单词”2个概率分布。

通俗理解LDA主题模型原理

2、基于LDA主题模型的关键词提取算法实现

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


# 简单文本处理
def get_text(text):
    flags = ('n', 'nr', 'ns', 'nt', 'eng', 'v', 'd')  # 词性
    stopwords = ('的', '就', '是', '用', '还', '在', '上', '作为')  # 停用词
    words_list = []
    for text in texts:
        words = [w.word for w in jp.cut(text) if w.flag in flags and w.word not in stopwords]
        words_list.append(words)
    return words_list


# 生成LDA模型
def LDA_model(words_list):
    # 构造词典
    # Dictionary()方法遍历所有的文本，为每个不重复的单词分配一个单独的整数ID，同时收集该单词出现次数以及相关的统计信息
    dictionary = corpora.Dictionary(words_list)
    print(dictionary)
    print('打印查看每个单词的id:')
    print(dictionary.token2id)  # 打印查看每个单词的id

    # 将dictionary转化为一个词袋
    # doc2bow()方法将dictionary转化为一个词袋。得到的结果corpus是一个向量的列表，向量的个数就是文档数。
    # 在每个文档向量中都包含一系列元组,元组的形式是（单词 ID，词频）
    corpus = [dictionary.doc2bow(words) for words in words_list]
    print('输出每个文档的向量:')
    print(corpus)  # 输出每个文档的向量

    # LDA主题模型
    # num_topics -- 必须，要生成的主题个数。
    # id2word    -- 必须，LdaModel类要求我们之前的dictionary把id都映射成为字符串。
    # passes     -- 可选，模型遍历语料库的次数。遍历的次数越多，模型越精确。但是对于非常大的语料库，遍历太多次会花费很长的时间。
    lda_model = models.ldamodel.LdaModel(corpus=corpus, num_topics=2, id2word=dictionary, passes=10)

    return lda_model


if __name__ == "__main__":
    texts = ['作为千元机中为数不多拥有真全面屏的手机，OPPO K3一经推出，就簇拥不少粉丝', \
             '很多人在冲着这块屏幕购买了OPPO K3之后，发现原来K3的过人之处不止是在屏幕上', \
             'OPPO K3的消费者对这部手机总体还是十分满意的', \
             '吉利博越PRO在7月3日全新吉客智能生态系统GKUI19发布会上正式亮相', \
             '今年上海车展，长安CS75 PLUS首次亮相', \
             '普通版车型采用的是双边共双出式排气布局；运动版本车型采用双边共四出的排气布局']
    # 获取分词后的文本列表
    words_list = get_text(texts)
    print('分词后的文本：')
    print(words_list)

    # 获取训练后的LDA模型
    lda_model = LDA_model(words_list)

    # 可以用 print_topic 和 print_topics 方法来查看主题
    # 打印所有主题，每个主题显示5个词
    topic_words = lda_model.print_topics(num_topics=2, num_words=5)
    print('打印所有主题，每个主题显示5个词:')
    print(topic_words)

    # 输出该主题的的词及其词的权重
    words_list = lda_model.show_topic(0, 5)
    print('输出该主题的的词及其词的权重:')
    print(words_list)


运行结果：



五、Word2Vec词聚类的关键词提取算法及实现

1、Word2Vec词向量表示

利用浅层神经网络模型自动学习词语在语料库中的出现情况，把词语嵌入到一个高维的空间中，通常在100-500维，在高维空间中词语被表示为词向量的形式。

特征词向量的抽取是基于已经训练好的词向量模型。

2、K-means聚类算法

聚类算法旨在数据中发现数据对象之间的关系，将数据进行分组，使得组内的相似性尽可能的大，组间的相似性尽可能的小。

算法思想是：首先随机选择K个点作为初始质心，K为用户指定的所期望的簇的个数，通过计算每个点到各个质心的距离，将每个点指派到最近的质心形成K个簇，然后根据指派到簇的点重新计算每个簇的质心，重复指派和更新质心的操作，直到簇不发生变化或达到最大的迭代次数则停止。

3、基于Word2Vec词聚类关键词提取方法的实现过程

主要思路是对于用词向量表示的词语，通过K-Means算法对文章中的词进行聚类，选择聚类中心作为文本的一个主要关键词，计算其他词与聚类中心的距离即相似度，选择topK个距离聚类中心最近的词作为关键词，而这个词间相似度可用Word2Vec生成的向量计算得到。

具体步骤如下：

对语料进行Word2Vec模型训练，得到词向量文件；
	
对文本进行预处理获得N个候选关键词；
	
遍历候选关键词，从词向量文件中提取候选关键词的词向量表示；
	
对候选关键词进行K-Means聚类，得到各个类别的聚类中心（需要人为给定聚类的个数）；
	
计算各类别下，组内词语与聚类中心的距离（欧几里得距离或曼哈顿距离），按聚类大小进行降序排序；
	
对候选关键词计算结果得到排名前TopK个词语作为文本关键词。

	 
注：第三方工具包Scikit-learn提供了K-Means聚类算法的相关函数，本文用到了sklearn.cluster.KMeans()函数执行K-Means算法，sklearn.decomposition.PCA()函数用于数据降维以便绘制图形。

六、信息增益关键词提取算法及实现

信息增益算法的详细介绍及实现方法总结参看博客：信息增益算法介绍及实现

七、互信息关键词提取算法及实现

1、互信息（Mutual Information，MI）

在概率论和信息论中，两个随机变量的互信息或转移信息（transinformation）是变量间相互依赖性的量度。不同于相关系数，互信息并不局限于实值随机变量，它更加一般且决定着联合分布 p(X,Y) 和分解的边缘分布的乘积 p(X)p(Y) 的相似程度。互信息是度量两个事件集合之间的相关性(mutual dependence)。

互信息被广泛用于度量一些语言现象的相关性。在信息论中，互信息常被用来衡量两个词的相关度，也用来计算词与类别之间的相关性。

2、互信息计算公式





 3、互信息算法实现

from sklearn import metrics
import numpy as np

# 训练集和训练标签
x_train = [[1, 2, 3, 4, 5],
           [5, 4, 3, 2, 1],
           [3, 3, 3, 3, 3],
           [1, 1, 1, 1, 1]]
y_train = [0, 1, 0, 1]
# 测试集和测试标签
x_test = [[2, 2, 2, 2, 2], [2, 1, 1, 2, 1]]

x_train = np.array(x_train)  # 转为array

# 存储每个特征与标签相关性得分
features_score_list = []
for i in range(len(x_train[0])):
    # 计算每个特征与标签的互信息
    feature_info = metrics.mutual_info_score(y_train, x_train[:, i])
    features_score_list.append(feature_info)

print(features_score_list)


运行结果： 



4、信息论中的互信息和决策树中的信息增益的关系 



两者表达意思是一样的，都是表示得知特征 X 的信息而使得类 Y 的信息的不确定性减少的程度。

注：

标准化互信息（Normalized Mutual Information，NMI）可以用来衡量两种聚类结果的相似度。
	
标准化互信息Sklearn实现：metrics.normalized_mutual_info_score(y_train, x_train[:, i])。
	
点互信息（Pointwise Mutual Information，PMI）这个指标来衡量两个事物之间的相关性（比如两个词）。
八、卡方检验关键词提取算法及实现

1、卡方检验

卡方是数理统计中用于检验两个变量独立性的方法，是一种确定两个分类变量之间是否存在相关性的统计方法，经典的卡方检验是检验定性自变量对定性因变量的相关性。

2、基本思路

原假设：两个变量是独立的
	
计算实际观察值和理论值之间的偏离程度
	
如果偏差足够小，小于设定阈值，就接受原假设；否则就否定原假设，认为两变量是相关的。
3、计算公式



其中，A为实际值，T为理论值。卡方检验可用于文本分类问题中的特征选择，此时不需要设定阈值，只关心找到最为相关的topK个特征。基本思想：比较理论频数和实际频数的吻合程度或者拟合优度问题。

4、基于sklearn的卡方检验实现

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

# 训练集和训练标签
x_train = [[1, 2, 3, 4, 5],
           [5, 4, 3, 2, 1],
           [3, 3, 3, 3, 3],
           [1, 1, 1, 1, 1]]
y_train = [0, 1, 0, 1]
# 测试集和测试标签
x_test = [[2, 2, 2, 2, 2], [2, 1, 1, 2, 1]]
y_test = [1, 1]

# 卡方检验选择特征
chi2_model = SelectKBest(chi2, k=3)  # 选择k个最佳特征
# 该函数选择训练集里的k个特征，并将训练集转化所选特征
x_train_chi2 = chi2_model.fit_transform(x_train, y_train)
# 将测试集转化为所选特征
x_test_chi2 = chi2_model.transform(x_test)

print('各个特征的得分：', chi2_model.scores_)
print('各个特征的p值：', chi2_model.pvalues_)  # p值越小，置信度越高，得分越高
print('所选特征的索引：', chi2_model.get_support(True))
print('特征提取转换后的训练集和测试集...')
print('x_train_chi2:', x_train_chi2)
print('x_test_chi2:', x_test_chi2)

运行结果：



九、基于树模型的关键词提取算法及实现

1、树模型

主要包括决策树和随机森林，基于树的预测模型（sklearn.tree 模块和 sklearn.ensemble 模块）能够用来计算特征的重要程度，因此能用来去除不相关的特征（结合 sklearn.feature_selection.SelectFromModel）

sklearn.ensemble模块包含了两种基于随机决策树的平均算法：RandomForest算法和Extra-Trees算法。这两种算法都采用了很流行的树设计思想：perturb-and-combine思想。这种方法会在分类器的构建时，通过引入随机化，创建一组各不一样的分类器。这种ensemble方法的预测会给出各个分类器预测的平均。

RandomForests 在随机森林（RF）中，该ensemble方法中的每棵树都基于一个通过可放回抽样（boostrap）得到的训练集构建。另外，在构建树的过程中，当split一个节点时，split的选择不再是对所有features的最佳选择。相反的，在features的子集中随机进行split反倒是最好的split方式。sklearn的随机森林（RF）实现通过对各分类结果预测求平均得到，而非让每个分类器进行投票（vote）。
	
Ext-Trees 在Ext-Trees中(详见ExtraTreesClassifier和 ExtraTreesRegressor)，该方法中，随机性在划分时会更进一步进行计算。在随机森林中，会使用侯选feature的一个随机子集，而非查找最好的阈值，对于每个候选feature来说，阈值是抽取的，选择这种随机生成阈值的方式作为划分原则。
2、树模型的关键词提取算法实现

（1）部分代码实现1

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.feature_selection import SelectFromModel

# 导入SelectFromModel结合ExtraTreesClassifier计算特征重要性，并按重要性阈值选择特征。
# 基于树模型进行模型选择
clf_model = ExtraTreesClassifier(n_estimators=250, random_state=0)
clf_model.fit(x_train, y_train)
# 获取每个词的特征权重,数值越高特征越重要
importances = clf_model.feature_importances_
# 选择特征重要性为1.5倍均值的特征
model = SelectFromModel(clf_model, threshold='1.5*mean', prefit=True)
x_train_new = model.transform(x_train)  # 返回训练集所选特征
x_test_new = model.transform(x_test)  # 返回测试集所选特征


（2）部分代码实现2

# 训练集和训练标签
x_train, y_train
# 候选特征词列表
words_list

# 基于树模型进行模型选择
forest = RandomForestClassifier(n_estimators=250, random_state=0)
forest.fit(x_train, y_train)
importances = forest.feature_importances_  # 获取每个词的特征权重

# 将词和词的权重存入字典
feature_words_dic = {}
for i in range(len(words_list)):
    feature_words_dic[words_list[i]] = importances[i]

# 对字典按权重由大到小进行排序
words_info_dic_sort = sorted(words_info_dic.items(), key=lambda x: x[1], reverse=True)

# 将关键词和词的权重分别存入列表
keywords_list = []  # 关键词列表
features_list = []  # 关键权重列表
for word in words_info_dic_sort:
    keywords_list.append(word[0])
    features_list.append(word[1])

# 选取前一千个关键词和权重写入文本文件
keywords = keywords_list[:1000]
features = features_list[:1000]

# 将含有关键字的文本写入文件
with open('data/keywords_features.txt', 'a', encoding="utf-8") as f:
    for i in range(len(keywords)):
        f.write(keywords[i] + '\t' + features[i] + '\n')

十、总结

本文总结了本人在实验过程中所用到的常用关键词抽取方法，实验数据是基于公司的内部数据，但此篇总结只是方法上的讲解和实现，没有针对某一具体数据集做相应的结果分析。从实验中可以很明显看出有监督关键词抽取方法通常会显著好于无监督方法，但是有监督方法依赖一定规模的标注数据。

 

 

参考：

1、NLP关键词抽取常见算法

2、gensim models.ldamodel

3、卡方检验原理及应用

4、特征选择 (feature_selection)

5、随机森林算法总结及调参

6、句子相似度计算

	

前段时间有粉丝问我什么时候更新公众号文章，老shi才突然意识到原来已经很久没有跟大家唠嗑机器学习那些事儿了。今天老shi准备跟大家简单介绍一下文本关键词提取常用的两种技术，即TF-IDF和TextRank。废话不多说，马上进入正题。
1、基于TF-IDF的文本关键词提取方法
首先，什么是TF-IDF？TF-IDF的文中解释为词频-逆文档频率，是文本关键词提取技术中最常用的方法之一。那么什么是词频？词频(Term Frequency，TF)，顾名思义就是词的频率。具体来说就是某一指定词语在当前文本中出现的频率。而逆文档频率(Inverse Document Frequency，IDF)是一个词语普遍重要性的度量。TF-IDF的主要思想是：如果某个词语在一篇文章中出现的频率很高，并且它在其他文章中较少出现，则认为该词语能很好地代表当前文章的含义。即一个词语的重要性与它在文档中出现的次数成正比，与它在语料库其他文档中出现的频率成反比。TF-IDF的具体计算公式如下：
由以上计算公式可知，TF-IDF是对文本所有候选关键词进行加权处理，最后根据权值对关键词进行排序。假设Dn为测试语料的大小，该算法的关键词提取步骤如下：
(1) 首先对于给定的文本D进行分词、词性标注和去除停用词等数据预处理操作。分词处理可以采用jieba分词，根据需要保留部分词性的词语，最终得到n个候选关键词，即D=[t1,t2,…,tn] ；
(2) 计算词语ti 在文本D中出现的词频(TF)；
(3) 计算词语ti 在整个语料库中的逆文档频率(IDF)，即IDF=log (Dn /(Dt +1))，其中，Dt 为语料库中词语ti 出现的文档个数；
(4) 计算得到词语ti 的TF-IDF=TF*IDF，并重复步骤(2)(3)(4)得到所有候选关键词的TF-IDF值；
(5) 最后对所有候选关键词计算结果进行倒序排列，得到排名前TopN个词语作为文本的关键词。
2、基于TextRank的文本关键词提取方法
在正式介绍TextRank方法之前，首先要介绍一下大名鼎鼎的PageRank算法。PageRank算法是Google创始人拉里·佩奇和谢尔盖·布林于1998年在斯坦福大学读研究生期间发明的，是用于根据网页间相互的链接关系来计算网页重要性的技术。PageRank算法的核心思想认为：如果一个网页被大量其他网页链接，说明这个网页比较重要，强调的是被链接网页的数量；另外，如果一个网页被排名很高的网页链接，说明这个网页比较重要，强调的是被链接网页的权重。
一般情况下，一个网页的PageRank值(PR)计算公式如下：
TextRank算法通过词之间的相邻关系构建网络，然后利用PageRank算法迭代计算每个节点的rank值，排序rank值即可得到文本关键词。
具体来说，TextRank文本关键词提取方法是利用局部词汇关系，即共现窗口，对候选关键词进行排序，该算法的文本关键词提取步骤如下：
(1)  首先对于给定的文本D进行分词、词性标注和去除停用词等数据预处理操作。分词处理可以采用jieba分词，根据需要保留部分词性的词语，最终得到n个候选关键词，即D=[t1,t2,…,tn] ；
(2) 构建候选关键词图G=(V,E)，其中V为节点集(由候选关键词组成)，并采用共现关系构造任意两点之间的边，两个节点之间仅当它们对应的词汇在长度为k的窗口中共现则表示两者之间存在边，k表示窗口大小，即共现窗口中最多共现k个词汇；
(3) 根据PageRank公式迭代计算各节点的权重，直至收敛；
(4) 对各节点权重进行倒序排列，得到排名前TopN个词汇作为文本关键词。
好了，本次分享到此。还是那句话：纸上得来终觉浅，绝知此事要躬行。由于时间关系，这里老shi就不展示具体实现代码了，但希望同学们自觉去尝试练习和实现以上介绍的两种文本关键词提取方法，这样才能加深理解老shi介绍的知识，真正为“你”所用！最后，不得不说之前由于个人原因，本公众号文章更新经常不及时，让粉丝们久等了，在此对粉丝们表示抱歉！接下来老shi会保持每两周更新1-2篇公众号文章的标准，请大家及时关注！如果觉得老shi的文章对你有所帮助，也希望同学们多多转发给你们的朋友，感谢大家的支持！

	

最近在研究关键词的提取算法，看到一篇关于关键词提取算法的总结，比较全面了，在这里分享给大家，希望能够帮助同学们~
原文链接：https://blog.nowcoder.net/n/ac016f8256f54c4b8c8784e99bccf28a
(ps：作者同意转发，如果想了解更多，请阅读全文)
目录
一、关键词提取概述
二、TF-IDF关键词提取算法及实现
三、TextRank关键词提取算法实现
四、LDA主题模型关键词提取算法及实现
五、Word2Vec词聚类的关键词提取算法及实现
六、信息增益关键词提取算法及实现
七、互信息关键词提取算法及实现
八、卡方检验关键词提取算法及实现
九、基于树模型的关键词提取算法及实现
十、总结
一、关键词提取概述
关键词是能够表达文档中心内容的词语，常用于计算机系统标引论文内容特征、信息检索、系统汇集以供读者检阅。关键词提取是文本挖掘领域的一个分支，是文本检索、文档比较、摘要生成、文档分类和聚类等文本挖掘研究的基础性工作。
从算法的角度来看，关键词提取算法主要有两类：无监督关键词提取方法和有监督关键词提取方法。
1、无监督关键词提取方法
不需要人工标注的语料，利用某些方法发现文本中比较重要的词作为关键词，进行关键词提取。该方法是先抽取出候选词，然后对各个候选词进行打分，然后输出topK个分值最高的候选词作为关键词。根据打分的策略不同，有不同的算法，例如TF-IDF，TextRank，LDA等算法。
无监督关键词提取方法主要有三类：基于统计特征的关键词提取(TF,TF-IDF)；基于词图模型的关键词提取(PageRank,TextRank)；基于主题模型的关键词提取(LDA)
基于统计特征的关键词提取算法的思想是利用文档中词语的统计信息抽取文档的关键词；
基于词图模型的关键词提取首先要构建文档的语言网络图，然后对语言进行网络图分析，在这个图上寻找具有重要作用的词或者短语，这些短语就是文档的关键词；
基于主题关键词提取算法主要利用的是主题模型中关于主题分布的性质进行关键词提取；
2、有监督关键词提取方法
将关键词抽取过程视为二分类问题，先提取出候选词，然后对于每个候选词划定标签，要么是关键词，要么不是关键词，然后训练关键词抽取分类器。当新来一篇文档时，提取出所有的候选词，然后利用训练好的关键词提取分类器，对各个候选词进行分类，最终将标签为关键词的候选词作为关键词。
3、无监督方法和有监督方法优的缺点
无监督方法不需要人工标注训练集合的过程，因此更加快捷，但由于无法有效综合利用多种信息 对候选关键词排序，所以效果无法与有监督方法媲美；而有监督方法可以通过训练学习调节多种信息对于判断关键词的影响程度，因此效果更优，有监督的文本关键词提取算法需要高昂的人工成本，因此现有的文本关键词提取主要采用适用性较强的无监督关键词提取。
4、关键词提取常用工具包
jieba
Textrank4zh (TextRank算法工具)
SnowNLP  (中文分析)简体中文文本处理
TextBlob (英文分析)
二、TF-IDF关键词提取算法及实现
TF-IDF算法的详细介绍及实现方法总结参看博客：TF-IDF算法介绍及实现
三、TextRank关键词提取算法实现
TextRank算法的详细介绍及实现方法总结参看博客：TextRank算法介绍及实现
四、LDA主题模型关键词提取算法及实现
1、LDA(Latent Dirichlet Allocation)文档主题生成模型
主题模型是一种统计模型用于发现文档集合中出现的抽象“主题”。主题建模是一种常用的文本挖掘工具，用于在文本体中发现隐藏的语义结构。
LDA也称三层贝叶斯概率模型，包含词、主题和文档三层结构；利用文档中单词的共现关系来对单词按主题聚类，得到“文档-主题”和“主题-单词”2个概率分布。
2、基于LDA主题模型的关键词提取算法实现
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
from gensim import corpora, models
import jieba.posseg as jp
import jieba
  
# 简单文本处理
def get_text(text):
    flags = ('n', 'nr', 'ns', 'nt', 'eng', 'v', 'd')  # 词性
    stopwords = ('的', '就', '是', '用', '还', '在', '上', '作为')  # 停用词
    words_list = []
    for text in texts:
        words = [w.word for w in jp.cut(text) if w.flag in flags and w.word not in stopwords]
        words_list.append(words)
    return words_list
  
# 生成LDA模型
def LDA_model(words_list):
    # 构造词典
    # Dictionary()方法遍历所有的文本，为每个不重复的单词分配一个单独的整数ID，同时收集该单词出现次数以及相关的统计信息
    dictionary = corpora.Dictionary(words_list)
    print(dictionary)
    print('打印查看每个单词的id:')
    print(dictionary.token2id)  # 打印查看每个单词的id
 
    # 将dictionary转化为一个词袋
    # doc2bow()方法将dictionary转化为一个词袋。得到的结果corpus是一个向量的列表，向量的个数就是文档数。
    # 在每个文档向量中都包含一系列元组,元组的形式是(单词 ID，词频)
    corpus = [dictionary.doc2bow(words) for words in words_list]
    print('输出每个文档的向量:')
    print(corpus)  # 输出每个文档的向量
 
    # LDA主题模型
    # num_topics -- 必须，要生成的主题个数。
    # id2word    -- 必须，LdaModel类要求我们之前的dictionary把id都映射成为字符串。
    # passes     -- 可选，模型遍历语料库的次数。遍历的次数越多，模型越精确。但是对于非常大的语料库，遍历太多次会花费很长的时间。
    lda_model = models.ldamodel.LdaModel(corpus=corpus, num_topics=2, id2word=dictionary, passes=10)
 
    return lda_model
  
if __name__ == "__main__":
    texts = ['作为千元机中为数不多拥有真全面屏的手机，OPPO K3一经推出，就簇拥不少粉丝', \
             '很多人在冲着这块屏幕购买了OPPO K3之后，发现原来K3的过人之处不止是在屏幕上', \
             'OPPO K3的消费者对这部手机总体还是十分满意的', \
             '吉利博越PRO在7月3日全新吉客智能生态系统GKUI19发布会上正式亮相', \
             '今年上海车展，长安CS75 PLUS首次亮相', \
             '普通版车型采用的是双边共双出式排气布局；运动版本车型采用双边共四出的排气布局']
    # 获取分词后的文本列表
    words_list = get_text(texts)
    print('分词后的文本：')
    print(words_list)
 
    # 获取训练后的LDA模型
    lda_model = LDA_model(words_list)
 
    # 可以用 print_topic 和 print_topics 方法来查看主题
    # 打印所有主题，每个主题显示5个词
    topic_words = lda_model.print_topics(num_topics=2, num_words=5)
    print('打印所有主题，每个主题显示5个词:')
    print(topic_words)
 
    # 输出该主题的的词及其词的权重
    words_list = lda_model.show_topic(0, 5)
    print('输出该主题的的词及其词的权重:')
    print(words_list)
运行结果：
五、Word2Vec词聚类的关键词提取算法及实现
1、Word2Vec词向量表示
利用浅层神经网络模型自动学习词语在语料库中的出现情况，把词语嵌入到一个高维的空间中，通常在100-500维，在高维空间中词语被表示为词向量的形式。
特征词向量的抽取是基于已经训练好的词向量模型。
2、K-means聚类算法
聚类算法旨在数据中发现数据对象之间的关系，将数据进行分组，使得组内的相似性尽可能的大，组间的相似性尽可能的小。
算法思想是：首先随机选择K个点作为初始质心，K为用户指定的所期望的簇的个数，通过计算每个点到各个质心的距离，将每个点指派到最近的质心形成K个簇，然后根据指派到簇的点重新计算每个簇的质心，重复指派和更新质心的操作，直到簇不发生变化或达到最大的迭代次数则停止。
3、基于Word2Vec词聚类关键词提取方法的实现过程
主要思路是对于用词向量表示的词语，通过K-Means算法对文章中的词进行聚类，选择聚类中心作为文本的一个主要关键词，计算其他词与聚类中心的距离即相似度，选择topK个距离聚类中心最近的词作为关键词，而这个词间相似度可用Word2Vec生成的向量计算得到。
具体步骤如下：
对语料进行Word2Vec模型训练，得到词向量文件；
对文本进行预处理获得N个候选关键词；
遍历候选关键词，从词向量文件中提取候选关键词的词向量表示；
对候选关键词进行K-Means聚类，得到各个类别的聚类中心(需要人为给定聚类的个数)；
计算各类别下，组内词语与聚类中心的距离(欧几里得距离或曼哈顿距离)，按聚类大小进行降序排序；
对候选关键词计算结果得到排名前TopK个词语作为文本关键词。
注：第三方工具包Scikit-learn提供了K-Means聚类算法的相关函数，本文用到了sklearn.cluster.KMeans()函数执行K-Means算法，sklearn.decomposition.PCA()函数用于数据降维以便绘制图形。
六、信息增益关键词提取算法及实现
信息增益算法的详细介绍及实现方法总结参看博客：信息增益算法介绍及实现
七、互信息关键词提取算法及实现
1、互信息(Mutual Information，MI)
在概率论和信息论中，两个随机变量的互信息或转移信息(transinformation)是变量间相互依赖性的量度。不同于相关系数，互信息并不局限于实值随机变量，它更加一般且决定着联合分布 p(X,Y) 和分解的边缘分布的乘积 p(X)p(Y) 的相似程度。互信息是度量两个事件集合之间的相关性(mutual dependence)。
互信息被广泛用于度量一些语言现象的相关性。在信息论中，互信息常被用来衡量两个词的相关度，也用来计算词与类别之间的相关性。
2、互信息计算公式
 3、互信息算法实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from sklearn import metrics
import numpy as np
 
# 训练集和训练标签
x_train = [[1, 2, 3, 4, 5],
           [5, 4, 3, 2, 1],
           [3, 3, 3, 3, 3],
           [1, 1, 1, 1, 1]]
y_train = [0, 1, 0, 1]
# 测试集和测试标签
x_test = [[2, 2, 2, 2, 2], [2, 1, 1, 2, 1]]
 
x_train = np.array(x_train)  # 转为array
 
# 存储每个特征与标签相关性得分
features_score_list = []
for i in range(len(x_train[0])):
    # 计算每个特征与标签的互信息
    feature_info = metrics.mutual_info_score(y_train, x_train[:, i])
    features_score_list.append(feature_info)
 
print(features_score_list)
运行结果： 
4、信息论中的互信息和决策树中的信息增益的关系 
两者表达意思是一样的，都是表示得知特征 X 的信息而使得类 Y 的信息的不确定性减少的程度。
注：
标准化互信息(Normalized Mutual Information，NMI)可以用来衡量两种聚类结果的相似度。
标准化互信息Sklearn实现：metrics.normalized_mutual_info_score(y_train, x_train[:, i])。
点互信息(Pointwise Mutual Information，PMI)这个指标来衡量两个事物之间的相关性(比如两个词)。
八、卡方检验关键词提取算法及实现
1、卡方检验
卡方是数理统计中用于检验两个变量独立性的方法，是一种确定两个分类变量之间是否存在相关性的统计方法，经典的卡方检验是检验定性自变量对定性因变量的相关性。
2、基本思路
原假设：两个变量是独立的
计算实际观察值和理论值之间的偏离程度
如果偏差足够小，小于设定阈值，就接受原假设；否则就否定原假设，认为两变量是相关的。
3、计算公式
其中，A为实际值，T为理论值。卡方检验可用于文本分类问题中的特征选择，此时不需要设定阈值，只关心找到最为相关的topK个特征。基本思想：比较理论频数和实际频数的吻合程度或者拟合优度问题。
4、基于sklearn的卡方检验实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
 
# 训练集和训练标签
x_train = [[1, 2, 3, 4, 5],
           [5, 4, 3, 2, 1],
           [3, 3, 3, 3, 3],
           [1, 1, 1, 1, 1]]
y_train = [0, 1, 0, 1]
# 测试集和测试标签
x_test = [[2, 2, 2, 2, 2], [2, 1, 1, 2, 1]]
y_test = [1, 1]
 
# 卡方检验选择特征
chi2_model = SelectKBest(chi2, k=3)  # 选择k个最佳特征
# 该函数选择训练集里的k个特征，并将训练集转化所选特征
x_train_chi2 = chi2_model.fit_transform(x_train, y_train)
# 将测试集转化为所选特征
x_test_chi2 = chi2_model.transform(x_test)
 
print('各个特征的得分：', chi2_model.scores_)
print('各个特征的p值：', chi2_model.pvalues_)  # p值越小，置信度越高，得分越高
print('所选特征的索引：', chi2_model.get_support(True))
print('特征提取转换后的训练集和测试集...')
print('x_train_chi2:', x_train_chi2)
print('x_test_chi2:', x_test_chi2)
运行结果：
九、基于树模型的关键词提取算法及实现
1、树模型
主要包括决策树和随机森林，基于树的预测模型(sklearn.tree 模块和 sklearn.ensemble 模块)能够用来计算特征的重要程度，因此能用来去除不相关的特征(结合 sklearn.feature_selection.SelectFromModel)
sklearn.ensemble模块包含了两种基于随机决策树的平均算法：RandomForest算法和Extra-Trees算法。这两种算法都采用了很流行的树设计思想：perturb-and-combine思想。这种方法会在分类器的构建时，通过引入随机化，创建一组各不一样的分类器。这种ensemble方法的预测会给出各个分类器预测的平均。
RandomForests 在随机森林(RF)中，该ensemble方法中的每棵树都基于一个通过可放回抽样(boostrap)得到的训练集构建。另外，在构建树的过程中，当split一个节点时，split的选择不再是对所有features的最佳选择。相反的，在features的子集中随机进行split反倒是最好的split方式。sklearn的随机森林(RF)实现通过对各分类结果预测求平均得到，而非让每个分类器进行投票(vote)。
Ext-Trees 在Ext-Trees中(详见ExtraTreesClassifier和 ExtraTreesRegressor)，该方法中，随机性在划分时会更进一步进行计算。在随机森林中，会使用侯选feature的一个随机子集，而非查找最好的阈值，对于每个候选feature来说，阈值是抽取的，选择这种随机生成阈值的方式作为划分原则。
2、树模型的关键词提取算法实现
(1)部分代码实现1
1
2
3
4
5
6
7
8
9
10
11
12
1
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.feature_selection import SelectFromModel
 
# 导入SelectFromModel结合ExtraTreesClassifier计算特征重要性，并按重要性阈值选择特征。
# 基于树模型进行模型选择
clf_model = ExtraTreesClassifier(n_estimators=250, random_state=0)
clf_model.fit(x_train, y_train)
# 获取每个词的特征权重,数值越高特征越重要
importances = clf_model.feature_importances_
# 选择特征重要性为1.5倍均值的特征
model = SelectFromModel(clf_model, threshold='1.5*mean', prefit=True)
x_train_new = model.transform(x_train)  # 返回训练集所选特征
x_test_new = model.transform(x_test)  # 返回测试集所选特征
(2)部分代码实现2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 训练集和训练标签
x_train, y_train
# 候选特征词列表
words_list
 
# 基于树模型进行模型选择
forest = RandomForestClassifier(n_estimators=250, random_state=0)
forest.fit(x_train, y_train)
importances = forest.feature_importances_  # 获取每个词的特征权重
 
# 将词和词的权重存入字典
feature_words_dic = {}
for i in range(len(words_list)):
    feature_words_dic[words_list[i]] = importances[i]
 
# 对字典按权重由大到小进行排序
words_info_dic_sort = sorted(words_info_dic.items(), key=lambda x: x[1], reverse=True)
 
# 将关键词和词的权重分别存入列表
keywords_list = []  # 关键词列表
features_list = []  # 关键权重列表
for word in words_info_dic_sort:
    keywords_list.append(word[0])
    features_list.append(word[1])
 
# 选取前一千个关键词和权重写入文本文件
keywords = keywords_list[:1000]
features = features_list[:1000]
 
# 将含有关键字的文本写入文件
with open('data/keywords_features.txt', 'a', encoding="utf-8") as f:
    for i in range(len(keywords)):
        f.write(keywords[i] + '\t' + features[i] + '\n')
十、总结
本文总结了本人在实验过程中所用到的常用关键词抽取方法，实验数据是基于公司的内部数据，但此篇总结只是方法上的讲解和实现，没有针对某一具体数据集做相应的结果分析。从实验中可以很明显看出有监督关键词抽取方法通常会显著好于无监督方法，但是有监督方法依赖一定规模的标注数据。
NLP关键词提取自然语言处理