【动手学深度学习-Pytorch版】Transformer代码总结

本文是纯纯的撸代码讲解,没有任何Transformer的基础内容~ 是从0榨干Transformer代码系列,借用的是李沐老师上课时讲解的代码。 本文是根据每个模块的实现过程来进行讲解的。如果您想获取关于Transformer具体的实现细节(不含代码)可以转到李宏毅老师的录播课:
油管需要翻墙~

在Transformer代码实现部分,首先需要准备Encoder和Decoder中每个层需要用到的模块,包括Encoder和Decoder中的嵌入层、位置编码、多头注意力、Add&Norm、基于位置的前馈网络(三维MLP)和Decoder中的掩蔽多头注意力以及全连接层。
在这里插入图片描述
下面依次实现它们,并用于生成EncoderBlock和DecoderBlock。【当然具体的Transformer细节可以从上一篇转载文章中看到,也可以从下面视频中看到】
【转载】Transformer模型详解(图解最完整版)

【论文必读#6:Transformer】GPT时代AI GC基础模型全解读】

基于位置的前馈网络

它其实相当于一个2层的多层感知机,中间使用激活函数ReLU()。需要注意的是:在Pytorch中如果输入不是二维的,那前面的所有维度默认都是样本的维度,而最后一个维度当做feature的维度。在基于位置的前馈网络中,输入向量X的维度为(批量大小,时间步数或序列长度,隐单元数或特征维度),输出向量O的维度为(批量大小,时间步数,ff_num_outputs)

"""在pytorch中如果输入不是二维的,那前面的所有维度默认都是样本的维度,后面的维度当做feature的维度"""
# @save
# 基于位置的前馈网络---》是一个输入是三维的MLP
class PositionWiseFFN(nn.Module):def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):super(PositionWiseFFN, self).__init__(**kwargs)self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)self.relu = nn.ReLU()self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)def forward(self, X):res_t2 = self.dense1(X)print('res_t2.shape:', res_t2.shape)  # [2,3,4]res_t3 = self.relu(res_t2)print('res_t3.shape:', res_t3.shape)  # [2,3,4]res_t4 = self.dense2(res_t3)print('res_t4.shape:', res_t4.shape)  # [2,3,8--->受一开始实例初始化时的num_outputs控制]return self.dense2(self.relu(self.dense1(X)))ffn = PositionWiseFFN(4, 4, 8)
ffn.eval()  # 6 x 4 · 4 x 4
res_t1 = ffn(torch.ones((2, 3, 4)))[0]
print('res_t1.shape:', res_t1.shape)  # torch.Size([3, 8])

可以看到,最终输出的最后一个维度不是由数据的最后维度控制的,而是在模型创建时的最后一个维度控制的。并且,在res_t1 = ffn(torch.ones((2, 3, 4)))[0]中,pytorch会将前两个维度看作是输入特征的维度。

Add & Norm

Add层即残差连接层,而Norm层则是用来进行normalization的。且残差连接要求两个输入的特征形状必须相同,以便在加法操作以后输出张量的形状相同。
当然在做normalization时会有层归一化和批量归一化,那这里为什么要用层归一化,而不是批量归一化呢?

因为批量归一化是对每个特征/通道里面的元素进行归一化,不适合序列长度会变的NLP应用。而层归一化是对每一个样本里面的元素进行归一化,可以用于Seq2Seq。
LayerNorm会把每个样本(所有特征)变成均值为0方差为1;BatchNorm会把每个特征变成均值为0方差为1

# @save
class AddNorm(nn.Module):"""先进行残差连接再进行规范化"""def __init__(self, normalized_shape, dropout, **kwargs):super(AddNorm, self).__init__(**kwargs)self.dropout = nn.Dropout(dropout)self.ln = nn.LayerNorm(normalized_shape)def forward(self, X, Y):return self.ln(self.dropout(Y) + X)

多头注意力机制

多头注意力机制,在前面的注意力章节已经实现了,这里直接调用的D2L库中的多头注意力类。当然,你也可以在D2L库中直接copy到工程里:

D2L库函数

