【NLP-00】TF-IDF算法：原理、应用与介绍_tf-idf算法和应用场景

TF-IDF实现

一、TF-IDF的介绍

TF-IDF（Term Frequency-Inverse Document Frequency）是一种用于衡量文本中某个词语重要程度的统计方法，它可以帮助我们确定每个词语在一个文档集合中的相对重要性。

TF-IDF由两部分组成：Term Frequency（词频）和Inverse Document Frequency（逆文档频率）。

Term Frequency指的是某个词语在文档中出现的次数除以文档中总词语数的比例。如果一个词语在文档中出现得越多，其重要性也就越高。

Inverse Document Frequency则是用来衡量一个词语在整个文档集合中的重要程度。文档集合中越少的文档包含某个词语，则该词语的IDF值越大，表示其在文档集合中的重要性越高。

TF-IDF = TF * IDF，某一特定文件内的高词语频率，以及该词语在整个文件集合中的低文件频率，可以产生出高权重的TF-IDF。因此，TF-IDF倾向于过滤掉常见的词语，保留重要的词语。注： TF-IDF算法非常容易理解，并且很容易实现，但是其简单结构并没有考虑词语的语义信息，无法处理一词多义与一义多词的情况。

二、TF-IDF的应用

TF-IDF（Term Frequency-Inverse Document Frequency）是一种用于衡量文本中某个词语重要程度的统计方法，它可以应用于许多自然语言处理任务，包括：

• 文本分类：在文本分类任务中，常常使用TF-IDF来表示文档中每个词语的重要性，以便于分类器进行区分。
• 关键词提取：TF-IDF可以通过计算某个词语在文本中出现的频率以及在整个文集中出现的文档数来确定哪些词语更加重要，从而实现关键词提取。
• 相似度计算：当需要对文本之间的相似度进行计算时，可以使用TF-IDF将文本转换为向量表示，然后计算两个向量之间的余弦相似度或欧几里得距离等指标。
• 推荐系统：在推荐系统中，可以使用TF-IDF来表示用户历史浏览记录或购买记录中的商品，以便于推荐算法进行个性化推荐。
• 搜索引擎：搜索引擎通常会根据用户的查询词语使用TF-IDF来排名搜索结果，将相关性高的结果排在前面。

三、python3实现TF-IDF算法

import math

def tf(word, doc):
    # 计算词频TF值
    return doc.count(word) / len(doc)

def idf(word, docs):
    # 计算逆文档频率IDF值
    return math.log10(len(docs) / sum(1 for doc in docs if word in doc))

def tf_idf(word, doc, docs):
    # 计算TF-IDF值
    return tf(word, doc) * idf(word, docs)
1
2
3
4
5
6
7
8
9
10
11
12
13

3.1 定义多个文档

docs = [
    "This is the first document.",
    "This is the second second document.",
    "And the third one.",
    "Is this the first document?"
]
1
2
3
4
5
6

3.2 计算每个文档中每个单词的TF-IDF值

doc_tfidf = {}
for i, doc in enumerate(docs):
    doc_tfidf[i] = {}
    for word in doc.split():
        doc_tfidf[i][word] = tf_idf(word, doc, docs)
1
2
3
4
5

3.3 打印结果

for i, doc in enumerate(docs):
    print("Document {}".format(i))
    for word in doc.split():
        print("{}: {}".format(word, doc_tfidf[i][word]))
1
2
3
4

四、Sklearn实现TF-IDF算法

from sklearn.feature_extraction.text import TfidfVectorizer
1

4.1 定义文本列表

text_list = ['This is the first document.',
            'This is the second second document.',
            'And the third one.',
            'Is this the first document?']
1
2
3
4

4.2 初始化TfidfVectorizer对象，并进行拟合转换

tfidf_vectorizer = TfidfVectorizer()
tfidf_matrix = tfidf_vectorizer.fit_transform(text_list)
1
2

