transformer

1 transformer介绍

• 概念
  • transformer是基于自注意力机制的seq2seq模型/架构/框架
• 核心思想
  • 基于注意力机制
  • 自注意力
  • 一般注意力
• 作用
  • 捕获超长距离语义关系
  • 并行计算
  • 灵活性: 处理不同的数据, 文本/语音/图像/视频
  • 扩展性: 层数和多头数量可调, transformer默认是6层, 8个头

2 transformer架构

• 输入部分
  • 词嵌入层
  • 位置编码层
• 输出部分
  • 线性层
  • softmax层
• 编码器部分
  • 多头自注意力子层
  • 前馈全连接子层
  • 残差连接层
  • 规范化层(层归一化)
• 解码器部分
  • 掩码多头自注意力子层
  • 编码器-解码器堵头一般注意力子层
  • 前馈全连接子层
  • 残差连接层
  • 规范化层(层归一化)

3 输入

3.1 文本嵌入层

• 概念

  • 将token转换成词向量过程
  • nn.Embedding()

• 代码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

  # 输入部分是由 词嵌入层和位置编码层组成 x = word_embedding + position_encoding import torch import torch.nn as nn import math # 词嵌入层 class Embeddings(nn.Module): # todo:1- 定义构造方法 init def __init__(self, vocab_size, d_model): super().__init__() # 初始化属性 self.vocab = vocab_size # 词表大小 self.d_model = d_model # 词向量维度 # 初始化词嵌入层对象 # padding_idx: 将值为0的值, 不进行词向量, 用0填充 self.embedding = nn.Embedding(num_embeddings=self.vocab, embedding_dim=self.d_model, padding_idx=0) # todo:2- 定义forward方法 前向传播 def forward(self, x): # 词嵌入结果乘以根号维度数 # 最终的词向量值和后续位置编码信息差不太多, 实现信息平衡 # 后续注意力机制使用的缩放点积, 乘和除相抵消 return self.embedding(x) * math.sqrt(self.d_model) if __name__ == '__main__': vocab_size = 1000 d_model = 512 # 创建测试数据 x = torch.LongTensor([[100, 2, 421, 508], [491, 998, 1, 0]]) # 创建词嵌入对象 my_embedding = Embeddings(vocab_size, d_model) # 调用对象实现词嵌入 embedded_result = my_embedding(x) print('embedded_result--->', embedded_result.shape, embedded_result)

3.2 位置编码器

• 概念

  • 通过一些计算方式给词向量引入位置信息工具
  • 位置编码器替代rnn/lstm/gru中的顺序执行 -> 拿到token和token位置信息

• 作用

  • transformer中不使用rnn/lstm/gru计算语义, 没有位置概念
  • 引入位置信息
  • x 我 x -> 没有位置信息:我x(前x) = 我x(后x) 引入位置信息:我x(前x) != 我x(后x)

• 方法

  • 使用正弦和余弦函数

    

  • 计算每个token在512维度上所有位置信息

  • PE -> 词维度上的位置信息

    • 索引下标偶数位用sin(第1,3,5…词), 索引下标奇数位用cos(第2,4,6…词)
    • 我 -> [sin(), cos(), sin(), …]
    • 爱 -> [sin(), cos(), …]

• transformer中为什么要引入位置编码?

  • 注意机制计算时只算token和token之间的语义关系/相关性, 没有考虑位置关系, 需要引入位置编码
  • transformer中使用正弦和余弦函数计算位置信息值
    • 周期性 -> sin(α+β) = sin(α)cos(β) + sin(β)cos(α)
      • 我-> sin(10) -> sin(10+20) = sin(10)cos(20) + sin(20)cos(10) = 爱
      • 可以学习到我和爱之间的位置关系(规律)
    • 取值范围[-1,1], 避免值太大或太小, 导致梯度消失或爆炸

• 代码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

  # 位置编码器 class PositionalEncoding(nn.Module): # todo:1- init方法, 计算出n个词位置矩阵 def __init__(self, d_model, max_len=5000, dropout_p=0.1): super().__init__() # 初始化属性 self.d_model = d_model # 词向量维度, 模型维度 self.max_len = max_len # 句子最大长度 self.dropout = nn.Dropout(p=dropout_p) # 获取句子所有token索引下标,作为pos # .unsqueeze(1)->在1轴升维 [[0],[1],...] pos = torch.arange(0, self.max_len).unsqueeze(1) # print('pos--->', pos.shape, pos) # 创建一个pe全0矩阵, 存储位置信息 形状(句子长度, 词维度) pe = torch.zeros(size=(self.max_len, self.d_model)) # print('pe--->', pe.shape, pe) # 获取2i结果, 对向量维度d_model取偶数下标值 _2i = torch.arange(0, self.d_model, 2).float() # print('_2i--->', _2i) # 计算位置信息 奇数位的词sin 偶数位的词cos pe[:, ::2] = torch.sin(pos / 10000 ** (_2i / self.d_model)) pe[:, 1::2] = torch.cos(pos / 10000 ** (_2i / self.d_model)) # 将pe位置矩阵升维, 三维数据集 pe = pe.unsqueeze(0) # print('pe--->', pe.shape, pe) # 存储到内存中, 后续便于加载 # pe属性中存储的是pe矩阵结果 self.register_buffer('pe', pe) # todo:2- forward方法 将位置信息添加到词嵌入结果中 def forward(self, x): """ :param x: 词嵌入层的输出结果 :return: 编码器的输入x """ print('x--->', x.shape, x) # x.shape[1], 句子中有多少个真实的token, 就在pe矩阵中取前多少个就可以 print('x.shape[1]--->', x.shape[1]) print('self.pe[:, :x.shape[1], :]--->', self.pe[:, :x.shape[1], :].shape, self.pe[:, :x.shape[1], :]) return x + self.pe[:, :x.shape[1], :] if __name__ == '__main__': vocab_size = 1000 d_model = 512 # 创建测试数据 # max_len=60, 句子最大长度 # 当前第1个句子长度为4, 后续需要补56个0 # 当前第2个句子长度为4 x = torch.LongTensor([[100, 2, 421, 508], [491, 998, 1, 211]]) # 创建词嵌入对象 my_embedding = Embeddings(vocab_size, d_model) # 调用对象实现词嵌入 embedded_result = my_embedding(x) print('embedded_result--->', embedded_result.shape, embedded_result) # 创建pe位置矩阵 生成位置特征数据[1,60,512] my_pe = PositionalEncoding(d_model=d_model, dropout_p=0.1, max_len=60) # 调用位置编码对象 pe_result = my_pe(embedded_result) print('pe_result--->', pe_result.shape, pe_result)

4 编码器

4.1 掩码张量

• 概念

  • 掩盖一些信息的二进制张量或下三角矩阵张量

• 作用

  • 屏蔽填充的信息
  • 屏蔽未来的信息

• transformer中使用

  • 编码器中只能使用padding mask
  • 解码器中使用padding mask 和 casual mask

• 代码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  import torch import matplotlib.pyplot as plt # tril():生成下三角矩阵 # triu():生成上三角矩阵 # diagonal: 移动对角线 def subsequent_mask(size): # 下三角 causal_mask = torch.tril(torch.ones(size=(size, size)), diagonal=0) # 上三角 # causal_mask = torch.triu(torch.ones(size=(size, size)), diagonal=0) return causal_mask if __name__ == '__main__': causal_mask = subsequent_mask(20) print('causal_mask--->', causal_mask.shape, causal_mask) # 绘图 plt.figure() plt.imshow(causal_mask) plt.show() # 模拟自回归,进行自回归掩码 scores = torch.randn(size=(5, 5)) mask = subsequent_mask(5) print('mask==0--->', mask==0) masked_result = scores.masked_fill(mask==0, value=float('-inf')) print('masked_result--->', masked_result)

4.2 自注意力机制

• 概念

  • 在同一序列中进行注意力计算
  • q=k=v

• 作用

  • 并行计算
  • 捕获更长距离的语义关系

• 为什么除以​$\sqrt{d_k}$

  • 防止q*k^T乘积值过大, 产生梯度饱和, 导致梯度消失

