自然语言处理：文本表示

介绍

大家好，博主又来给大家分享知识了。今天给大家分享的内容是自然语言处理中的文本表示。

在当今数字化信息爆炸的时代，自然语言处理作为人工智能领域的重要分支，发挥着越来越关键的作用。

而文本表示，则是自然语言处理的基石之一，它就像是一把神奇的钥匙，能够将人类丰富多样、充满语义的自然语言，转化为计算机可以理解和处理的形式。话不多说，我们直接进入正题。

文本表示

概念阐述

在自然语言处理(NLP)中，文本表示是将人类自然语言文本转化为计算机能够理解和处理的形式的过程，其目的是用一种合适的数据结构或数学模型来表达文本的语义、语法等信息，以便后续进行各种自然语言处理任务。

文本表示是自然语言处理的基础和关键步骤，合适的文本表示方法能够显著提高自然语言处理任务(如文本分类、机器翻译、信息检索等)的效果。

词的表示

概念阐述

在自然语言处理中，词的表示是指将自然语言中的单词转化为计算机能够理解和处理的形式，其目的是用一种合适的方式来表达词的语义、语法等特征信息。

词的表示形式主要涵盖离散符号表示、稀疏向量表示以及稠密向量表示这三种。

离散符号表示

离散符号表示是自然语言处理领域中用于表示词的一种传统方式，它主要有两种常见形式：将词表示为字符串，或者将词表示为固定词表中的索引编号。

字符串形式

字符串形式直接把词当作一个字符序列，也就是我们日常看到和书写的词汇形式。例如，“book”，“apple”，“cat”等词，在这种表示下，它们就是以原本的字符串呈现。这种表示符合人们对词的直观认知，就像在字典中查阅单词时，看到的就是单词的字符串形式。

完整代码

# 定义一个名为NLPTextRepresentation的类，用于处理文本表示相关任务
class NLPTextRepresentation:# 类的初始化方法，此处不做任何初始化操作def __init__(self):# pass语句占位，不进行实际操作pass# 定义一个实例方法text_representation用于文本表示处理def text_representation(self):# 定义几个以字符串形式表示的词word1 = "book"word2 = "apple"word3 = "cat"# 将这些词存储在一个列表中word_list = [word1, word2, word3]# 打印每个词及其类型，以展示它们是以字符串形式表示的for word in word_list:print(f"词: {word}, 类型: {type(word)}")# 定义一个句子，句子也是由多个以字符串形式表示的词组成sentence = "I have a cat and an apple on the table near the book"# 对句子进行简单的按空格分词，每个分词结果也是字符串形式words_in_sentence = sentence.split()# 打印分词后的结果及每个词的类型print("\n句子分词结果:")for w in words_in_sentence:print(f"词: {w}, 类型: {type(w)}")# 当脚本作为主程序运行时执行以下代码
if __name__ == "__main__":# 创建NLPTextRepresentation类的一个实例nlp_text_representation = NLPTextRepresentation()# 调用实例的text_representation方法进行文本表示处理nlp_text_representation.text_representation()

运行结果

词: book, 类型: <class 'str'>
词: apple, 类型: <class 'str'>
词: cat, 类型: <class 'str'>句子分词结果:
词: I, 类型: <class 'str'>
词: have, 类型: <class 'str'>
词: a, 类型: <class 'str'>
词: cat, 类型: <class 'str'>
词: and, 类型: <class 'str'>
词: an, 类型: <class 'str'>
词: apple, 类型: <class 'str'>
词: on, 类型: <class 'str'>
词: the, 类型: <class 'str'>
词: table, 类型: <class 'str'>
词: near, 类型: <class 'str'>
词: the, 类型: <class 'str'>
词: book, 类型: <class 'str'>进程已结束，退出代码为 0

索引编号形式

索引符号形式先构建一个包含众多词汇的固定词表，然后给词表中的每个词分配一个独一无二的索引编号。比如有一个词表包含“dog”，“elephant”，“fish”等词，“dog”可能被赋予编号1，“elephant”被赋予编号2等。当处理文本时，文本中的词会被转换为词表中对应的索引编号。例如文本“I have a dog”，经过处理后，在计算机内部“dog”可能就被记录为其在词表中的索引编号1(假设其他词也有相应编号)。

完整代码

