自然语言处理：词频-逆文档频率

介绍

大家好，博主又来给大家分享知识了。本来博主计划完成稠密向量表示的内容分享后，就开启自然语言处理中文本表示的讲解。可在整理分享资料的时候，博主发现还有个知识点，必须得单独拎出来好好说道说道。

这就是TF-IDF，也就是词频-逆文档频率。它在自然语言处理里堪称“幕后功臣”，在文本表示、文本分类、信息检索等诸多关键任务中，发挥着超乎想象的作用。那么，我们直接进入正题。

TF-IDF

在自然语言处理(NLP)领域，理解文本数据的含义并从中提取有价值的信息是核心任务。TF-IDF(Term Frequency-Inverse Document Frequency)作为一种重要的统计方法，在文本表示、文本分类、信息检索、关键词提取等众多任务中发挥着关键作用。

基础概念

词频

Term Frequency, TF。词频衡量的是一个词在一篇文档中出现的频率。直观地说，一个词在文档中出现的次数越多，它对该文档的重要性可能越高。例如，在文档“我喜欢苹果，苹果很美味”中，“苹果”这个词出现了两次，相对其他词出现的频率较高，可能在该文档中具有一定重要性。

其计算公式为： $TF_{t,d} = \frac{n_{t,d}}{\sum_{k} n_{k,d}}$

其中， $TF_{t,d}$ 表示词 $t$ 在文档 $d$ 中的词频， $n_{t,d}$ 是词 $t$ 在文档 $d$ 中出现的次数， $\sum_{k} n_{k,d}$ 是文档 $d$ 中所有词的出现次数总和。

逆文档频率

Inverse Document Frequency, IDF。逆文档频率反映了一个词在整个文档集合中的普遍重要性。如果一个词在大量文档中都出现，那么它对于区分不同文档的作用就较小。相反，一个只在少数文档中出现的词，对于识别这些特定文档更为关键。

例如，“的”，“是”等常用词在几乎所有文档中都会频繁出现，它们的区分能力较弱。而专业术语如“量子纠缠”，只在特定领域的文档中出现，其区分能力较强。

其计算公式为： $IDF_{t} = \log \frac{N}{n_{t}}$

其中， $IDF_{t}$ 表示词 $t$ 的逆文档频率， $N$ 是文档集合中的文档总数， $n_{t}$ 是包含词 $t$ 的文档数量。

TF-IDF加权

TF-IDF加权综合了词频和逆文档频率，通过将两者相乘得到每个词在文档中的TF-IDF值。

公式为： $TF-IDF_{t,d} = TF_{t,d} \times IDF_{t}$

TF-IDF值越高，说明该词对当前文档越重要，同时在整个文档集中相对不常见，具有较强的区分性。

代码实现

计算词频(TF)

完整代码

# 从collections模块导入Counter类，用于统计元素出现的次数
from collections import Counter


# 定义一个名为NLPTextRepresentation的类，用于处理文本表示相关任务
class NLPTextRepresentation:
    # 类的初始化方法，此处不做任何初始化操作
    def __init__(self):
        # pass 语句占位，不进行实际操作
        pass

    # 定义一个方法，用于计算文档中每个单词的词频(TF)
    def compute_tf(self, document):
        # 将输入的文档按空格分割成单词列表
        words = document.split()
        # 使用Counter统计每个单词在文档中出现的次数
        word_count = Counter(words)
        # 计算文档中单词的总数
        total_words = len(words)
        # 初始化一个空字典，用于存储每个单词的词频
        tf_dict = {}
        # 遍历统计结果中的每个单词及其出现次数
        for word, count in word_count.items():
            # 计算该单词的词频并存储到字典中
            tf_dict[word] = count / total_words
        # 返回存储词频的字典
        return tf_dict


# 当脚本作为主程序运行时执行以下代码
if __name__ == "__main__":
    # 创建NLPTextRepresentation类的一个实例
    nlp_text_representation = NLPTextRepresentation()
    # 定义一个示例文档
    document = "我喜欢苹果 苹果很美味"
    # 调用compute_tf方法计算文档中单词的词频
    tf_result = nlp_text_representation.compute_tf(document)
    # 打印计算得到的词频结果
    print(tf_result)

运行结果

{'我喜欢苹果': 0.5, '苹果很美味': 0.5}

进程已结束，退出代码为 0

在这段代码中，首先使用split()方法将输入的文档字符串分割成单词列表。然后，利用Counter类统计每个单词在文档中出现的次数。

接着，计算文档的总词数，通过遍历每个单词及其出现次数，将每个单词的出现次数除以总词数，得到该单词在文档中的词频，并存储在字典tf_dict中。

最后返回这个字典，其中键为单词，值为对应的词频。

计算逆文档频率(IDF)

完整代码

# 导入math模块，用于使用数学函数，这里主要是为了计算对数
import math