4.3 输出特征名称和IDF值

feature_names = tfidf_vectorizer.get_feature_names()
idf_values = tfidf_vectorizer.idf_
for i, name in enumerate(feature_names):
    print(name, idf_values[i])
1
2
3
4

4.4 输出TF-IDF矩阵

print(tfidf_matrix.toarray())
1

五、TF-IDF算法改进——TF-IWF算法

TF-IWF（Term Frequency-Inverse Within-Document Frequency）算法是TF-IDF算法的一种改进形式，它旨在克服TF-IDF算法中的缺点，即无法区分某个词语在不同文档中的重要性。

TF-IWF算法通过引入“逆文档内词频”（Inverse Within-Document Frequency，IWF）来解决这个问题。具体来说，IWF值表示一个词语在当前文档中的出现频率与所有文档中该词语出现频率之和的比值的倒数。

TF-IWF算法的计算公式如下：

TF-IWF = TF * log(N / (1 + sum(IWF)))

其中，TF为词频，N为文档总数，sum(IWF)表示当前文档中所有词语的IWF值之和。

相比于TF-IDF算法，TF-IWF算法将考虑到每个词语在不同文档中的重要性，从而更好地反映了其在整个文集中的重要性。例如，在一个讨论健康饮食的文集中，某个词语在大多数文档中都出现了很多次，但是在某个特定文档中只出现了一次，那么在该文档中该词语的IWF值会很高，从而降低了其TF-IWF值，表明在该文档中它的重要性较低。

需要注意的是，TF-IWF算法也有其局限性，例如当某个词语在所有文档中的出现频率都很低时，其IWF值会趋近于0，从而导致其TF-IWF值过高，可能会影响结果的准确性。因此，在实际应用中需要根据具体情况进行权衡和调整。

六、TF-IDF算法的具体应用

6.1 TF-IDF 文本分类

TF-IDF算法可以用于文本分类，其基本思路是将文本转换成数值特征表示，然后使用分类器对这些特征进行分类。以下是一个简单的TF-IDF文本分类算法的实现步骤：

• 收集训练数据集，并对每个样本进行预处理，如去除停用词、标点符号等。
• 使用TF-IDF算法将每个样本表示为一个向量。具体来说，对于每个样本，计算其中每个单词的TF-IDF值，并将它们组合成一个向量表示该样本。
• 使用这些向量作为特征输入到分类器中，训练分类器并调整超参数。可以使用任意一种分类器，如朴素贝叶斯、支持向量机等。
• 对于新的文本样本，首先进行预处理，然后使用与训练集相同的方式计算其TF-IDF向量，并使用训练好的分类器进行分类。

以下是一个示例代码，演示了如何使用sklearn库实现TF-IDF文本分类算法：

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
1
2

6.1.1 定义文本列表和对应的类别标签

text_list = ['This is a positive review.',
             'I really enjoyed this movie!',
             'What a waste of time.',
             'I would not recommend this movie to anyone.']

labels = [1, 1, 0, 0]  # 1代表正面评价，0代表负面评价
1
2
3
4
5
6

6.1.2 初始化TfidfVectorizer对象，并进行拟合转换

tfidf_vectorizer = TfidfVectorizer()
X = tfidf_vectorizer.fit_transform(text_list)
1
2

6.1.3 训练Naive Bayes分类器

clf = MultinomialNB().fit(X, labels)
1

6.1.4 测试新的文本样本

new_text = ['A great movie, highly recommended!']
X_new = tfidf_vectorizer.transform(new_text)
y_pred = clf.predict(X_new)

print(y_pred)  # 输出预测结果，这里输出1，代表正面评价
1
2
3
4
5

6.2 TF-IDF 关键词提取

TF-IDF算法可以用于关键词提取，其基本思路是通过计算某个词语在文本中的出现频率和在整个文集中的出现频率，来评估该词语对文本的重要性。以下是一个简单的TF-IDF关键词提取算法的实现步骤：