# 定义一个名为NLPTextRepresentation的类，用于处理文本表示相关任务
class NLPTextRepresentation:# 类的初始化方法，此处不做任何初始化操作def __init__(self):# pass语句占位，不进行实际操作pass# 定义一个实例方法text_representation用于文本表示处理def text_representation(self):# 定义一个固定的词表，包含多个常见的单词vocabulary = ["dog", "elephant", "fish", "cat", "bird", "rabbit", "I", "have", "a", "and"]# 使用字典推导式创建一个字典，将词表中的每个单词映射到一个从1开始的唯一索引编号word_to_index = {word: index for index, word in enumerate(vocabulary, start=1)}# 定义一个待处理的文本字符串text = "I have a dog and a cat"# 对文本进行分词，按空格将文本拆分成多个单词并存储在列表中words = text.split()# 初始化一个空列表，用于存储转换后的索引编号indexes = []# 遍历分词后的每个单词for word in words:# 检查当前单词是否存在于词表对应的索引字典中if word in word_to_index:# 如果存在，将该单词对应的索引编号添加到indexes列表中indexes.append(word_to_index[word])else:# 如果不存在，将-1添加到indexes列表中，表示该单词是未知词indexes.append(-1)# 打印原始输入的文本print("原始文本:", text)# 打印分词后的单词列表print("分词结果:", words)# 打印转换后的索引编号列表print("转换后的索引编号:", indexes)# 当脚本作为主程序运行时执行以下代码
if __name__ == "__main__":# 创建NLPTextRepresentation类的一个实例nlp_text_representation = NLPTextRepresentation()# 调用实例的text_representation方法进行文本表示处理nlp_text_representation.text_representation()

运行结果

原始文本: I have a dog and a cat
分词结果: ['I', 'have', 'a', 'dog', 'and', 'a', 'cat']
转换后的索引编号: [7, 8, 9, 1, 10, 9, 4]进程已结束，退出代码为 0

稀疏向量表示

在文本表示中，需要将文本转化为计算机能够处理的形式，而稀疏向量表示就是其中一种有效的手段。例如在词袋模型中，通过构建一个包含大量词汇的词表，将每个文档表示为一个向量，这个向量的维度与词表大小相同。

对于文档中出现的词，在向量对应位置上标记其出现的次数或其他相关统计值，而未出现的词对应的位置则为0，这样得到的就是一个稀疏向量。

此外，在一些基于统计的文本分析任务(如文本分类、信息检索等)中，稀疏向量表示能够简洁地表示文本的特征，便于后续的计算和分析。尽管它在语义表达方面存在一定的局限性，但在许多场景下依然是一种重要且实用的文本表示方法。

稀疏向量表示详解内容，请大家阅读博主的这篇博文：自然语言处理：稀疏向量表示-CSDN博客

稠密向量表示

在文本表示中，为了让计算机能够理解和处理文本信息，需要将文本转化为合适的表示形式。稠密向量表示就是其中一种非常有效的方式。通过将文本中的词、短语甚至整个文档映射为固定维度且元素较为密集(几乎没有零值)的向量，这些向量蕴含了丰富的语义信息。

• 例如，在自然语言处理任务中，像词嵌入技术生成的词向量(如GloVe、Word2Vec产生的向量)，将每个词表示为一个稠密向量，词与词之间的语义关系能够通过向量之间的运算(如距离计算)来体现。在文档层面，也可以通过一些方法将整个文档表示为一个稠密向量，用于文档分类、信息检索等任务。

所以，稠密向量表示是文本表示的重要组成部分，它在挖掘文本语义信息和支持各种自然语言处理任务方面发挥着关键作用。

GloVe

在众多实现稠密向量表示的方法中，词嵌入技术脱颖而出。词嵌入能够学习到词在上下文语境中的语义表示，为NLP任务带来了显著的性能提升。而Gensim作为一个强大的Python工具包，为我们提供了便捷的词嵌入操作接口。下面，我们将通过一个具体的例子，展示如何使用Gensim加载 GloVe词嵌入模型，进一步了解词的稠密向量表示。

下载预先训练好的词向量

我们首先需要从GloVe: Global Vectors for Word Representation下载预先训练好GloVe词向量集合压缩包(这里博主为了做讲解，下载的是glove.6B)。

下载完成后，解压压缩包，选择自己要使用的预训练的词向量集合(博主这里使用的是glove.6B.200d)。

注：

• “6B”代表该词向量集合是基于大约60亿个词(6 billion tokens)的语料库训练得到的。这个大规模的语料库包含了丰富的词汇和语言信息，使得训练出的词向量能够更好地反映语言的实际使用情况和语义关系。
• “200d”表示每个词对应的向量维度为200。也就是说，在这个glove.6B.200d词向量集合中，每个词都被表示为一个长度为200的实数向量。向量的每个维度都包含了一定的语义信息，这些维度共同编码了词的语义特征。一般来说，较高的维度可以容纳更多的语义信息，但也会增加计算和存储的成本。

将该词向量集合(glove.6B.200d)放到代码加载的路径。例如：博主放到了"D:\Software\PythonProjects\NaturalLanguageProcessing"，这也是博主自然语言处理项目所在的目录。

 完整代码