• 代码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

  from input import * # 定义缩放点积注意力规则函数, 方便后续调用 def attention(query, key, value, mask=None, dropout=None): """ 注意力计算封装函数 :param query: 输入x 解码器掩码多头自注意力子层输出 :param key: 输入x 编码器输出结果 :param value: 输入x 编码器输出结果 :param mask: 是否掩码 :param dropout: dropout层对象 函数名 :return: 动态c, 权重概率矩阵 """ # todo:1- 获取d_k, 词维度数 d_k = query.shape[-1] # print('d_k--->', d_k) # todo:2- q和k计算权重分数矩阵 scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k) # print('scores--->', scores.shape, scores) # todo:3- 判断是否需要进行掩码操作 if mask is not None: scores = scores.masked_fill(mask == 0, value=-1e9) print('='*50) # print('scores--->', scores.shape, scores) # todo:4- 权重分数矩阵进行softmax操作, 得到权重概率矩阵 p_attn = torch.softmax(scores, dim=-1) print('p_attn--->', p_attn.shape, p_attn) # todo:5- 判断是否对权重概率矩阵进行dropout正则化 if dropout is not None: p_attn = dropout(p_attn) # todo:6- 计算动态c矩阵 c = torch.matmul(p_attn, value) print('c--->', c.shape, c) return c, p_attn if __name__ == '__main__': vocab = 1000 # 词表大小是1000 d_model = 512 # 词嵌入维度是512维 # 输入x 形状是2 x 4 x = torch.LongTensor([[100, 2, 421, 0], [491, 998, 0, 0]]) # 输入部分的Embeddings类 my_embeddings = Embeddings(vocab, d_model) embedded_result = my_embeddings(x) dropout_p = 0.1 # 置0概率为0.1 max_len = 60 # 句子最大长度 # 输入部分的PositionalEncoding类 my_pe = PositionalEncoding(d_model, max_len, dropout_p) pe_result = my_pe(embedded_result) # 调用attention函数 # 准备q,k,v query=key=value=pe_result # 自注意力 print('query--->', query.shape) # 准备mask掩码张量 padding_mask # unsqueeze(1) -> 形状(2,1,4) 后续进行masked_fill操作, 会进行广播, 变成 (2,4,4) mask = (x!= 0).type(torch.uint8).unsqueeze(1) # casual mask # mask = torch.tril(torch.ones(4, 4)) print('mask--->', mask.shape, mask) c, p_attn = attention(query, key, value, mask) print('c--->', c.shape, c) print('p_attn--->', p_attn.shape, p_attn)

4.3 多头注意力机制

• 概念

  • 使用多个头并行计算注意力, 可以从不同子空间维度学习特征

• 作用

  • 得到更丰富的特征
  • 增强模型表达能力

• 多头指的是什么

  • 在进行注意力计算时由多个人分别取算不同子空间的注意力

• 实现流程

  • q,k,v分别经过线性层计算, 得到wq,wk,wv
  • 将线性计算的q,k,v进行多头转换操作,分别计算注意力
  • 将多头注意力结果合并(类似于还原操作)后的结果经过线性层计算

• 代码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

  # 定义克隆函数, 用于克隆不同子层 def clones(module, N): return nn.ModuleList(copy.deepcopy(module) for _ in range(N)) # 创建多头注意力机制类 class MultiHeadedAttention(nn.Module): # todo:1- init方法 def __init__(self, head, d_model, dropout_p=0.1): super().__init__() assert d_model % head ==0, 'd_model不能被head整数' self.d_k = d_model // head self.dropout = nn.Dropout(p=dropout_p) self.head = head # 初始为None, 还没有计算注意力 self.attn = None # 4个线性层 # 前3个分别对q,k,v进行线性学习 # 第1个对多头注意力拼接结果进行线性学习 self.linears = clones(nn.Linear(d_model, d_model), 4) # print('self.linears--->', self.linears) # todo:2- forward方法 def forward(self, query, key, value, mask=None): # todo:1- 获取batch_size大小 batch_size = query.size()[0] # print('batch_size--->', batch_size) # todo:2- 准备空列表, 存储线性计算+变形结果 output_list = [] # todo:3- q,k,v分别进行线性计算 for model, x in zip(self.linears, (query, key, value)): # print('model--->', model) # print('x--->', x) output = model(x) # todo:4- 线性计算结果变形 -> (batch_size, seq_len, head, d_k) # transpose(1, 2):词数和词向量相邻, 更好的学习特征 output = output.view(batch_size, -1, self.head, self.d_k).transpose(1, 2) # todo:5- 将变形结果保存到空列表中 output_list.append(output) # 获取q, k, v # print('output_list--->', len(output_list)) query = output_list[0] key = output_list[1] value = output_list[2] # todo:6- 计算多头注意力, 调用attention函数 (batch_size, seq_len, head, d_k) x, p_attn = attention(query, key, value, mask) # print('x--->', x.shape) # todo:7- 多头注意力结果变形 -> (batch_size, seq_len, word_dim) x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.head*self.d_k) # print('x--->', x.shape) # todo:8- 经过线性层计算返回输出结果 # self.linears[-1]: 线性层对象 x = self.linears[-1](x) return x if __name__ == '__main__': vocab = 1000 # 词表大小是1000 d_model = 512 # 词嵌入维度是512维 # 输入x 形状是2 x 4 x = torch.LongTensor([[100, 2, 421, 0], [491, 998, 0, 0]]) # 输入部分的Embeddings类 my_embeddings = Embeddings(vocab, d_model) embedded_result = my_embeddings(x) dropout_p = 0.1 # 置0概率为0.1 max_len = 60 # 句子最大长度 # 输入部分的PositionalEncoding类 my_pe = PositionalEncoding(d_model, max_len, dropout_p) pe_result = my_pe(embedded_result) # 调用attention函数 # 准备q,k,v query=key=value=pe_result # 自注意力 # print('query--->', query.shape) # 准备mask掩码张量 padding_mask # unsqueeze(1) -> 形状(2,1,4) 后续进行masked_fill操作, 会进行广播, 变成 (2,4,4) # 多头注意力机制,需要得到(2,1,1,4)形状mask mask = (x!= 0).type(torch.uint8).unsqueeze(1).unsqueeze(2) # casual mask # mask = torch.tril(torch.ones(4, 4)) # print('mask--->', mask.shape, mask) # c, p_attn = attention(query, key, value, mask) # print('c--->', c.shape, c) # print('p_attn--->', p_attn.shape, p_attn) head=8 # 创建多头注意力机制类对象 my_mha = MultiHeadedAttention(head, d_model) # 调用多头注意力机制对象 mha_result = my_mha(query, key, value, mask) print('mha_result--->', mha_result.shape, mha_result)

4.4 前馈全连接层

• 概念

  • 由两层线性层和一层relu激活层

• 作用

  • 提取更丰富的非线性特征, 增强模型表达能力

• 代码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

  # 前馈全连接层 class PositionwiseFeedForward(nn.Module): def __init__(self, d_model, d_ff, dropout_p=0.1): super().__init__() # 定义两层线性层 # d_ff>d_model self.linear1 = nn.Linear(d_model, d_ff) self.linear2 = nn.Linear(d_ff, d_model) # 定义dropout层 self.dropout = nn.Dropout(p=dropout_p) def forward(self, x): output = torch.relu(self.linear1(x)) output = self.dropout(output) print('output--->', output.shape) return self.linear2(output) if __name__ == '__main__': vocab = 1000 # 词表大小是1000 d_model = 512 # 词嵌入维度是512维 # 输入x 形状是2 x 4 x = torch.LongTensor([[100, 2, 421, 0], [491, 998, 0, 0]]) # 输入部分的Embeddings类 my_embeddings = Embeddings(vocab, d_model) embedded_result = my_embeddings(x) dropout_p = 0.1 # 置0概率为0.1 max_len = 60 # 句子最大长度 # 输入部分的PositionalEncoding类 my_pe = PositionalEncoding(d_model, max_len, dropout_p) pe_result = my_pe(embedded_result) # 调用attention函数 # 准备q,k,v query = key = value = pe_result # 自注意力 # print('query--->', query.shape) # 准备mask掩码张量 padding_mask # unsqueeze(1) -> 形状(2,1,4) 后续进行masked_fill操作, 会进行广播, 变成 (2,4,4) # 多头注意力机制,需要得到(2,1,1,4)形状mask mask = (x != 0).type(torch.uint8).unsqueeze(1).unsqueeze(2) # casual mask # mask = torch.tril(torch.ones(4, 4)) # print('mask--->', mask.shape, mask) # c, p_attn = attention(query, key, value, mask) # print('c--->', c.shape, c) # print('p_attn--->', p_attn.shape, p_attn) head = 8 # 创建多头注意力机制类对象 my_mha = MultiHeadedAttention(head, d_model) # 调用多头注意力机制对象 mha_result = my_mha(query, key, value, mask) print('mha_result--->', mha_result.shape, mha_result) # 创建前馈全连接对象 d_ff = 2048 my_ff = PositionwiseFeedForward(d_model, d_ff) ff_result = my_ff(mha_result) print('ff_result--->', ff_result.shape)

seq2seq

1 RNN案例-seq2seq英译法

1.1 seq2seq模型介绍

• 模型结构
  • 编码器 encoder
  • 解码器 decoder
  • 编码器和解码器中可以使用RNN模型或者是transformer模型
