标签：2021.09.27工作内容
 参考资料：TF-IDF算法介绍及实现
 声明：本文中大量内容转载至参考资料，仅归纳整理和加入部分个人观点心得，侵删
 
概念
 
定义
 TF-IDF(term frequency-inverse document frequency)是一种用于信息检索与数据挖掘的常用加权技术，常用于挖掘文章中的关键词。
特点：简单高效，用于最开始的文本数据清洗。
TF-IDF
 （1）TF：词频
 可以统计到停用词，并把它们过滤，避免对结果造成影响。
 e.g.：“的”、“了”、“是”等等
 （2）IDF：逆文档频率
 在词的频率相同时，不同词的重要性却不同。IDF会给常见的词较小的权重。
 e.g.：假设“量化”和“系统”的词频相同，则重要性：“量化” > “系统”
实现方法
 当有TF和IDF后，将其相乘，能够得到一个词的TF-IDF的值。某个词在文章中的TF-IDF越大，那么它在文章中的重要性越高。
 
算法步骤
 
计算词频
 词频 = 某个词在文章中出现的次数 / 文章的总次数
计算逆文档的频率
 需要一个语料库（corpus）来模拟语言的使用环境。
 逆文档频率 = log(语料库的文档总数 / (包含该词的文档数 + 1))
计算TF-IDF
 TF-IDF= TF × IDF
 与一个词在文档中出现的次数成正比。
 与该词在整个语言中出现的次数成反比。
 
优缺点
 
优点
 简单高效，容易理解。
缺点
 （1）词频衡量此的重要性不够全面，有时重要的词出现得不多
 （2）无法体现位置信息=>无法体现该词在上下文中的重要性=>用word2vec算法来支持
 
python实现TF-IDF算法
 
自己构建语料库
 这个例子比较特殊，dataset既是语料库，可是我们要统计核心词的对象。
 
# -*- coding: utf-8 -*-
from collections import defaultdict
import math
import operator

"""
函数说明:创建数据样本
Returns:
    dataset - 实验样本切分的词条
    classVec - 类别标签向量
"""


def loadDataSet():
    dataset = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],  # 切分的词条
               ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
               ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'my'],
               ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
               ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
               ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    classVec = [0, 1, 0, 1, 0, 1]  # 类别标签向量，1代表好，0代表不好
    return dataset, classVec


"""
函数说明：特征选择TF-IDF算法
Parameters:
     list_words:词列表
Returns:
     dict_feature_select:特征选择词字典
"""
#dataset:文件夹，word_list:某一个文件，word某个词

def feature_select(dataset):
    # 总词频统计
    doc_frequency = defaultdict(int) #记录每个词出现的次数，可以把它理解成一个可变长度的list，只要你索引它，它就自动扩列
    for file in dataset:
        for word in file:
            doc_frequency[word] += 1
    # 计算每个词的TF值
    word_tf = {}  # 存储没个词的tf值
    for i in doc_frequency:
        word_tf[i] = doc_frequency[i] / sum(doc_frequency.values()) #sum(doc.frequency.values)

    # 计算每个词的IDF值
    doc_num = len(dataset)
    word_idf = {}  # 存储每个词的idf值
    word_doc = defaultdict(int)  # 存储包含该词的文档数
    for word in doc_frequency:
        for file in dataset:
            if word in file:
                word_doc[word] += 1
    #word_doc和doc_frequency的区别是word_doc存储的是包含这个词的文档数，即如果一个文档里有重复出现一个词则word_doc < doc_frequency
    for word in doc_frequency:
        word_idf[word] = math.log(doc_num / (word_doc[word] + 1))

    # 计算每个词的TF*IDF的值
    word_tf_idf = {}
    for word in doc_frequency:
        word_tf_idf[word] = word_tf[word] * word_idf[word]

    # 对字典按值由大到小排序
    dict_feature_select = sorted(word_tf_idf.items(), key=operator.itemgetter(1), reverse=True)
    return dict_feature_select


if __name__ == '__main__':
    data_list, label_list = loadDataSet()  # 加载数据
    features = feature_select(data_list)  # 所有词的TF-IDF值
    print(features)
 
运算结果：
 
 2. NLTK实现TF-IDF算法
 由于我的电脑安装了本地代理所以不能下载nltk的语料库，这里只贴代码供大家参考
 
from nltk.text import TextCollection
from nltk.tokenize import word_tokenize
 