class MultiHeadAttention(d2l.Module):"""Multi-head attention.Defined in :numref:`sec_multihead-attention`"""def __init__(self, num_hiddens, num_heads, dropout, bias=False, **kwargs):super().__init__()self.num_heads = num_headsself.attention = d2l.DotProductAttention(dropout)self.W_q = nn.LazyLinear(num_hiddens, bias=bias)self.W_k = nn.LazyLinear(num_hiddens, bias=bias)self.W_v = nn.LazyLinear(num_hiddens, bias=bias)self.W_o = nn.LazyLinear(num_hiddens, bias=bias)def forward(self, queries, keys, values, valid_lens):# Shape of queries, keys, or values:# (batch_size, no. of queries or key-value pairs, num_hiddens)# Shape of valid_lens: (batch_size,) or (batch_size, no. of queries)# After transposing, shape of output queries, keys, or values:# (batch_size * num_heads, no. of queries or key-value pairs,# num_hiddens / num_heads)queries = self.transpose_qkv(self.W_q(queries))keys = self.transpose_qkv(self.W_k(keys))values = self.transpose_qkv(self.W_v(values))if valid_lens is not None:# On axis 0, copy the first item (scalar or vector) for num_heads# times, then copy the next item, and so onvalid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)# Shape of output: (batch_size * num_heads, no. of queries,# num_hiddens / num_heads)output = self.attention(queries, keys, values, valid_lens)# Shape of output_concat: (batch_size, no. of queries, num_hiddens)output_concat = self.transpose_output(output)return self.W_o(output_concat)def transpose_qkv(self, X):"""Transposition for parallel computation of multiple attention heads.Defined in :numref:`sec_multihead-attention`"""# Shape of input X: (batch_size, no. of queries or key-value pairs,# num_hiddens). Shape of output X: (batch_size, no. of queries or# key-value pairs, num_heads, num_hiddens / num_heads)X = X.reshape(X.shape[0], X.shape[1], self.num_heads, -1)# Shape of output X: (batch_size, num_heads, no. of queries or key-value# pairs, num_hiddens / num_heads)X = X.permute(0, 2, 1, 3)# Shape of output: (batch_size * num_heads, no. of queries or key-value# pairs, num_hiddens / num_heads)return X.reshape(-1, X.shape[2], X.shape[3])def transpose_output(self, X):"""Reverse the operation of transpose_qkv.Defined in :numref:`sec_multihead-attention`"""X = X.reshape(-1, self.num_heads, X.shape[1], X.shape[2])X = X.permute(0, 2, 1, 3)return X.reshape(X.shape[0], X.shape[1], -1)

EncoderBlock

下面实现编码器中的一个块(EncoderBlock),其中包括两个子层:多头注意力和基于位置的前馈网络。

在这里插入图片描述
EncoderBlock的forward()函数比较简单,就是将传入的特征X(前提是已经进行了Embedding)依次传入:
多头注意力

self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)

加 & 规范化

self.addnorm1 = AddNorm(norm_shape, dropout)

形成特征向量Y,然后再将Y传入逐位前馈网络和加 & 规范化层形成最终的输出

self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)
self.addnorm2 = AddNorm(norm_shape, dropout)

最后整合所有代码,利用forward函数进行前向传播:

# @save  ffn 前馈神经网络
class EncoderBlock(nn.Module):def __init__(self, key_size, query_size, value_size, num_hiddens,norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,dropout, use_bias=False, **kwargs):super(EncoderBlock, self).__init__(**kwargs)self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)self.addnorm1 = AddNorm(norm_shape, dropout)self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)self.addnorm2 = AddNorm(norm_shape, dropout)def forward(self, X, valid_lens):# print('EncoderBlock中的X',X)# with  open('D://pythonProject//f-write//D2L-Transformer/encoder-X.txt', 'w') as f:#     f.write(str(X))# X传入的是size还是数据?---->数据Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))return self.addnorm2(Y, self.ffn(Y))

Transformer的编码器和解码器有一个非常好的特性,就是它们的任何层都不会改变其输入的形状,即永远保持:输出形状 = 输入形状

"""Transformer编码器的任何层都不会改变其输入的形状"""
"""Transformer编码器的输出形状 = 输入形状"""
X = torch.ones((2, 100, 24))
valid_lens = torch.tensor([3, 2])
# key_size = 24 query_size = 24 value_size = 24
# num_hiddens = 24
# norm_shape = [100,24]  ffn_num_input = 24
# ffn_num_hiddens = 48   num_heads = 8
# dropout = 0.5
encoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)
encoder_blk.eval()
res = encoder_blk(X, valid_lens).shape
print('encoder_blk(X,valid_lens).shape:', res)
# encoder_blk(X,valid_lens).shape: torch.Size([2, 100, 24])

TransformerEncoder

官网上给出了一个关于TransformerEncoder中对于输入特征向量X进行缩放的一段话:

由于这里使用的是值范围在-1和1之间的固定位置编码,因此通过学习得到的输入的嵌入表示的值需要先乘以嵌入维度的平方根进行重新缩放,然后再与位置编码相加。