• 工作流程
  • 编码器生成上下文语义张量 -> 什么是nlp? 将问题转换成语义张量
  • 解码器根据编码器的语义张量和上一时间步的预测值以及上一时间步的隐藏状态值进行当前时间步的预测
    • 自回归模式
• 局限性
  • 信息瓶颈问题
  • 长序列问题

1.2 数据集介绍

• 每行样本由英文句子和法文句子对组成, 中间用\t分隔开
• 英文句子是编码器的输入序列, 法文句子是解码器的输出序列(预测序列)对应的真实序列

1.3 案例实现步骤

1.3.1 文本清洗工具函数

• utils.py

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

  # 用于正则表达式 import re # 用于构建网络结构和函数的torch工具包 import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader # torch中预定义的优化方法工具包 import torch.optim as optim import time # 用于随机生成数据 import random import numpy as np import matplotlib.pyplot as plt # 定义变量 # 选择设备 cpu/gpu # 'cuda'->使用所有显卡 'cuda:0'->使用第一张显卡 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # 起始符号下标 # sos -> start of sentences SOS_token = 0 # 结束符号下标 EOS_token = 1 # 文件路径 data_path = 'data/eng-fra-v2.txt' # 最大句子长度, 预处理分析的结果 MAX_LENGTH = 10 # 定义处理文本的工具函数 处理句子中的特殊符号/大小写/换行符 def normalizeString(s: str): # 转换成小写, 并删掉两端的空白符号 str = s.lower().strip() # 正则表达式匹配标签符号'.?!' 转换成 ' .?!' str = re.sub(r'([.!?])', r' \1', str) # print('str--->', str) # 正则表达式匹配除a-z.!?之外的其他的符号 转换成 ' ' str = re.sub(r'[^a-z.!?]+', r' ', str) # print('str--->', str) return str if __name__ == '__main__': str1 = 'I m sad.@' normalizeString(str1)

1.3.2 数据预处理

• preprocess.py

  • 清洗文本和构建词表

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

    from utils import * def my_getdata(): # todo:1- 读取文件数据集, 得到 [[英文句子1, 法文句子1], [英文句子2, 法文句子2], ...]内存数据集 # 1-1 with open 读取文件数据集 with open(data_path, 'r', encoding='utf-8') as f: my_lines = f.read().strip().split('\n') # print('my_lines --->', my_lines) # 1-2 获取 [[英文句子1, 法文句子1], [英文句子2, 法文句子2], ...] 数据集格式 # 定义两个空列表 tmp_pair, my_pairs = [], [] # 循环遍历my_lines for line in my_lines: # print('line--->', line) # i m . j ai ans . # 对my_lines中每行样本使用\t分割符进行分割后再循环遍历 for item in line.split('\t'): # print('item--->', item) # 将每行样本中的英文句子和法文句子使用工具函数进行清洗, 保存到tmp_pair列表中 tmp_pair.append(normalizeString(item)) # 将tmp_pair列表保存到my_pairs列表中 my_pairs.append(tmp_pair) # 重置tmp_pair列表 tmp_pair = [] # print('my_pairs的长度为--->', len(my_pairs)) # print('my_pairs[:4]--->', my_pairs[:4]) # todo:2-构建英文和法文词表 {词:下标} {下标:词} # 2-0: 初始化词表, 有SOS和EOS两个词 english_word2index = {'SOS':0, 'EOS':1} # 定义第3个词起始下标 english_word_n = 2 french_word2index = {'SOS': 0, 'EOS': 1} french_word_n = 2 # 2-1: 循环遍历my_pairs [['i m .', 'j ai ans .'], ...] for pair in my_pairs: # print('pair--->', pair) # ['i m .', 'j ai ans .'] # 2-2: 对英文句子或法文句子根据 ' '空格进行分割, 再进行循环遍历 for word in pair[0].split(' '): # print('word--->', word) # i m . # 2-3: 使用if语句, 判断当前词是否在词表中, 如果不在添加进去 if word not in english_word2index.keys(): english_word2index[word] = english_word_n # 更新词下标 english_word_n+=1 for word in pair[1].split(' '): # 2-3: 使用if语句, 判断当前词是否在词表中, 如果不在添加进去 if word not in french_word2index.keys(): french_word2index[word] = french_word_n # 更新词下标 french_word_n+=1 # 2-4 获取{下标:词}格式词表 english_index2word = {v:k for k, v in english_word2index.items()} french_index2word = {v:k for k, v in french_word2index.items()} # print('english_word2index--->', len(english_word2index), english_word2index) # print('french_word2index--->', len(french_word2index), french_word2index) # print('english_index2word--->', len(english_index2word), english_index2word) # print('french_index2word--->', len(french_index2word), french_index2word) # print('english_word_n--->', english_word_n) # print('french_word_n--->', french_word_n) return english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs if __name__ == '__main__': (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata()

  • 构建数据源对象

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

    # 自定义张量数据源类 class MyPairsDataset(Dataset): # todo:1- init构造方法, 初始化属性 def __init__(self, my_pairs, english_word2index, french_word2index): self.my_pairs = my_pairs # [[], [], ...] self.english_word2index = english_word2index self.french_index2word = french_word2index # 获取数据集长度 self.sample_len = len(my_pairs) # todo:2- len方法, 返回数据集的长度 def __len__(self): return self.sample_len # todo:3- getitem方法, 对数据进行处理, 转换成张量数据对象 def __getitem__(self, index): """ 转换成张量数据对象 :param index: 数据集的下标 -> 第index个样本 :return: tensor_x, tensor_y """ # 3-1: 修正index, 防止超过下标边界 index = min(max(index, 0), self.sample_len - 1) # print('index--->', index) # 3-2: 获取当前index样本中的 x和y x = self.my_pairs[index][0] y = self.my_pairs[index][1] # print('x--->', x) # print('y--->', y) # 3-3: 将x和y的字符串数据转换成下标表示 词表 # self.english_word2index[word]: 根据key获取字典中的value x = [self.english_word2index[word] for word in x.split(' ')] y = [self.french_index2word[word] for word in y.split(' ')] # print('x--->', x) # print('y--->', y) # 3-4: 每个样本最后加EOS下标 结束符号 x.append(EOS_token) y.append(EOS_token) # print('x--->', x) # print('y--->', y) # 3-5: 将下标列表转换成张量对象 # device: 将张量创建到对应的设备上 GPU/CPU tensor_x = torch.tensor(x, dtype=torch.long, device=device) tensor_y = torch.tensor(y, dtype=torch.long, device=device) # print('tensor_x--->', tensor_x) # print('tensor_y--->', tensor_y) return tensor_x, tensor_y if __name__ == '__main__': (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建自定义数据源对象 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) print('my_dataset数据集条目数--->', len(my_dataset)) print(my_dataset[0]) # 创建数据加载器对象 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 循环遍历数据加载器 for i, (x, y) in enumerate(my_dataloader): print('x--->', x.shape, x) print('y--->', y.shape, y) break

1.3.3 构建基于GRU的编码器和解码器

• 构建基于GRU的编码器 encoderrnn.py

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

  from preprocess import * class EncoderRNN(nn.Module): # todo:1- 定义构造方法 init def __init__(self, input_size, hidden_size): super().__init__() # 输入特征维度属性 input_size是英文词表的大小 self.input_size = input_size # 词嵌入层和隐藏层特征维度属性 共用 self.hidden_size = hidden_size # 词嵌入层对象属性 self.embedding = nn.Embedding(num_embeddings=self.input_size, embedding_dim=self.hidden_size) # gru层对象属性 # input_size: 上一层输出特征维度数 # hidden_size: 当前层输出特征维度数 # batch_first: x和hidden形状 -> (句子数, 句子长度, 词维度) self.gru = nn.GRU(input_size=self.hidden_size, hidden_size=self.hidden_size, batch_first=True) # todo:2- 定义前向传播方法 forward def forward(self, input, hidden): # print('input--->', input.shape) # 词嵌入操作 词向量化 embedded = self.embedding(input) # print('embedded--->', embedded.shape) # gru层前向传播操作 output, hn = self.gru(embedded, hidden) # print('output--->', output.shape) # print('hn--->', hn.shape) return output, hn # todo:3- 定义初始化隐藏状态值方法 inithidden def inithidden(self): return torch.zeros(size=(1, 1, self.hidden_size), device=device) if __name__ == '__main__': # 获取数据 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建张量数据集 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) # 创建数据加载器 # batch_size: 当前设置为1, 因为句子长度不一致 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 创建编码器对象 my_encoderrnn = EncoderRNN(input_size=english_word_n, hidden_size=256).to(device=device) for i, (x, y) in enumerate(my_dataloader): # 一次性喂数据 # 初始化隐藏状态值 hidden = my_encoderrnn.inithidden() encoder_output, hn = my_encoderrnn(x, hidden) print('encoder_output--->', encoder_output.shape) print('hn--->', hn.shape) # 一个时间步一个时间步喂数据, gru底层实现 了解,解码器需要这样操作 hidden = my_encoderrnn.inithidden() # x.shape[1]: 获取当前x的token数, 时间步数 for j in range(x.shape[1]): # print('x--->', x) # print('x[0]--->', x[0]) # print('x[0][j]--->', x[0][j]) tmp_x = x[0][j].view(1, -1) print('tmp_x--->', tmp_x) output, hidden = my_encoderrnn(tmp_x, hidden) print('观察：最后一个时间步output输出是否相等') # hidden_size = 8 效果比较好 print('encoder_output[0][-1]===>', encoder_output[0][-1]) print('output===>', output) break