#首先，构建语料库corpus
sents=['this is sentence one','this is sentence two','this is sentence three']
sents=[word_tokenize(sent) for sent in sents] #对每个句子进行分词
print(sents)  #输出分词后的结果
corpus=TextCollection(sents)  #构建语料库
print(corpus)  #输出语料库
 
#计算语料库中"one"的tf值
tf=corpus.tf('one',corpus)    # 1/12
print(tf)
 
#计算语料库中"one"的idf值
idf=corpus.idf('one')      #log(3/1)
print(idf)
 
#计算语料库中"one"的tf-idf值
tf_idf=corpus.tf_idf('one',corpus)
print(tf_idf)
 
利用sklearn做tf-idf
 
import sklearn
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer

x_train = ['TF-IDF 主要 思想 是', '算法 一个 重要 特点 可以 脱离 语料库 背景',
           '如果 一个 网页 被 很多 其他 网页 链接 说明 网页 重要']
x_test = ['原始 文本 进行 标记', '主要 思想']

# 该类会将文本中的词语转换为词频矩阵，矩阵元素a[i][j] 表示j词在i类文本下的词频
vectorizer = CountVectorizer(max_features=10) #列数为10
# 该类会统计每个词语的tf-idf权值
tf_idf_transformer = TfidfTransformer()
# 将文本转为词频矩阵并计算tf-idf
tf_idf = tf_idf_transformer.fit_transform(vectorizer.fit_transform(x_train))
# 将tf-idf矩阵抽取出来，元素a[i][j]表示j词在i类文本中的tf-idf权重
x_train_weight = tf_idf.toarray()

# 对测试集进行tf-idf权重计算
tf_idf = tf_idf_transformer.transform(vectorizer.transform(x_test))
x_test_weight = tf_idf.toarray()  # 测试集TF-IDF权重矩阵

print('vectorizer.fit_transform(x_train) : ')
print(vectorizer.fit_transform(x_train))
print('输出x_train文本向量：')
print(x_train_weight)
print('输出x_test文本向量：')
print(x_test_weight)

 

 4. 利用Jieba实现tf-idf
 
import jieba.analyse
 
text='关键词是能够表达文档中心内容的词语，常用于计算机系统标引论文内容特征、
信息检索、系统汇集以供读者检阅。关键词提取是文本挖掘领域的一个分支，是文本检索、
文档比较、摘要生成、文档分类和聚类等文本挖掘研究的基础性工作'
 
keywords=jieba.analyse.extract_tags(text, topK=5, withWeight=False, allowPOS=())
print(keywords)
 
注：
 
jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
 sentence 为待提取的文本
 topK 为返回几个 TF/IDF 权重最大的关键词，默认值为 20
 withWeight 为是否一并返回关键词权重值，默认值为 False
 allowPOS 仅包括指定词性的词，默认值为空，即不筛选
 
运行结果：
 
 （安装不了就pip install jieba; conda install jieba; pip3 install jieba;都尝试一边，我用pip3安装才成功的，如果还不成功可以去jieba官网手动下载后自行配置到anaconda环境）

目录
 
1、TF-IDF算法介绍
 
（1）TF是词频(Term Frequency)
 
（2） IDF是逆向文件频率(Inverse Document Frequency)
 
（3）TF-IDF实际上是：TF * IDF
 
2、TF-IDF应用
 
3、Python3实现TF-IDF算法
 
4、NLTK实现TF-IDF算法
 
5、Sklearn实现TF-IDF算法
 
6、Jieba实现TF-IDF算法
 
7、TF-IDF算法的不足
 
8、TF-IDF算法改进——TF-IWF算法
 

1、TF-IDF算法介绍
 
       TF-IDF（term frequency–inverse document frequency，词频-逆向文件频率）是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。
 
       TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。
 
       TF-IDF的主要思想是：如果某个单词在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。
 
（1）TF是词频(Term Frequency)
 
        词频（TF）表示词条（关键字）在文本中出现的频率。
 
        这个数字通常会被归一化(一般是词频除以文章总词数), 以防止它偏向长的文件。
 
        公式：           即：
 
 
 
        其中 ni,j 是该词在文件 dj 中出现的次数，分母则是文件 dj 中所有词汇出现的次数总和；
 
（2） IDF是逆向文件频率(Inverse Document Frequency)
 
        逆向文件频率 (IDF) ：某一特定词语的IDF，可以由总文件数目除以包含该词语的文件的数目，再将得到的商取对数得到。
 