# 导入pprint模块，用于美观地打印数据结构
import pprint
# 从gensim库的models模块中导入KeyedVectors类，用于加载预训练词向量
from gensim.models import KeyedVectors# 定义一个名为NLPTextRepresentation的类，用于处理文本表示相关任务
class NLPTextRepresentation:# 类的初始化方法，初始化时将预训练词向量模型设为Nonedef __init__(self):# 初始化实例属性，用于存储预训练的词向量模型self.pretrained_word_vector_model = None# # 定义一个实例方法text_representation用于文本表示处理def text_representation(self):# 加载GloVe200维的预训练词向量模型self.pretrained_word_vector_model = KeyedVectors.load_word2vec_format(# 指定要加载的GloVe词向量文件的路径"D:/Software/PythonProjects/NaturalLanguageProcessing/glove.6B.200d.txt",# 表明加载的文件不是二进制格式binary=False,# 表明文件没有标题行no_header=True)# 打印与'book'最相似的词pprint.pprint(self.pretrained_word_vector_model.most_similar('book'))# 打印与'plane'最相似的词pprint.pprint(self.pretrained_word_vector_model.most_similar('plane'))# 定义一个实例方法solve_word_analogy用于解决词语类比问题def solve_word_analogy(self, base_word_1, related_word_1, base_word_2):# 根据输入的词语进行类比计算，找到最相似的词analogy_result = self.pretrained_word_vector_model.most_similar(# 正向词列表，用于计算类比关系positive=[base_word_2, related_word_1],# 负向词列表，用于计算类比关系negative=[base_word_1])# 返回类比结果中的第一个词return analogy_result[0][0]# 当脚本作为主程序运行时执行以下代码
if __name__ == "__main__":# 创建NLPTextRepresentation类的一个实例nlp_text_representation = NLPTextRepresentation()# 调用实例的text_representation方法进行文本表示处理nlp_text_representation.text_representation()# 进行词语类比计算，打印英国和中国语言类比的结果print(nlp_text_representation.solve_word_analogy("britain", "british", "china"))# 进行词语类比计算，打印加拿大和挪威代表性事物类比的结果print(nlp_text_representation.solve_word_analogy("canada", "maple", "norway"))# 进行词语类比计算，打印形容词最高级类比的结果print(nlp_text_representation.solve_word_analogy("high", "highest", "large"))# 进行词语类比计算，打印不同程度描述词类比的结果print(nlp_text_representation.solve_word_analogy("nice", "wonderful", "awful"))# 进行词语类比计算，打印性别相关词语类比的结果print(nlp_text_representation.solve_word_analogy("boy", "girl", "uncle"))

运行结果

[('books', 0.8452467918395996),('author', 0.7746455669403076),('novel', 0.7485204935073853),('published', 0.7451642751693726),('memoir', 0.7047821283340454),('wrote', 0.6971326470375061),('written', 0.6967507004737854),('essay', 0.6844283938407898),('biography', 0.681260347366333),('autobiography', 0.6770558953285217)]
[('airplane', 0.7965999245643616),('planes', 0.7498337626457214),('crashed', 0.7370129823684692),('jet', 0.7351437211036682),('flight', 0.734633207321167),('aircraft', 0.7169479727745056),('crash', 0.7128624320030212),('airliner', 0.6871931552886963),('flew', 0.6739749908447266),('helicopter', 0.6698653101921082)]
chinese
spruce
largest
horrible
aunt进程已结束，退出代码为 0

Word2Vec

在自然语言处理的文本表示中，Word2Vec是一种非常重要且广泛应用的词嵌入(Word Embedding)技术，它旨在将文本中的每个词映射为一个低维的连续向量，从而实现对词的数值化表示。

Word2Vec基于分布式假设，即如果两个词在文本中经常出现在相似的上下文环境中，那么它们的语义也很可能相似。它通过构建一个预测模型，利用词的上下文信息来预测目标词，或者利用目标词来预测其上下文，从而学习到词的向量表示。

在这个过程中，每个词都被映射到一个低维的向量空间中，在这个空间里，语义相近的词在位置上也更接近。

接下来，将为大家展示Word2Vec相关代码。该代码包含文本预处理环节、Skip-Gram算法的具体实现，并且会借助PyTorch框架完成优化过程。在本次代码实践中，我们选用《牧羊少年奇幻之旅》(The Alchemist)这本书的文本内容作为训练语料。

完整代码

在执行此部分代码之前，大家需预先安装代码所依赖的库。具体的安装命令为：

pip install numpy
pip install nltk
pip install torch torchvision torchaudio
pip install matplotlib

注： 

• numpy全称为Numerical Python，是Python科学计算的基础库，它提供了高效的多维数组对象(ndarray)以及对这些数组进行快速操作的各类函数。
• nltk全称为Natural Language Toolkit，即自然语言工具包，是Python中一个广泛使用的用于自然语言处理(NLP)的开源库。nltk提供了丰富的工具、数据集和算法，可帮助开发者进行文本处理、分析和理解，覆盖了自然语言处理的多个基础任务和高级技术，让开发者能够更便捷地实现各种自然语言处理应用。
• torch是PyTorch深度学习框架的核心库。PyTorch是一个开源的深度学习框架，被广泛应用于自然语言处理、计算机视觉、语音识别等领域。torchvision是PyTorch的一个扩展库，专门用于计算机视觉任务。torchaudio是PyTorch的另一个扩展库，用于音频处理任务。
• matplotlib是Python中一个非常流行且功能强大的用于数据可视化的第三方库，matplotlib提供了一整套用于创建各种静态、动态和交互式可视化图表的工具，涵盖了从简单的折线图、散点图到复杂的多子图布局、3D图形等多种类型。

