Pytorch复现Transformer

已于 2024-10-04 07:36:30 修改
阅读量481 收藏 6
点赞数 3
文章标签： pytorch transformer 人工智能
于 2024-10-04 07:27:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52447211/article/details/142698652
版权

文章目录

第TR3周：Pytorch复现Transformer

在这里插入图片描述

1.多头注意力机制

在这里插入图片描述

import math
import torch
import torch.nn as nn

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

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]     ## batch_size
        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)    ## python中的-1 ？？
        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，
        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)    ## 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_mdoel, dropout, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        
        ## 初始化Shape为(max_len, d_model)的PE(positional encoding)
        pe = torch.zeros(max_len, d_model).to(device)
        
        ## 初始化一个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和positional 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):
        ## 自注意力机制
        attn_output = self.self_attn(x, x, x, mask)
        x = x + self.dropout(attn_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_layers, n_decoder_layers, 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_layers)])
        self.decoder_layers = nn.ModuleList([DecoderLayer(d_model, n_heads, d_ff, dropout) for _ in range(n_decoder_layers)])
        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])

总结

本周主要学习了解了Transformer，通过代码对于Transformer有了一个全面的了解，其中重点了解Transformer的自注意力机制。

计算机真好丸
关注
第TR3周：Pytorch复现Transformer
lihuhelihu的博客
08-02 1524
Transformer可以看作是seq2seq模型的一种，因此，先从seq2seq的角度对Transformer进行宏观结构的学习。下图1先便是Transformer整体结构图，与seq2seq模型类似，Transformer模型结构中的左半部分为编码器，右半部分为解码器，下面我们来一步步拆解Transformer。在某种程度上，可以将Transformer看作是Seq2Seq的一种演变，Transformer可以执行Seq2Seq任务，并且相对于传统的Seq2Seq模型具有更好的性能和可扩展性。
第26周：Pytorch复现Transformer
weixin_46620278的博客
09-28 910
🍨 本文为 [🔗365天深度学习训练营] 中的学习记录博客[K同学啊]从整体上把握Transformer模型，明白它是个什么东西，可以干嘛读懂Transformer的复现代码一、基本概念对Transformer和自注意力机制的基本概念进行了解，并结合代码进行实际学习操作[🔗365天深度学习训练营][K同学啊]
使用Pytorch复现Transformer
weixin_54561434的博客
08-04 289
使用Pytorch复现Transformer，并完成机器翻译任务(法语 -> 英文、英文 -> 中文)
Pytorch复现 Transformer cssdn
qq_60245590的博客
03-29 695
这表示对于每个批次中的32个样本的每个位置，模型都会输出一个10000维的向量，向量表示每个词汇的分数或概率。使用PyTorch框架初始化一个Transformer模型，并为模型的源和目标序列生成随机数据以及对应的掩码。这段代码是构建Transformer模型的核心，通常用于机器翻译、文本摘要、问答系统等自然语言处理任务。代码通过模型进行前向传播，并打印输出的形状。根据Transformer模型的设计，输出的形状应该是。
Transformer Pytorch复现
Big_Huang的博客
05-11 844
贴一个自己根据原论文已经参考众多项目的一个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.
（深度学习记录）第TR4周：Pytorch复现Transformer
weixin_55952636的博客
06-07 574
多头注意力机制拓展了模型关注不同位置的能力，赋予Attention层多个“子表示空间”。
第TR1---TR3周： Pytorch复现Transformer
m0_62017984的博客
07-05 1085
主要序列转导模型基于复杂的循环或卷积神经网络，包括编码器和解码器。mechanism.性能最好的模型还通过注意力机制连接编码器和解码器。我们提出了一种新的简单网络架构——Transformer，它完全基于注意力机制，完全不需要递归和卷积。对两个机器翻译任务的实验表明，这些模型具有卓越的质量，同时具有更高的并行性，并且需要的训练时间显着减少。我们的模型在 WMT 2014 英德翻译任务中获得了 28.4 BLEU，比现有的最佳结果（包括集成）提高了 2 BLEU 以上。
（深度学习记录）第TR2周：Pytorch复现Transformer
weixin_55952636的博客
05-16 459
【代码】（深度学习记录）第TR2周：Pytorch复现Transformer。
Transformer 模型 pytorch 复现代码+注解+推理测试
Illusionna_的博客
07-10 232
【代码】Transformer 模型 pytorch 复现代码+注解+推理测试。
基于Pytorch复现Point-Transformer，用于ShapeNet数据集点云分割
04-25
基于Point Transformers复现点云分割任务 ## 准备数据： 使用连接下载 **ShapeNet** 数据集 ## 训练： ```bash python train.py ``` ## 实验结果： | Models | Accuracy | cat.mIOU | ins.mIOU | | -------...
从零复现transformer-基于pytorch复现内含数据集.zip
04-16
从零复现transformer-基于pytorch复现内含数据集 本项目是一个基于PyTorch的Transformer模型的复现项目，旨在帮助用户从零开始理解和实现Transformer模型。项目包含数据集和预训练模型，方便用户快速部署和使用。 ...
transformer-使用Pytorch实现Transformer-项目源码-附完整复现细节.zip
10-21
transformer_使用Pytorch实现Transformer_项目源码_附完整复现细节
基于Pytorch复现Point-Transformer，用于ShapeNet数据集点云分割_Point-Transfor
09-16
基于Pytorch复现Point-Transformer，用于ShapeNet数据集点云分割_Point-Transformer-Pytorch
PyTorch：torchvision中的dataset的使用
m0_73640344的博客
11-11 401
通过有效利用和transforms，研究者和开发者可以更高效地进行图像数据的加载和预处理，这对于构建和训练深度学习模型至关重要。正确理解这些工具的使用方法和配置参数，将帮助用户避免常见问题，优化模型训练流程。
pytorch量化训练
最新发布
程序员深度学习
11-11 496
可以应用到模型的特定部分或整个模型上model.fc1.qconfig = custom_qconfig # 应用到模型的一个特定层和# 应用到整个模型。
运用PyTorch创建模型
算法与编程之美
11-11 271
1 问题如何导入数据集？如何优化模型参数？2 方法步骤1：导入必要的库首先，我们需要导入PyTorch库。你可以使用以下命令来安装PyTorch接下来，导入必要的库：我们将参数传递给 。这将在我们的数据集上包装一个可迭代对象，并支持 自动配料、采样、洗牌和多进程数据加载。在这里，我们定义一个 64 的批大小，即每个元素 在数据加载器中，可迭代将返回一批 64 个特征和标签。步骤2：定义神经网络模型...
常用的损失函数pytorch实现
啾啾的博客
11-11 117
一些常用的损失函数实现
基于YOLOv8模型的安全背心目标检测系统（PyTorch+Pyside6+YOLOv8模型）
BestSongC的博客
11-10 607
基于YOLOv8模型的安全背心目标检测系统可用于日常生活中检测与定位安全背心目标，利用深度学习算法可实现图片、视频、摄像头等方式的目标检测，另外本系统还支持图片、视频等格式的结果可视化与结果导出
Pytorch无法使用GPU的问题的原因
m0_73640344的博客
11-11 104
从你提供的信息来看，尽管你的环境中安装了与CUDA相关的库（如libcublas等），但PyTorch还是无法使用GPU。False。
transformer pytorch复现
09-09
要在PyTorch中复现transformer模型，可以使用point-transformer-pytorch库进行安装和导入。首先，使用命令`pip install point-transformer-pytorch`来安装这个库。然后，从point_transformer_pytorch库中导入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值