TFIDF原理
 
对于若干个文章的集合，我们要提取每篇文章具有代表性的关键词，我们应该怎么做呢？
 
最直观也是最容易想到的方法，就是统计每个词汇在文章中出现的频率TF（term frequency），频率高的就是具有代表性的词汇。TF的计算方法如下：
 
                                                           
 
另外一点，举个例子，我们有三类文章A,B,C，首先这3篇文章都有一个高频率词汇“中国”（而且是频率最高的词汇），其次，A文章第二高频词汇为“体育”，B“艺术”，C“音乐”；请问，你觉得“中国”可以作为ABC任意一片文章最具有代表性的词汇吗？明显不可以。所以，除了考虑词汇的频率之外，还需考虑词汇在其他文档当中出现的概率，我们通常认为：如果一个词汇在某篇文章中出现了，而在其他文章中没有出现，则该词汇更偏向于是该文章的关键词。我们用一下公式来衡量：
 
                                                
 
综合考虑以上两个关键词要素，我们可以得到TFIDF的计算公式：
 
                                                  
 
参考文献：
 
[1] tfidf - wiki
 
[2] TF-IDF与余弦相似性的应用（一）：自动提取关键词

import gensim
import math
import jieba
import jieba.posseg as posseg
from jieba import analyse
from gensim import corpora, models
import functools
import numpy as np


# 停用词表加载方法
# 停用词表存储路径，每一行为一个词，按行读取进行加载
# 进行编码转换确保匹配准确率
def get_stopword_list():
    stopword_path = '.\\stopword.txt'
    stopword_list = [sw.replace('\n', '') for sw in open(stopword_path, encoding='utf8').readlines()]
    return stopword_list


# 分词方法，调用结巴接口
def seg_to_list(sentence, pos=False):
    if not pos:
        # 不进行词性标注分词
        seg_list = jieba.cut(sentence)
    else:
        # 进行词性标注分词
        seg_list = posseg.cut(sentence)

    return seg_list


# 去除干扰词
def word_filter(seg_list, pos=False):
    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 word not in stopword_list and len(word) > 1:
            filter_list.append(word)
    return filter_list


# 数据加载，pos为是否词性标注的参数，corpus_path为数据集路径
def load_data(pos=False, corpus_path='.\\corpus.txt'):
    # 调用上面方式对数据集进行处理，处理后的每条数据仅保留非干扰词
    doc_list = []
    for line in open(corpus_path,  'r', encoding='utf8'):
        content = line.strip()
        seg_list = seg_to_list(content, pos)
        filter_list = word_filter(seg_list, pos)
        doc_list.append(filter_list)

    return doc_list


# idf值统计方法
def train_idf(doc_list):
    idf_dic = {}
    # 总文档数
    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/(v+1.0))

    # 对于没有在字典中的词，默认其仅在一个文档出现，得到默认idf值
    default_idf = math.log(tt_count/1.0)
    return idf_dic, default_idf


#  排序函数，用于topK关键词的按值排序
def cmp(e1, e2):
    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


# TF-IDF类
class TfIdf(object):
    # 四个参数分别是：训练好的idf字典，默认idf值，处理后的待提取文本，关键词数量
    def __init__(self, idf_dic, default_idf, word_list, keyword_num):
        self.word_list = word_list
        self.idf_dic, self.default_idf = idf_dic, default_idf
        self.tf_dic = self.get_tf_dic()
        self.keyword_num = keyword_num

        # 统计tf值
    def get_tf_dic(self):
        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

        return tf_dic

    # 按公式计算tf-idf
    def get_tfidf(self):
        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()


# 主题模型
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.tfidf_corpus = 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 doc2bowvec(self, word_list):
        vec_list = [1 if word in word_list else 0 for word in self.dictionary]
        print("vec_list", vec_list)
        return vec_list

    # 词空间构建方法和向量化方法，在没有gensim接口时的一般处理方法
    def word_dictionary(self, doc_list):
        dictionary = []
        # 2及变1及结构
        for doc in doc_list:
            # extend he append 方法有何异同 容易出错
            dictionary.extend(doc)

        dictionary = list(set(dictionary))

        return dictionary

    # 得到数据集的主题 - 词分布
    def get_wordtopic(self, word_dic):
        wordtopic_dic = {}
        for word in word_dic:
            singlist = [word]
            # 计算每个词胡加权向量
            word_corpus = self.tfidf_model[self.dictionary.doc2bow(singlist)]
            # 计算每个词de主题向量
            word_topic = self.model[word_corpus]
            wordtopic_dic[word] = word_topic

        return wordtopic_dic

    def train_lsi(self):
        lsi = models.LsiModel(self.tfidf_corpus, id2word=self.dictionary, num_topics=self.num_topics)
        return lsi

    def train_lda(self):
        lda = models.LdaModel(self.tfidf_corpus, id2word=self.dictionary, num_topics=self.num_topics)
        return lda

    # 计算词的分布和文档的分布的相似度，取相似度最高的keyword_num个词作为关键词
    def get_simword(self, word_list):
        # 文档的加权向量
        sentcorpus = self.tfidf_model[self.dictionary.doc2bow(word_list)]
        # 文档主题 向量
        senttopic = self.model[sentcorpus]
        # senttopic [(0, 0.03457821), (1, 0.034260772), (2, 0.8970413), (3, 0.034119748)]
        # 余弦相似度计算

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