• 构建基于GRU的解码器 decoderrnn.py

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

  from encoderrnn import * class DecoderRNN(nn.Module): # todo:1- 定义构造方法 init def __init__(self, output_size, hidden_size): super().__init__() # 初始化法文词表大小维度属性=线性输出层的维度 self.output_size = output_size # 初始化gru隐藏层和词嵌入层的维度属性 共用 self.hidden_size = hidden_size # 初始化词嵌入层 # num_embeddings: 法文词表大小 # embedding_dim: 词向量初始维度 self.embeding = nn.Embedding(num_embeddings=self.output_size, embedding_dim=self.hidden_size) # 初始化gru层 self.gru = nn.GRU(input_size=self.hidden_size, hidden_size=self.hidden_size, batch_first=True) # 初始化全连接层 线性层+激活层 # out_features: 法文词表大小 预测出n个词的生成概率 self.out = nn.Linear(in_features=self.hidden_size, out_features=self.output_size) # dim:一定是-1, 按行处理 self.softmax = nn.LogSoftmax(dim=-1) # todo:2- 定义前向传播方法 forward def forward(self, input, hidden): print('input--->', input.shape) # 词嵌入操作 embedded = self.embeding(input) print('embedded--->', embedded.shape) # 通过relu激活函数引入非线性因素, 防止过拟合(x<0置为0, 神经元死亡) embedded = torch.relu(embedded) print('embedded--->', embedded.shape) # gru层操作 # ouput: 输入input的语义信息, 形状为(句子数, 句子长度, 词维度) 三维 output, hidden = self.gru(embedded, hidden) print('output--->', output.shape, output) # 全连接层操作 # output[0]: 全连接层一般是二维数据, 所以要取出当前token的二维表示 # 返回的output是 logsoftmax结果, 后续的值可能会有负值, 不是softmax的概率值 output = self.softmax(self.out(output[0])) print('output--->', output.shape, output) return output, hidden if __name__ == '__main__': # 获取数据 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建张量数据集 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) # 创建数据加载器 # batch_size: 当前设置为1, 因为句子长度不一致 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 创建编码器对象 my_encoderrnn = EncoderRNN(input_size=english_word_n, hidden_size=256).to(device=device) # 创建解码器对象 output_size = french_word_n hidden_size = 256 my_decoderrnn = DecoderRNN(output_size, hidden_size).to(device) for i, (x, y) in enumerate(my_dataloader): # 编码器进行编码 一次性喂数据 # 初始化隐藏状态值 hidden = my_encoderrnn.inithidden() encoder_output, hn = my_encoderrnn(x, hidden) print('encoder_output--->', encoder_output.shape) print('hn--->', hn.shape, hn) # 解码器进行解码, 自回归, 一个一个token进行解码 for j in range(y.shape[1]) : # 获取当前预测token时间步的输入x(等同于上一时间步的预测y) # 当前以真实y中的每个token作为输入, 模拟解码器的界面过程, 实际上第一个输入token一定是起始符号 tmp_y = y[0][j].view(1, -1) # 进行解码 # 初始的隐藏状态值=编码器最后一个时间步的隐藏状态值 my_decoderrnn(tmp_y, hn) break break

• 构建基于GRU和Attention的解码器 decoderrnn.py

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134

  # 带加性注意力机制的解码器 class AttnDecoderRNN(nn.Module): # todo:1- 定义构造方法 init def __init__(self, output_size, hidden_size, dropout_p=0.2, max_length=MAX_LENGTH): super().__init__() # 初始化词嵌入层的输入维度和全连接层的输出维度一致 self.output_size = output_size # 初始化编码器解码器隐藏层维度属性 解码器的第一个隐藏状态值=编码器的最后一个隐藏状态值 # 初始化词嵌入层维度属性 共享 self.hidden_size = hidden_size # 初始化最大句子长度属性 -> 所有句子 c的长度固定 self.max_length = max_length # 初始化dropout概率属性 self.dropout_p = dropout_p # 初始化 embeding层 self.embedding = nn.Embedding(num_embeddings=self.output_size, embedding_dim=self.hidden_size) # 初始化 gru层 self.gru = nn.GRU(input_size=self.hidden_size, hidden_size=self.hidden_size, batch_first=True) # 初始化 全连接层 self.out = nn.Linear(in_features=self.hidden_size, out_features=self.output_size) self.softmax = nn.LogSoftmax(dim=-1) # 初始化注意力机制中两个线性层 """ q:解码器当前预测时间步的隐藏状态值 k:解码器当前预测时间步的上一时间步隐藏状态值 v:编码器的output输出 q,k,v三个特征维度相同 都是hidden_size """ # in_features: q和k的特征维度拼接 # out_features: 后续权重概率矩阵->(1, 1, max_len) 和 V矩阵相乘 V->(1, max_len, hidden_size) self.attn = nn.Linear(in_features=self.hidden_size + self.hidden_size, out_features=self.max_length) # in_features: q和c的特征维度拼接 # out_features: 输出的维度和gru层的输入维度保持一致 self.attn_combine = nn.Linear(in_features=self.hidden_size + self.hidden_size, out_features=self.hidden_size) # 初始化dropout层 self.dropout = nn.Dropout(p=self.dropout_p) # todo:2- 定义前向传播方法 forward def forward(self, input, hidden, encoder_outputs): """ 前向传播计算 :param input: q, 解码器当前预测时间步的输入x, 也是上一个时间步预测的输出y :param hidden: k, 上一个时间步的隐藏状态值, 第一个时间步的上一个隐藏状态值=编码器最后一个时间步的隐藏状态值 :param encoder_outputs: v, 编码器的输出 output, 后续是统一长度都为10, 10个token, 不足10个token用0填充 :return: 预测词表概率向量, 当前时间步的隐藏状态值, 权重概率矩阵 """ # 2-1 词嵌入操作 embedded = self.embedding(input) # 使用dropout防止过拟合 embedded = self.dropout(embedded) print('embedded--->', embedded.shape, embedded) # 2-2 计算权重分数矩阵, 之后再计算权重概率矩阵 # q和k在特征维度轴拼接 + 线性计算 + softmax计算 # embedded[0]: 获取二维向量表示, 线性层一般接收二维数据 attn_weights = torch.softmax(self.attn(torch.cat(tensors=[embedded[0], hidden[0]], dim=1)), dim=-1) print('attn_weights--->', attn_weights.shape, attn_weights) # print(torch.sum(input=attn_weights)) # 2-3 计算动态c, 加权求和 权重概率矩阵和v进行三维矩阵乘法 # bmm() 三维矩阵乘法, 目前attn_weights和encoder_outputs二维矩阵 attn_applied = torch.bmm(attn_weights.unsqueeze(0), encoder_outputs.unsqueeze(0)) print('attn_applied--->', attn_applied.shape, attn_applied) # 2-4 q和动态c融合线性计算, 得到gru的输入x # unsqueeze():得到三维数据, gru的输入x的形状要求 output = self.attn_combine(torch.cat(tensors=[embedded[0], attn_applied[0]], dim=1)).unsqueeze(0) print('output--->', output.shape, output) # relu激活函数, 非线性因素 output = torch.relu(output) # 2-5 gru层操作 output, hidden = self.gru(output, hidden) print('output--->', output.shape, output) print('hidden--->', hidden.shape, hidden) # 2-6 全连接层操作 output = self.softmax(self.out(output[0])) print('output--->', output.shape, output) return output, hidden, attn_weights if __name__ == '__main__': # 获取数据 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建张量数据集 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) # 创建数据加载器 # batch_size: 当前设置为1, 因为句子长度不一致 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 创建编码器对象 my_encoderrnn = EncoderRNN(input_size=english_word_n, hidden_size=256).to(device=device) # 创建解码器对象 output_size = french_word_n hidden_size = 256 # my_decoderrnn = DecoderRNN(output_size, hidden_size).to(device) # 创建带attn的解码器对象 my_attndecoderrnn = AttnDecoderRNN(output_size, hidden_size).to(device) for i, (x, y) in enumerate(my_dataloader): # print('x--->', x.shape) # 编码器进行编码 一次性喂数据 # 初始化隐藏状态值 hidden = my_encoderrnn.inithidden() encoder_output, hn = my_encoderrnn(x, hidden) print('encoder_output--->', encoder_output.shape, encoder_output) # print('hn--->', hn.shape, hn) # 获取填充成最大程度的编码器c或者output # 初始化全0的张量 形状(10, 256) [[0,0,0,0,0,0,...],[],[]] encoder_output_c = torch.zeros(size=(MAX_LENGTH, my_encoderrnn.hidden_size), device=device) # 将encoder_output真实值赋值到encoder_output_c对应位置 for idx in range(x.shape[1]): encoder_output_c[idx] = encoder_output[0][idx] print('encoder_output_c--->', encoder_output_c.shape, encoder_output_c) # 解码器进行解码, 自回归, 一个一个token进行解码 for j in range(y.shape[1]): # 获取当前预测token时间步的输入x(等同于上一时间步的预测y) # 当前以真实y中的每个token作为输入, 模拟解码器的界面过程, 实际上第一个输入token一定是起始符号 tmp_y = y[0][j].view(1, -1) # 进行解码 # 初始的隐藏状态值=编码器最后一个时间步的隐藏状态值 # my_decoderrnn(tmp_y, hn) # hn:编码器端最后一个时间步的隐藏状态值, 也是解码器端第一个时间步的初始的隐藏状态值 print('hn--->', hn.shape, hn) output, hidden, attn_weights = my_attndecoderrnn(tmp_y, hn, encoder_output_c) print('=' * 80) print('output--->', output.shape, output) print('hidden--->', hidden.shape, hidden) print('attn_weights--->', attn_weights.shape, attn_weights) break break