如果包含词条t的文档越少, IDF越大，则说明词条具有很好的类别区分能力。
 
        公式：         
 
        其中，|D| 是语料库中的文件总数。 |{j:ti∈dj}| 表示包含词语 ti 的文件数目（即 ni,j≠0 的文件数目）。如果该词语不在语料库中，就会导致分母为零，因此一般情况下使用 1+|{j:ti∈dj}|
 
        即：
 
（3）TF-IDF实际上是：TF * IDF
 
       某一特定文件内的高词语频率，以及该词语在整个文件集合中的低文件频率，可以产生出高权重的TF-IDF。因此，TF-IDF倾向于过滤掉常见的词语，保留重要的词语。
 
       公式：
 
     
 
       注：  TF-IDF算法非常容易理解，并且很容易实现，但是其简单结构并没有考虑词语的语义信息，无法处理一词多义与一义多词的情况。
 
2、TF-IDF应用
 
     （1）搜索引擎；（2）关键词提取；（3）文本相似性；（4）文本摘要
 
3、Python3实现TF-IDF算法
 
注意：该代码tf计算使用的是整个语料，这里只是举个简单的例子，大家在写的时候按文档计算词频即可！我这里就不做修改了
 
# -*- coding: utf-8 -*-
from collections import defaultdict
import math
import operator

"""
函数说明:创建数据样本
Returns:
    dataset - 实验样本切分的词条
    classVec - 类别标签向量
"""
def loadDataSet():
    dataset = [ ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],    # 切分的词条
                   ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                   ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                   ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                   ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                   ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid'] ]
    classVec = [0, 1, 0, 1, 0, 1]  # 类别标签向量，1代表好，0代表不好
    return dataset, classVec


"""
函数说明：特征选择TF-IDF算法
Parameters:
     list_words:词列表
Returns:
     dict_feature_select:特征选择词字典
"""
def feature_select(list_words):
    #总词频统计
    doc_frequency=defaultdict(int)
    for word_list in list_words:
        for i in word_list:
            doc_frequency[i]+=1

    #计算每个词的TF值
    word_tf={}  #存储没个词的tf值
    for i in doc_frequency:
        word_tf[i]=doc_frequency[i]/sum(doc_frequency.values())

    #计算每个词的IDF值
    doc_num=len(list_words)
    word_idf={} #存储每个词的idf值
    word_doc=defaultdict(int) #存储包含该词的文档数
    for i in doc_frequency:
        for j in list_words:
            if i in j:
                word_doc[i]+=1
    for i in doc_frequency:
        word_idf[i]=math.log(doc_num/(word_doc[i]+1))

    #计算每个词的TF*IDF的值
    word_tf_idf={}
    for i in doc_frequency:
        word_tf_idf[i]=word_tf[i]*word_idf[i]

    # 对字典按值由大到小排序
    dict_feature_select=sorted(word_tf_idf.items(),key=operator.itemgetter(1),reverse=True)
    return dict_feature_select

if __name__=='__main__':
    data_list,label_list=loadDataSet() #加载数据
    features=feature_select(data_list) #所有词的TF-IDF值
    print(features)
    print(len(features))
 
运行结果：
 
 
4、NLTK实现TF-IDF算法
 
from nltk.text import TextCollection
from nltk.tokenize import word_tokenize

#首先，构建语料库corpus
sents=['this is sentence one','this is sentence two','this is sentence three']
sents=[word_tokenize(sent) for sent in sents] #对每个句子进行分词
print(sents)  #输出分词后的结果
corpus=TextCollection(sents)  #构建语料库
print(corpus)  #输出语料库

#计算语料库中"one"的tf值
tf=corpus.tf('one',corpus)    # 1/12
print(tf)

#计算语料库中"one"的idf值
idf=corpus.idf('one')      #log(3/1)
print(idf)

#计算语料库中"one"的tf-idf值
tf_idf=corpus.tf_idf('one',corpus)
print(tf_idf)
 
运行结果：
 
 
5、Sklearn实现TF-IDF算法
 
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer

x_train = ['TF-IDF 主要 思想 是','算法 一个 重要 特点 可以 脱离 语料库 背景',
           '如果 一个 网页 被 很多 其他 网页 链接 说明 网页 重要']
x_test=['原始 文本 进行 标记','主要 思想']

#该类会将文本中的词语转换为词频矩阵，矩阵元素a[i][j] 表示j词在i类文本下的词频
vectorizer = CountVectorizer(max_features=10)
#该类会统计每个词语的tf-idf权值
tf_idf_transformer = TfidfTransformer()
#将文本转为词频矩阵并计算tf-idf
tf_idf = tf_idf_transformer.fit_transform(vectorizer.fit_transform(x_train))
#将tf-idf矩阵抽取出来，元素a[i][j]表示j词在i类文本中的tf-idf权重
x_train_weight = tf_idf.toarray()

