一. 自然语言处理概述
自然语言处理（Nature language Processing, NLP）研究的主要是通过计算机算法来理解自然语言。对于自然语言来说，处理的数据主要就是人类的语言，例如：汉语、英语、法语等，该类型的数据不像我们前面接触的过的结构化数据、或者图像数据可以很方便的进行数值化。
二. 词嵌入层
词嵌入层的作用就是将文本转换为向量。
语料分词, 构建词与索引的映射词表
nn.Embedding构建词嵌入矩阵
原理
词嵌入层首先会根据输入的词的数量构建一个词向量矩阵[词个数, 词向量(多少列表示一个词)] => [word_count, 词向量维度]，例如: 我们有 100 个词，每个词希望转换成 128 维度的向量，那么构建的矩阵形状即为: 100*128，输入的每个词都对应了一个该矩阵中的一个向量。
API及代码
API
在 PyTorch 中，使用 nn.Embedding 词嵌入层来实现输入词的向量化。
nn.Embedding(num_embeddings=10, embedding_dim=4) """ nn.Embedding 对象构建时，最主要有两个参数: num_embeddings 表示词的数量 embedding_dim 表示用多少维的向量来表示每个词 """
词转词向量步骤
-
先将语料进行分词，构建词与索引的映射，我们可以把这个映射叫做
词表Vocab，词表中每个词都对应了一个唯一的索引 -
然后使用 nn.Embedding 构建词嵌入矩阵，词索引对应的向量即为该词对应的数值化后的向量表示。
例如，文本数据为: "北京冬奥的进度条已经过半，不少外国运动员在完成自己的比赛后踏上归途。"，
代码
import jieba
import torch.nn as nn
import torch
if __name__ == '__main__':# 读取文本txt = '北京冬奥的进度条已经过半，不少外国运动员在完成自己的比赛后踏上归途。'# jieba分词words = jieba.lcut(txt)print('文本分词: \n', words)# 去重unique_words = list(set(words))print('去重后分词: \n', unique_words)# 构建词嵌入层embedding = nn.Embedding(num_embeddings=len(unique_words), embedding_dim=4)print('词嵌入层: \n', embedding)# 词语的词向量表示# enumerate: 获取索引和元素for i, word in enumerate(unique_words):# print(torch.tensor(i), word)# 将第i个词转为tensor, 并通过词嵌入层进行转换print(word, embedding(torch.tensor(i)))
三. 循环网络RNN
原理
基本介绍
文本数据是具有序列特性的
例如: "我爱你", 这串文本就是具有序列关系的，"爱" 需要在 "我" 之后，"你" 需要在 "爱" 之后, 如果颠倒了顺序，那么可能就会表达不同的意思。
为了表示出数据的序列关系，需要使用循环神经网络(Recurrent Nearal Networks, RNN) 来对数据进行建模，RNN 是一个作用于处理带有序列特点的样本数据。
计算过程
h 表示隐藏状态,
每一次的输入都会包含两个值: 上一个时间步的隐藏状态、当前状态的输入值，输出当前时间步的隐藏状态和当前时间步的预测结果。
上述内容画了 3 个神经元, 但是实际上只有一个神经元，"我爱你" 三个字是重复输入到同一个神经元中。
首先初始化出第一个隐藏状态h0，一般都是全0的一个向量，然后将 "我" 进行词嵌入，转换为向量的表示形式，送入到第一个时间步，然后输出隐藏状态 h1，然后将 h1 和 "爱" 输入到第二个时间步，得到隐藏状态 h2, 将 h2 送入到全连接网络，得到 "你" 的预测概率。
神经元内部计算
上述公式中:
1.Wih 表示输入数据的权重
2.bih 表示输入数据的偏置
3.Whh 表示输入隐藏状态的权重
4.bhh 表示输入隐藏状态的偏置
最后对输出的结果使用 tanh 激活函数进行计算，得到该神经元你的输出。
API
API
RNN = torch.nn.RNN(input_size,hidden_size，num_layer) """ 参数意义是： input_size：输入数据的维度，一般设为词向量的维度；embed_num hidden_size：隐藏层h的维数，也是当前层神经元的输出维度；神经元个数 num_layer: 隐藏层h的层数，默认为1. 层数 将RNN实例化就可以将数据送入进行处理。 """
★RNN层的使用
模型实例化
RNN = torch.nn.RNN(input_size,hidden_size，num_layer)
前向传播
输入数据和输出结果
将RNN实例化就可以将数据送入其中进行处理，处理的方式如下所示：
output, hn = RNN(x, h0)
输入数据:输入主要包括词嵌入的x 、初始的隐藏层h0
x的表示形式为[seq_len, batch, input_size]，即[句子的长度(句中词数量)，batch的大小(句子数量)，词向量的维度(embed_num: 多少列表示一个词)]
h0的表示形式为[num_layers, batch, hidden_size]，即[隐藏层的层数，batch的大小，隐藏层h的维数(对比卷积核维度)]
输出结果：主要包括输出结果output,最后一层的hn
output的表示形式与输入x类似，为[seq_len, batch, hidden_size]，即[句子的长度，batch的大小，输出向量的维度]
hn的表示形式与输入h0一样，为[num_layers, batch, hidden_size]，即[隐藏层的层数，batch的大，隐藏层h的维度]
RNN展开
一个神经元循环
反向传播
四. 文本生成案例
获取数据构建词表
# 1. 构建词表
def create_vocab():file_name = 'data/jaychou_lyrics.txt'unique_words = []all_words = []for line in open(file_name, 'r', encoding='utf-8'):words = jieba.lcut(line)# 将文件中的行数据分词结果存储到all_words中all_words.append(words)unique_words.extend(list(set(words)))unique_words = list(set(unique_words))# print(unique_word)# print(len(unique_word)) # 5703# 词表长度word_count = len(unique_words)# 词到索引的映射word_to_idx = {word: idx for idx, word in enumerate(unique_words)}# 词表索引表示每行的词对应的索引corpus_idx = []# 遍历每行数据for words in all_words:# 用于存储每行词对应的索引temp = []# 遍历每行数据中的每个词for word in words:# 将词的索引添加到temp中temp.append(word_to_idx[word])# 一行词的索引添加到temp中后, 在末尾添加特殊符号, 方便后续使用# 添加空格在词表中的索引: (word_to_idx[' '])temp.append(word_to_idx[' '])# 将一行词的索引添加到corpus_idx中, 以' '对应的索引表示结尾corpus_idx.extend(temp)return unique_words, word_to_idx, word_count, corpus_idx
构建数据集对象
# 2. 构建数据集对象 class LyricsDataset(torch.utils.data.Dataset):def __init__(self, corpus_idx, num_chars):# 文档数据中词的索引self.corpus_idx = corpus_idx# 每个句子中词的个数self.num_chars = num_chars# 词的数量self.word_count = len(self.corpus_idx) # 未去重的词数量# 句子数量self.number = self.word_count // self.num_chars def __len__(self):# 返回句子数量return self.number def __getitem__(self, idx):# idx指词的索引，并将其修正索引值到文档的范围里面start = min(max(idx, 0), self.word_count - self.num_chars - 2)# 输入值x = self.corpus_idx[start: start + self.num_chars]# 网络预测结果（目标值）y = self.corpus_idx[start + 1: start + 1 + self.num_chars]# 返回结果return torch.tensor(x), torch.tensor(y)
构建网络模型
# 3. 构建模型
# 模型构建
class TextGenerator(nn.Module):def __init__(self, word_count):super(TextGenerator, self).__init__()# 初始化词嵌入层: 词向量的维度为128self.ebd = nn.Embedding(word_count, 128)# 循环网络层: 词向量维度 128, 隐藏向量维度 128, 网络层数1self.rnn = nn.RNN(128, 128, 1)# 输出层: 特征向量维度128与隐藏向量维度相同,词表中词的个数self.out = nn.Linear(128, word_count)
def forward(self, inputs, hidden):# 输出维度: (batch, seq_len,词向量维度 128)embed = self.ebd(inputs)print('*' * 50)# 初始化的时候会将input_size传递过来print('embed维度: ', embed.shape) # (2, 10, 128)print('*' * 50)# 修改维度: (seq_len, batch,词向量维度 128)output, hidden = self.rnn(embed.transpose(0, 1), hidden)# 输入维度: (seq_len*batch,词向量维度 ) 输出维度: (seq_len*batch, 128)output = self.out(output.reshape((-1, output.shape[-1])))# 网络输出结果return output, hidden
def init_hidden(self, bs=2):# 隐藏层的初始化:[网络层数, batch, 隐藏层向量维度]return torch.zeros(1, bs, 128)
模型训练
def train(batch_size=2, num_chars=10, epoch=10):# 构建词典index_to_word, word_to_index, word_count, corpus_idx = create_vocab()# 数据集lyrics = LyricsDataset(corpus_idx, num_chars) # 语料库的索引(未去重), 每个句子中词的个数# 初始化模型model = TextGenerator(word_count) # 去重后词表长度# 损失函数criterion = nn.CrossEntropyLoss()# 优化方法optimizer = optim.Adam(model.parameters(), lr=1e-3)# 训练轮数# epoch = 10for epoch_idx in range(epoch): # 数据加载器lyrics_dataloader = DataLoader(lyrics, shuffle=True, batch_size=batch_size, drop_last=True)# 训练时间start = time.time()iter_num = 0 # 迭代次数# 训练损失total_loss = 0.0# 遍历数据集for x, y in lyrics_dataloader:# 隐藏状态的初始化hidden = model.init_hidden(x.size(0))# 模型计算output, hidden = model(x, hidden)# 计算损失# y:[batch,seq_len]->[seq_len,batch]->[seq_len*batch]y = torch.transpose(y, 0, 1).contiguous().view(-1)loss = criterion(output, y)optimizer.zero_grad()loss.backward()optimizer.step()iter_num += 1 # 迭代次数加1total_loss += loss.item()# 打印训练信息print('epoch %3s loss: %.5f time %.2f' % (epoch_idx + 1, total_loss / iter_num, time.time() - start))# 模型存储torch.save(model.state_dict(), 'data/lyrics_model_%d.pth' % epoch)
模型预测
def predict(start_word, sentence_length, bs=1):# 构建词典index_to_word, word_to_index, word_count, _ = create_vocab()# 构建模型model = TextGenerator(word_count)# 加载参数model.load_state_dict(torch.load('data/lyrics_model_10.pth', weights_only=False))# 隐藏状态hidden = model.init_hidden(bs=bs) # 预测时的batch_size必须为1, 一次只能预测一个词# 将起始词转换为索引word_idx = word_to_index[start_word]# 产生的词的索引存放位置generate_sentence = [word_idx]# 遍历到句子长度，获取每一个词for _ in range(sentence_length):# 模型预测output, hidden = model(torch.tensor([[word_idx]]), hidden)# 获取预测结果word_idx = torch.argmax(output)generate_sentence.append(word_idx)# 根据产生的索引获取对应的词，并进行打印for idx in generate_sentence:print(index_to_word[idx], end='')print()
if __name__ == '__main__':# unique_words, word_to_idx, word_count, corpus_idx = create_vocab()# print(corpus_idx)# print(word_to_idx['\n'])# print(word_count)# # print(len(word_to_idx))# # print(corpus_idx)# dataset = LyricsDataset(corpus_idx, 30)# x, y = dataset.__getitem__(491237) # 49136# print(x)# print(y)# ld = DataLoader(dataset, batch_size=10)# for x, y in ld:# print(x)# print(y)# print('-' * 50)# model = TextGenerator(word_count)# hidden = model.init_hidden(x.size(0))# output, hidden = model(x, hidden)# print(f'x维度: {x.shape}')# print(f'output维度: {output.shape}')## break# train(batch_size=1, epoch=30, num_chars=30)predict('温柔', 100, bs=1)