1.3.4 构建模型训练函数并进行训练

• Teacher Forcing介绍

  • 概念
    • 解码时用真实y值作为输入
    • 一种增强模型训练效果的技术
  • 作用
    • 加快模型收敛速度
    • 稳定模型训练过程
    • 使用真实y,损失值小
  • 优点
    • 加快模型收敛速度
    • 稳定模型训练过程
    • 使用真实y,损失值小
  • 缺点
    • 训练和测试时不一致, 测试推理没有真实y, 导致模型过拟合
  • 改进方法
    • Scheduled Sampling: 计划采样
      • 随机生成一个随机数和Teacher Forcing比例进行比较
      • if判断
        • 小于等于比例, 真实y
        • 大于比例, 预测y
    • Curriculum Learning: 课程学习
      • Teacher Forcing比例: 前期大, 后期小, 衰减
      • 调整训练样本的顺序
        • 先训练短句, 再训练长度
        • 先训练高质量句子, 再训练低质量句子

• 构建内部迭代训练函数 train.py

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

  from decoderrnn import * # 模型训练参数 mylr = 1e-4 epochs = 2 # 设置teacher_forcing比率为0.5 teacher_forcing_ratio = 0.5 # 1000次迭代打印一次信息 print_interval_num = 1000 # 100次迭代绘制损失曲线 plot_interval_num = 100 def train_iters(x,y, my_encoderrnn:EncoderRNN, my_attndecoderrnn:AttnDecoderRNN, myadam_encode: optim.Adam, myadam_decode: optim.Adam, mynllloss: nn.NLLLoss): """ 模型训练的内部函数 -> 内循环代码封装 :param x: 英文句子 :param y: 真实法文句子 :param my_encoderrnn: 编码器 :param my_attndecoderrnn: 解码器 :param myadam_encode: 编码器优化器 :param myadam_decode: 解码器优化器 :param mynllloss: 解码器损失函数对象 :return: 当前句子的平均损失 """ # todo:1- 切换模型训练模式 my_encoderrnn.train() my_attndecoderrnn.train() # todo:2- 初始化编码器隐藏状态值 encode_h0 = my_encoderrnn.inithidden() # todo:3- 调用编码器获取v和k output就是v k就是解码器的初始隐藏状态值 encode_output, encode_hn = my_encoderrnn(x, encode_h0) # print('encode_output--->', encode_output.shape, encode_output) # print('encode_hn--->', encode_hn.shape, encode_hn) # todo:4- 处理v, 统一长度, 都是10 v encode_output_c = torch.zeros(size=(MAX_LENGTH, my_encoderrnn.hidden_size), device=device) # print('encode_output_c--->', encode_output_c.shape, encode_output_c) for idx in range(x.shape[1]): encode_output_c[idx] = encode_output[0, idx] # print('encode_output_c--->', encode_output_c.shape, encode_output_c) # todo:5- 准备解码器第一个时间步的参数 q,k,v # 准备k decode_hidden = encode_hn # 准备q input_y = torch.tensor(data=[[SOS_token]], device=device) # print('input_y--->', input_y.shape, input_y) # todo:6- 初始化变量, 存储信息 myloss = 0.0 # 当前句子的总损失 iters_num = 0 # 当前句子的token数 # todo:7- 判断教师强制机制是否成立, 返回True或False user_teacher_forcing = True if random.random() < teacher_forcing_ratio else False # print('user_teacher_forcing--->', user_teacher_forcing) # todo:8- 解码器自回归解码 # 预测什么时候结束? ①到达循环次数,法文句子长度 ②预测出EOS_token for idx in range(y.shape[1]): # 调用解码器模型对象, 返回预测token, 隐藏状态值, 注意力机制概率矩阵 output_y, hidden, attn_weights = my_attndecoderrnn(input_y, decode_hidden, encode_output_c) # print('output_y--->', output_y.shape, output_y) # 获取当前时间步真实的token target_y = y[0][idx].view(1) # print('target_y--->', target_y.shape, target_y) # 计算损失值 myloss += mynllloss(output_y, target_y) # print('myloss--->', myloss) # 更新iters_num数 iters_num += 1 # print('iters_num--->', iters_num) # 使用教师强制机制, 判断下一时间步使用真实token还是预测token if user_teacher_forcing: # input_y = y[0][idx].view(1, -1) input_y = target_y.view(1, -1) # print('input_y--->', input_y.shape, input_y) else: # 返回最大值和对应的下标 topv, topi = output_y.topk(1) # print('topv--->', topv) # print('topi--->', topi) # 预测出结束符号, 解码结束 if topi.item() == EOS_token: break input_y = topi # todo:9-梯度清零, 反向传播, 梯度更新 myadam_encode.zero_grad() myadam_decode.zero_grad() myloss.backward() myadam_encode.step() myadam_decode.step() # todo:10- 句子的平均损失 总损失/token数 return myloss.item() / iters_num

• 构建模型训练函数 train.py

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

  def train_seq2seq(): # 获取数据 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 实例化 mypairsdataset对象 实例化 mydataloader mypairsdataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) mydataloader = DataLoader(dataset=mypairsdataset, batch_size=1, shuffle=True) # 实例化编码器 my_encoderrnn 实例化解码器 my_attndecoderrnn my_encoderrnn = EncoderRNN(english_word_n, 256).to(device) my_attndecoderrnn = AttnDecoderRNN(output_size=french_word_n, hidden_size=256, dropout_p=0.1, max_length=10).to( device) # 实例化编码器优化器 myadam_encode 实例化解码器优化器 myadam_decode myadam_encode = optim.Adam(my_encoderrnn.parameters(), lr=mylr) myadam_decode = optim.Adam(my_attndecoderrnn.parameters(), lr=mylr) # 实例化损失函数 mycrossentropyloss = nn.NLLLoss() mynllloss = nn.NLLLoss() # 定义模型训练的参数 plot_loss_list = [] # 循环轮次 epoch for epoch_idx in range(1, epochs + 1): # 初始化打印日志的总损失 和 绘图总损失 print_loss_total = 0.0 plot_loss_total = 0.0 # 开始时间 starttime = time.time() # 循环迭代次数, batch数 # start: 默认为0, 第一条数据的标号为0; 1->第一条数据的标号为1 for item, (x, y) in enumerate(mydataloader, start=1): # 模型训练, 调用内部迭代函数 loss = train_iters(x, y, my_encoderrnn, my_attndecoderrnn, myadam_encode, myadam_decode, mynllloss) # print('loss--->', loss) # 统计损失值 print_loss_total += loss plot_loss_total += loss # 1000次迭代打印一次日志 if item % 1000 == 0: print_loss_avg = print_loss_total / print_interval_num # 重置print_loss_total 0 print_loss_total = 0.0 # 打印日志，日志内容分别是：训练耗时，当前迭代步，当前进度百分比，当前平均损失 print('轮次%d 损失%.6f 时间:%d' % (epoch_idx, print_loss_avg, time.time() - starttime)) # 100次收集一次损失, 用于绘图 if item % 100 == 0: plot_loss_avg = plot_loss_total / plot_interval_num plot_loss_list.append(plot_loss_avg) plot_loss_total = 0.0 torch.save(my_encoderrnn.state_dict(), './model/my_encoderrnn_model_%d.bin' % (epoch_idx)) torch.save(my_attndecoderrnn.state_dict(), './model/my_attndecoderrnn_model_%d.bin' % (epoch_idx)) # 绘制损失值的曲线图 plt.figure() plt.plot(plot_loss_list.detach().numpy()) plt.savefig('./image/plot_loss_list.png') plt.show() return plot_loss_list if __name__ == '__main__': plot_loss_list = train_seq2seq()