# 定义一个名为NLPTextRepresentation的类，用于处理自然语言处理中的文本表示相关任务
class NLPTextRepresentation:
    # 类的初始化方法，目前不做任何初始化操作
    def __init__(self):
        # 占位语句，不执行任何实际逻辑
        pass

    # 定义一个方法，用于计算语料库中每个单词的逆文档频率（IDF）
    def compute_idf(self, corpus):
        # 计算语料库中文档的总数
        total_docs = len(corpus)
        # 初始化一个空字典，用于存储每个单词在多少个文档中出现过
        word_in_doc_count = {}
        # 遍历语料库中的每一个文档
        for doc in corpus:
            # 将当前文档按空格分割成单词，并使用 set 去重
            words = set(doc.split())
            # 遍历当前文档中出现的每个唯一单词
            for word in words:
                # 如果该单词还未在word_in_doc_count字典中
                if word not in word_in_doc_count:
                    # 则将该单词添加到字典中，并将其出现文档数初始化为 1
                    word_in_doc_count[word] = 1
                else:
                    # 否则，将该单词出现的文档数加 1
                    word_in_doc_count[word] += 1
        # 初始化一个空字典，用于存储每个单词的逆文档频率
        idf_dict = {}
        # 遍历word_in_doc_count字典中的每个单词及其出现文档数
        for word, count in word_in_doc_count.items():
            # 计算该单词的逆文档频率（使用自然对数），并存储到idf_dict中
            idf_dict[word] = math.log(total_docs / count)
        # 返回存储逆文档频率的字典
        return idf_dict


# 当脚本作为主程序运行时执行以下代码
if __name__ == "__main__":
    # 创建NLPTextRepresentation类的一个实例
    nlp_text_representation = NLPTextRepresentation()
    # 定义一个语料库，包含多个文档
    corpus = ["我喜欢苹果 苹果很美味", "我喜欢香蕉 香蕉很甜", "苹果和香蕉都是水果"]
    # 调用compute_idf方法计算语料库中每个单词的逆文档频率
    idf_result = nlp_text_representation.compute_idf(corpus)
    # 打印计算得到的逆文档频率结果
    print(idf_result)

运行结果

{'我喜欢苹果': 1.0986122886681098, '苹果很美味': 1.0986122886681098, '我喜欢香蕉': 1.0986122886681098, '香蕉很甜': 1.0986122886681098, '苹果和香蕉都是水果': 1.0986122886681098}

进程已结束，退出代码为 0

在这段代码中，首先计算语料库中总的文档数量。然后，遍历语料库中的每一篇文档，将文档中的单词通过set()方法去重，以确保每个单词只被统计一次。

对于每个单词，如果它不在word_in_doc_count字典中，则将其初始值设为 1；如果已经存在，则将其对应的值加 1，这样word_in_doc_count字典记录了每个单词在多少篇文档中出现过。

接下来，通过遍历word_in_doc_count字典，根据逆文档频率的计算公式，计算每个单词的逆文档频率，并存储在idf_dict字典中返回。

计算词频-逆文档频率(TF-IDF)

完整代码

# 从collections模块导入Counter类，用于统计元素出现的次数
from collections import Counter
# 导入math模块，用于使用数学函数，这里主要是为了计算对数
import math