那这里有一个问题:矩阵相加满足广播机制,为什么要进行缩放嘞?答案就是如果不进行缩放,那么位置信息就会掩盖词嵌入特征的权重,更为完整的解释在下方,原出处是在D2L该章节的讨论区:

token是one-hot,经过embedding相当于从词嵌入矩阵W中取特定行,
而W被 Xavier初始化,其方差和嵌入维数成反比。也就是嵌入维数越大,
方差越小,权重越集中于0
,后续再和positional encoding相加,
词嵌入特征由于绝对值太小,可能被位置信息掩盖,难以影响模型后续计
算。因此需要放大W的方差,最直接的方法就是乘以维度的平方根。

解决了输入特征X的缩放问题,再来看下面Encoder的代码就很简单了:

# @save
class TransformerEncoder(d2l.Encoder):"""Transformer编码器"""def __init__(self, vocab_size, key_size, query_size, value_size,num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,num_heads, num_layers, dropout, use_bias=False, **kwargs):super(TransformerEncoder, self).__init__(**kwargs)self.num_hiddens = num_hiddensself.embedding = nn.Embedding(vocab_size, num_hiddens)self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)self.blks = nn.Sequential()for i in range(num_layers):self.blks.add_module("block" + str(i),EncoderBlock(key_size, query_size, value_size, num_hiddens,norm_shape, ffn_num_input, ffn_num_hiddens,num_heads, dropout, use_bias))def forward(self, X, valid_lens, *args):# 因为位置编码值在-1到1之间# 因此嵌入值乘以嵌入维度的平方根进行缩放,# 然后再与位置编码相加# with  open('D://pythonProject//f-write//D2L-Transformer/TransformerEncoder-X1-encoder.txt', 'w') as f:# f.write(str(X))X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))# with  open('D://pythonProject//f-write//D2L-Transformer/TransformerEncoder-X2-encoder.txt', 'w') as f:#     f.write(str(X))self.attention_weights = [None] * len(self.blks)# 列表:[None, None, None, None, None...]with  open('D://pythonProject//f-write//D2L-Transformer/TransformerEncoder-self.blks.txt', 'w') as f:f.write(str(self.blks))# print(self.blks)"""拿到每一层的注意力权重并保存起来"""for i, blk in enumerate(self.blks):X = blk(X, valid_lens)self.attention_weights[i] = blk.attention.attention.attention_weightsreturn X

在上面的TransformerEncoder类中主要干了下面几个活:
首先,在__init__函数中,利用for循环依次创建了多个EncoderBlock,这里Block的大小也就是下图中n的值:
在这里插入图片描述
想必看完了上面的Transformer论文讲解视频,初学者也会恍然大悟,其实Transformer就是一个串并联电池组,其中这里的n就是左侧串联电池组的个数。
其次,要对输入特征X进行Embedding词嵌入。由上面Block的代码可得知,它并没有干词嵌入的活,所以在Encoder中要先进行词嵌入,才能将生成的嵌入信息传入到Block中。
最后,保存每个电池中的注意力权重。并返回经过处理后的特征向量X。

下面我们将指定超参数进行Encoder模型的训练:

vocab_size = 200
key_size = 24
query_size = 24
value_size = 24
num_hiddens = 24
norm_shape = [100, 24]
ffn_num_input = 24
ffn_num_hiddens = 48
num_heads = 8
num_layers = 2
dropout = 0.5

"""指定了超参数来创建一个两层Transformer编码器"""
"""Transformer编码器输出的形状是(批量大小,时间步数,num_hiddens)"""
encoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)
encoder.eval()
res = encoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape
print('encoder-shape:',res)

DecoderBlock

在DecoderBlock中,第一个子层——掩蔽多头注意力的输入来自于上一个编码器的输出。同时掩蔽自注意力中的参数dec_valid_lens是为了便于任何查询只会与解码器中所有已经生成词元的位置(即直到该查询位置为止)进行注意力计算,这样就可以在解码器中保留自回归的属性,仅仅对已知的数据进行建模,即 X t X_t Xt仅仅依赖于 X t − 1 X_{t-1} Xt1以及该时刻以前的上下文信息。因此,在下面代码中,我们通过state[2]存储每个层的key value对的信息,用dec_valid_lens变量存储实际的掩码长度。