1.3.5 构建模型评估函数并测试

• 构建模型评估函数

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

  from decoderrnn import * PATH1 = 'model/my_encoderrnn_2.pth' PATH2 = 'model/my_attndecoderrnn_2.pth' def seq2seq_evaluate(x, my_encoderrnn: EncoderRNN, my_attndecoderrnn: AttnDecoderRNN, french_index2word): """ 推理内部函数, 得到预测的法文 :param x: 需要推理的英文句子 :param my_encoderrnn: 编码器 :param my_attndecoderrnn: 解码器 :param french_index2word: 法文词汇表, 根据最大概率的下标从词表中获取法文词 :return: 法文列表, 注意力权重概率矩阵 """ with torch.no_grad(): my_encoderrnn.eval() my_attndecoderrnn.eval() # todo: 1- 编码器编码 encode_h0 = my_encoderrnn.inithidden() encode_output, encode_hn = my_encoderrnn(x, encode_h0) # todo: 2- 处理编码的输出 得到解码器的参数v encode_output_c = torch.zeros(size=(MAX_LENGTH, my_encoderrnn.hidden_size), device=device) for idx in range(x.shape[1]): encode_output_c[idx] = encode_output[0, idx] # todo: 3- 准备解码器的q和k参数 decode_hidden = encode_hn input_y = torch.tensor(data=[[SOS_token]], device=device) # todo: 4- 定义变量 预测词空列表 decode_words = [] # todo: 6- 创建(10,10)全0张量, 存储每个时间步的注意力权重 # (10, 10) -> 10:最多10个时间步 10:权重概率矩阵特征数为10 decoder_attentions = torch.zeros(size=(MAX_LENGTH, MAX_LENGTH), device=device) # todo: 7- 解码器解码 for i in range(MAX_LENGTH): # 解码 output_y, decode_hidden, attn_weights = my_attndecoderrnn(input_y, decode_hidden, encode_output_c) # print('attn_weights--->', attn_weights.shape, attn_weights) # 保存当前时间步的attn_weights decoder_attentions[i] = attn_weights # print('decoder_attentions--->', decoder_attentions.shape, decoder_attentions) # 获取当前时间步的预测结果 topv topi # topi = torch.argmax(output_y) topv, topi = output_y.topk(1) # 判断topi是否是EOS_token下标值 # 如果是,解码结束 if topi.item() == EOS_token: decode_words.append('<EOS>') break else: decode_words.append(french_index2word[topi.item()]) # 进行下一个时间步的预测 input_y = topi # 返回法文列表, 注意力权重概率矩阵 # [: i+1]->后续的值都为0,没有意义 return decode_words, decoder_attentions[: i+1]

• 调用模型评估函数

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

  # 定义模型推理函数 def inference(): # todo:1- 加载推理数据集 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # todo:2- 创建张量数据集 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) # todo:3- 加载模型 # 编码器模型对象 my_encoderrnn = EncoderRNN(input_size=english_word_n, hidden_size=256) print('my_encoderrnn--->', my_encoderrnn) # 加载模型参数 # map_location: 将模型加载到什么设备中 # lambda storage,loc: storage:保存时在哪个设备,加载就在哪个设备 # strict: 是否严格按照创建时键值匹配加载 -> init方法中gru层属性名 # True: 匹配不成功, 报错 False: 不报错, 但是不执行不匹配的层 my_encoderrnn.load_state_dict(torch.load(PATH1, map_location=lambda storage,loc: storage), strict=False) print('my_encoderrnn--->', my_encoderrnn) # 解码器模型对象 my_attndecoderrnn = AttnDecoderRNN(output_size=french_word_n, hidden_size=256) my_attndecoderrnn.load_state_dict(torch.load(PATH2, map_location=lambda storage,loc: storage), strict=False) # todo:4- 准备3条测试样本 my_samplepairs = [['i m impressed with your french .', 'je suis impressionne par votre francais .'], ['i m more than a friend .', 'je suis plus qu une amie .'], ['she is beautiful like her mother .', 'elle est belle comme sa mere .']] print('my_samplepairs--->', len(my_samplepairs)) # todo:5- 对测试样本进行处理, 训练时怎么做特征工程,推理时一样 for idx, pair in enumerate(my_samplepairs): x = pair[0] y = pair[1] # print('x--->', x) # print('y--->', y) # 对x转换成下标张量对象 tem_x = [english_word2index[word] for word in x.split(' ')] tem_x.append(EOS_token) tensor_x = torch.tensor([tem_x], dtype=torch.long, device=device) # print('tensor_x--->', tensor_x.shape, tensor_x) # todo:6- 调用内部封装推理函数,进行推理 decode_words, decoder_attentions = seq2seq_evaluate(tensor_x, my_encoderrnn, my_attndecoderrnn, french_index2word) # print('decode_words--->', decode_words) # print('decoder_attentions--->', decoder_attentions.shape, decoder_attentions) # todo:7- 将预测的法文列表转换成字符串文本 output_sentence = ' '.join(decode_words) print('\n') print('需要推理的英文句子--->', x) print('真实的法文句子--->', y) print('推理的法文句子--->', output_sentence) if __name__ == '__main__': inference()

• attention张量制图

2 transformer介绍

• 概念
  • transformer是基于自注意力机制的seq2seq模型/架构/框架
• 核心思想
  • 基于注意力机制
  • 自注意力
  • 一般注意力
• 作用
  • 捕获超长距离语义关系
  • 并行计算
  • 灵活性: 处理不同的数据, 文本/语音/图像/视频
  • 扩展性: 层数和多头数量可调, transformer默认是6层, 8个头

3 transformer架构

• 输入部分
  • 词嵌入层
  • 位置编码层
• 输出部分
  • 线性层
  • softmax层
• 编码器部分
  • 多头自注意力子层
  • 前馈全连接子层
  • 残差连接层
  • 规范化层(层归一化)
• 解码器部分
  • 掩码多头自注意力子层
  • 编码器-解码器堵头一般注意力子层
  • 前馈全连接子层
  • 残差连接层
  • 规范化层(层归一化)

RNN案例-seq2seq英译法

1 RNN案例-seq2seq英译法

1.1 seq2seq模型介绍

• 模型结构
  • 编码器 encoder
  • 解码器 decoder
  • 编码器和解码器中可以使用RNN模型或者是transformer模型
• 工作流程
  • 编码器生成上下文语义张量 -> 什么是nlp? 将问题转换成语义张量
  • 解码器根据编码器的语义张量和上一时间步的预测值以及上一时间步的隐藏状态值进行当前时间步的预测
    • 自回归模式
• 局限性
  • 信息瓶颈问题
  • 长序列问题

1.2 数据集介绍

• 每行样本由英文句子和法文句子对组成, 中间用\t分隔开
• 英文句子是编码器的输入序列, 法文句子是解码器的输出序列(预测序列)对应的真实序列

1.3 案例实现步骤

1.3.1 文本清洗工具函数

• utils.py

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

  # 用于正则表达式 import re # 用于构建网络结构和函数的torch工具包 import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader # torch中预定义的优化方法工具包 import torch.optim as optim import time # 用于随机生成数据 import random import numpy as np import matplotlib.pyplot as plt # 定义变量 # 选择设备 cpu/gpu # 'cuda'->使用所有显卡 'cuda:0'->使用第一张显卡 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # 起始符号下标 # sos -> start of sentences SOS_token = 0 # 结束符号下标 EOS_token = 1 # 文件路径 data_path = 'data/eng-fra-v2.txt' # 最大句子长度, 预处理分析的结果 MAX_LENGTH = 10 # 定义处理文本的工具函数 处理句子中的特殊符号/大小写/换行符 def normalizeString(s: str): # 转换成小写, 并删掉两端的空白符号 str = s.lower().strip() # 正则表达式匹配标签符号'.?!' 转换成 ' .?!' str = re.sub(r'([.!?])', r' \1', str) # print('str--->', str) # 正则表达式匹配除a-z.!?之外的其他的符号 转换成 ' ' str = re.sub(r'[^a-z.!?]+', r' ', str) # print('str--->', str) return str if __name__ == '__main__': str1 = 'I m sad.@' normalizeString(str1)

1.3.2 数据预处理

