02_NLP文本预处理之文本张量表示法

文本张量表示法

概念

将文本使用张量进行表示,一般将词汇表示为向量,称为词向量,再由各个词向量按顺序组成矩阵形成文本表示

例如:

["人生", "该", "如何", "起头"]

==>

# 每个词对应矩阵中的一个向量
[[1.32, 4,32, 0,32, 5.2],
 [3.1, 5.43, 0.34, 3.2],
 [3.21, 5.32, 2, 4.32],
 [2.54, 7.32, 5.12, 9.54]]

作用

将文本表示成张量（矩阵）形式，能够使语言文本可以作为计算机处理程序的输入，进行接下来一系列的解析工作。

连接文本与计算机
- 将文本张量转换为数值形式输入,使其能够被计算机处理和理解
表达语义信息
- 捕捉词语关系
  
  好的文本张量表示方法，例如词嵌入，可以将词语映射到高维空间中，使得语义相似的词语在向量空间中也彼此接近。例如，“king” 和 “queen” 的向量在空间中会比 “king” 和 “apple” 更接近。
- 保留上下文信息
  
  对于句子和文档的表示方法，例如句嵌入和文档嵌入，能够保留文本的上下文信息，例如词语之间的顺序和依赖关系。
- 理解文本含义
  
  通过将文本映射到向量空间，模型可以学习到文本的深层语义含义，而不仅仅是表面上的字面意思。
提升模型性能
- 特征提取
  
  文本张量表示可以看作是对文本进行特征提取的过程，将文本转换为计算机可以理解的特征。
- 降维
  
  一些文本张量表示方法，例如词嵌入，可以将文本的维度降低，减少模型的计算量，并避免维度灾难。
- 减少噪声
  
  一些文本张量表示方法，例如 TF-IDF，可以对文本中的噪声进行过滤，突出重要信息。

方法

one-hot编码

概念:每个单词都会被映射到一个高维向量中，该向量中只有一个元素是 1，其他所有元素都是 0。
举例

假设我们有一个包含以下 5 个单词的词汇表（Vocabulary）：
- “cat”
- “dog”
- “fish”
- “bird”
- “rabbit”
我们需要为每个单词生成一个向量，向量的维度等于词汇表中单词的数量（在这个例子中是 5）。

1. 构建词汇表：

我们的词汇表如下：

Index Word
0 cat
1 dog
2 fish
3 bird
4 rabbit

2. 生成 One-hot 向量：

每个单词都会被转换为一个与词汇表大小相同的向量，其中该单词所在位置的值为 1，其余位置的值为 0。
- “cat” -> [1, 0, 0, 0, 0]
- “dog” -> [0, 1, 0, 0, 0]
- “fish” -> [0, 0, 1, 0, 0]
- “bird” -> [0, 0, 0, 1, 0]
- “rabbit” -> [0, 0, 0, 0, 1]
特点:
- 稀疏性
  
  one-hot编码通常会产生非常稀疏的向量，尤其是词汇表很大时。大部分元素为零，只有一个位置是1。
- 高维度
  
  词汇表的大小决定了one-hot向量的维度。如果词汇表包含10000个单词，那么每个单词的表示将是一个长度为10000的向量。
- 信息缺失
  
  one-hot编码无法表达词与词之间的语义关系。例如，“cat” 和 “dog” 的表示完全不同，尽管它们在语义上很接近。
优缺点:
- 优点:实现简单,容易理解
- 缺点:高维度稀疏向量的特性导致其计算效率低下,无法捕捉词之间的语义相似性.在大语料集下,每个向量的长度过大,占据大量内存

Index	Word
0	cat
1	dog
2	fish
3	bird
4	rabbit

one-hot的编码实现

核心思路: 使用Tokenizer + 列表构成的向量实现