# 定义一个名为NLPTextRepresentation的类，用于处理自然语言处理中的文本表示相关任务
class NLPTextRepresentation:
    # 类的初始化方法，目前不做任何初始化操作
    def __init__(self):
        # 占位语句，不执行任何实际逻辑
        pass

    # 定义一个方法，用于计算文档中每个单词的词频（TF）
    def compute_tf(self, document):
        # 将输入的文档按空格分割成单词列表
        words = document.split()
        # 使用Counter统计每个单词在文档中出现的次数
        word_count = Counter(words)
        # 计算文档中单词的总数
        total_words = len(words)
        # 初始化一个空字典，用于存储每个单词的词频
        tf_dict = {}
        # 遍历统计结果中的每个单词及其出现次数
        for word, count in word_count.items():
            # 计算该单词的词频并存储到字典中
            tf_dict[word] = count / total_words
        # 返回存储词频的字典
        return tf_dict

    # 定义一个方法，用于计算语料库中每个单词的逆文档频率（IDF）
    def compute_idf(self, corpus):
        # 计算语料库中文档的总数
        total_docs = len(corpus)
        # 初始化一个空字典，用于存储每个单词在多少个文档中出现过
        word_in_doc_count = {}
        # 遍历语料库中的每一个文档
        for doc in corpus:
            # 将当前文档按空格分割成单词，并使用set去重
            words = set(doc.split())
            # 遍历当前文档中出现的每个唯一单词
            for word in words:
                # 如果该单词还未在word_in_doc_count字典中
                if word not in word_in_doc_count:
                    # 则将该单词添加到字典中，并将其出现文档数初始化为1
                    word_in_doc_count[word] = 1
                else:
                    # 否则，将该单词出现的文档数加1
                    word_in_doc_count[word] += 1
        # 初始化一个空字典，用于存储每个单词的逆文档频率
        idf_dict = {}
        # 遍历word_in_doc_count字典中的每个单词及其出现文档数
        for word, count in word_in_doc_count.items():
            # 计算该单词的逆文档频率(使用自然对数)，并存储到idf_dict中
            idf_dict[word] = math.log(total_docs / count)
        # 返回存储逆文档频率的字典
        return idf_dict

    # 定义一个方法，用于计算语料库中每个文档里单词的TF-IDF值
    def compute_tfidf(self, corpus):
        # 初始化一个空列表，用于存储每个文档的TF-IDF结果
        tfidf_corpus = []
        # 调用compute_idf方法计算语料库中所有单词的逆文档频率
        idf = self.compute_idf(corpus)
        # 遍历语料库中的每一个文档
        for doc in corpus:
            # 调用compute_tf方法计算当前文档中每个单词的词频
            tf = self.compute_tf(doc)
            # 初始化一个空字典，用于存储当前文档中每个单词的TF-IDF值
            tfidf_doc = {}
            # 遍历当前文档词频字典中的每个单词
            for word in tf:
                # 计算该单词的TF-IDF值并存储到字典中
                tfidf_doc[word] = tf[word] * idf[word]
            # 将当前文档的TF-IDF结果添加到tfidf_corpus列表中
            tfidf_corpus.append(tfidf_doc)
        # 返回存储所有文档TF-IDF结果的列表
        return tfidf_corpus


# 当脚本作为主程序运行时执行以下代码
if __name__ == "__main__":
    # 创建NLPTextRepresentation类的一个实例
    nlp_text_representation = NLPTextRepresentation()
    # 定义一个包含多个文档的语料库
    corpus = ["我喜欢苹果 苹果很美味", "我喜欢香蕉 香蕉很甜", "苹果和香蕉都是水果"]
    # 调用compute_tfidf方法计算语料库中每个文档里单词的TF-IDF值
    tfidf_result = nlp_text_representation.compute_tfidf(corpus)
    # 遍历计算得到的TF-IDF结果列表
    for i, doc in enumerate(tfidf_result):
        # 打印每个文档的TF-IDF计算结果
        print(f"文档{i + 1}的TF-IDF结果: {doc}")

运行结果

文档1的TF-IDF结果: {'我喜欢苹果': 0.5493061443340549, '苹果很美味': 0.5493061443340549}
文档2的TF-IDF结果: {'我喜欢香蕉': 0.5493061443340549, '香蕉很甜': 0.5493061443340549}
文档3的TF-IDF结果: {'苹果和香蕉都是水果': 1.0986122886681098}

进程已结束，退出代码为 0

这段代码首先调用前面定义的compute_idf函数计算整个语料库的逆文档频率。然后，遍历语料库中的每一篇文档，对每篇文档调用compute_tf函数计算词频。

接着，对于每个词，将其在当前文档中的词频乘以其在整个语料库中的逆文档频率，得到该词在当前文档中的TF-IDF值，并存储在tfidf_doc字典中。

最后，将每篇文档的TF-IDF字典结果添加到tfidf_corpus列表中并返回。这段代码的目的是将前面计算得到的词频和逆文档频率进行综合计算，得到每篇文档中每个词的TF-IDF值，从而完成TF-IDF加权的计算过程。

TF-IDF的优点

简单有效：TF-IDF的计算原理直观易懂，实现相对简单，不需要复杂的模型训练过程，却能在很多实际应用中取得较好的效果，如文本分类、信息检索等。
突出关键信息：通过加权计算，能够突出那些在特定文档中频繁出现且在整个文档集中相对不常见的词，这些词往往与文档的主题紧密相关，有助于快速定位文档的核心内容。
可扩展性好：无论是小规模还是大规模的文档集合，TF-IDF都能适用，并且计算资源消耗相对可控。在处理大规模文本数据时，可以通过分布式计算等方式进一步优化计算效率。

TF-IDF的缺点

忽略语义信息：TF-IDF只考虑了词的出现频率和文档分布，完全没有涉及词与词之间的语义关系。例如，“汽车”和“轿车”在语义上相近，但TF-IDF无法体现这种关系，可能会导致在一些需要语义理解的任务中效果不佳。
依赖文档集合：逆文档频率的计算依赖于整个文档集合，当文档集合发生变化时，需要重新计算IDF值，这在实时性要求较高的应用场景中可能会带来不便。
无法处理多义词：对于具有多种含义的词，TF-IDF不能区分其在不同上下文中的语义差异，会将其视为同一个词进行计算，可能影响对文本的准确理解。