第TR3周：Pytorch复现Transformer

最新推荐文章于 2025-05-08 21:22:13 发布
最新推荐文章于 2025-05-08 21:22:13 发布
阅读量993 收藏 18
点赞数 32
CC 4.0 BY-SA版权
文章标签： pytorch transformer 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43414521/article/details/146376841

本人往期文章可查阅： 深度学习总结

📌本周任务详情：

  • 1.从整体上把握Transformer模型，明白它是个什么东西，可以干嘛
  • 2.读懂Transformer的复现代码

一、Transformer 与 Seq2Seq

       在之前的任务重我们学习了 Seq2Seq，知晓了 Attention 为 RNN 带来的优点。那么有没有一种神经网络结构直接基于 attention 构造，并且不再依赖 RNN、LSTM 或者 CNN 网络结构了呢？答案便是：Transformer。Seq2Seq 和 Transformer 都是用于处理序列数据的深度学习模型，但它们是两种不同的架构。

1.Seq2Seq：

  • 定义：Seq2Seq 是一种用于序列到序列任务的模型架构，最初用于机器翻译。这意味着它可以处理输入序列，并生成相应的输出序列。
  • 结构：Seq2Seq 模型通常由两个主要部分组成：编码器和解码器。编码器负责将输入序列编码为固定大小的向量，而解码器则使用此向量生成输出序列。
  • 问题：传统的Seq2Seq模型在处理长序列时可能会遇到梯度消失/爆炸等问题，而Transformer 模型的提出正是为了解决这些问题。

2.Transformer：

  • 定义：Transformer是一种更现代的深度学习模型，专为处理序列数据而设计，最初用于自然语言处理任务。它不依赖于RNN或CNN等传统结构，而是引入了注意力机制。
  • 结构：Transformer 模型主要由编码器和解码器组成，它们由自注意力层和全连接前馈网络组成。它使用注意力机制来捕捉输入序列中不同位置之间的依赖关系，同时通过多头注意力来提高模型的表达能力。
  • 优势：Transformer 的设计使其能够更好地处理长距离依赖关系，同时具有更好的并行性。

       在某种程度上，可以将 Transformer 看作是 Seq2Seq 的一种演变，Transformer 可以执行 Seq2Seq 任务，并且相对于传统的 Seq2Seq 模型具有更好的性能和可扩展性。

Transformer 论文原文：Attention Is All You Need

       与 RNN 这类神经网络结构相比，Transformer 一个巨大的优点是：模型在处理序列输入时，可以对整个序列进行并行计算，不需要按照时间步循环递归处理输入序列。 

       上图便是 Transformer 整体结构图，与 Seq2Seq 模型类似，Transformer 模型结构中的左半部分为编码器，右半部分为解码器，下面我们来一步步拆解 Transformer。

二、Transformer 宏观结构

       Transformer 可以看作是 seq2seq 模型的一种，因此，先从 seq2seq 的角度对 Transformer 进行宏观结构的学习。以机器翻译任务为例，先将 Transformer 看作一个黑盒，黑盒的输入是法语文本序列，输出是英语文本序列。

图2：Transformer黑盒输入和输出 

       将上图中的中间部分  “THE TRANSFORMER” 拆开成 seq2seq 标准结构，得到下图：左边是编码器部分 Encoders，右边是解码器部分 Decoders。

图3 ：Encoders-Decoders

       下面， 再将上图中的编码器和解码器细节绘出，得到下图。我们可以看到，编码部分由多层编码器（Encoder）组成。解码部分也是由多层的解码器（Decoder）组成。每层编码器、解码器网络结构是一样的，但是不同层编码器、解码器网络结构不共享参数。

 图4:6层编码器和6层解码器

       其中，单层编码器主要由自注意力层（Self-Attention Layer）和全连接前馈网络（Feed Forward Neural Network，FFNN）组成，如下图所示：

图5 ：单层编码器

       其中，解码器在编码器的自注意力层和全连接前馈网络中间插入了一个Encoder-Decoder Attention 层，这个层帮助解码器聚焦于输入序列最相关的部分。