• 对文本进行预处理，如去除停用词、标点符号等。
• 对于每个词语，计算其在当前文本中的出现频率，即TF值（Term Frequency）。
• 计算每个词语在整个文集中的出现频率，即DF值（Document Frequency）。DF值可以定义为包含该词语的文档数目除以总文档数目的比例。
• 根据TF值和DF值计算每个词语的TF-IDF值，即TF-IDF = TF * log(N / DF)，其中N为总文档数目。
• 对所有词语按照TF-IDF值从大到小排序，并选取前n个作为关键词。

以下是一个示例代码，演示了如何使用sklearn库实现TF-IDF关键词提取算法：

from sklearn.feature_extraction.text import TfidfVectorizer
1

6.2.1 定义文本列表

text_list = ['This is a sample sentence.',
             'Another example sentence.',
             'A third sentence for testing.']
1
2
3

初始化TfidfVectorizer对象，并进行拟合转换

tfidf_vectorizer = TfidfVectorizer()
X = tfidf_vectorizer.fit_transform(text_list)
1
2

6.2.2 获取所有词语及其对应的TF-IDF值

feature_names = tfidf_vectorizer.get_feature_names()
for i in range(X.shape[0]):
    print('Document %d:' % i)
    for j in range(X.shape[1]):
        if X[i, j] > 0:
            print('    %s: %.4f' % (feature_names[j], X[i, j]))
1
2
3
4
5
6

6.2.3 提取前n个关键词

n = 2
for i in range(X.shape[0]):
    print('Keywords of document %d:' % i)
    idx = X[i].toarray().argsort()[0, -n:][::-1]
    for j in idx:
        print('    %s' % feature_names[j])  
1
2
3
4
5
6

6.3 TF-IDF 相似度提取

TF-IDF算法可以用于计算文本之间的相似度，其基本思路是通过计算两个文本的TF-IDF向量之间的余弦相似度来评估它们之间的相似程度。以下是一个简单的TF-IDF相似度计算算法的实现步骤：

• 对文本进行预处理，如去除停用词、标点符号等。
• 对于每个文本，使用TF-IDF算法将其表示为一个向量。
• 计算两个文本向量之间的余弦相似度，即cosine_similarity(v1, v2) = dot(v1, v2) / (norm(v1) * norm(v2))，其中dot()代表向量点积运算，norm()代表向量范数运算。
• 根据余弦相似度值评估两个文本之间的相似程度，常见的做法是将余弦相似度值限制在0到1之间，越接近1代表越相似。

以下是一个示例代码，演示了如何使用sklearn库实现TF-IDF相似度计算算法：

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
1
2

6.3.1 定义文本列表

text_list = [‘This is a sample sentence.’,
‘Another example sentence.’,
‘A third sentence for testing.’]

6.3.2 初始化TfidfVectorizer对象，并进行拟合转换

tfidf_vectorizer = TfidfVectorizer()
X = tfidf_vectorizer.fit_transform(text_list)
1
2

6.3.3 计算两个文本向量之间的余弦相似度

similarity_matrix = cosine_similarity(X)
1

6.3.4 输出相似度矩阵

for i in range(similarity_matrix.shape[0]):
    for j in range(similarity_matrix.shape[1]):
        if i == j:
            continue
        print('Similarity between document %d and document %d: %.4f' % (i, j, similarity_matrix[i, j]))
1
2
3
4
5

6.4 TF-IDF 推荐系统

TF-IDF算法可以用于构建基于内容的推荐系统，其基本思路是利用每个用户过去喜欢的物品（如电影、图书等）来构建一个用户画像，然后根据用户画像和候选物品的TF-IDF向量之间的余弦相似度来推荐相似的物品。以下是一个简单的TF-IDF推荐系统算法的实现步骤：