text_representation_dataset.py文件中的TextRepresentationDataset类：

# 从nltk库的tokenize模块导入句子分词和单词分词的函数
from nltk.tokenize import sent_tokenize, word_tokenize
# 从collections模块导入defaultdict类，用于创建具有默认值的字典
from collections import defaultdict
# 导入numpy库，用于进行数值计算和数组操作
import numpy as np# 定义一个名为TextRepresentationDataset的类，用于文本表示数据集的处理
class TextRepresentationDataset:# 类的构造函数，初始化对象时调用，默认对文本进行分词def __init__(self, do_tokenize=True):# 初始化单词频率字典，用于记录每个单词的出现频率self.word_frequency = None# 初始化单词到索引的映射字典self.word_to_id = None# 初始化索引到单词的映射字典self.id_to_word = None# 初始化存储单词索引列表的变量self.word_id_list = None# 以只读模式打开指定文本文件，并以UTF-8编码读取文件内容raw_text = open('The Alchemist.txt', 'r', encoding='utf-8').read()# 判断是否需要对文本进行分词操作if do_tokenize:# 对读取的文本进行句子分词，并将所有单词转换为小写self.sentence_list = sent_tokenize(raw_text.lower())# 对每个句子进行单词分词，将结果存储在列表中self.word_list = [word_tokenize(sent) for sent in self.sentence_list]else:# 如果不进行分词，直接将原始文本存储在对象属性中self.raw_text = raw_text# 定义创建词汇表的方法，可指定最小词频，低于该频率的词会被丢弃def create_vocabulary(self, minimum_frequency=1):# 创建一个默认值为0的字典，用于统计单词频率word_freq = defaultdict(int)# 遍历每个句子for single_sentence in self.word_list:# 遍历句子中的每个单词for single_word in single_sentence:# 统计每个单词的出现次数word_freq[single_word] += 1# 将统计好的单词频率字典存储在对象属性中self.word_frequency = word_freq# 初始化单词到索引的映射字典，添加特殊标记<unk>和<pad>self.word_to_id = {'<unk>': 1, '<pad>': 0}# 初始化索引到单词的映射字典，添加特殊标记<unk>和<pad>self.id_to_word = {1: '<unk>', 0: '<pad>'}# 对统计好的单词频率字典按频率从高到低排序for word, freq in sorted(word_freq.items(), key=lambda x: -x[1]):# 注释说明：丢弃低频词# 判断单词频率是否大于最小词频要求if freq > minimum_frequency:# 将单词添加到单词到索引的映射字典中self.word_to_id[word] = len(self.word_to_id)# 将索引和单词的映射添加到索引到单词的映射字典中self.id_to_word[len(self.id_to_word)] = wordelse:# 如果单词频率低于最小词频，停止添加break# 定义获取单词分布的方法def obtain_word_distribution(self):# 创建一个长度为词汇表大小的全零数组，用于存储单词分布dist = np.zeros(len(self.word_to_id))# 遍历统计好的单词频率字典for word, freq in self.word_frequency.items():# 判断单词是否在词汇表中if word in self.word_to_id:# 将单词的频率存储到对应索引的位置dist[self.word_to_id[word]] = freqelse:# 如果单词不在词汇表中，将其频率累加到<unk>对应的位置dist[1] += freq# 对存储单词分布的数组进行归一化处理dist /= dist.sum()# 返回归一化后的单词分布数组return dist# 定义将单词转换为索引的方法，可选择移除单单词的句子def transform_tokens_to_ids(self, remove_single_word=True):# 初始化存储单词索引列表的变量self.word_id_list = []# 遍历每个句子for single_sentence in self.word_list:# 将句子中的每个单词转换为对应的索引，如果单词不在词汇表中，使用<unk>的索引ids = [self.word_to_id.get(word, 1) for word in single_sentence]# 判断转换后的索引列表长度是否为1且需要移除单单词的句子if len(ids) == 1 and remove_single_word:# 如果满足条件，跳过该句子continue# 将转换后的索引列表添加到存储单词索引列表的变量中self.word_id_list.append(ids)# 返回存储单词索引列表的变量return self.word_id_list

该类的主要作用是对文本数据进行预处理，包括分词、构建词汇表、统计单词频率、计算单词分布以及将单词转换为索引等操作，为后续的自然语言处理任务(如文本分类、语言模型训练等)提供必要的数据准备。 

skip_gram_with_nce.py文件中的SkipGramWithNCE类和BatchDataCollator类：