• preprocess.py

  • 清洗文本和构建词表

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

    from utils import * def my_getdata(): # todo:1- 读取文件数据集, 得到 [[英文句子1, 法文句子1], [英文句子2, 法文句子2], ...]内存数据集 # 1-1 with open 读取文件数据集 with open(data_path, 'r', encoding='utf-8') as f: my_lines = f.read().strip().split('\n') # print('my_lines --->', my_lines) # 1-2 获取 [[英文句子1, 法文句子1], [英文句子2, 法文句子2], ...] 数据集格式 # 定义两个空列表 tmp_pair, my_pairs = [], [] # 循环遍历my_lines for line in my_lines: # print('line--->', line) # i m . j ai ans . # 对my_lines中每行样本使用\t分割符进行分割后再循环遍历 for item in line.split('\t'): # print('item--->', item) # 将每行样本中的英文句子和法文句子使用工具函数进行清洗, 保存到tmp_pair列表中 tmp_pair.append(normalizeString(item)) # 将tmp_pair列表保存到my_pairs列表中 my_pairs.append(tmp_pair) # 重置tmp_pair列表 tmp_pair = [] # print('my_pairs的长度为--->', len(my_pairs)) # print('my_pairs[:4]--->', my_pairs[:4]) # todo:2-构建英文和法文词表 {词:下标} {下标:词} # 2-0: 初始化词表, 有SOS和EOS两个词 english_word2index = {'SOS':0, 'EOS':1} # 定义第3个词起始下标 english_word_n = 2 french_word2index = {'SOS': 0, 'EOS': 1} french_word_n = 2 # 2-1: 循环遍历my_pairs [['i m .', 'j ai ans .'], ...] for pair in my_pairs: # print('pair--->', pair) # ['i m .', 'j ai ans .'] # 2-2: 对英文句子或法文句子根据 ' '空格进行分割, 再进行循环遍历 for word in pair[0].split(' '): # print('word--->', word) # i m . # 2-3: 使用if语句, 判断当前词是否在词表中, 如果不在添加进去 if word not in english_word2index.keys(): english_word2index[word] = english_word_n # 更新词下标 english_word_n+=1 for word in pair[1].split(' '): # 2-3: 使用if语句, 判断当前词是否在词表中, 如果不在添加进去 if word not in french_word2index.keys(): french_word2index[word] = french_word_n # 更新词下标 french_word_n+=1 # 2-4 获取{下标:词}格式词表 english_index2word = {v:k for k, v in english_word2index.items()} french_index2word = {v:k for k, v in french_word2index.items()} # print('english_word2index--->', len(english_word2index), english_word2index) # print('french_word2index--->', len(french_word2index), french_word2index) # print('english_index2word--->', len(english_index2word), english_index2word) # print('french_index2word--->', len(french_index2word), french_index2word) # print('english_word_n--->', english_word_n) # print('french_word_n--->', french_word_n) return english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs if __name__ == '__main__': (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata()

  • 构建数据源对象

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

    # 自定义张量数据源类 class MyPairsDataset(Dataset): # todo:1- init构造方法, 初始化属性 def __init__(self, my_pairs, english_word2index, french_word2index): self.my_pairs = my_pairs # [[], [], ...] self.english_word2index = english_word2index self.french_index2word = french_word2index # 获取数据集长度 self.sample_len = len(my_pairs) # todo:2- len方法, 返回数据集的长度 def __len__(self): return self.sample_len # todo:3- getitem方法, 对数据进行处理, 转换成张量数据对象 def __getitem__(self, index): """ 转换成张量数据对象 :param index: 数据集的下标 -> 第index个样本 :return: tensor_x, tensor_y """ # 3-1: 修正index, 防止超过下标边界 index = min(max(index, 0), self.sample_len - 1) # print('index--->', index) # 3-2: 获取当前index样本中的 x和y x = self.my_pairs[index][0] y = self.my_pairs[index][1] # print('x--->', x) # print('y--->', y) # 3-3: 将x和y的字符串数据转换成下标表示 词表 # self.english_word2index[word]: 根据key获取字典中的value x = [self.english_word2index[word] for word in x.split(' ')] y = [self.french_index2word[word] for word in y.split(' ')] # print('x--->', x) # print('y--->', y) # 3-4: 每个样本最后加EOS下标 结束符号 x.append(EOS_token) y.append(EOS_token) # print('x--->', x) # print('y--->', y) # 3-5: 将下标列表转换成张量对象 # device: 将张量创建到对应的设备上 GPU/CPU tensor_x = torch.tensor(x, dtype=torch.long, device=device) tensor_y = torch.tensor(y, dtype=torch.long, device=device) # print('tensor_x--->', tensor_x) # print('tensor_y--->', tensor_y) return tensor_x, tensor_y if __name__ == '__main__': (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建自定义数据源对象 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) print('my_dataset数据集条目数--->', len(my_dataset)) print(my_dataset[0]) # 创建数据加载器对象 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 循环遍历数据加载器 for i, (x, y) in enumerate(my_dataloader): print('x--->', x.shape, x) print('y--->', y.shape, y) break

1.3.3 构建基于GRU的编码器和解码器

• 构建基于GRU的编码器

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

  from preprocess import * class EncoderRNN(nn.Module): # todo:1- 定义构造方法 init def __init__(self, input_size, hidden_size): super().__init__() # 输入特征维度属性 input_size是英文词表的大小 self.input_size = input_size # 词嵌入层和隐藏层特征维度属性 共用 self.hidden_size = hidden_size # 词嵌入层对象属性 self.embedding = nn.Embedding(num_embeddings=self.input_size, embedding_dim=self.hidden_size) # gru层对象属性 # input_size: 上一层输出特征维度数 # hidden_size: 当前层输出特征维度数 # batch_first: x和hidden形状 -> (句子数, 句子长度, 词维度) self.gru = nn.GRU(input_size=self.hidden_size, hidden_size=self.hidden_size, batch_first=True) # todo:2- 定义前向传播方法 forward def forward(self, input, hidden): # print('input--->', input.shape) # 词嵌入操作 词向量化 embedded = self.embedding(input) # print('embedded--->', embedded.shape) # gru层前向传播操作 output, hn = self.gru(embedded, hidden) # print('output--->', output.shape) # print('hn--->', hn.shape) return output, hn # todo:3- 定义初始化隐藏状态值方法 inithidden def inithidden(self): return torch.zeros(size=(1, 1, self.hidden_size), device=device) if __name__ == '__main__': # 获取数据 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建张量数据集 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) # 创建数据加载器 # batch_size: 当前设置为1, 因为句子长度不一致 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 创建编码器对象 my_encoderrnn = EncoderRNN(input_size=english_word_n, hidden_size=256).to(device=device) for i, (x, y) in enumerate(my_dataloader): # 一次性喂数据 # 初始化隐藏状态值 hidden = my_encoderrnn.inithidden() encoder_output, hn = my_encoderrnn(x, hidden) print('encoder_output--->', encoder_output.shape) print('hn--->', hn.shape) # 一个时间步一个时间步喂数据, gru底层实现 了解,解码器需要这样操作 hidden = my_encoderrnn.inithidden() # x.shape[1]: 获取当前x的token数, 时间步数 for j in range(x.shape[1]): # print('x--->', x) # print('x[0]--->', x[0]) # print('x[0][j]--->', x[0][j]) tmp_x = x[0][j].view(1, -1) print('tmp_x--->', tmp_x) output, hidden = my_encoderrnn(tmp_x, hidden) print('观察：最后一个时间步output输出是否相等') # hidden_size = 8 效果比较好 print('encoder_output[0][-1]===>', encoder_output[0][-1]) print('output===>', output) break