创建Tokenizer示例
tokenizer = Tokenizer()
- Tokenizer() 是 Keras.preprocessing.text 模块中的一个文本处理类。
- 它用于构建词典，并提供方法将文本转换为整数索引或其他格式（如 One-hot、词频矩阵等）。
- 默认情况下，它会自动对文本进行标记化（Tokenization），并创建一个 word_index（单词到索引的映射）
训练 Tokenizer
tokenizer.fit_on_texts(texts=vocabs)
- fit_on_texts(texts)用于基于提供的文本数据构建词典。
- texts（这里是 vocabs）应该是一个包含多个句子的列表，每个句子是一个字符串。
- Tokenizer 解析所有文本，统计每个单词的出现次数，并将单词转换为唯一的整数索引。
Tokenizer的主要属性
- word_index 单词到索引的映射 => 字典类型的成员属性
- word_counts（单词出现次数）
- texts_to_sequences()（文本转索引序列）

构建one-hot编码器

from tensorflow.keras.preprocessing.text import Tokenizer
import joblib
# 根据语料库生成one-hot编码器
def dm_onehot_gen():
    """
        1.准备语料
        2.实例化词汇映射器Tokenizer,使用映射器拟合现有文本 -> 生成 index_word word_index
        3.查询单词的索引下标
        4.保存映射器
    """
    # 1. 准备语料
    vocabs = {"周杰伦", "陈奕迅", "王力宏", "李宗盛", "范丞丞", "杨宗纬"}
    # 2.实例化词汇映射器Tokenizer,使用映射器拟合现有文本 -> 生成 index_word word_index
    tokenizer = Tokenizer()
    tokenizer.fit_on_texts(texts=vocabs)

    print(tokenizer.word_index)
    # 3.查询单词的 idx
    for vocab in vocabs:
        zero_list = [0] * len(vocabs)
        # 注意!! tokenizer生成的`word_index`字典是从下标1开始的
        idx = tokenizer.word_index[vocab] - 1
        zero_list[idx] = 1
        print(f'{vocab}的one-hot编码是->\t{zero_list}')

    # 4. 保存映射器
    path = './model/tokenizer'
    joblib.dump(tokenizer, filename=path)
    print('save tokenizer.....done')

使用one-hot编码器

def dm_one_hot_use(token = '周杰伦'):
    """
        1.加载映射器
        2.查询单词的索引下标,赋值给zero_list,生成one-hot向量
    :return:
    """
    # 2. 加载映射器
    tokenizer = joblib.load('./model/tokenizer')
    # 3.根据给定的token查询词表进行编码

    zero_list = [0] * len(tokenizer.word_index)

    cursor = tokenizer.word_index.get(token)
    if cursor is not None:
        idx = cursor - 1
        zero_list[idx] = 1
        print(f'{token}的one-hot向量表示为->{zero_list}')
    else:
        print('语料库中找不到该词语~')
        raise Exception

Word2Vec

概念
- Word2Vec是一种流行的将词汇表示成向量的无监督训练方法，该过程将构建神经网络模型，将网络参数作为词汇的向量表示，通过上下文信息来学习词语的分布式表示（即词向量）。它包含CBOW和skipgram两种训练模式。
- Word2Vec实际上利用了文本本身的信息来构建 “伪标签”。模型不是被人为地告知某个词语的正确词向量，而是通过上下文词语来预测中心词（CBOW）或者通过中心词来预测上下文词语（Skip-gram）。
- Word2Vec的目标是将每个词转换为一个固定长度的向量，这些向量能够捕捉词与词之间的语义关系。
特点
- 低维稠密表示
  
  Word2Vec通过训练得到的词向量通常是稠密的，即大部分值不为零，每个向量的维度较小（通常几十到几百维）。
- 捕捉语义关系
  
  Word2Vec可以通过词向量捕捉到词之间的语义相似性，例如通过向量运算可以发现"king"-“man”+“woman"≈"queen”。
优缺点
- 优点：能够生成稠密的词向量，捕捉词与词之间的语义关系，计算效率高。
- 缺点：需要大量的语料来训练，且可能不适用于某些特定任务（例如：词语的多义性）。

CBOW(Continuous bag of words)模式
- 概念:给定一段用于训练的上下文词汇(周围词汇),预测目标词汇

例如，在句子"the quick brown fox jumps over the lazy dog"中，如果目标词是"jumps"，则CBOW模型使用"the"，“quick”，“brown”，“fox”，“over”，“the”，“lazy”，“dog"这些上下文词来预测"jumps”。

图中窗口大小为9, 使用前后4个词汇对目标词汇进行预测。