# 导入PyTorch库，用于深度学习任务
import torch
# 从PyTorch中导入神经网络模块
from torch import nn
# 导入PyTorch的函数式接口，用于常用的神经网络函数
import torch.nn.functional as functional
# 导入NumPy库，用于数值计算
import numpy as np# 定义一个名为BatchDataCollator的类，用于批量数据的整理
class BatchDataCollator:# 定义一个类方法，用于整理一批数据@classmethoddef collate_data_batch(cls, batch_data):# 将输入的批量数据转换为NumPy数组batch_data = np.array(batch_data)# 从批量数据中提取输入索引，并转换为PyTorch的长整型张量input_indices = torch.tensor(batch_data[:, 0], dtype=torch.long)# 从批量数据中提取目标标签，并转换为PyTorch的长整型张量target_labels = torch.tensor(batch_data[:, 1], dtype=torch.long)# 返回一个字典，包含输入索引和目标标签return {'input_indices': input_indices, 'target_labels': target_labels}# 定义一个名为SkipGramWithNCE的类，继承自PyTorch的神经网络模块
class SkipGramWithNCE(nn.Module):# 类的构造函数，初始化模型的参数def __init__(self, vocabulary_size, embedding_dim, word_distribution, negative_sample_num=20):# 调用父类的构造函数super(SkipGramWithNCE, self).__init__()# 打印模型的参数信息，包括词汇表大小、嵌入维度和负样本数量print(f'vocabulary_size = {vocabulary_size}, embedding_dim = {embedding_dim}, ' + f'negative_sample_num = {negative_sample_num}')# 定义输入嵌入层，将词汇表中的单词映射到指定维度的向量空间self.input_embedding_layer = nn.Embedding(vocabulary_size, embedding_dim)# 定义输出嵌入层，将词汇表中的单词映射到指定维度的向量空间self.output_embedding_layer = nn.Embedding(vocabulary_size, embedding_dim)# 对单词分布进行0.75次幂运算word_distribution = np.power(word_distribution, 0.75)# 对处理后的单词分布进行归一化处理word_distribution /= word_distribution.sum()# 将处理后的单词分布转换为PyTorch张量self.word_distribution_tensor = torch.tensor(word_distribution)# 保存负样本的数量self.negative_sample_num = negative_sample_num# 定义前向传播方法，用于计算模型的输出def forward(self, input_indices, target_labels):# 通过输入嵌入层将输入索引转换为嵌入向量input_embedded = self.input_embedding_layer(input_indices)# 通过输出嵌入层将目标标签转换为嵌入向量output_embedded = self.output_embedding_layer(target_labels)# 获取输入嵌入向量的批次大小batch_size_val = input_embedded.size(0)# 根据单词分布张量，随机采样负样本单词的索引negative_word_indices = torch.multinomial(self.word_distribution_tensor,batch_size_val * self.negative_sample_num, replacement=True).view(batch_size_val, -1)# 通过输出嵌入层将负样本单词的索引转换为嵌入向量negative_embedded = self.output_embedding_layer(negative_word_indices)# 计算正样本项，使用logsigmoid函数对输入嵌入向量和输出嵌入向量的点积求和positive_term = functional.logsigmoid(torch.sum(input_embedded * output_embedded, dim=1))# 计算负样本项，使用logsigmoid函数对负样本嵌入向量和输入嵌入向量的批量矩阵乘法结果取负negative_term = functional.logsigmoid(- torch.bmm(negative_embedded, input_embedded.unsqueeze(2)).squeeze())# 对负样本项在维度1上求和negative_term = torch.sum(negative_term, dim=1)# 计算损失值，取正样本项和负样本项之和的平均值的负值loss_value = -torch.mean(positive_term + negative_term)# 返回计算得到的损失值return loss_value

BatchDataCollator类主要用于将批量数据进行整理和处理，使其能够以合适的格式输入到模型中进行训练。 

SkipGramWithNCE类实现了带有负采样对比估计(Negative Sampling with Contrastive Estimation，NCE)的Skip-Gram模型，用于学习词向量。Skip-Gram模型的目标是根据中心词预测其上下文词，而NCE是一种用于提高训练效率的技术，通过采样少量的负样本(即非上下文词)来近似计算损失。

nlp_text_normalization.py文件中的NLPTextRepresentation类(此文件被设定为主运行文件)：