• 构建基于GRU的解码器

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

  from encoderrnn import * class DecoderRNN(nn.Module): # todo:1- 定义构造方法 init def __init__(self, output_size, hidden_size): super().__init__() # 初始化法文词表大小维度属性=线性输出层的维度 self.output_size = output_size # 初始化gru隐藏层和词嵌入层的维度属性 共用 self.hidden_size = hidden_size # 初始化词嵌入层 # num_embeddings: 法文词表大小 # embedding_dim: 词向量初始维度 self.embeding = nn.Embedding(num_embeddings=self.output_size, embedding_dim=self.hidden_size) # 初始化gru层 self.gru = nn.GRU(input_size=self.hidden_size, hidden_size=self.hidden_size, batch_first=True) # 初始化全连接层 线性层+激活层 # out_features: 法文词表大小 预测出n个词的生成概率 self.out = nn.Linear(in_features=self.hidden_size, out_features=self.output_size) # dim:一定是-1, 按行处理 self.softmax = nn.LogSoftmax(dim=-1) # todo:2- 定义前向传播方法 forward def forward(self, input, hidden): print('input--->', input.shape) # 词嵌入操作 embedded = self.embeding(input) print('embedded--->', embedded.shape) # 通过relu激活函数引入非线性因素, 防止过拟合(x<0置为0, 神经元死亡) embedded = torch.relu(embedded) print('embedded--->', embedded.shape) # gru层操作 # ouput: 输入input的语义信息, 形状为(句子数, 句子长度, 词维度) 三维 output, hidden = self.gru(embedded, hidden) print('output--->', output.shape, output) # 全连接层操作 # output[0]: 全连接层一般是二维数据, 所以要取出当前token的二维表示 # 返回的output是 logsoftmax结果, 后续的值可能会有负值, 不是softmax的概率值 output = self.softmax(self.out(output[0])) print('output--->', output.shape, output) return output, hidden if __name__ == '__main__': # 获取数据 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建张量数据集 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) # 创建数据加载器 # batch_size: 当前设置为1, 因为句子长度不一致 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 创建编码器对象 my_encoderrnn = EncoderRNN(input_size=english_word_n, hidden_size=256).to(device=device) # 创建解码器对象 output_size = french_word_n hidden_size = 256 my_decoderrnn = DecoderRNN(output_size, hidden_size).to(device) for i, (x, y) in enumerate(my_dataloader): # 编码器进行编码 一次性喂数据 # 初始化隐藏状态值 hidden = my_encoderrnn.inithidden() encoder_output, hn = my_encoderrnn(x, hidden) print('encoder_output--->', encoder_output.shape) print('hn--->', hn.shape, hn) # 解码器进行解码, 自回归, 一个一个token进行解码 for j in range(y.shape[1]) : # 获取当前预测token时间步的输入x(等同于上一时间步的预测y) # 当前以真实y中的每个token作为输入, 模拟解码器的界面过程, 实际上第一个输入token一定是起始符号 tmp_y = y[0][j].view(1, -1) # 进行解码 # 初始的隐藏状态值=编码器最后一个时间步的隐藏状态值 my_decoderrnn(tmp_y, hn) break break

• 构建基于GRU和Attention的解码器

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134

  # 带加性注意力机制的解码器 class AttnDecoderRNN(nn.Module): # todo:1- 定义构造方法 init def __init__(self, output_size, hidden_size, dropout_p=0.2, max_length=MAX_LENGTH): super().__init__() # 初始化词嵌入层的输入维度和全连接层的输出维度一致 self.output_size = output_size # 初始化编码器解码器隐藏层维度属性 解码器的第一个隐藏状态值=编码器的最后一个隐藏状态值 # 初始化词嵌入层维度属性 共享 self.hidden_size = hidden_size # 初始化最大句子长度属性 -> 所有句子 c的长度固定 self.max_length = max_length # 初始化dropout概率属性 self.dropout_p = dropout_p # 初始化 embeding层 self.embedding = nn.Embedding(num_embeddings=self.output_size, embedding_dim=self.hidden_size) # 初始化 gru层 self.gru = nn.GRU(input_size=self.hidden_size, hidden_size=self.hidden_size, batch_first=True) # 初始化 全连接层 self.out = nn.Linear(in_features=self.hidden_size, out_features=self.output_size) self.softmax = nn.LogSoftmax(dim=-1) # 初始化注意力机制中两个线性层 """ q:解码器当前预测时间步的隐藏状态值 k:解码器当前预测时间步的上一时间步隐藏状态值 v:编码器的output输出 q,k,v三个特征维度相同 都是hidden_size """ # in_features: q和k的特征维度拼接 # out_features: 后续权重概率矩阵->(1, 1, max_len) 和 V矩阵相乘 V->(1, max_len, hidden_size) self.attn = nn.Linear(in_features=self.hidden_size + self.hidden_size, out_features=self.max_length) # in_features: q和c的特征维度拼接 # out_features: 输出的维度和gru层的输入维度保持一致 self.attn_combine = nn.Linear(in_features=self.hidden_size + self.hidden_size, out_features=self.hidden_size) # 初始化dropout层 self.dropout = nn.Dropout(p=self.dropout_p) # todo:2- 定义前向传播方法 forward def forward(self, input, hidden, encoder_outputs): """ 前向传播计算 :param input: q, 解码器当前预测时间步的输入x, 也是上一个时间步预测的输出y :param hidden: k, 上一个时间步的隐藏状态值, 第一个时间步的上一个隐藏状态值=编码器最后一个时间步的隐藏状态值 :param encoder_outputs: v, 编码器的输出 output, 后续是统一长度都为10, 10个token, 不足10个token用0填充 :return: 预测词表概率向量, 当前时间步的隐藏状态值, 权重概率矩阵 """ # 2-1 词嵌入操作 embedded = self.embedding(input) # 使用dropout防止过拟合 embedded = self.dropout(embedded) print('embedded--->', embedded.shape, embedded) # 2-2 计算权重分数矩阵, 之后再计算权重概率矩阵 # q和k在特征维度轴拼接 + 线性计算 + softmax计算 # embedded[0]: 获取二维向量表示, 线性层一般接收二维数据 attn_weights = torch.softmax(self.attn(torch.cat(tensors=[embedded[0], hidden[0]], dim=1)), dim=-1) print('attn_weights--->', attn_weights.shape, attn_weights) # print(torch.sum(input=attn_weights)) # 2-3 计算动态c, 加权求和 权重概率矩阵和v进行三维矩阵乘法 # bmm() 三维矩阵乘法, 目前attn_weights和encoder_outputs二维矩阵 attn_applied = torch.bmm(attn_weights.unsqueeze(0), encoder_outputs.unsqueeze(0)) print('attn_applied--->', attn_applied.shape, attn_applied) # 2-4 q和动态c融合线性计算, 得到gru的输入x # unsqueeze():得到三维数据, gru的输入x的形状要求 output = self.attn_combine(torch.cat(tensors=[embedded[0], attn_applied[0]], dim=1)).unsqueeze(0) print('output--->', output.shape, output) # relu激活函数, 非线性因素 output = torch.relu(output) # 2-5 gru层操作 output, hidden = self.gru(output, hidden) print('output--->', output.shape, output) print('hidden--->', hidden.shape, hidden) # 2-6 全连接层操作 output = self.softmax(self.out(output[0])) print('output--->', output.shape, output) return output, hidden, attn_weights if __name__ == '__main__': # 获取数据 (english_word2index, english_index2word, english_word_n, french_word2index, french_index2word, french_word_n, my_pairs) = my_getdata() # 创建张量数据集 my_dataset = MyPairsDataset(my_pairs, english_word2index, french_word2index) # 创建数据加载器 # batch_size: 当前设置为1, 因为句子长度不一致 my_dataloader = DataLoader(dataset=my_dataset, batch_size=1, shuffle=True) # 创建编码器对象 my_encoderrnn = EncoderRNN(input_size=english_word_n, hidden_size=256).to(device=device) # 创建解码器对象 output_size = french_word_n hidden_size = 256 # my_decoderrnn = DecoderRNN(output_size, hidden_size).to(device) # 创建带attn的解码器对象 my_attndecoderrnn = AttnDecoderRNN(output_size, hidden_size).to(device) for i, (x, y) in enumerate(my_dataloader): # print('x--->', x.shape) # 编码器进行编码 一次性喂数据 # 初始化隐藏状态值 hidden = my_encoderrnn.inithidden() encoder_output, hn = my_encoderrnn(x, hidden) print('encoder_output--->', encoder_output.shape, encoder_output) # print('hn--->', hn.shape, hn) # 获取填充成最大程度的编码器c或者output # 初始化全0的张量 形状(10, 256) [[0,0,0,0,0,0,...],[],[]] encoder_output_c = torch.zeros(size=(MAX_LENGTH, my_encoderrnn.hidden_size), device=device) # 将encoder_output真实值赋值到encoder_output_c对应位置 for idx in range(x.shape[1]): encoder_output_c[idx] = encoder_output[0][idx] print('encoder_output_c--->', encoder_output_c.shape, encoder_output_c) # 解码器进行解码, 自回归, 一个一个token进行解码 for j in range(y.shape[1]): # 获取当前预测token时间步的输入x(等同于上一时间步的预测y) # 当前以真实y中的每个token作为输入, 模拟解码器的界面过程, 实际上第一个输入token一定是起始符号 tmp_y = y[0][j].view(1, -1) # 进行解码 # 初始的隐藏状态值=编码器最后一个时间步的隐藏状态值 # my_decoderrnn(tmp_y, hn) # hn:编码器端最后一个时间步的隐藏状态值, 也是解码器端第一个时间步的初始的隐藏状态值 print('hn--->', hn.shape, hn) output, hidden, attn_weights = my_attndecoderrnn(tmp_y, hn, encoder_output_c) print('=' * 80) print('output--->', output.shape, output) print('hidden--->', hidden.shape, hidden) print('attn_weights--->', attn_weights.shape, attn_weights) break break