• 对用户的历史行为数据进行预处理，如去除重复记录、无效数据等。
• 对于每个用户，使用TF-IDF算法将其历史行为表示为一个向量，即用户画像。
• 对于每个候选物品，使用TF-IDF算法将其表示为一个向量。
• 计算用户画像和候选物品向量之间的余弦相似度，选择与用户画像相似度最高的前n个物品作为推荐结果。

以下是一个示例代码，演示了如何使用sklearn库实现TF-IDF推荐系统算法：

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
1
2

6.4.1 定义用户历史行为数据列表

user_history = {'user1': ['This is a sample sentence.', 'Another example sentence.'],
                'user2': ['Another example sentence.', 'A third sentence for testing.']}
1
2

6.4.2 定义候选物品列表

item_list = ['This is a sample sentence.',
             'Another example sentence.',
             'A third sentence for testing.',
             'A fourth sentence for testing.']
1
2
3
4

6.4.3 初始化TfidfVectorizer对象，并进行拟合转换

tfidf_vectorizer = TfidfVectorizer()
X_item = tfidf_vectorizer.fit_transform(item_list)
1
2

6.4.4 针对每个用户，计算其历史行为向量和候选物品向量之间的余弦相似度，并输出推荐结果

for user, history in user_history.items():
    X_user = tfidf_vectorizer.transform(history)
    similarity_matrix = cosine_similarity(X_user, X_item)
    indices = similarity_matrix.argsort()[0][::-1][:2]
    recommended_items = [item_list[i] for i in indices]
    print('Recommend items for %s: %s' % (user, recommended_items))
1
2
3
4
5
6

6.5 TF-IDF 搜索引擎

TF-IDF算法可以用于构建基于内容的搜索引擎，其基本思路是根据用户输入的关键词构建一个查询向量，并根据候选文档的TF-IDF向量和查询向量之间的余弦相似度来排序返回结果。以下是一个简单的TF-IDF搜索引擎算法的实现步骤：

• 对用户输入的关键词进行预处理，如去除停用词、标点符号等。
• 使用TF-IDF算法将用户输入的关键词表示为一个向量，即查询向量。
• 对于每个候选文档，使用TF-IDF算法将其表示为一个向量。
• 计算查询向量和候选文档向量之间的余弦相似度，选择与查询向量相似度最高的前n个文档作为搜索结果。

以下是一个示例代码，演示了如何使用sklearn库实现TF-IDF搜索引擎算法：

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
1
2

6.5.1 定义候选文档列表

doc_list = ['This is a sample sentence.',
            'Another example sentence.',
            'A third sentence for testing.',
            'A fourth sentence for testing.']
1
2
3
4

6.5.2 定义用户输入的关键词

query = 'sample testing'
1

6.5.3 初始化TfidfVectorizer对象，并进行拟合转换

tfidf_vectorizer = TfidfVectorizer()
X_doc = tfidf_vectorizer.fit_transform(doc_list)
1
2

6.5.4 将用户输入的关键词转换为查询向量

X_query = tfidf_vectorizer.transform([query])
1

6.5.5 计算查询向量和候选文档向量之间的余弦相似度，并输出搜索结果

similarity_matrix = cosine_similarity(X_query, X_doc)
indices = similarity_matrix.argsort()[0][::-1][:2]
search_results = [doc_list[i] for i in indices]
print('Search results: %s' % search_results)
1
2
3
4

在上述代码中，我们首先定义了一个包含多个候选文档的列表，以及一个表示用户输入关键词的字符串。然后我们使用TfidfVectorizer对象将候选文档转换为TF-IDF向量，并将用户输入的关键词转换为查询向量，计算查询向量和候选文档向量之间的余弦相似度，选择与查询向量相似度最高的前n个文档作为搜索结果，并输出结果。

需要注意的是，上述代码只是一个简单的示例，实际使用时需要根据具体情况进行修改和调整。此外，还可以采用其他方法来进一步优化搜索引擎的效果，例如基于BM25算法的搜索引擎算法。