class DecoderBlock(nn.Module):"""解码器中第i个块"""def __init__(self,key_size,query_size,value_size,num_hiddens,norm_shape,ffn_num_input,ffn_num_hiddens,num_heads,dropout,i,**kwargs):super(DecoderBlock, self).__init__(**kwargs)self.i = i    #  用于表示这是第i个DecoderBlock块# 掩蔽???多头注意力self.attention1 = d2l.MultiHeadAttention(key_size,query_size,value_size,num_hiddens,num_heads,dropout)# 加 & 规范化self.addnorm1 = AddNorm(norm_shape,dropout)# 多头注意力self.attention2 = d2l.MultiHeadAttention(key_size,query_size,value_size,num_hiddens,num_heads,dropout)# 加 & 规范化self.addnorm2 = AddNorm(norm_shape,dropout)# 逐位前馈网络self.ffn = PositionWiseFFN(ffn_num_input,ffn_num_hiddens,num_hiddens)# 加 & 规范化self.addnorm3 = AddNorm(norm_shape,dropout)def forward(self,X,state):enc_outputs,enc_valid_lens = state[0],state[1]# 训练阶段,输出序列的所有词元都在同一时间处理# 因此state[2][self.i]初始化为None# 预测阶段,输出序列是通过词元一个接着一个解码的# 因此state[2][self.i]包含着直到当前时间步第i个块解码的输出表示"""训练时,由于每次都需要调用init_state函数,因此重新训练一个batch时,state[2]始终是一个None列表,当测试时,由于每次根据当前时间步的词元预测下一个词元时都不会重新调用init_state()函数,不会重新初始化state,因此state[2]里面保存的是之前时间步预测出来的词元信息(存的是decoder每层第一个掩码多头注意力state信息)"""if state[2][self.i] is None:print('state[2][self.i]--->为空')key_values = Xelse:# 在predict的时候,key和values是之前得到的上下文信息print('state[2][self.i]--->不为空')key_values = torch.cat((state[2][self.i],X),axis=1)state[2][self.i] = key_values# 在我们训练的时候会执行model.train(),这时候将training设置为True,# 在执行eval()的时候,将training设置为false。if self.training:batch_size,num_steps,_ = X.shape"""训练时执行当前时间步的query时只看它前面的keys,values,不看它后面的keys,values。因为预测时是从左往右预测的,右边还没有预测出来,因此右侧的keys是没有的,看不到右侧的keys;训练时预测当前时间步词元能看到后面的目标词元,因此需要dec_valid_lens"""# dec_valid_lens的开头:(batch_size,num_steps),# 其中每一行是[1,2,...,num_steps]"""dec_valid_lens用于掩蔽注意力遮掉后面的长度"""dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)else:"""测试时预测当前时间步的词元只能看到之前预测出来的词元,后面还没预测的词元还看不到,因此dec_valid_lens可以不需要"""dec_valid_lens = None# 第一层:掩蔽多头注意力X2 = self.attention1(X,key_values,key_values,dec_valid_lens)# 第二层:加 & 规范化Y = self.addnorm1(X,X2)# 编码器-解码器注意力# enc_outputs的开头:(batch_size,num_steps,num_hiddens)# 第三层:多头注意力 它的key和value来自于Encoder的OutputY2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)# 第四层:加 & 规范化Z = self.addnorm2(Y, Y2)# 第五层 + 第六层:逐位前馈网络 + 加&规范化return self.addnorm3(Z, self.ffn(Z)), state

在上述代码中__init_()函数定义了一个解码器块用到的注意力机制、Add&Norm层以及FFN层。
在这里插入图片描述

难点在于forward函数:它将获取的上下文信息(包括编码器的输出信息、编码器输出信息实际的tokens长度)分别放到了变量enc_outputs以及变量enc_valid_lens中。那问题来了:state里面究竟存放的是什么信息?要回答这个问题,需要用到下面实例化的代码:

"""为了便于在“编码器-解码器”注意力中进行缩放点积计算和残差连接中进行加法计算,编码器和解码器的特征维度都是num_hiddens。
"""
decoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)
decoder_blk.eval()
X = torch.ones((2, 100, 24))
state = [encoder_blk(X, valid_lens), valid_lens, [None]]
res = decoder_blk(X, state)[0].shape
print('decoder_blk.shape:',res)

在上述代码中初始化state的时候state的形状以及存放的内容就是forward()函数接收到的state信息:

  1. state[0] : 编码器的输出信息
  2. state[1] : 编码器的输出信息有效长度valid-lens
  3. state[2]: 这里一开始初始化为空,而在DecoderBlock中可以发现,后面将使用它作为每一个DecoderBlock中的key_value值的存储。