# 计算TFIDF值 并输出前10个关键字
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 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)


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


# test
if __name__ == '__main__':
    text = '6月19日,《2012年度“中国爱心城市”公益活动新闻发布会》在京举行。' + \
           '中华社会救助基金会理事长许嘉璐到会讲话。基金会高级顾问朱发忠,全国老龄' + \
           '办副主任朱勇,民政部社会救助司助理巡视员周萍,中华社会救助基金会副理事长耿志远,' + \
           '重庆市民政局巡视员谭明政。晋江市人大常委会主任陈健倩,以及10余个省、市、自治区民政局' + \
           '领导及四十多家媒体参加了发布会。中华社会救助基金会秘书长时正新介绍本年度“中国爱心城' + \
           '市”公益活动将以“爱心城市宣传、孤老关爱救助项目及第二届中国爱心城市大会”为主要内容,重庆市' + \
           '、呼和浩特市、长沙市、太原市、蚌埠市、南昌市、汕头市、沧州市、晋江市及遵化市将会积极参加' + \
           '这一公益活动。中国雅虎副总编张银生和凤凰网城市频道总监赵耀分别以各自媒体优势介绍了活动' + \
           '的宣传方案。会上,中华社会救助基金会与“第二届中国爱心城市大会”承办方晋江市签约,许嘉璐理' + \
           '事长接受晋江市参与“百万孤老关爱行动”向国家重点扶贫地区捐赠的价值400万元的款物。晋江市人大' + \
           '常委会主任陈健倩介绍了大会的筹备情况。'

    pos = True
    seg_list = seg_to_list(text, pos)
    filter_list = word_filter(seg_list, pos)

    print('TF-IDF模型结果：')
    tfidf_extract(filter_list, pos, 10)
    # 晋江市/ 城市/ 大会/ 爱心/ 中华/ 基金会/ 陈健倩/ 重庆市/ 许嘉璐/ 巡视员/
    print('LSI模型结果：')
    topic_extract(filter_list, 'LSI', pos)
    print('LDA模型结果：')
    topic_extract(filter_list, 'LDA', pos)
    print('TextRank模型结果：')
    textrank_extract(text)

# LDA模型结果：
# doc_list>>>>>>>>>>> [['南都讯', '记者', '刘凡', '周昌', '日票', '深圳', '地铁', '车厢', '...]..]
# 先构建词空间self.dictionary  Dictionary(4064 unique tokens: ['上将', '专门', '乘客', '仪式', '体验']...)
# 使用BOW模型向量化corpus [[(0, 1), (1, 1), (2, 2), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), ...
# dictionary变化前 ['南都讯', '记者', '刘凡', '周昌', '日票', '深圳', '地铁', '车厢', '坐票',..
# dictionary变化后 ['四联', '注音版', '前瞻性', '饲料', '成正比', '省城', '正值', '养白',
# self.wordtopic_dic 得到数据集的主题-词分布 {'四联': [(0, 0.12684152), (1, 0.12683797), (2, 0.12792856),
# (3, 0.61839193)], '注音版': [(0, 0.61396044), (1, 0.12880294), (2, 0.12856448), ....
# 晋江市/ 年度/ 频道/ 民政部/ 大会/ 陈健倩/ 许嘉璐/ 重庆市/ 人大常委会/ 巡视员/

# LDA 和LSI LSA步骤总结
# 数据集处理
# 1先构建词空间  Dictionary(4064 unique tokens: ['上将', '专门', '乘客', '仪式', '体验']...)
# 2使用BOW模型向量化   corpus [[(0, 1), (1, 1), (2, 2), (3, 1),。。。
# 3对每个词，根据tf-idf进行加权，得到加权后的向量表示
# 根据数据集获得模型
# 4得到数据集的主题-词分布  model (得到每个词的向量）（文档转列表 再转集合去重，再转列表）
# {'白血病': [(0, 0.1273009), (1, 0.6181468), (2, 0.12732704), (3, 0.12722531)], '婴儿': [。。。
# 然后求文档 文档的分布的
# 5词》向量》tf/idf加权》同第4步得到文档的分布向量 [(0, 0.033984687), (1, 0.033736005), (2, 0.8978361), (3, 0.03444325)]
# 计算余弦距离得到结果


