深度学习 - Transformer 组成详解

已于 2024-06-27 10:39:05 修改
阅读量463 收藏 7
点赞数 10
文章标签： 深度学习 transformer 人工智能
于 2024-06-27 10:20:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47552266/article/details/140005724
版权

整体结构

在这里插入图片描述

1. 嵌入层（Embedding Layer）

在这里插入图片描述
生活中的例子：字典查找

想象你在读一本书，你不认识某个单词，于是你查阅字典。字典为每个单词提供了一个解释，帮助你理解这个单词的意思。嵌入层就像这个字典，它将每个单词（或输入序列中的每个标记）映射到一个高维向量（解释），这个向量包含了单词的各种语义信息。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import math

class EmbeddingLayer(nn.Module):
    def __init__(self, vocab_size, d_model, max_seq_length=512):
        super(EmbeddingLayer, self).__init__()
        # vocab_size: 词汇表的大小，即输入序列中可能的不同标记的总数。
        # d_model: 每个嵌入向量的维度，即词嵌入向量的长度。
        # max_seq_length: 序列的最大长度，用于位置嵌入。
        self.embedding = nn.Embedding(vocab_size, d_model)  # 词嵌入层
        self.pos_embedding = nn.Embedding(max_seq_length, d_model)  # 位置嵌入层
        self.d_model = d_model

        # 初始化位置编码
        pe = torch.zeros(max_len, d_model)
        # 生成词位置列表
        position = torch.arange(0, max_len).unsqueeze(1)
        # 根据公式计算词位置参数
        div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))
        # 生成词位置矩阵
        my_matmulres = position * div_term
        # 给位置编码矩阵奇数列，赋值sin曲线特征
        pe[:, 0::2] = torch.sin(my_matmulres)
        # 给位置编码矩阵偶数列，赋值cos曲线特征
        pe[:, 1::2] = torch.cos(my_matmulres)

        # 形状变化 [max_seq_length,d_model]-->[1,max_seq_length,d_model]
        pe = pe.unsqueeze(0)

        # 把pe位置编码矩阵 注册成模型的持久缓冲区buffer; 模型保存再加载时，可以根模型参数一样，一同被加载
        # 什么是buffer: 对模型效果有帮助的，但是却不是模型结构中超参数或者参数，不参与模型训练
        self.register_buffer('pe', pe)

    def forward(self, x):
        seq_length = x.size(1)  # 序列长度
        pos = torch.arange(0, seq_length, device=x.device).unsqueeze(0)  # 生成位置索引
        return self.embedding(x) * math.sqrt(self.d_model) + self.pe[:,:x.size()[-1], :]  # 词嵌入和位置嵌入相加

2. 多头自注意力机制（Multi-Head Self-Attention）

在这里插入图片描述
生活中的例子：小组讨论

想象你在一个小组讨论中，每个人（每个位置上的单词）都提出自己的观点（Query），并听取其他人的意见（Key和Value）。每个人对所有其他人的观点进行加权平均，以形成自己的新观点。多头注意力机制类似于多个小组同时进行讨论，每个小组从不同的角度（头）讨论问题，然后将所有讨论结果合并在一起。