对于state[2]的内容,在TransformerDecoder也有用到。TransformerDecoder__init__()函数中初始化Block时会将局部变量i的值传到DecoderBlock中,作为每一个Bock的下标。

        for i in range(num_layers):#print('执行了~')self.blks.add_module("block"+str(i),DecoderBlock(key_size,query_size,value_size,num_hiddens,norm_shape,ffn_num_input,ffn_num_hiddens,num_heads,dropout,i))

而DecoderBlock中也是巧用了其传过来的变量i,这里的i依旧可以看做是每一个Block的索引值。同时,DecoderBlock会将state[2]变成一个二维数组,第二个维度就是每一个层的state[2]信息,即key value pair的内容。训练时,由于每次都需要调用init_state函数,因此重新训练一个batch时,state[2]始终是一个None列表,当测试时,由于每次根据当前时间步的词元预测下一个词元时都不会重新调用init_state()函数,不会重新初始化state,因此state[2]里面保存的是之前时间步预测出来的词元信息(存的是decoder每层第一个掩码多头注意力state信息)
对应代码:

        if state[2][self.i] is None:print('state[2][self.i]--->为空')key_values = Xelse:# 在predict的时候,key和values是之前得到的上下文信息print('state[2][self.i]--->不为空')key_values = torch.cat((state[2][self.i],X),axis=1)state[2][self.i] = key_values

对于dec_valid_lens的处理同样是通过判断模型的状态来进行的,首先,训练时执行当前时间步的query时只看它前面的keys,values, 不看它后面的keys,values。因为预测时是从左往右预测的,右边还没有预测出来,因此右侧的keys是没有的,看不到右侧的keys;训练时预测当前时间步词元能看到后面的目标词元,因此需要dec_valid_lens。这里会将dec_valid_lens利用torch.arange()生成一个在1到num_steps + 1中的数,同时repeat成(batch_size, 1)

其次,测试时预测当前时间步的词元只能看到之前预测出来的词元,后面还没预测的词元还看不到,因此dec_valid_lens可以不需要

        if self.training:batch_size,num_steps,_ = X.shape"""训练时执行当前时间步的query时只看它前面的keys,values,不看它后面的keys,values。因为预测时是从左往右预测的,右边还没有预测出来,因此右侧的keys是没有的,看不到右侧的keys;训练时预测当前时间步词元能看到后面的目标词元,因此需要dec_valid_lens"""# dec_valid_lens的开头:(batch_size,num_steps),# 其中每一行是[1,2,...,num_steps]"""dec_valid_lens用于掩蔽注意力遮掉后面的长度"""dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)else:"""测试时预测当前时间步的词元只能看到之前预测出来的词元,后面还没预测的词元还看不到,因此dec_valid_lens可以不需要"""dec_valid_lens = None

最后是堆叠电池——将特征信息X依次输入到DecoderBlock中需要实现的掩蔽多头注意力、加 & 规范化、注意力机制、加 & 规范化、逐位前馈网络 + 加&规范化中。

当然,正如编码器部分所述的那样,Transformer的解码器与编码器的输入输出都是保持同样的特征维度的,下面是一个测试实例:

decoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)
decoder_blk.eval()
X = torch.ones((2, 100, 24))
state = [encoder_blk(X, valid_lens), valid_lens, [None]]
res = decoder_blk(X, state)[0].shape
print('decoder_blk.shape:',res)

TransformerDecoder

在TransformerDecoder中的主要任务是生成多个DecoderBlock。最后,通过一个全连接层计算所有vocab_size个可能的输出词元的预测值。另外,解码器的自注意力权重和编码器解码器注意力权重都被存储下来,方便日后可视化的需要。
块的堆叠是在__init__()中完成的,上面也讲过:生成块
初始化state时是根据上面Block所列的state的每一个索引存储值进行初始化的。第一个是编码器的输出、第二个是编码器输出信息的实际长度、第三个是存储的每个Block中的key 与 value的值(当然他们初始化都为None):在这里插入图片描述
forward()函数中主要是保存了解码器中每一个的自注意权重:
在这里插入图片描述

全部代码:

"""最后,通过一个全连接层计算所有vocab_size个可能的输出词元的预测值。"""
"""解码器的自注意力权重和编码器解码器注意力权重都被存储下来,方便日后可视化的需要"""
class TransformerDecoder(d2l.AttentionDecoder):def __init__(self,vocab_size,key_size,query_size,value_size,num_hiddens,norm_shape,ffn_num_input,ffn_num_hiddens,num_heads,num_layers,dropout,**kwargs):super(TransformerDecoder, self).__init__(**kwargs)self.num_hiddens = num_hiddensself.num_layers = num_layersself.embedding = nn.Embedding(vocab_size,num_hiddens)self.pos_encoding = d2l.PositionalEncoding(num_hiddens,dropout)self.blks = nn.Sequential()for i in range(num_layers):#print('执行了~')self.blks.add_module("block"+str(i),DecoderBlock(key_size,query_size,value_size,num_hiddens,norm_shape,ffn_num_input,ffn_num_hiddens,num_heads,dropout,i))# 用dense作为输出self.dense = nn.Linear(num_hiddens,vocab_size)def init_state(self,enc_outputs,enc_valid_lens,*args):return [enc_outputs,enc_valid_lens,[None] * self.num_layers]def forward(self,X,state):X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))self._attention_weights = [[None] * len(self.blks) for _ in range(2)]for i,blk in enumerate(self.blks):X,state = blk(X,state)# 解码器自注意力权重self._attention_weights[0][i] = blk.attention1.attention.attention_weights"""编码器-解码器 自注意力权重"""self._attention_weights[1][i] = blk.attention2.attention.attention_weightsreturn self.dense(X),state@propertydef attention_weights(self):return self._attention_weights

训练

训练部分主要是实例化“编码器-解码器”架构,编码器2层,解码器2层,使用4头注意力。同时为了进行Seq2Seq上的学习,下面使用了“英语-法语”机器翻译数据集上训练Transformer模型。这里有一个棘手的问题在D2L讨论区被提出:为什么用于残差连接和归一化的参数norm_shape不是根据train的num_steps为10而设置层[10,32]?

答案简洁表示就是在测试时会出现矩阵维度不适导致运算错误,具体来讲:

因为这里考虑到了train时的num_steps是10,但是在predict的时候num_steps则为1。所以为了适应不同的时间步,且训练和预测都使用同一个网络,所以这里norm_shape为[32]。将其改为[10,32]时训练误差减小很多:loss 0.005, 3700.9 tokens/sec on cpu
但是测试时会报错:

RuntimeError: Given normalized_shape=[10, 32], expected input with shape [*, 10, 32], but got input of size[1, 1, 32]

其余内容和序列到序列的学习部分内容就大同小异了~

"""训练"""
"""实例化编码器-解码器架构
编码器:2层
解码器:2层
使用:4头注意力
为了进行序列到序列的学习,下面在“英语-法语”机器翻译数据集上训练Transformer模型
"""
num_hiddens,num_layers,dropout,batch_size,num_steps = 32,2,0.1,64,10
lr,num_epochs,device = 0.005,200,d2l.try_gpu()
ffn_num_input,ffn_num_hiddens,num_heads =32,64,4
key_size,query_size,value_size = 32,32,32norm_shape = [32]
# norm_shape = [10,32]
"""
这里的norm_shape为什么不设置成[10,32]?
因为这里考虑到了train时的num_steps是10,但是在predict的时候num_steps则为1
所以为了适应不同的时间步,且训练和预测都使用同一个网络,所以这里norm_shape为[32]将其改为[10,32]时训练误差减小很多:loss 0.005, 3700.9 tokens/sec on cpu
但是测试时会报错:
RuntimeError: Given normalized_shape=[10, 32], expected input with shape [*, 10, 32], but got input of size[1, 1, 32]
"""
train_iter,src_vocab,tgt_vocab = d2l.load_data_nmt(batch_size,num_steps)
encoder = TransformerEncoder(len(src_vocab),key_size,query_size,value_size,num_hiddens,norm_shape,ffn_num_input,ffn_num_hiddens,num_heads,num_layers,dropout)
decoder = TransformerDecoder(len(tgt_vocab),key_size,query_size,value_size,num_hiddens,norm_shape,ffn_num_input,ffn_num_hiddens,num_heads,num_layers,dropout)
net = d2l.EncoderDecoder(encoder,decoder)
d2l.train_seq2seq(net,train_iter,lr,num_epochs,tgt_vocab,device)
plt.show()engs = ['go .', "i lost .", 'he\'s calm .', 'i\'m home .']
fras = ['va !', 'j\'ai perdu .', 'il est calme .', 'je suis chez moi .']
for eng, fra in zip(engs, fras):translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)print(f'{eng} => {translation}, ',f'bleu {d2l.bleu(translation, fra, k=2):.3f}')

当进行最后一个英语到法语的句子翻译工作时,让我们可视化Transformer的注意力权重。编码器自注意力权重的形状为(编码器层数,注意力头数,num_steps或查询的数目,num_steps或“键-值”对的数目)【来自于D2L官网描述】

enc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads,-1, num_steps))
res = enc_attention_weights.shape
print('enc_attention_weights.shape',res)