图6 ：单层解码器

       总结一下，我们基本了解了 Transformer 由编码部分和解码部分组成，而编码部分和解码部分又由多个网络结构相同的编码层和解码层组成。每个编码层由自注意力层和全连接前馈网络组成，每个解码层由自注意力层、全连接前馈网络和 Encoder-Decoder attention 组成。

三、复现 Transformer

1.多头注意力机制

import math,torch
import torch.nn as nn

#device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
#device
class MultiHeadAttention(nn.Module):
    # n_heads：多头注意力的数量
    # hid_dim：每个词输出的向量维度
    def __init__(self,hid_dim,n_heads):
        super(MultiHeadAttention,self).__init__()
        self.hid_dim=hid_dim
        self.n_heads=n_heads
        
        # 强制 hid_dim必须整除 h
        assert hid_dim % n_heads==0
        # 定义 W_q 矩阵
        self.w_q=nn.Linear(hid_dim,hid_dim)
        # 定义 W_k 矩阵
        self.w_k=nn.Linear(hid_dim,hid_dim)
        # 定义 W_v 矩阵
        self.w_v=nn.Linear(hid_dim,hid_dim)
        self.fc=nn.Linear(hid_dim,hid_dim)
        # 缩放
        self.scale=torch.sqrt(torch.FloatTensor([hid_dim//n_heads]))
     
    def forward(self,query,key,value,mask=None):
        # 注意 Q，K，V 在句子长度这一个维度的数值可以一样，可以不一样
        # K：[64,10,300]，假设batch_size为64，有10个词，每个词的Query向量是300维
        # V：[64,10,300]，假设batch_size为64，有10个词，每个词的Query向量是300维
        # Q：[64,12,300]，假设batch_size为64，有12个词，每个词的Query向量是300维
        bsz=query.shape[0]
        Q=self.w_q(query)
        K=self.w_k(key)
        V=self.w_v(value)
        # 这里把 K Q V 矩阵拆分为多组注意力
        # 最后一维就是用 self.hid_dim // self.n_heads 来得到的，表示每组注意力的向量长度
        # 每个 head 的向量长度是：300/6=50
        # 64 表示 batch size，6表示有6组注意力，10表示有10个词，50表示每组注意力的词的向量长度
        # K：[64,10,300] 拆分多组注意力 -> [64,10,6,50] 转置得到 -> [64,6,10,50]
        # V：[64,10,300] 拆分多组注意力 -> [64,10,6,50] 转置得到 -> [64,6,10,50]
        # Q：[64,12,300] 拆分多组注意力 -> [64,12,6,50] 转置得到 -> [64,6,12,50]
        # 转置是为了把注意力的数量6放到前面，把10和50放到后面，方便下面计算
        Q=Q.view(bsz,-1,self.n_heads,self.hid_dim //
                 self.n_heads).permute(0,2,1,3)
        K=K.view(bsz,-1,self.n_heads,self.hid_dim //
                 self.n_heads).permute(0,2,1,3)
        V=V.view(bsz,-1,self.n_heads,self.hid_dim //
                 self.n_heads).permute(0,2,1,3)
        
        # 第一步：Q 乘以 K 的转置，除以scale
        # [64,6,12,50] * [64,6,50,10] = [64,6,12,10]
        # attention: [64,6,12,10]
        attention=torch.matmul(Q,K.permute(0,1,3,2))/self.scale
        
        # 如果 mask 不为空，就把mask为0的位置的attention分数设置为-1e10，
        # 这里用“0”来指示哪些位置的词向量不能被attention到，比如padding位置，
        # 当然也可以用“1”或者其他数字来指示，主要涉及下面2行代码的改动
        if mask is not None:
            attention=attention.masked_fill(mask==0,-1e10)
            
            # 第二步：计算上一步结果的softmax，再经过dropout，得到attention
            # 注意，这里是对最后一维做softmax，也就是在输入序列的维度做softmax
            # attention:[64,6,12,10]
        attention=torch.softmax(attention,dim=-1)
        
        # 第三步，attention结果与V相乘，得到多头注意力的结果
        # [64,6,12,10] * [64,6,10,50] = [64,6,12,50]
        # x:[64,6,12,50]
        x=torch.matmul(attention,V)
        
        # 因为query有12个词，所以把12放到前面，把50和6放到后面，方便下面拼接多组的结果
        # x:[64,6,12,50] 转置-> [64,12,6,50]
        x=x.permute(0,2,1,3).contiguous()
        # 这里的矩阵转换就是：把多组注意力的结果拼接起来
        # 最终结果就是 [64,12,300]
        # x: [64,12,6,50] -> [64,12,300]
        x=x.view(bsz,-1,self.n_heads*(self.hid_dim//self.n_heads))
        x=self.fc(x)
        return x

2.前馈传播

class Feedforward(nn.Module):
    def __init__(self,d_model,d_ff,dropout=0.1):
        super(Feedforward,self).__init__()
        # 两层线性映射和激活函数ReLU
        self.linear1=nn.Linear(d_model,d_ff)
        self.dropout=nn.Dropout(dropout)
        self.linear2=nn.Linear(d_ff,d_model)
        
    def forward(self,x):
        x=torch.nn.functional.relu(self.linear1(x))
        x=self.dropout(x)
        x=self.linear2(x)
        return x

3.位置编码

class PositionalEncoding(nn.Module):
    "实现位置编码"
    def __init__(self,d_model,dropout,max_len=5000):
        super(PositionalEncoding,self).__init__()
        self.dropout=nn.Dropout(p=dropout)
        
        # 初始化Shape为(max_len,d_model)的PE(positonal encoding)
        pe=torch.zeros(max_len,d_model)
        
        # 初始化一个tensor [[0,1,2,3,……]]
        position=torch.arange(0,max_len).unsqueeze(1)
        # 这里就是sin和cos括号中的内容，通过e和ln进行了变换
        div_term=torch.exp(torch.arange(0,d_model,2)*-(math.log(10000.0)/d_model))
        
        pe[:,0::2]=torch.sin(position*div_term) # 计算PE(pos,2i)
        pe[:,1::2]=torch.cos(position*div_term) # 计算PE(pos,2i+1)
        
        pe=pe.unsqueeze(0) # 为了方便计算，在最外面在unsqueeze出一个batch
        
        # 如果一个参数不参与梯度下降，但又希望保存model的时候将其保存下来
        # 这个时候就可以用register_buffer
        self.register_buffer("pe",pe)
        
    def forward(self,x):
        """
        x为embedding后inputs，例如(1,7,128)，batch size为1,7个单词，单词维度为128
        """
        # 将x和position encoding相加
        x=x+self.pe[:,:x.size(1)].requires_grad_(False)
        return self.dropout(x)

4.编码层

class EncoderLayer(nn.Module):
    def __init__(self,d_model,n_heads,d_ff,dropout=0.1):
        super(EncoderLayer,self).__init__()
        # 编码器层包含自注意力机制和前馈神经网络
        self.self_attn=MultiHeadAttention(d_model,n_heads)
        self.feedforward=Feedforward(d_model,d_ff,dropout)
        self.norm1=nn.LayerNorm(d_model)
        self.norm2=nn.LayerNorm(d_model)
        self.dropout=nn.Dropout(dropout)
        
    def forward(self,x,mask):
        # 自注意力机制
        atten_output=self.self_attn(x,x,x,mask)
        x=x+self.dropout(atten_output)
        x=self.norm1(x)
        
        # 前馈神经网络
        ff_output=self.feedforward(x)
        x=x+self.dropout(ff_output)
        x=self.norm2(x)
        
        return x

5.解码层

class DecoderLayer(nn.Module):
    def __init__(self,d_model,n_heads,d_ff,dropout=0.1):
        super(DecoderLayer,self).__init__()
        # 解码器层包含自注意力机制、编码器-解码器注意力机制和前馈神经网络
        self.self_attn=MultiHeadAttention(d_model,n_heads)
        self.enc_attn=MultiHeadAttention(d_model,n_heads)
        self.feedforward=Feedforward(d_model,d_ff,dropout)
        self.norm1=nn.LayerNorm(d_model)
        self.norm2=nn.LayerNorm(d_model)
        self.norm3=nn.LayerNorm(d_model)
        self.dropout=nn.Dropout(dropout)
        
    def forward(self,x,enc_output,self_mask,context_mask):
        # 自注意力机制
        attn_output=self.self_attn(x,x,x,self_mask)
        x=x+self.dropout(attn_output)
        x=self.norm1(x)
        
        # 编码器-解码器注意力机制
        attn_output=self.enc_attn(x,enc_output,enc_output,context_mask)
        x=x+self.dropout(attn_output)
        x=self.norm2(x)
        
        # 前馈神经网络
        ff_output=self.feedforward(x)
        x=x+self.dropout(ff_output)
        x=self.norm3(x)
        
        return x

6.Transformer模型构建

class Transformer(nn.Module):
    def __init__(self,vocab_size,d_model,n_heads,n_encoder_layer,
                 n_decoder_layer,d_ff,dropout=0.1):
        super(Transformer,self).__init__()
        # Transformer 模型包含词嵌入、位置编码、编码器和解码器
        self.embedding=nn.Embedding(vocab_size,d_model)
        self.positional_encoding=PositionalEncoding(d_model,dropout)
        self.encoder_layers=nn.ModuleList([EncoderLayer(d_model,n_heads,d_ff,dropout) for _ in range(n_encoder_layer)])
        self.decoder_layers=nn.ModuleList([DecoderLayer(d_model,n_heads,d_ff,dropout) for _ in range(n_decoder_layer)])
        self.fc_out=nn.Linear(d_model,vocab_size)
        self.dropout=nn.Dropout(dropout)
        
    def forward(self,src,trg,src_mask,trg_mask):
        # 词嵌入和位置编码
        src=self.embedding(src)
        src=self.positional_encoding(src)
        trg=self.embedding(trg)
        trg=self.positional_encoding(trg)
        
        # 编码器
        for layer in self.encoder_layers:
            src=layer(src,src_mask)
            
        # 解码器
        for layer in self.decoder_layers:
            trg=layer(trg,src,trg_mask,src_mask)
            
        # 输出层
        output=self.fc_out(trg)
        
        return output
# 使用示例
vocab_size=10000  # 假设词汇表大小为10000
d_model=512
n_heads=8
n_encoder_layers=6
n_decoder_layers=6
d_ff=2048
dropout=0.1

transformer_model=Transformer(vocab_size,d_model,n_heads,n_encoder_layers,
                              n_decoder_layers,d_ff,dropout)
# 定义输入，这里的输入是假设的，需要根据实际情况修改
src=torch.randint(0,vocab_size,(32,10)) # 源语言句子
trg=torch.randint(0,vocab_size,(32,20)) # 目标语言句子
src_mask=(src!=0).unsqueeze(1).unsqueeze(2) # 掩码，用于屏蔽填充的位置
trg_mask=(trg!=0).unsqueeze(1).unsqueeze(2) # 掩码，用于屏蔽填充的位置

# 模型前向传播
output=transformer_model(src,trg,src_mask,trg_mask)
print(output.shape)

输出：

torch.Size([32, 20, 10000])

OreoCC
关注
TR3：Pytorch复现Transformer
u012249506的博客
11-14 1355
Transformer 网络架构架构由 Ashish Vaswani 等人在 Attention Is All You Need一文中提出，并用于机器翻译任务，和以往网络架构有所区别的是，该网络架构中，编码器和解码器没有采用 RNN 或 CNN 等网络架构，而是采用完全依赖于注意力机制的架构。网络架构如下所示： Transformer改进了RNN被人诟病的训练慢的特点，利用self-attention可以实现快速并行。注意力机制是神经网络中一个迷人的概念，特别是在涉及到像 NLP 这样的任务时。它就像给
复现iTransformer实操，并与PatchTST的多变量——变压器油温时序数据预测对比
最新发布
2301_76610365的博客
06-27 733
本文对比分析了PatchTST和iTransformer两种多变量时间序列预测模型。PatchTST采用通道独立策略，将多变量序列拆分为单变量输入Transformer；iTransformer则通过转置数据，利用注意力机制建模变量相关性。实验结果显示：在较长序列（336窗口）上，PatchTST表现略优（RMSE 0.284 vs 0.291）；而在较短序列（96窗口）时，iTransformer更佳（0.243 vs 0.239）。
复现 transformer
m0_57122465的博客
05-31 1630
首先是一些掩码操作这行代码主要是在实现序列屏蔽的过程中构造一个形状为(batch_size, seq_len)大小的布尔型张量mask 其中，元素(i,j)的值为True表示对应输入序列中的第i个样本在位置j上存在有效元素，反之，该位置不存在有效元素。具体而言，valid_len 是一个长度为batch_size的一维张量，表示每个序列中有效元素的数量（seq_len可能大于有效长度）。
Raki的paper复现：Transformer
Raki_J的博客
01-13 838
咕咕咕了很久，它终于要来辣！ 本blog将会按照paper中的顺序，完整复现transformer模型，但是不会有训练的部分，想看训练部分的请参考哈佛的blog原文（： reference： 哈佛大学NLP组的transformer复现 Transformer源码详解（Pytorch版本） 老规矩，先上整体架构图： Encoder and Decoder Stacks 此处的Encoder是堆叠之后的结果，每个layer是单个encoder，首先将其复制 NNN = 6次 class Encoder
手搓Transformer代码（简易版）复现
qq_50374797的博客
06-06 2041
Transformer 架构中的一个关键组件，可以用于编码器（Encoder）的自注意力（Self-Attention）、解码器（Decoder）的掩蔽自注意力（Masked Self-Attention）以及编码器-解码器（Encoder-Decoder）的注意力机制。，其中包含了多个句子，每个句子都是一个包含三个字符串的列表：中文句子（编码器输入）、带有开始符号的英文句子（解码器输入）、以及英文句子（解码器输出）。中的每个句子，并将每个句子的单词转换成对应的数字。，其中包含了三对中文到英语的句子。
第TR3周：pytorch复现transformer
03-11
好的，我现在需要帮助用户了解如何使用PyTorch实现Transformer模型。首先，我应该回顾一下PyTorch中Transformer的相关组件。记得PyTorch提供了nn.Transformer模块，包括编码器、解码器、多头注意力机制等。用户可能...
第TR1---TR3周： Pytorch复现Transformer
m0_62017984的博客
07-05 1177
主要序列转导模型基于复杂的循环或卷积神经网络，包括编码器和解码器。mechanism.性能最好的模型还通过注意力机制连接编码器和解码器。我们提出了一种新的简单网络架构——Transformer，它完全基于注意力机制，完全不需要递归和卷积。对两个机器翻译任务的实验表明，这些模型具有卓越的质量，同时具有更高的并行性，并且需要的训练时间显着减少。我们的模型在 WMT 2014 英德翻译任务中获得了 28.4 BLEU，比现有的最佳结果（包括集成）提高了 2 BLEU 以上。
（深度学习记录）第TR4周：Pytorch复现Transformer
weixin_55952636的博客
06-07 632
多头注意力机制拓展了模型关注不同位置的能力，赋予Attention层多个“子表示空间”。
TR3复现Tramsformer
tjl521314_21的博客
08-08 730
Transformer模型是深度学习中的一个革命性架构，自从在NLP领域引入以来，就因其高效处理序列数据的能力而迅速成为主流。本文将通过代码实现详细剖析Transformer模型的各个组件，包括多头注意力机制、前馈神经网络、位置编码、编码器和解码器等部分。Transformer模型由Vaswani等人在2017年提出，首次在自然语言处理任务中完全摆脱了循环神经网络（RNN），依赖于自注意力机制来处理序列数据。它不仅在机器翻译、文本生成等任务中表现优异，还在各种任务中展现了良好的扩展性和性能。
Transformer源码复现（学习笔记）
m0_74041686的博客
03-17 1215
本文详细讲解了作者学习Transformer源码的过程与思考
【论文复现】Transformer
weixin_73074012的博客
08-09 874
Transformer应用范围非常广泛，涵盖了自然语言处理、时间序列数据预测、图像处理等领域。由于笔者之前都是应用，但是对于原理并没有深刻理解导致想要进行进一步的调试难度比较大，所以学习Transformer的原理以便更加好地运用Transformer。这一篇文章写的非常好，非常清晰地展示了用代码实现Transformer的具体编程步骤以及原理解释，另外和展示了用Pytorch复现Transformer代码的全过程。
【深度学习】(2) Transformer 网络解析，代码复现，附Pytorch完整代码
博观而约取，厚积而薄发
06-27 9333
今天和各位分享一下如何使用 Pytorch 构建 Transformer 模型。本文的重点在代码复现，部分知识点介绍的不多，我会在之后的四篇博文中详细介绍 Encoder，Decoder，(Mask)MutiHeadAttention，以及实战案例。之前我也介绍过 Vision Tranformer，该模型的 Pytorch 和 TensorFlow2 的复现和实战案例可以看我的这两篇博文：https://blog.csdn.net/dgvv4/article/details/124792386ht...
手把手教你复现Transformer模型
Z4400840的博客
01-20 1392
Transformer模型是由Google在2017年发表的论文《AttentionIsAllYouNeed》中提出的一种基于注意力机制的深度学习模型架构。起初用于解决机器翻译任务中的序列到序列问题，后由于其出色的性能被广泛应用于各种自然语言处理（NLP）任务及计算机视觉（CV）等其他领域中。Transformer架构引入了。
transformer核心复现
weixin_42975688的博客
10-08 372
transformer核心复现 import torch import torch.nn.functional as F import numpy as np import math, copy, time from torch.autograd import Variable import matplotlib.pyplot as plt import seaborn seaborn.set_context(context="talk") #------------------------------主体
【传知代码】transformer-论文复现
感谢关注-最近在编写开源的自动化测试框架还没整理完
05-24 1747
Transformer模型是谷歌2017年提出的，它革新性地用自注意力机制替代了传统的CNN和RNN，解决了长距离依赖问题并实现了高效并行计算。模型包含编码器和解码器，每个由多层Transformer块组成，块内有自注意力层、前馈层并采用残差连接和层归一化。源码可在相关文章附件获取。模型通过位置编码处理序列位置信息，多头自注意力能捕捉不同层面的上下文。训练时，使用CIFAR100数据集，通过ResNet提取特征，再用PyTorch Lightning进行训练和评估。
Transformer Pytorch复现
Big_Huang的博客
05-11 911
贴一个自己根据原论文已经参考众多项目的一个transformer复现： import torch import torch.nn as nn from torch.nn import functional as F class PositionalEncoding(nn.Module): def __init__(self, din, max_len=5000): super().__init__() self.dropout = nn.Dropout(p=0.
Transformer代码复现(带详细解释）
2301_81248263的博客
05-08 695
本文介绍了Transformer模型的代码复现，重点讲解了输入部分和编码器部分的实现。输入部分包括源文本嵌入层、目标文本嵌入层及其位置编码器。文本嵌入层通过Embeddings类实现，将词汇映射为词向量，并乘以词嵌入维度的平方根。位置编码器通过PositionalEncoding类实现，使用正弦和余弦函数生成位置信息，并将其与词嵌入相加。编码器部分由多个编码器层堆叠而成，每个编码器层包含多头自注意力子层和前馈全连接子层，并通过残差连接和规范化层进行优化。多头注意力机制通过MultiHeadedAttenti
复现Transformer模型
weixin_51278988的博客
02-09 647
假如进来一句话，首先这里面有15个token，第一步经过embedding层，每一个词都是128维度的向量**[15,128]，**接着为这个embedding提供position encoding。该函数的第一个参数是输入的矩阵，第二个参数 diagonal 是一个可选参数，用于控制对角线的偏移量。在transformer中，embedding主要是为每个词提供一个向量，然后position embedding主要是提供位置信息，这里着重讲解一下一个句子进来，它是如何进行嵌入和位置相加的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值