# list.append(object) 向列表中添加一个对象object
# list.extend(sequence) 把一个序列seq的内容添加到列表中
# music_media = ['compact disc', '8-track tape', 'long playing record']
# new_media = ['DVD Audio disc', 'Super Audio CD']
# music_media.append(new_media)
# print music_media
# >>>['compact disc', '8-track tape', 'long playing record', ['DVD Audio disc', 'Super Audio CD']]
# 使用append的时候，是将new_media看作一个对象，整体打包添加到music_media对象中。
# music_media = ['compact disc', '8-track tape', 'long playing record']
# new_media = ['DVD Audio disc', 'Super Audio CD']
# music_media.extend(new_media)
# print music_media
# >>>['compact disc', '8-track tape', 'long playing record', 'DVD Audio disc', 'Super Audio CD']
 
 

 

 

  
 
 
 商品评论标签提取作为商品评论中的一个比较有意思的问题。评论标签提取的主要任务是从评论中了解到用户对产品的哪些功能、属性进行了怎样的评论，并抽取成简短有效的信息。
 
关键词提取Vs评论标签提取
 
 商品标签提取和关键词的抽取还不是同样的NLP问题，关键词提取更侧重于文章或者评论本身表达的意义，关键词窥探整个文本的主题思想，实验证明像TextRank, TFIDF等传统的方法抽取出来的关键词和评论观点相差很远。
 
 目前我们实验了两版抽取过程，V1.0主要是基于深度学习TextCNN分类模型，V2.0主要是人工强规则+TextCNN模型，我们定义为半监督的个性化标签抽取。哈哈哈，名字比较忽悠人。。。。
 
 标签提取，可以理解是一个多分类问题。我们首先想到了现在最火的深度学习模型FastText或者TextCNN，做分类准确率高，速度也要保证。但是在这个过程中需要大量的样本，自己标注，好像不太现实。首先我们想到了友商的评论数据，在此特意感谢一下友商贡献的标注数据。我们爬取了大概700w带标签的评论数据，针对有些数据不太符合我们的要求，剔除其中的一些。经过整理后，我们使用TextCNN模型（TextCNN会在下面的文章进行介绍）做多分类处理。
 
 样本大概为：“快递送货较快，满意。空调外观大气、美观，个人非常喜欢，老婆也觉得很不错。安装的位置也很合适，看上去跟装修风格很搭，很不错。安装完毕后还给打扫了卫生，点个赞！”对应的标签：漂亮美观。
 
 总体来说准确度和效果都不错，但是友商也有不厚道的地方，不提供差评标签。话说你买东西看评论是看差评的多一些还是好评的一些？
 

 

  
 
 
 反正我等这样的三流码农是看差评的，呵呵...
 
 还有毕竟别人家的商品标签是针对自家商品来说的，我们自己的SKU产品智能设备和电子产品比较多，貌似都用他们的也不太合理。基于这些，我们就需要自己定义自己的个性化标签。下面说说我们自己的评论标签提的过程。
 
 个性化标签提取
 
 1.词性+规则: 这个是比较容易实施的最简单的方法,比如主体词性一般为名词或名词短语，而修饰词一般为形容词或动名词之类的。根据既定规则，我们可以把句子分词、词性标注，然后提取出名词和形容词动名词之类，在这里我们使用的是HanLp这个自然语言处理包。大概处理流程是先分词-->词性标注-->用规则提取tag。
 
 这种方法的优点是简单、快速，但是缺点是显而易见的----精度不高。因为提取的名词和形容词可能没有关系，还有可能词性标注错了（词性标注不可能百分百正确）被错误召回。比如“小米开机很快”用这种方法会召回“小米”（名词）、“很快”（形容词），这显然是错误的。 如下图“小米”和“很快”没半毛钱关系。
 

 

  
 
 
 2.依存关系+词性+规则：针对上述方法存在的问题，很自然的引入句法分析来验证句子成分之间的关系。大概处理的方法是在上面的基础上进行句子依存关系分析。我们发现我们需要的标签类型大概如:外观不错，质量很好，制工精巧等，这样的标签短语句式都是主谓宾结构的。
 