接下来,将逐行呈现两层多头注意力的权重。每个注意力头都根据查询、键和值的不同的表示子空间来表示不同的注意力。

d2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions',ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)],figsize=(7, 3.5))
plt_show.show()

为了可视化解码器的自注意力权重和“编码器-解码器”的注意力权重,我们需要完成更多的数据操作工作。例如用零填充被掩蔽住的注意力权重。值得注意的是,解码器的自注意力权重和“编码器-解码器”的注意力权重都有相同的查询:即以序列开始词元(beginning-of-sequence,BOS)打头,再与后续输出的词元共同组成序列。

dec_attention_weights_2d = [head[0].tolist()for step in dec_attention_weight_seqfor attn in step for blk in attn for head in blk]
dec_attention_weights_filled = torch.tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)
dec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))
dec_self_attention_weights, dec_inter_attention_weights = \dec_attention_weights.permute(1, 2, 3, 0, 4)
res_dec_self_attention_weight_shape = dec_self_attention_weights.shape
res_dec_inter_attention_weight_shape = dec_inter_attention_weights.shape
print('res_dec_self_attention_weight_shape:',res_dec_self_attention_weight_shape)
print('res_dec_inter_attention_weight_shape:',res_dec_inter_attention_weight_shape)

由于解码器自注意力的自回归属性,查询不会对当前位置之后的“键-值”对进行注意力计算。

# Plusonetoincludethebeginning-of-sequencetoken
d2l.show_heatmaps(dec_self_attention_weights[:, :, :, :len(translation.split()) + 1],xlabel='Key positions', ylabel='Query positions',titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))
plt_show.show()

与编码器的自注意力的情况类似,通过指定输入序列的有效长度, 输出序列的查询不会与输入序列中填充位置的词元进行注意力计算。

d2l.show_heatmaps(dec_inter_attention_weights, xlabel='Key positions',ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)],figsize=(7, 3.5))
plt_show.show()

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/148615.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

国庆中秋特辑(七)Java软件工程师常见20道编程面试题

以下是中高级Java软件工程师常见编程面试题,共有20道。 如何判断一个数组是否为有序数组? 答案:可以通过一次遍历,比较相邻元素的大小。如果发现相邻元素的大小顺序不对,则数组不是有序数组。 public boolean isSort…

【Unity】两种方式实现弹跳平台/反弹玩家(玩家触发与物体自身触发事件实现蹦床的物理效果)

一、声明 只实现物理反弹的效果,不实现蹦床会有的视觉拉伸效果,请自行找相关代码 二、实现 经过我的实践,我发现要想实现一个平台反弹的效果,要么就选择给player添加一个物理材质(平台加了没用)&#xff0…

arduino嵌入式1,LED闪烁案例

CVE系列在等等吧,环境我有点懒得搭建了 文章目录 前言一、anduino是什么玩意儿?二、使用步骤1.找蓝图/画蓝图2.写入数据成果 总结 前言 最近在学习嵌入式开发,我的单片机到了,然后我就沉迷于嵌入式开发的环境中 提示:…

Linux嵌入式学习之Ubuntu入门(六)shell脚本详解

系列文章内容 Linux嵌入式学习之Ubuntu入门(一)基本命令、软件安装、文件结构、编辑器介绍 Linux嵌入式学习之Ubuntu入门(二)磁盘文件介绍及分区、格式化等 Linux嵌入式学习之Ubuntu入门(三)用户、用户组…

go-fastdfs分布式文件存储集群搭建和测试

一、官方文件 https://sjqzhang.github.io/go-fastdfs/#character2、集群原理 小集群原理: 大集群原理 二、服务端集群部署 1、在集群每个节点机器上下载安装包 (建议使用最新稳定版本) wget --no-check-certificate https://github.com/sjqzhang/go…

【Linux基础】Linux发展史

👉系列专栏:【Linux基础】 🙈个人主页:sunny-ll 一、前言 本篇主要介绍Linux的发展历史,这里并不需要我们掌握,但是作为一个合格的Linux学习者与操作者,这些东西是需要了解的,而且…

docker基本命令

一、镜像操作 1、搜索镜像 docker search 仓库名/镜像名 2、下载镜像 docker pull 仓库名/镜像名:标签 若不指明标签,则表示下载最新版本的【标签为latest】 3、查看镜像 docker images 4、创建镜像 docker tag 原仓库/镜像名:原标名 新…

机器人制作开源方案 | 家庭清扫拾物机器人