#对测试集进行tf-idf权重计算
tf_idf = tf_idf_transformer.transform(vectorizer.transform(x_test))
x_test_weight = tf_idf.toarray()  # 测试集TF-IDF权重矩阵

print('输出x_train文本向量：')
print(x_train_weight)
print('输出x_test文本向量：')
print(x_test_weight)
 
运行结果：
 
 
6、Jieba实现TF-IDF算法
 
import jieba.analyse

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

keywords=jieba.analyse.extract_tags(text, topK=5, withWeight=False, allowPOS=())
print(keywords)
 
运行结果：
 
 
注：
 
jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
sentence 为待提取的文本
topK 为返回几个 TF/IDF 权重最大的关键词，默认值为 20
withWeight 为是否一并返回关键词权重值，默认值为 False
allowPOS 仅包括指定词性的词，默认值为空，即不筛选
7、TF-IDF算法的不足
 
TF-IDF 采用文本逆频率 IDF 对 TF 值加权取权值大的作为关键词，但 IDF 的简单结构并不能有效地反映单词的重要程度和特征词的分布情况，使其无法很好地完成对权值调整的功能，所以 TF-IDF 算法的精度并不是很高，尤其是当文本集已经分类的情况下。
 
在本质上 IDF 是一种试图抑制噪音的加权，并且单纯地认为文本频率小的单词就越重要，文本频率大的单词就越无用。这对于大部分文本信息，并不是完全正确的。IDF 的简单结构并不能使提取的关键词， 十分有效地反映单词的重要程度和特征词的分布情 况，使其无法很好地完成对权值调整的功能。尤其是在同类语料库中，这一方法有很大弊端，往往一些同类文本的关键词被盖。
 
TF-IDF算法实现简单快速，但是仍有许多不足之处：
 
（1）没有考虑特征词的位置因素对文本的区分度，词条出现在文档的不同位置时，对区分度的贡献大小是不一样的。
 
（2）按照传统TF-IDF，往往一些生僻词的IDF(反文档频率)会比较高、因此这些生僻词常会被误认为是文档关键词。
 
（3）传统TF-IDF中的IDF部分只考虑了特征词与它出现的文本数之间的关系，而忽略了特征项在一个类别中不同的类别间的分布情况。
 
（4）对于文档中出现次数较少的重要人名、地名信息提取效果不佳。
 
8、TF-IDF算法改进——TF-IWF算法
 
详细改进方法参看论文：改进的 TF-IDF 关键词提取方法
 
 
 
交流学习资料共享欢迎入QQ群：955817470

3.TF-IDF
 3.1.TF-IDF算法介绍
 3.2.TF-IDF应用
 3.3.NLTK实现TF-IDF算法
 3.4.Sklearn实现TF-IDF算法
 3.5.Jieba实现TF-IDF算法
 3.6.TF-IDF算法的不足
 3.7.TF-IDF算法改进—TF-IWF算法
 
3.TF-IDF
 
以下转自：https://blog.csdn.net/asialee_bird/article/details/81486700
 
3.1.TF-IDF算法介绍
 
TF-IDF（term frequency–inverse document frequency，词频-逆向文件频率）是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。
 
TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。
 
TF-IDF的主要思想是：如果某个单词在一篇文章中出现的频率TF高，并且在其它文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。
 
（1）TF是词频(Term Frequency)
 词频（TF）表示词条（关键字）在文本中出现的频率。
 这个数字通常会被归一化（一般是词除以文章总词数），以防止它偏向长的文件。
 
 其中ni,j是该词在文件dj中出现的次数，分母则是文件dj中所有词汇出现的次数总和;
 
（2）IDF是逆向文件频率(Inverse Document Frequency)
 逆向文件频率（IDF）:某一特定词语的IDF，可以由总文件数目除以包含该词语的文件的数目，再将得到的商取对数得到。
 如果包含词条t的文档越少,IDF越大，则说明词条具有很好的类别区分能力。
 
 其中，|D|是语料库中的文件总和。 |{j:ti∈dj}|表示包含词语ti的文件数目（即ni,j≠0的文件数目）。如果该词语不在语料库中，就会导致分母为零，因此一般情况下使用 1+|{j:ti∈dj}|
 