再如：小米手机外观看起来还是很大气的
 

 

  
 
 
 根据规则提取出主体名词为“外观”，形容词为“大气”，“看起来”、“还是”、“很”都是修饰“大气”的，组成ADV（状中关系），“外观”和“大气”组成SBV(主谓关系)，显然句法成分验证没问题，最终评论标签: 外观+大气。
 
 3.标签归一化
 
 在抽取句子标签的过程中，我们利用上述规则可能抽取了很多短语，比如：质量不错，质量很好，东西不错，做工精巧，做工精妙，做工不错，做工还行等一系列这样的相似短语，这个时候可能还需要对评价词/观点词进行归一化处理，如：“质量不错，质量很好，东西不错”都归一化为“质量好”这个标签，“做工精巧，做工精妙，做工不错，做工还行”归一化到“做工精巧，那么如何进行归一化处理呢？这个时候我们需要使用21世界自然语言处理界最伟大的发明之一 word2vec了，利用DBSCAN+Word2Vec对候选标签进行层次化聚类，然后针对每个品类取top20的标签进行人工review。具体过程就不说了，有兴趣的可以下面留言讨论。
 
 这样我们就完事了吗？通过上面的流程处理后，标签的提取基本上准确率非常高了，但是召回方面还是比较差的。怎么处理这样的问题呢？我们可以回想一下，上述方法基本上都是强规则的人工定义过程。我们可以利用这些处理过的数据回到有监督评论标签提：1.利用强规则提取标签，定义若干样本;2.对这些样本再进行一次TextCNN模型训练；3.利用训练好的TextCNN模型去作分类处理。经过上述方法，目前已经取得了非常好的效果。
 

 

  
 

转：https://blog.csdn.net/lo_single/article/details/76039748
 
tf-idf简介
 在信息提取的应用场景之中，我们往往需要一些文本中的重要的词而不是文本中的所有词语来进行分析，即使原文本已经进行了去停用词的处理。 
 那么什么样的词算是文本中的关键词呢？一方面，这个词应该在文本中出现的次数比较多；另一方面，这个词应该不那么常见，若是这个词在很多文档中都有出现，这个词显然不能用来作为代表某个文档的重要词汇。一个合适的算法便是tf-idf算法。 
 tf-idf是term frequency–inverse document frequency的缩写。该算法用一种统计学的方法来衡量一个词语在文本中的重要程度，常被用于信息提取、文本挖掘等场景之中。该算法的核心便是计算一个文本中某个词语的tf值与idf值。
 
tf计算
 tf是term frequency的缩写，指文本中的词频。衡量一个词语在文档中的出现频率有很多方法，最简单也足够有效的，便是直接计算这个词出现的次数，来作为这个词的tf值。
 
idf计算
 idf是inverse document frequency的缩写，指“逆文档频率”，是一个用来衡量一个词常见程度的值。这个值的计算不应该基于单个文档，而应该考虑所有要进行分析的文档，来得出结果。 
 idf值的计算方法也有很多，这里仅提供一个常见的公式： 
 
分母处加一，是为了防止某个词从未出现过而导致分母为0。
 算法实现
 上面的两个值显然都与一个词的重要程度正相关，所以将其直接相乘，以乘积比较不同词之间的重要程度差异。下面是使用
 
python的实现：
 
def idf(corpus):
    idfs = {}
    d = 0.0

    # 统计词出现次数
    for doc in corpus:
        d += 1
        counted = []
        for word in doc:
            if not word in counted:
                counted.append(word)
                if word in idfs: 
                    idfs[word] += 1
                else: 
                    idfs[word] = 1

    # 计算每个词逆文档值
    for word in idfs:
        idfs[word] = math.log(d/float(idfs[word]))

    return idfs


if __name__ == '__main__':
    # 获取需要的语料库，根据实际情况自行更改
    # 这里获取的语料库是每个文档的分词结果列表的列表
    corpus = getCorpus()
    idfs = idf(corpus)
    for doc in corpus:
        tfidfs = {}
        for word in doc:
            if word in tfs:
                tfidfs[word] += 1
            else:
                tfidfs[word] = 1
        for word in tfidfs:
            tfidfs[word] *= idfs[word]
 
总结
 tf-idf算法非常简单，但其有一个极为致命的缺陷，就是没有考虑词语的语义信息，无法处理一词多义与一义多词的情况。 
 在过去，往往通过结合一些外部信息如“知网”（WordNet）或者使用可以表达隐藏信息的概率模型来处理这一缺陷。 
 2013年，Google开源了其Word2Vec算法，通过计算上下文来将词语进行向量化表示，在正常的训练结果下语义相近的词语向量距离较近而语义较远的词语距离向量较远。结合这一深度学习的新算法，tf-idf的传统问题得到了很好的解决。
 --------------------- 
 作者：lo_single 
 来源：CSDN 
 原文：https://blog.csdn.net/lo_single/article/details/76039748 
 版权声明：本文为博主原创文章，转载请附上博文链接！