作者:罗诚、李旭洋、胡旭、符粒楷 单位:南昌交通学院 人工智能学院 指导老师:揭吁菡 在家庭中我们有时无法到一些低矮阴暗的地方进行探索,比如茶几下或者床底下,特别是在部分家庭中,如果没有及时对这些阴…

【网络安全】2023年堡垒机品牌大全

随着大家网络安全意识的增加,随着国家等保政策的严格执行,越来越多的企业开始采购堡垒机。这里就给大家总结了部分堡垒机品牌,让大家参考参考。 2023年堡垒机品牌大全 1、行云堡垒 2、JumpServer 3、安恒 4、骞云 5、齐治 6、阿里云 …

【应用层协议】HTTPS的加密流程

文章目录 1. 认识HTTPS2. 密文3. HTTPS加密流程3.1 对称加密3.2 非对称加密3.3 证书 1. 认识HTTPS HTTPS(超文本传输协议安全)也是一个应用层协议,它是在HTTP协议的基础上引入了一个加密层。 也就是HTTP协议传输文本的方式是明文,…

【Docker Compose】Docker Compose 的安装,使用以及实现微服务集群的部署

文章目录 前言:Docker 部署存在的问题一、 初识 Docker Compose1.1 什么是 Docker Compose1.2 在 CentOS 上安装 Docker Compose 二、深入了解 Docker Compose 文件2.1 Docker Compose 文件概述2.2 Docker Compose 文件详解2.3 示例:编写 Docker Compose…

Flutter AI五子棋

前言 在上一篇文章中,讲解了如何实现双人在本地对战的五子棋,但是只有一个人的时候就不太好玩,同时博主也没有把五子棋相关的文章写过瘾。那么这篇文章,我们来实现一个功能更加丰富的五子棋吧!在设计五子棋的算法方面&…

mysql5.7停止维护时间

mysql5.7将于2023年10月停止官网支持和更新;老项目要准备升级,新项目的mysql必须是mysql8.0(2023-10) 官方升级咨询地址 oracle官方升级咨询地址https://go.oracle.com/LP116153?elq_mid247718&sh1518132002061316121320310…

vue、vuex状态管理

使用步骤: 1、安装vuex 口诀:“233”、“344” 数字分别对应,“vue版本,vue 路由版本、vuex 版本”。 所以这里了使用vuex3版本: yarn add vuex3 2、创建仓库文件 编写如下: // 这个文件用于存放vuex的…

JAVA面经整理(7)

一)什么是AQS? 1)AQS也被称之为是抽象同步队列,它是JUC包底下的多个组件的底层实现,Lock,CountDownLatch和Semphore底层都使用到了AQS AQS的核心思想就是给予一个等待队列和同步状态来实现的,它的内部使用一个先进先出…

机器视觉工程师努力工作确实不一定涨工资,但是努力工作,确实有很大可能涨工资

机器视觉工程师努力工作确实不一定涨工资,但是努力工作,确实有很大可能涨工资 其实在我们机器视觉工程张薪资方面,正常是一年两次调整周期。

arm 汇编基础指令

实现1-100求和 .text .globl _start_start:mov r0, #1 i&#xff0c;i1mov r1, #100 条件变量i<100mov r2, #0 sumLoop: 循环cmp r0,r1 比较r0和r1的大小bhi stop 当r0>r1时&#xff0c;跳到stop标签a…

Android 中级控件

目录 一、图形定制1.1 图形Drawable1.2 形状图形1.3 状态列表图形 二、选择按钮2.1 复选框2.2 开关按钮2.3 单选按钮 三、文本输入3.1 编辑框3.2 焦点变更监听器3.3 文本变化监听器 四、对话框4.1 提醒对话框4.2 日期对话框4.3 时间对话框 一、图形定制 1.1 图形Drawable ~~~~…

苹果签名有多少种类之TF签名(TestFlight签名)是什么?优势是什么?什么场合需要应用到?

&#xff08;一&#xff09;TestFlight 能够让您&#xff1a;邀请内部和外部的测试人员为应用程序提供反馈。 跟踪应用程序在测试过程中发现的 bug 和用户体验问题。 收集 Crash 报告&#xff0c;了解应用程序在真实设备上的运行状况。 要使用 TestFlight&#xff0c;您可以按照…

基于Java的校园跑腿接单管理系统设计与实现(源码+lw+部署文档+讲解等)

文章目录 前言具体实现截图论文参考详细视频演示为什么选择我自己的网站自己的小程序&#xff08;小蔡coding&#xff09;有保障的售后福利 代码参考源码获取 前言 &#x1f497;博主介绍&#xff1a;✌全网粉丝10W,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域优质创作…