CBOW的核心思想:语义相近的词在相似的上下文中出现。

CBOW的模型架构

输入层:将上下文词的one-hot编码输入模型（窗口内的词，忽略顺序）。
隐藏层:对上下文词向量求平均，生成一个D维向量（词向量的中间表示）。
输出层:通过softmax或负采样，将隐藏层向量映射到词汇表概率分布，预测目标词。

CBOW的前向传播过程

输入层 → 隐藏层
- 每个上下文词通过权重矩阵 WW（维度 V×D，V为词汇表大小）映射为D维向量。
- 隐藏层输出为上下文词向量的平均值：
  $h=\frac{1}C * Σ_{c=1}^{C}W *x_c$
  
  （C为上下文词数量，** $x_c$ **为第c个词的one-hot向量）。
隐藏层 → 输出层
- 隐藏层向量通过权重矩阵 W′W′（维度 D×V）映射到词汇表空间： $u=(W′)^T⋅h$
- 使用softmax计算目标词概率分布：
  $p(wt∣context)=\frac{exp⁡(u_{w_t})}{Σ^{V}_{v=1}exp⁡(u_{w_t})}$
损失函数和优化
- 损失函数: 多分类下的交叉熵损失(实际目标词为one-hot编码): $L=−log(p(w_t∣context))$
- 参数更新：通过反向传播更新权重矩阵 W 和 W′。
  - 仅更新与当前上下文词和目标词相关的行或列（稀疏更新）。

CBOW过程说明

假设我们给定的训练语料只有一句话: Hope can set you free (愿你自由成长)，窗口大小为3，因此模型的第一个训练样本来自Hope can set，因为是CBOW模式，所以将使用Hope和set作为输入，can作为输出，在模型训练时，Hope，can，set等词汇都使用它们的one-hot编码。如图所示: 每个one-hot编码的单词与各自的变换矩阵(即参数矩阵3x5->随机初始化，这里的3是指最后得到的词向量维度)相乘，得到上下文表示矩阵(3x1)，也就是词向量。将所有上下文词语的词向量按元素平均，得到平均词向量。
接着, 将上下文表示矩阵（平均词向量）与变换矩阵(参数矩阵5x3->随机初始化，所有的变换矩阵共享参数)相乘，得到5x1的结果矩阵，使用softmax函数将得分向量转换为概率分布，它将与我们真正的目标矩阵即can的one-hot编码矩阵（5x1）进行损失的计算，然后更新网络参数完成一次模型迭代。
最后窗口按顺序向后移动，重新更新参数，直到所有语料被遍历完成，得到最终的变换矩阵(3x5)，这个变换矩阵与每个词汇的one-hot编码(5x1)相乘，得到的3x1的矩阵就是该词汇的word2vec张量表示。

Skip-gram模式
- 概念:给定一个目标词，预测其上下文词汇。
例如，在句子"the quick brown fox jumps over the lazy dog"中，如果目标词是"jumps"，skip-gram模型尝试预测它周围的词，如"the"，“quick”，“brown”，“fox”，“over”，“the”，“lazy”，“dog”。

图中窗口大小为9，使用目标词汇对前后四个词汇进行预测。
- 核心思想：一个词的含义可以通过其周围的上下文词来表征。
Skip-gram的模型结构:
- 输入层: 输入目标词的one-hot编码。
- 隐藏层: 将目标词映射成D维向量(转换为低维稠密向量)
- 输出层:通过softmax或负采样，预测窗口内所有上下文词的概率分布。
Skip-gram的前向传播过程
1. 输入层 → 隐藏层
  - 目标词的one-hot编码 x 通过权重矩阵 W**（维度 V×D）映射为D维向量: $h=W^T⋅x$
  - 此向量 h 直接表示目标词的词向量。
2. 隐藏层 → 输出层
  - 对每个上下文词位置，计算其概率分布： $u_c=(W′)^T⋅h ,(c=1,2,…,C)$
  W′是输出权重矩阵，维度 D×V ,C 为窗口内上下文词总数
  - 使用softmax为每个上下文位置生成概率：
    $p(wc∣wt)=\frac{exp⁡(uc,wc)}{Σ^{V}_{v=1}exp⁡(uc,wc)}$