# 从skip_gram_with_nce模块中导入SkipGramWithNCE类和BatchDataCollator类
from skip_gram_with_nce import SkipGramWithNCE, BatchDataCollator
# 从text_representation_dataset模块中导入TextRepresentationDataset类
from text_representation_dataset import TextRepresentationDataset
# 导入numpy库，用于数值计算和数组操作
import numpy as np
# 从 tqdm库中导入trange函数，用于显示训练进度条
from tqdm import trange
# 导入matplotlib库，用于数据可视化
import matplotlib# 设置matplotlib的后端为TkAgg，用于显示图形界面
matplotlib.use('TkAgg')
# 从matplotlib库中导入pyplot模块，并将其重命名为plt
from matplotlib import pyplot as plt
# 从torch.utils.data模块中导入DataLoader类，用于批量加载数据
from torch.utils.data import DataLoader
# 从torch.optim模块中导入Adam优化器
from torch.optim import Adam# 定义一个名为NLPTextRepresentation的类，用于处理文本表示相关任务
class NLPTextRepresentation:# 类的初始化方法，此处不做任何初始化操作def __init__(self):# pass 语句占位，不进行实际操作pass# 定义一个实例方法text_representation用于文本表示处理def text_representation(self):# 创建TextRepresentationDataset类的实例，用于处理文本数据text_repr_dataset = TextRepresentationDataset()# 调用实例的create_vocabulary方法，创建词汇表，最小词频设为 1text_repr_dataset.create_vocabulary(minimum_frequency=1)# 调用实例的transform_tokens_to_ids方法，将分词结果转换为索引序列token_index_sentences = text_repr_dataset.transform_tokens_to_ids()# 设置上下文窗口大小为2context_window_size = 2# 初始化一个空列表，用于存储训练数据training_data = []# 遍历每个句子的索引序列for sentence in token_index_sentences:# 遍历句子中的每个词的索引for i in range(len(sentence)):# 遍历当前词索引前后的上下文窗口范围for j in range(i - context_window_size, i + context_window_size + 1):# 跳过自身索引、越界索引if j == i or j < 0 or j >= len(sentence):continue# 获取中心词的索引central_word_index = sentence[i]# 获取上下文词的索引context_word_index = sentence[j]# 将中心词索引和上下文词索引作为一个样本添加到训练数据列表中training_data.append([central_word_index, context_word_index])# 将训练数据列表转换为numpy数组training_data = np.array(training_data)# 打印训练数据的形状和内容print(training_data.shape, training_data)# 获取词汇表的大小vocabulary_size = len(text_repr_dataset.word_to_id)# 设置嵌入维度为128embedding_dimension = 128# 调用实例的obtain_word_distribution方法，获取单词分布word_distribution = text_repr_dataset.obtain_word_distribution()# 打印单词分布print(word_distribution)# 创建SkipGramWithNCE类的实例，初始化模型skip_gram_model = SkipGramWithNCE(vocabulary_size, embedding_dimension, word_distribution)# 定义训练参数以及训练循环# 设置训练的轮数为100training_epochs = 100# 设置每个批次的数据数量为128batch_size = 128# 设置学习率为0.001learning_rate = 1e-3# 初始化一个空列表，用于存储每一轮的损失值epoch_losses = []# 创建BatchDataCollator类的实例，用于整理批量数据data_collation_helper = BatchDataCollator()# 创建DataLoader实例，用于批量加载训练数据data_loader = DataLoader(training_data, batch_size=batch_size, shuffle=True,collate_fn=data_collation_helper.collate_data_batch)# 创建Adam优化器实例，用于更新模型参数optimizer = Adam(skip_gram_model.parameters(), lr=learning_rate)# 清空模型的梯度skip_gram_model.zero_grad()# 将模型设置为训练模式skip_gram_model.train()# 训练过程，每步读取数据，送入模型计算损失，并使用PyTorch进行优化# 使用trange函数创建一个进度条，显示训练轮数with trange(training_epochs, desc='epoch', ncols=60) as progress_bar:# 遍历每一轮训练for epoch in progress_bar:# 遍历每个批次的数据for step, batch_data in enumerate(data_loader):# 将批次数据输入模型，计算损失loss = skip_gram_model(**batch_data)# 更新进度条的描述信息，显示当前轮数和损失值progress_bar.set_description(f'epoch-{epoch}, loss={loss.item():.4f}')# 反向传播计算梯度loss.backward()# 使用优化器更新模型参数optimizer.step()# 清空模型的梯度skip_gram_model.zero_grad()# 将当前轮的损失值添加到损失列表中epoch_losses.append(loss.item())# 将损失列表转换为numpy数组epoch_losses = np.array(epoch_losses)# 绘制损失值随训练轮数变化的折线图plt.plot(range(len(epoch_losses)), epoch_losses)# 设置 x 轴标签为训练轮数plt.xlabel('training epochs')# 设置 y 轴标签为损失值plt.ylabel('loss value')# 显示绘制的图形plt.show()# 当脚本作为主程序运行时执行以下代码
if __name__ == "__main__":# 创建NLPTextRepresentation类的一个实例nlp_text_representation = NLPTextRepresentation()# 调用实例的text_representation方法进行文本表示处理nlp_text_representation.text_representation()

该类整合了文本数据处理、模型构建、训练以及结果可视化等一系列操作，实现了基于Skip-Gram 模型的词向量训练和相关分析任务。

运行结果