其中，|D| 是语料库中的文件总数。 |{j:ti∈dj}| 表示包含词语 ti 的文件数目（即 ni,j≠0 的文件数目）。如果该词语不在语料库中，就会导致分母为零，因此一般情况下使用 1+|{j:ti∈dj}|
 
即：
 
 （3）TF-IDF实际上是：TF*IDF
 某一特定文件内的高词语频率，以及该词语在整个文件集合中的低文件频率，可以产生出高权重的TF-IDF。因此，TF-IDF倾向于过滤掉常见的词语，保留重要的词语。
 公式：
 
 注：TF-IDF算法非常容易理解，并且很容易实现，但是其简单结构并没有考虑词语的语义信息，无法处理一词多义与一义多词的情况。
 
3.2.TF-IDF应用
 
（1）搜索引擎；（2）关键词提取；（3）文本相似性；（4）文本摘要
 
3.3.NLTK实现TF-IDF算法
 
from nltk.text import TextCollection
from nltk.tokenize import word_tokenize

# 首先，构建语料库corpus
sents = ['this is sentence one', 'this is sentence two', 'this is sentence three']
sents = [word_tokenize(sent) for sent in sents]  # 对每个句子进行分词
print(sents)  # 输出分词后的结果
'''
输出结果：
[['this', 'is', 'sentence', 'one'], ['this', 'is', 'sentence', 'two'], ['this', 'is', 'sentence', 'three']]
'''

corpus = TextCollection(sents)  # 构建语料库
print(corpus)  # 输出分词后的结果
'''
输出结果：
<Text: this is sentence one this is sentence two...>
'''

# 计算语料库中"one"的tf值
tf = corpus.tf('one', corpus)  # 结果为： 1/12
print(tf)
'''
输出结果：
0.08333333333333333
'''

# 计算语料库中"one"的idf值
idf = corpus.idf('one')  # log(3/1)
print(idf)
"""
输出结果：
1.0986122886681098
"""

# 计算语料库中"one"的tf-idf值
tf_idf = corpus.tf_idf('one', corpus)
print(tf_idf)
'''
输出结果：
0.0915510240556758
'''
 
3.4.Sklearn实现TF-IDF算法
 
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer

x_train = ['TF-IDF 主要 思想 是', '算法 一个 重要 特点 可以 脱离 语料库 背景',
           '如果 一个 网页 被 很多 其他 网页 链接 说明 网页 重要']
x_test = ['原始 文本 进行 标记', '主要 思想']

# 该类会将文本中的词语转换为词频矩阵，矩阵元素a[i][j] 表示j词在i类文本下的词频
vectorizer = CountVectorizer(max_features=10)
# 该类会统计每个词语的tf-idf权值
tf_idf_transformer = TfidfTransformer()
# 将文本转为词频矩阵并计算tf-idf
tf_idf = tf_idf_transformer.fit_transform(vectorizer.fit_transform(x_train))
print("--------------------------tf_idf-------------------------------")
print(tf_idf)
print('--------------------------x_train_weight-----------------------')
# 将tf-idf矩阵抽取出来，元素a[i][j]表示j词在i类文本中的tf-idf权重
x_train_weight = tf_idf.toarray()
print(x_train_weight)
print("---------------------------------------------------------------")

# 对测试集进行tf-idf权重计算
tf_idf = tf_idf_transformer.transform(vectorizer.transform(x_test))
x_test_weight = tf_idf.toarray()  # 测试集TF-IDF权重矩阵

print('输出x_train文本向量:')
print(x_train_weight)
print('输出x_test文本向量：')
print(x_test_weight)
 
输出结果：
 
--------------------------tf_idf-------------------------------
  (0, 2)	0.7071067811865476
  (0, 0)	0.7071067811865476
  (1, 9)	0.3349067026613031
  (1, 7)	0.4403620672313486
  (1, 6)	0.4403620672313486
  (1, 5)	0.4403620672313486
  (1, 3)	0.4403620672313486
  (1, 1)	0.3349067026613031
  (2, 9)	0.22769009319862868
  (2, 8)	0.29938511033757165
  (2, 4)	0.8981553310127149
  (2, 1)	0.22769009319862868
--------------------------x_train_weight-----------------------
[[0.70710678 0.         0.70710678 0.         0.         0.
  0.         0.         0.         0.        ]
 [0.         0.3349067  0.         0.44036207 0.         0.44036207
  0.44036207 0.44036207 0.         0.3349067 ]
 [0.         0.22769009 0.         0.         0.89815533 0.
  0.         0.         0.29938511 0.22769009]]