3. 损失函数与优化
  - 损失函数：对每个上下文词计算交叉熵损失，并求和： $L=−∑_{c=1}^Clog⁡p(wc∣wt)$
  - 参数更新：通过反向传播更新 WW 和 W′W′，仅涉及目标词和上下文词相关的行或列。
Skip-gram模式下的word2vec过程说明
- 假设我们给定的训练语料只有一句话: Hope can set you free (愿你自由成长)，窗口大小为3，因此模型的第一个训练样本来自Hope can set，因为是skip-gram模式，所以将使用can作为输入，Hope和set作为输出，在模型训练时，Hope、can、set等词汇都使用它们的one-hot编码。如图所示: 将can的one-hot编码与变换矩阵(即参数矩阵3x5, 这里的3是指最后得到的词向量维度)相乘, 得到目标词汇表示矩阵(3x1)。
- 接着, 将目标词汇表示矩阵与多个变换矩阵(参数矩阵5x3)相乘, 得到多个5x1的结果矩阵，使用softmax函数将得分向量转换为概率分布，它将与我们Hope和set对应的one-hot编码矩阵(5x1)进行损失的计算, 然后更新网络参数完成一次模型迭代。
- 最后窗口按序向后移动，重新更新参数，直到所有语料被遍历完成，得到最终的变换矩阵即参数矩阵(3x5)，这个变换矩阵与每个词汇的one-hot编码(5x1)相乘，得到的3x1的矩阵就是该词汇的word2vec张量表示。
词向量的检索获取
- 神经网络训练完毕后，神经网络的参数矩阵w就我们的想要词向量。如何检索某1个单词的向量呢？以CBOW方式举例说明如何检索a单词的词向量。
- 如下图所示：a的onehot编码[10000]，用参数矩阵[3,5] * a的onehot编码[10000]，可以把参数矩阵的第1列参数给取出来，这个[3,1]的值就是a的词向量。

Word2Vec的编码实现

使用的核心库与函数介绍

fasttext:是facebook开源的一个词向量与文本分类工具。

下面是该工具包的安装方法：

官网（fasttext-wheel）下载对应操作系统对应python解析器版本的fasttext模块的whl文件

进入到base虚拟环境，然后在whl文件目录下通过以下命令安装

# 当前目录下要有whl文件名称
pip install asttext_wheel-0.9.2-cp311-cp311-win_amd64.whl

使用到的函数:fasttext.train_unsuperised

函数功能:返回一个无监督训练过后的词向量训练模型

部分超参数解释
input:输入的文件路径
model:'skipgram'或者'cbow', 默认为'skipgram',在实践中,skipgram模式在利用子词方面比cbow更好.
dim:词嵌入维度
epoch:训练迭代次数
lr:学习率
thread:使用的线程数

实现流程

数据来源：http://mattmahoney.net/dc/enwik9.zip

原始数据预处理

# 使用wikifil.pl文件处理脚本来清除XML/HTML格式的内容
perl wikifil.pl data/enwik9 > data/fil9 # 该命令已经执行

词向量的训练

import fasttext

def word2vec_train():
    model = fasttext.train_unsupervised(input='./data/fil9', model='skipgram', dim=300, lr=1e-1, epoch=1, thread=12)
    print('word2vec->done')

    model.save_model(path='./model/fil9.bin')
    print('model->save')

模型效果检验

def model_use(k=10):
    model = fasttext.load_model(path='./model/fil9.bin')

    vector = model.get_word_vector(word='the')
    print(f'the的词向量表示为{vector}')

    nn = model.get_nearest_neighbors(word='the', k=k)
    print(f'the的{k}个最相近邻居为:{nn}')

词嵌入 Word Embedding

Word Embedding（词嵌入）是一种将自然语言中的词语映射到低维连续向量空间的技术，使得词语的语义和语法关系能通过向量间的距离和方向体现。它是自然语言处理（NLP）的基础技术之一。

经典模型与方法

Word2Vec（2013）
- Skip-Gram：通过中心词预测上下文词。
- CBOW（Continuous Bag-of-Words）：通过上下文词预测中心词。
- 示例：king - man + woman ≈ queen（向量运算体现语义关系）。