(15326, 2) [[ 1  1][ 1 20][ 1  1]...[28  1][ 1  2][ 1 28]]
[0.         0.46239338 0.42310675 0.02326182 0.00827087 0.007753940.00646162 0.00465236 0.00361851 0.00361851 0.00361851 0.003360040.00310158 0.00232618 0.00206772 0.00206772 0.00206772 0.002067720.00206772 0.00180925 0.00155079 0.00155079 0.00155079 0.001550790.00155079 0.00129232 0.00129232 0.00103386 0.00103386 0.001033860.00103386 0.00103386 0.00103386 0.00077539 0.00077539 0.000775390.00077539 0.00077539 0.00077539 0.00077539 0.00051693 0.000516930.00051693 0.00051693 0.00051693 0.00051693 0.00051693 0.000516930.00051693 0.00051693 0.00051693 0.00051693 0.00051693 0.000516930.00051693 0.00051693 0.00051693 0.00051693 0.00051693 0.00051693]
vocabulary_size = 60, embedding_dim = 128, negative_sample_num = 20
epoch-99, loss=3.9004: 100%|█| 100/100 [00:18<00:00,  5.29it

运行结果解析

图表坐标轴含义

• 横坐标(training epochs)：表示训练轮数，范围从0到100，对应代码中设置的training_epochs=100，即模型对整个训练数据集进行100次遍历训练。
• 纵坐标(loss value)：表示损失值，反映了模型在训练过程中预测结果与真实结果之间的差距。损失值越低，说明模型的预测效果越好。

折线走势分析

• 起始阶段(0-10轮左右)：损失值从接近19迅速下降，在下降过程中出现了一定波动。这是因为在训练初期，模型的参数是随机初始化的，对数据的拟合能力较差，损失值较高。随着训练的进行，优化器(代码中使用的是Adam优化器)开始调整模型参数，使得损失值快速下降。波动可能是由于不同批次数据的分布差异以及随机初始化的影响。
• 中间阶段(10-40轮左右)：损失值下降速度变缓，并且在一定范围内波动。此时模型已经初步学习到了数据中的一些特征，但还没有完全收敛，继续在调整参数以更好地拟合数据，所以损失值虽然仍在下降，但幅度变小，且由于数据的随机性和模型训练的不稳定性，存在一定波动。
• 后期阶段(40-100轮左右)：损失值趋于平稳，基本在4附近小范围波动。这表明模型已经接近收敛状态，进一步调整参数对损失值的降低作用不大，模型在当前的训练设置下已经达到了一个相对稳定的拟合程度。

与代码的关联

• 在代码中，每一轮训练结束后，会将当前轮的损失值(loss.item())记录到epoch_losses列表中，训练完成后将该列表转换为numpy数组，然后使用plt.plot(range(len(epoch_losses)), epoch_losses)绘制损失值随训练轮数的变化曲线，横坐标是训练轮数序列，纵坐标是对应的损失值序列，最终呈现出这张可视化图表。

稠密向量表示详解内容，请大家阅读博主的这篇博文：自然语言处理：稠密向量表示-CSDN博客

文档表示

概念阐述

在自然语言处理的文本表示中，文档表示是将文本形式的文档转化为计算机可处理的数字形式，以让计算机理解文档语义和特征，进而实现信息检索、文本分类、情感分析等任务。

TF-IDF

TF-IDF(Term Frequency-Inverse Document Frequency)：即词频-逆文档频率，是一种用于信息检索和文本挖掘的常用加权技术，也是一种统计方法，用以评估一个字词对于文件集或语料库中某一份文件的重要程度。

TF-IDF是常见的文档表示方法一只，它基于词袋模型，不仅考量词在文档中的出现频率(TF)，还结合词在整个文档集合中的稀有程度(IDF)。在情感分析等自然语言处理任务中，积极的词可通过TF-IDF体现其重要性。如果某个积极词，像 “很棒”，“超赞”，“喜欢”等，在一篇文档中出现频率(TF)较高，同时在整个文档集合中出现的文档数量较少(IDF较高)，那么这个词的TF-IDF值就高，能突出该文档在情感表达上的特点。

在众多实际场景中，常常会对文档所对应的TF-IDF向量进一步执行L2归一化操作。通过这种方式，能够让不同文档的TF-IDF向量具备相同的模长属性，从而更有利于对它们进行相互间的比较分析。接下来，我用具体代码来给大家展示TF-IDF的实现。

完整代码

# 导入NumPy库，用于数值计算
import numpy as np# 定义TFIDF类，用于计算文本的TF-IDF值
class TFIDF:# 类的构造函数，初始化类的属性def __init__(self, vocabulary_size, normalization='l2', smooth_inverse_document_frequency=True,sublinear_term_frequency=True):# 初始化逆文档频率为None，后续会在fit方法中计算self.inverse_document_frequency = None# 存储词汇表的大小self.vocabulary_size = vocabulary_size# 存储归一化的方式，默认为'l2'self.normalization = normalization# 存储是否对逆文档频率进行平滑处理的标志，默认为Trueself.smooth_inverse_document_frequency = smooth_inverse_document_frequency# 存储是否使用次线性词频的标志，默认为Trueself.sublinear_term_frequency = sublinear_term_frequency# 该方法用于计算逆文档频率(IDF)def fit(self, document_collection):# 创建一个全零数组，用于存储每个词的文档频率document_frequency = np.zeros(self.vocabulary_size, dtype=np.float64)# 遍历文档集合中的每个文档for document in document_collection:# 遍历文档中出现的唯一词for word_id in set(document):# 对应词的文档频率加 1document_frequency[word_id] += 1# 如果开启平滑处理，文档频率数组每个元素加1document_frequency += int(self.smooth_inverse_document_frequency)# 计算文档总数，若开启平滑处理则总数加1total_documents = len(document_collection) + int(self.smooth_inverse_document_frequency)# 根据公式计算逆文档频率并存储在类的属性中self.inverse_document_frequency = np.log(total_documents / document_frequency) + 1# 该方法用于将文档集合转换为TF-IDF矩阵def transform(self, document_collection):# 确保已经调用fit方法计算了逆文档频率assert hasattr(self, 'inverse_document_frequency')# 创建一个全零矩阵，用于存储词频矩阵term_frequency_matrix = np.zeros((len(document_collection), self.vocabulary_size), dtype=np.float64)# 遍历文档集合，获取文档的索引和内容for index, document in enumerate(document_collection):# 遍历文档中的每个词for word in document:# 对应位置的词频加1term_frequency_matrix[index, word] += 1# 如果使用次线性词频，对词频矩阵取对数if self.sublinear_term_frequency:term_frequency_matrix = np.log(term_frequency_matrix + 1)# 计算TF-IDF矩阵，词频矩阵乘以逆文档频率tfidf_matrix = term_frequency_matrix * self.inverse_document_frequency# 如果开启了归一化if self.normalization:# 计算TF-IDF矩阵每行的L2范数row_norm = (tfidf_matrix ** 2).sum(axis=1)# 将范数为0的行的范数设为1，避免除零错误row_norm[row_norm == 0] = 1# 对TF-IDF矩阵进行L2归一化tfidf_matrix /= np.sqrt(row_norm)[:, None]# 返回最终的TF-IDF矩阵return tfidf_matrix# 该方法先调用fit方法，再调用transform方法def fit_transform(self, document_collection):# 调用fit方法计算逆文档频率self.fit(document_collection)# 调用transform方法计算并返回TF-IDF矩阵return self.transform(document_collection)# 当此Python文件作为主程序直接运行时，执行下面的代码块
if __name__ == "__main__":# 定义一个简单的文档集合，每个文档用单词的索引列表表示document_collection = [[0, 1, 2],[1, 2, 3],[0, 2, 3]]# 假设词汇表大小为4，因为document_collection中出现的最大索引为3vocabulary_size = 4# 创建TFIDF类的实例tfidf = TFIDF(vocabulary_size)# 调用fit_transform方法计算TF-IDF矩阵tfidf_matrix = tfidf.fit_transform(document_collection)# 打印计算得到的TF-IDF矩阵print("TF-IDF矩阵:")print(tfidf_matrix)

运行结果

TF-IDF矩阵:
[[0.61980538 0.61980538 0.48133417 0.        ][0.         0.61980538 0.48133417 0.61980538][0.61980538 0.         0.48133417 0.61980538]]进程已结束，退出代码为 0

代码分析

该类的核心功能是计算TF-IDF值。TF-IDF是一种用于评估一个字词对于一个文档集或语料库中的某一份文档的重要程度的统计方法。该类通过fit和transform方法，结合fit_transform这个便捷方法，完成了TF-IDF值的计算。

• fit方法：此方法会遍历输入的文档集合，统计每个词在多少个文档中出现过，以此计算逆文档频率(IDF)。逆文档频率反映了一个词的普遍重要性，一个词在越少的文档中出现，其IDF值越高。
• transform方法：该方法先计算每个文档中各个词的词频(TF)，即一个词在文档中出现的频率。然后将词频与之前计算好的IDF相乘，得到TF-IDF值。最终形成一个矩阵，每一行代表一个文档，每一列代表一个词，矩阵中的元素就是对应文档中对应词的TF-IDF值。
• fit_transform方法：它是fit和transform方法的组合，方便用户一次性完成IDF计算和TF-IDF矩阵的生成。

TF-IDF详解内容，请大家阅读博主的这篇博文：自然语言处理：词频-逆文档频率-CSDN博客

结束

好了，本次分享就到这里。相信通过刚刚的内容，大家对自然语言处理里的文本表示有了更多的理解，也对它在实际应用中蕴藏的巨大潜力有了全新的认知。真心希望这次分享能成为大家在自然语言处理学习与实践旅程中的助力，给大家带来一些启发。

总的来说，自然语言处理领域正蓬勃发展，充满无限生机与可能，而文本表示作为其中的核心基础，其重要性不言而喻，且相关技术也在不断推陈出新。相信大家也能在这片充满活力与机遇的领域中，始终保持热情，积极探索，勇于实践，不断收获成长与进步。

那么本次分享就到这里了。最后，博主还是那句话：请大家多去大胆的尝试和使用，成功总是在不断的失败中试验出来的，敢于尝试就已经成功了一半。如果大家对博主分享的内容感兴趣或有帮助，请点赞和关注。大家的点赞和关注是博主持续分享的动力🤭，博主也希望让更多的人学习到新的知识。