---------------------------------------------------------------
输出x_train文本向量:
[[0.70710678 0.         0.70710678 0.         0.         0.
  0.         0.         0.         0.        ]
 [0.         0.3349067  0.         0.44036207 0.         0.44036207
  0.44036207 0.44036207 0.         0.3349067 ]
 [0.         0.22769009 0.         0.         0.89815533 0.
  0.         0.         0.29938511 0.22769009]]
输出x_test文本向量：
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]]
 
3.5.Jieba实现TF-IDF算法
 
import jieba.analyse

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

keywords=jieba.analyse.extract_tags(text, topK=20, withWeight=False, allowPOS=())
print(keywords)
 
注：
 jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
 
sentence 为待提取的文本。
topK 为返回几个 TF/IDF 权重最大的关键词，默认值为 20
withWeight为是否一并返回关键词权重值，默认值为False
allowPOS仅包括指定词性的词，默认为空，即不筛选
 
3.6.TF-IDF算法的不足
 
TF-IDF 采用文本逆频率 IDF 对 TF 值加权取权值大的作为关键词，但 IDF 的简单结构并不能有效地反映单词的重要程度和特征词的分布情况，使其无法很好地完成对权值调整的功能，所以 TF-IDF 算法的精度并不是很高，尤其是当文本集已经分类的情况下。
 
在本质上 IDF 是一种试图抑制噪音的加权，并且单纯地认为文本频率小的单词就越重要，文本频率大的单词就越无用。这对于大部分文本信息，并不是完全正确的。IDF 的简单结构并不能使提取的关键词， 十分有效地反映单词的重要程度和特征词的分布情 况，使其无法很好地完成对权值调整的功能。尤其是在同类语料库中，这一方法有很大弊端，往往一些同类文本的关键词被盖。
 
TF-IDF算法实现简单快速，但是仍有许多不足之处：
 （1）没有考虑特征词的位置因素对文本的区分度，词条出现在文档的不同位置时，对区分度的贡献大小是不一样的。
 （2）按照传统TF-IDF，往往一些生僻词的IDF(反文档频率)会比较高、因此这些生僻词常会被误认为是文档关键词。
 （3）传统TF-IDF中的IDF部分只考虑了特征词与它出现的文本数之间的关系，而忽略了特征项在一个类别中不同的类别间的分布情况。
 （4）对于文档中出现次数较少的重要人名、地名信息提取效果不佳。
 
3.7.TF-IDF算法改进—TF-IWF算法
 
https://pdf.hanspub.org//CSA20130100000_81882762.pdf

什么是 TF-IDF 算法？
 
TF（全称TermFrequency），中文含义词频，简单理解就是关键词出现在网页当中的频次。
 
IDF（全称InverseDocumentFrequency），中文含义逆文档频率，简单来说就是该关键词出现在所有文档里面的一种数据集合。
 
在信息检索中，tf-idf或TFIDF（术语频率 – 逆文档频率的缩写）是一种数字统计，旨在反映单词对集合或语料库中的文档的重要程度。
 
它经常被用作搜索信息检索，文本挖掘和用户建模的加权因子。tf-idf值按比例增加一个单词出现在文档中的次数，并被包含该单词的语料库中的文档数量所抵消，这有助于调整某些单词在一般情况下更频繁出现的事实。Tf-idf是当今最受欢迎的术语加权方案之一;数字图书馆中83％的基于文本的推荐系统使用tf-idf。比如关键词“中国”在A网页里面出现了100次，那么它的TF值则是100次（词频），假设搜索引擎所收录的所有网页里面有1亿网页包含“中国”该关键词，那么IDF将由IDF公式计算出它对应的数据值。统一来理解则是TF是计算自己网页内的关键词频次，而TDF是计算所有文档里面包含该关键词的一种概率数值。
 
搜索引擎经常使用tf-idf加权方案的变体作为在给定用户查询的情况下对文档的相关性进行评分和排序的中心工具。tf-idf可以成功地用于各种主题领域的停用词过滤，包括文本摘要和分类。
 
TF （Term Frequency）—— “单词频率”
 
意思就是说，我们计算一个查询关键字中某一个单词在目标文档中出现的次数。举例说来，如果我们要查询 “Car Insurance”，那么对于每一个文档，我们都计算“Car” 这个单词在其中出现了多少次，“Insurance”这个单词在其中出现了多少次。这个就是 TF 的计算方法。
 