class MultiHeadSelfAttention(nn.Module):
    def __init__(self, d_model, nhead):
        super(MultiHeadSelfAttention, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        self.nhead = nhead
        self.d_model = d_model

        # 定义线性变换层
        self.q_linear = nn.Linear(d_model, d_model)
        self.k_linear = nn.Linear(d_model, d_model)
        self.v_linear = nn.Linear(d_model, d_model)
        self.out_linear = nn.Linear(d_model, d_model)

        self.scale = (d_model // nhead) ** 0.5  # 缩放因子

    def forward(self, x):
        batch_size = x.size(0)  # 获取批大小
        # 线性变换并分成多头
        q = self.q_linear(x).view(batch_size, -1, self.nhead, self.d_model // self.nhead).transpose(1, 2)
        k = self.k_linear(x).view(batch_size, -1, self.nhead, self.d_model // self.nhead).transpose(1, 2)
        v = self.v_linear(x).view(batch_size, -1, self.nhead, self.d_model // self.nhead).transpose(1, 2)

        # 计算注意力得分
        scores = torch.matmul(q, k.transpose(-2, -1)) / self.scale
        attn = torch.nn.functional.softmax(scores, dim=-1)  # 计算注意力权重
        context = torch.matmul(attn, v).transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)  # 加权求和
        out = self.out_linear(context)  # 最后一层线性变换
        return out

3. 前馈神经网络（Feed-Forward Network）

在这里插入图片描述
生活中的例子：信息过滤和处理

想象你在整理会议纪要，需要对会议地录音进行归纳、总结和补充。前馈神经网络类似于这个过程，它对输入的信息进行进一步处理和转换，以提取重要特征。

class FeedForwardNetwork(nn.Module):
    def __init__(self, d_model, dim_feedforward, dropout=0.1):
        super(FeedForwardNetwork, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在前馈神经网络中使用的dropout比率，用于正则化。
        self.linear1 = nn.Linear(d_model, dim_feedforward)  # 第一个线性层
        self.dropout = nn.Dropout(dropout)  # dropout层
        self.linear2 = nn.Linear(dim_feedforward, d_model)  # 第二个线性层

    def forward(self, x):
        return self.linear2(self.dropout(torch.nn.functional.relu(self.linear1(x))))  # 激活函数ReLU和dropout

4. 层归一化（Layer Normalization）

在这里插入图片描述
生活中的例子：团队合作中的标准化

想象你在一个团队中工作，每个人都有不同的工作习惯和标准。为了更好地合作，团队决定采用统一的工作标准（如文档格式、命名规范等）。层归一化类似于这种标准化过程，它将输入归一化，使得每个特征的均值为0，标准差为1，以稳定和加速训练。

class LayerNorm(nn.Module):
    def __init__(self, d_model, eps=1e-6):
        super(LayerNorm, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # eps: 用于数值稳定的小值，防止除以零。
        self.gamma = nn.Parameter(torch.ones(d_model))  # 缩放参数
        self.beta = nn.Parameter(torch.zeros(d_model))  # 偏移参数
        self.eps = eps  # epsilon，用于数值稳定

    def forward(self, x):
        mean = x.mean(dim=-1, keepdim=True)  # 计算均值
        std = x.std(dim=-1, keepdim=True)  # 计算标准差
        return self.gamma * (x - mean) / (std + self.eps) + self.beta  # 归一化

5. 残差连接（Residual Connection）

在这里插入图片描述
生活中的例子：备忘录

想象你在会议上记了很多笔记。为了确保不会遗漏任何重要信息，你在总结时会参照这些笔记。残差连接类似于这个过程，它将每层的输入直接加到输出上，确保信息不会在层与层之间丢失。

class ResidualConnection(nn.Module):
    def __init__(self, d_model, dropout=0.1):
        super(ResidualConnection, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # dropout: 在残差连接中使用的dropout比率，用于正则化。
        self.norm = LayerNorm(d_model)  # 层归一化
        self.dropout = nn.Dropout(dropout)  # dropout层

    def forward(self, x, sublayer):
        return x + self.dropout(sublayer(self.norm(x)))  # 残差连接

6. 编码器层（Encoder Layer）

在这里插入图片描述
生活中的例子：多轮面试

想象你在参加多轮面试，每轮面试都有不同的考官，考察不同的方面（如专业知识、沟通能力等）。每轮面试都帮助你更全面地展示自己。编码器层类似于这种多轮面试的过程，每层处理输入序列的不同方面，逐层提取和增强特征。

class EncoderLayer(nn.Module):
    def __init__(self, d_model, nhead, dim_feedforward, dropout=0.1):
        super(EncoderLayer, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.self_attn = MultiHeadSelfAttention(d_model, nhead)  # 多头自注意力机制
        self.feed_forward = FeedForwardNetwork(d_model, dim_feedforward, dropout)  # 前馈神经网络
        self.sublayers = nn.ModuleList([ResidualConnection(d_model, dropout) for _ in range(2)])  # 两个子层（注意力和前馈网络）

    def forward(self, src):
        src = self.sublayers[0](src, lambda x: self.self_attn(x))  # 应用自注意力机制
        src = self.sublayers[1](src, self.feed_forward)  # 应用前馈神经网络
        return src

7. 解码器层（Decoder Layer）

在这里插入图片描述
生活中的例子：逐步解谜

想象你在玩一个解谜游戏，每解决一个谜题（每层解码器），你都会得到新的线索，逐步解开整个谜题。解码器层类似于这种逐步解谜的过程，每层结合当前解码的结果和编码器的输出，逐步生成目标序列。

class DecoderLayer(nn.Module):
    def __init__(self, d_model, nhead, dim_feedforward, dropout=0.1):
        super(DecoderLayer, self).__init__()
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.self_attn = MultiHeadSelfAttention(d_model, nhead)  # 多头自注意力机制
        self.cross_attn = MultiHeadSelfAttention(d_model, nhead)  # 编码器-解码器注意力
        self.feed_forward = FeedForwardNetwork(d_model, dim_feedforward, dropout)  # 前馈神经网络
        self.sublayers = nn.ModuleList([ResidualConnection(d_model, dropout) for _ in range(3)])  # 三个子层（自注意力、交叉注意力、前馈网络）

    def forward(self, tgt, memory):
        tgt = self.sublayers[0](tgt, lambda x: self.self_attn(x))  # 应用自注意力机制
        tgt = self.sublayers[1](tgt, lambda x: self.cross_attn(x, memory))  # 应用编码器-解码器注意力
        tgt = self.sublayers[2](tgt, self.feed_forward)  # 应用前馈神经网络
        return tgt

8. 编码器（Encoder）

在这里插入图片描述

class Encoder(nn.Module):
    def __init__(self, num_layers, d_model, nhead, dim_feedforward, dropout=0.1):
        super(Encoder, self).__init__()
        # num_layers: 编码器层的数量，即堆叠的编码器层数。
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.layers = nn.ModuleList([EncoderLayer(d_model, nhead, dim_feedforward, dropout) for _ in range(num_layers)])  # 堆叠多个编码器层

    def forward(self, src):
        for layer in self.layers:
            src = layer(src)  # 依次通过每个编码器层
        return src

9. 解码器（Decoder）

class Decoder(nn.Module):
    def __init__(self, num_layers, d_model, nhead, dim_feedforward, dropout=0.1):
        super(Decoder, self).__init__()
        # num_layers: 解码器层的数量，即堆叠的解码器层数。
        # d_model: 输入和输出的维度，即每个位置的特征向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.layers = nn.ModuleList([DecoderLayer(d_model, nhead, dim_feedforward, dropout) for _ in range(num_layers)])  # 堆叠多个解码器层

    def forward(self, tgt, memory):
        for layer in self.layers:
            tgt = layer(tgt, memory)  # 依次通过每个解码器层
        return tgt

10. Transformer模型

class TransformerModel(nn.Module):
    def __init__(self, vocab_size, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout=0.1):
        super(TransformerModel, self).__init__()
        # vocab_size: 词汇表的大小，即输入序列中可能的不同标记的总数。
        # d_model: 每个嵌入向量的维度，即词嵌入向量的长度。
        # nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
        # num_encoder_layers: 编码器层的数量，即堆叠的编码器层数。
        # num_decoder_layers: 解码器层的数量，即堆叠的解码器层数。
        # dim_feedforward: 前馈神经网络的隐藏层维度。
        # dropout: 在各层中使用的dropout比率，用于正则化。
        self.embedding = EmbeddingLayer(vocab_size, d_model)  # 嵌入层
        self.encoder = Encoder(num_encoder_layers, d_model, nhead, dim_feedforward, dropout)  # 编码器
        self.decoder = Decoder(num_decoder_layers, d_model, nhead, dim_feedforward, dropout)  # 解码器
        self.fc = nn.Linear(d_model, vocab_size)  # 最后一层线性变换，将输出维度映射到

词汇表大小

    def forward(self, src, tgt):
        src = self.embedding(src)  # 嵌入输入序列
        tgt = self.embedding(tgt)  # 嵌入目标序列
        memory = self.encoder(src)  # 编码器处理输入序列
        output = self.decoder(tgt, memory)  # 解码器处理目标序列
        output = self.fc(output)  # 映射到词汇表大小
        return output

训练示例

# 参数
# vocab_size: 词汇表的大小，即输入序列中可能的不同标记的总数。
# d_model: 每个嵌入向量的维度，即词嵌入向量的长度。
# nhead: 注意力头的数量，多头注意力机制中并行的注意力计算数。
# num_encoder_layers: 编码器层的数量，即堆叠的编码器层数。
# num_decoder_layers: 解码器层的数量，即堆叠的解码器层数。
# dim_feedforward: 前馈神经网络的隐藏层维度。
# dropout: 在各层中使用的dropout比率，用于正则化。
# batch_size: 每个训练批次中的样本数量。
# seq_length: 输入序列的长度。
# num_epochs: 训练的轮数，即遍历整个训练集的次数。
vocab_size = 1000
d_model = 512
nhead = 8
num_encoder_layers = 6
num_decoder_layers = 6
dim_feedforward = 2048
dropout = 0.1
batch_size = 32
seq_length = 10
num_epochs = 10

# 数据集
src = torch.randint(0, vocab_size, (batch_size, seq_length))
tgt = torch.randint(0, vocab_size, (batch_size, seq_length))

dataset = TensorDataset(src, tgt)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 模型实例
model = TransformerModel(vocab_size, d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout)

# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练
for epoch in range(num_epochs):
    for src_batch, tgt_batch in dataloader:
        tgt_input = tgt_batch[:, :-1]  # 目标输入
        tgt_output = tgt_batch[:, 1:]  # 目标输出

        optimizer.zero_grad()
        output = model(src_batch, tgt_input)  # 前向传播
        output = output.permute(1, 2, 0)  # 调整形状以匹配损失函数
        loss = criterion(output, tgt_output)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}")

print("训练完成")

代码说明

  1. EmbeddingLayer：将输入序列和位置嵌入映射到高维空间。
  2. MultiHeadSelfAttention：实现多头自注意力机制，包括查询、键和值的线性变换和注意力计算。
  3. FeedForwardNetwork：前馈神经网络，用于进一步处理特征。
  4. LayerNorm：层归一化，用于稳定训练过程。
  5. ResidualConnection：残差连接，帮助训练更深的网络。
  6. EncoderLayer：将多头自注意力机制和前馈神经网络组合在一起，形成编码器层。
  7. DecoderLayer：包括多头自注意力机制、编码器-解码器注意力和前馈神经网络，形成解码器层。
  8. Encoder：由多个编码器层堆叠而成。
  9. Decoder：由多个解码器层堆叠而成。
  10. TransformerModel：将编码器和解码器组合在一起，形成完整的Transformer模型。
想胖的壮壮
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
transformer详解.docx
08-07
Transformer是深度学习领域的一种革命性模型，首次在2017年的论文《Attention is All You Need》中提出，主要用于自然语言处理任务。该模型的核心特点是放弃了传统的RNN（循环神经网络）和CNN（卷积神经网络）中的...
详解深度学习系统的训练技巧-综合文档
05-22
此外，卷积神经网络（CNN）在图像处理中，循环神经网络（RNN）在序列数据处理，以及Transformer在NLP任务中的应用也是深度学习的重要组成部分。 优化器的选择也至关重要。传统的梯度下降算法可能收敛速度慢，Adam、...
Transformer详详祥解！！！
m0_50345460的博客
06-22 791
query 、 key 、 value 的概念其实来源于推荐系统。基本原理是：给定一个 query，计算query 与 key 的相关性，然后根据query 与 key 的相关性去找到最合适的 value。举个例子：在电影推荐中。query 是某个人对电影的喜好信息（比如兴趣点、年龄、性别等）、key 是电影的类型（喜剧、年代等）、value 就是待推荐的电影。
深度学习-Transformer详解
fzz97_的博客
02-06 9567
主要介绍了Transformer模型，注意力机制
Swin-Transformer网络结构详解
霹雳吧啦Wz
11-03 21万+
文章目录0 前言1 网络整体框架2 Patch Merging详解3 W-MSA详解Ω(MSA)\Omega (MSA)Ω(MSA)模块计算量Ω(W−MSA)\Omega (W-MSA)Ω(W−MSA)模块计算量4 SW-MSA详解5 Relative Position Bias详解6 模型详细配置参数 0 前言 Swin Transformer是2021年微软研究院发表在ICCV上的一篇文章，并且已经获得ICCV 2021 best paper的荣誉称号。Swin Transformer网络是Tran
Swin-Transformer 详解
m0_47005029的博客
03-10 2702
最全的介绍关于Swin-Transformer
Vision Transformer详解
热门推荐
霹雳吧啦Wz
06-26 24万+
论文名称： An Image Is Worth 16x16 Words: Transformers For Image Recognition At Scale 论文下载链接：https://arxiv.org/abs/2010.11929 原论文对应源码：https://github.com/google-research/vision_transformer Pytorch实现代码： pytorch_classification/vision_transformer 文章目录前言模型详解Vision
TR3 - Transformer算法详解
Loser
04-05 817
本周在理论上学习了Transformer模型的结构、组成、训练过程。让我印象最深刻的就是Seq2Seq模型不仅有一个输入头，它的编码器是和CV模型共通的，但是编码器也有输入，并且先每个时间步只输出一个单词，这点和RNN一样并没有什么变化。这也制约了NLP任务的训练和推理。另外我没想到它的损失函数竟然和最基础的分类网络一样，用简单的交叉熵损失就可以。
【论文阅读】Swin-transformer网络结构详解
aixiaomi123的博客
01-19 2152
Swin-transformer 网络架构详解
【深度学习】详解 Vision Transformer (ViT)
闻韶
07-18 9万+
【深度学习】详解 Vision Transformer (ViT)
【动手学深度学习-Pytorch版】Transformer代码总结
qq_43858783的博客
10-05 750
手撸Transformer代码（李沐老师上课代码~）
深度学习java及其算法详解
09-05
在“深度学习java及其算法详解”这一资源中，我们探讨的是如何将Java编程语言与深度学习技术相结合，以及深入理解基础的计算机科学概念，特别是数据结构和算法。Java是一种广泛应用于企业级应用、移动开发（如...
Transformer 系列训练库代码 mmcv-1.2.7
02-25
`mmcv`是一个高性能的计算机视觉基础库，尤其在深度学习领域，它为Transformer模型的训练提供了强大的支持。Transformer模型，由Vaswani等人在2017年的论文《Attention is All You Need》中提出，已经逐渐成为自然...
【深度学习】数据增强基本介绍和常用的数据增强方法
F2ancisZ的博客
07-06 841
常用于深度学习模型的数据增强方法。包括传统基于图像处理的几何变换方法和基于GAN、领域自适应、主动学习等模型的方法。欢迎讨论。
【MindSpore学习打卡】应用实践-自然语言处理-深入理解LSTM+CRF在序列标注中的应用
最新发布
weixin_43427267的博客
07-08 1131
CRF是一种概率图模型，适用于捕获序列中相邻Token之间的依赖关系。设xx0xnxx0​...xn​为输入序列，yy0ynyy0​...yn​为输出的标注序列，其中nnn为序列的最大长度。则输出序列yyyPy∣xexp⁡Scorexy∑y′∈Yexp⁡Scorexy′Py∣x∑y′∈Y​expScorexy′expScorexy​其中，Scorexy。
动手学深度学习（Pytorch版）代码实践 -循环神经网络-55循环神经网络的从零开始实现和简洁实现
李思成的博客
07-06 614
【代码】动手学深度学习（Pytorch版）代码实践 -循环神经网络-54~55循环神经网络的从零开始实现和简洁实现。
深度学习中的超参数及超参数搜索算法
qlkaicx的博客
07-08 487
在深度学习中，超参数（Hyperparameters）是指在训练模型时需要预先设置的参数，它们不会在训练过程中自动更新，而是通过手动调整来优化模型的性能。超参数的设置对模型的训练效果有着至关重要的影响。
基于深度学习的高压线路巡线
weixin_42605076的博客
07-07 620
基于深度学习的高压线路巡线是一项通过无人机、机器人或固定摄像头等设备采集图像和视频数据，并利用深度学习技术自动检测和分析高压线路状态的技术。这项技术旨在提高巡检效率、降低人工成本和提升电力系统的安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值