Word2Vec是一种Word Embedding方法，专门用于生成词的稠密向量表示。Word2Vec通过神经网络训练，利用上下文信息将每个词表示为一个低维稠密向量。

GloVe（2014）
基于全局词共现矩阵，结合统计信息与局部上下文，优化词语的向量表示。
上下文相关嵌入
- ELMo（2018）：通过双向LSTM生成动态词向量，同一词在不同语境中有不同表示。
- BERT（2018）：基于Transformer的预训练模型，通过掩码语言建模（MLM）捕捉深层上下文信息。

编码实现(了解)

import jieba
import torch
from tensorflow.keras.preprocessing.text import Tokenizer
import torch.nn as nn


def dm_embedd():
    # todo:1-创建文本句子, 生成文本
    sentence1 = '哎呀~今天天气真好'
    sentence2 = "只因你实在是太美"
    sentences = [sentence1, sentence2]
    print('sentences->', sentences)
    # todo: 2-获取文本词列表
    word_list = list()
    for s in sentences:
        word_list.append(jieba.lcut(s))
    print('word_list->', word_list)
    # todo: 3- 借助Tokenizer类,实现下标与词的映射字典,文本下标表示
    """
    Tokenizer类的参数:
        num_words: the maximum number of words to keep, based
        on word frequency. Only the most common `num_words-1` words will
        be kept.
        filters: a string where each element is a character that will be
            filtered from the texts. The default is all punctuation, plus
            tabs and line breaks, minus the `'` character.
        lower: boolean. Whether to convert the texts to lowercase.
        split: str. Separator for word splitting.
        char_level: if True, every character will be treated as a token.
        oov_token: if given, it will be added to word_index and used to
            replace out-of-vocabulary words during text_to_sequence calls
        analyzer: function. Custom analyzer to split the text.
            The default analyzer is text_to_word_sequence
    """
    tokenizer = Tokenizer()
    tokenizer.fit_on_texts(texts=word_list)

    # 打印 my_token_list
    my_token_list = tokenizer.index_word.values()  # <class 'dict_values'>
    # print('my_token_list->', my_token_list)

    # 打印文本数值化后的句子
    sentence2id = tokenizer.texts_to_sequences(texts=word_list)
    # print('sentence2id->', sentence2id)

    # todo: 4- 创建nn.Embedding层
    embed = nn.Embedding(num_embeddings=len(my_token_list), embedding_dim=8)
    # print('embed--->',embed)
    # print('nn.Embedding层词向量矩阵-->', embed.weight.data, embed.weight.data.shape, type(embed.weight.data))

    # # todo: 5-创建SummaryWriter对象
    # from torch.utils.tensorboard import SummaryWriter
    # summary_writer = SummaryWriter(log_dir='./data/runs')
    # # add_embedding(mat=embed.weight.data, metadata=my_token_list)
    # # mat:词向量表示 张量或numpy数组
    # # metadata:词标签
    # # 作用: 将高维数据（如词嵌入、特征向量等）投影到低维空间（通常是二维或三维），以便在 TensorBoard 的 Embedding Projector 中进行可视化。
    # summary_writer.add_embedding(mat=embed.weight.data, metadata=my_token_list)
    # summary_writer.close()

    # todo: 5-创建SummaryWriter对象
    from torch.utils.tensorboard import SummaryWriter
    summary_writer = SummaryWriter(log_dir='./data/runs')
    # add_embedding(mat=embed.weight.data, metadata=my_token_list)
    # mat:词向量表示 张量或numpy数组
    # metadata:词标签
    # 作用: 将高维数据（如词嵌入、特征向量等）投影到低维空间（通常是二维或三维），以便在 TensorBoard 的 Embedding Projector 中进行可视化。
    summary_writer.add_embedding(mat=embed.weight.data, metadata=my_token_list)
    summary_writer.close()

    # todo: -6 从nn.Embedding层中根据idx拿词向量
    for idx in range(len(my_token_list)):
        tmp_vector = embed(torch.tensor(idx))
        print(f'{tokenizer.index_word[idx + 1]}的词嵌入向量为:{tmp_vector.detach().numpy()}')