TF背后的隐含的假设是，查询关键字中的单词应该相对于其他单词更加重要，而文档的重要程度，也就是相关度，与单词在文档中出现的次数成正比。比如，“Car” 这个单词在文档 A 里出现了 5 次，而在文档 B 里出现了 20 次，那么 TF 计算就认为文档 B 可能更相关。
 
然而，信息检索工作者很快就发现，仅有TF不能比较完整地描述文档的相关度。因为语言的因素，有一些单词可能会比较自然地在很多文档中反复出现，比如英语中的 “The”、“An”、“But” 等等。这些词大多起到了链接语句的作用，是保持语言连贯不可或缺的部分。然而，如果我们要搜索 “How to Build A Car” 这个关键词，其中的 “How”、“To” 以及 “A” 都极可能在绝大多数的文档中出现，这个时候 TF 就无法帮助我们区分文档的相关度了。
 
IDF（Inverse Document Frequency）—— “逆文档频率”
 
就在这样的情况下应运而生。这里面的思路其实很简单，那就是我们需要去 “惩罚”（Penalize）那些出现在太多文档中的单词。
 
也就是说，真正携带 “相关” 信息的单词仅仅出现在相对比较少，有时候可能是极少数的文档里。这个信息，很容易用 “文档频率” 来计算，也就是，有多少文档涵盖了这个单词。很明显，如果有太多文档都涵盖了某个单词，这个单词也就越不重要，或者说是这个单词就越没有信息量。因此，我们需要对 TF 的值进行修正，而 IDF 的想法是用 DF 的倒数来进行修正。倒数的应用正好表达了这样的思想，DF 值越大越不重要。
 
让我们从一个实例开始讲起。假定现在有一篇长文《中国的蜜蜂养殖》，我们准备用计算机提取它的关键词。
 
一个容易想到的思路，就是找到出现次数最多的词。如果某个词很重要，它应该在这篇文章中多次出现。于是，我们进行"词频"（Term Frequency，缩写为TF）统计。
 
结果你肯定猜到了，出现次数最多的词是----“的”、“是”、“在”----这一类最常用的词。它们叫做"停用词"（stop words），表示对找到结果毫无帮助、必须过滤掉的词。
 
假设我们把它们都过滤掉了，只考虑剩下的有实际意义的词。这样又会遇到了另一个问题，我们可能发现"中国"、“蜜蜂”、"养殖"这三个词的出现次数一样多。这是不是意味着，作为关键词，它们的重要性是一样的？
 
显然不是这样。因为"中国"是很常见的词，相对而言，"蜜蜂"和"养殖"不那么常见。如果这三个词在一篇文章的出现次数一样多，有理由认为，“蜜蜂"和"养殖"的重要程度要大于"中国”，也就是说，在关键词排序上面，"蜜蜂"和"养殖"应该排在"中国"的前面。
 
所以，我们需要一个重要性调整系数，衡量一个词是不是常见词。如果某个词比较少见，但是它在这篇文章中多次出现，那么它很可能就反映了这篇文章的特性，正是我们所需要的关键词。
 
用统计学语言表达，就是在词频的基础上，要对每个词分配一个"重要性"权重。最常见的词（“的”、“是”、“在”）给予最小的权重，较常见的词（“中国”）给予较小的权重，较少见的词（“蜜蜂”、“养殖”）给予较大的权重。这个权重叫做"逆文档频率"（Inverse Document Frequency，缩写为IDF），它的大小与一个词的常见程度成反比。
 
知道了"词频"（TF）和"逆文档频率"（IDF）以后，将这两个值相乘，就得到了一个词的TF-IDF值。某个词对文章的重要性越高，它的TF-IDF值就越大。所以，排在最前面的几个词，就是这篇文章的关键词。
 
下面就是这个算法的细节。
 
第一步，计算词频。
 
 考虑到文章有长短之分，为了便于不同文章的比较，进行"词频"标准化。
 
 或者
 
 第二步，计算逆文档频率。
 
这时，需要一个语料库（corpus），用来模拟语言的使用环境。
 

 如果一个词越常见，那么分母就越大，逆文档频率就越小越接近0。分母之所以要加1，是为了避免分母为0（即所有文档都不包含该词）。log表示对得到的值取对数。
 
第三步，计算TF-IDF。
 
 可以看到，TF-IDF与一个词在文档中的出现次数成正比，与该词在整个语言中的出现次数成反比。所以，自动提取关键词的算法就很清楚了，就是计算出文档的每个词的TF-IDF值，然后按降序排列，取排在最前面的几个词。
 
还是以《中国的蜜蜂养殖》为例，假定该文长度为1000个词，“中国”、“蜜蜂”、“养殖"各出现20次，则这三个词的"词频”（TF）都为0.02。然后，搜索Google发现，包含"的"字的网页共有250亿张，假定这就是中文网页总数。包含"中国"的网页共有62.3亿张，包含"蜜蜂"的网页为0.484亿张，包含"养殖"的网页为0.973亿张。则它们的逆文档频率（IDF）和TF-IDF如下：
 
 log(250亿/（62.3亿+1）)约等于0.603
 “中国”这个词的词频怎么算的就不知道了
 
从上表可见，"蜜蜂"的TF-IDF值最高，"养殖"其次，"中国"最低。（如果还计算"的"字的TF-IDF，那将是一个极其接近0的值。）所以，如果只选择一个词，"蜜蜂"就是这篇文章的关键词。
 
除了自动提取关键词，TF-IDF算法还可以用于许多别的地方。比如，信息检索时，对于每个文档，都可以分别计算一组搜索词（“中国”、“蜜蜂”、“养殖”）的TF-IDF，将它们相加，就可以得到整个文档的TF-IDF。这个值最高的文档就是与搜索词最相关的文档。
 
TF-IDF算法的优点是简单快速，结果比较符合实际情况。缺点是，单纯以"词频"衡量一个词的重要性，不够全面，有时重要的词可能出现次数并不多。而且，这种算法无法体现词的位置信息，出现位置靠前的词与出现位置靠后的词，都被视为重要性相同，这是不正确的。（一种解决方法是，对全文的第一段和每一段的第一句话，给予较大的权重。这一点对于SEO特别重要）
 
TF-IDF算法思想：
 
TF-IDF的核心思想是通过该算法进行有效的计算网页的核心关键词。虽然语义分析以及中文分词能够简单的计算出页面的关键词主题，但是由于互联网内容信息重复度较大，同一个内容单纯从分词角度来讲是不足以满足搜索引擎针对网页的内容是否更加符合用户的需求。而TF-IDF则可以用过算法公式来计算用户搜索词与网页之间的相似度。
 
比如网页标题“小黑的同桌叫马天”，这里面的、叫在搜索引擎里面一般都称为停用词，也就是无意义词。而去掉这些词剩下的词则是小黑、同桌、马天。根据分词原理，这三个词都是名词，那么作为用户而言去看这个标题明显知道是阐述马天是网页的核心关键词，但是对于搜索引擎来说并不能深刻的理解该网页的核心关键词。对于这三个词，一般我们都有一个词的重要程度系数。从常见度来说，越常见的东西则不重要，反之越不常见越重要。那么搜索引擎是如何知道该词的常见程度呢？可以通过相关搜索结果数来计算关键词的重要度。
 
TF-IDF算法应用：
 
关于TF-IDF的算法实战应用，最常见的方式则是利用TF-IDF算法的计算方式来进行定位网页的核心词，从而网站大量提升关键词排名。首先我们要理解真正原创文章的含义，真正的内容原创有两种，一种是网页内容与总语料库文档不重合，另一种则是关键词与该关键词的相关结果文档不重合。而TF-IDF最佳的运用方式则是可以采用换汤不换药的操作方式来进行关键词排名。比如优化一个关键词“山药的功效与作用”，那么我们可以去抄袭一篇“人参的功效与作用”的文章，并且替换网页里面的所有人参关键词，尽管这篇文章在人参里面是重复性很高的文章。但是在山药的功效与作用里面它就是独一无二的。并且刻意增加山药文章里面的TF值，让搜索引擎认定该网页的核心关键词。
 
镜像站专门干这事！
 
网站镜像是通过TF-IDF算法应用的经典案例，内容全部抄袭，网页标题（title）与文章标题不同，目的就是用来提升网页的点击率。并且文章标题我们可以发现互博国际该关键词是一个由多个词组成的词组，通过分词符号可以让互博国际变成一个关键词（词组形成关键词）。并且在网页内容里面，自然的分布关键词的频次（TF），从而达到关键词的强调性，即使内容在其他文章里面出现，但是在互博国际里面，该内容则是独一无二的原创（不重合）。为了提升网页的点击率，我们可以将网页的标题（title）写的更加规范，这样排名一旦上来，还有利于用户的点击，从而提升网页关键词的排名更佳状态。
 
参考：SEO算法篇，TFIDF算法讲解及在SEO中的利用