【一文读懂】讲透强大的算法模型“Transformer”-CSDN博客

本文链接：https://blog.csdn.net/u011376987/article/details/141760387

Transformer 模型是一种基于注意力机制的深度学习模型，广泛应用于自然语言处理（NLP）任务，如机器翻译、文本生成和语义理解。

它最初由 Vaswani 等人在2017年的论文《Attention is All You Need》中提出。它突破了传统序列模型（如RNN和LSTM）的局限，能够并行处理序列数据，从而大大提高了训练效率和模型性能。

Transformer 模型的基本结构

Transformer 模型由两个主要部分组成：编码器（Encoder）和解码器（Decoder）。

编码器将输入序列编码为一个固定长度的上下文向量，解码器则根据这个上下文向量生成输出序列。

编码器和解码器各由多个层（Layer）堆叠而成。

与编码器中的FFN相同，用于对注意力机制的输出进行非线性变换。

编码器（Encoder）

编码器的主要作用是将输入序列转换为一组上下文向量，供解码器使用。

每个编码器层包括两个主要的子层：

每个子层之后都会使用残差连接（Residual Connection）和层归一化（Layer Normalization），这有助于避免梯度消失问题并加快训练收敛速度。
- 多头自注意力机制（Multi-Head Self-Attention）
  
  捕捉输入序列中不同位置之间的依赖关系。
  
  通过不同的注意力头（Attention Heads），模型可以从多个不同的角度来看待输入序列。
- 前馈神经网络（Feed-Forward Neural Network, FFN）
  
  对经过注意力机制处理的序列进行进一步的非线性变换。
解码器（Decoder）

与编码器类似，解码器也由多个层组成，每个解码器层包含三个子层：

每个子层同样有残差连接和层归一化。
- 掩码多头自注意力机制
  
  与编码器中的多头自注意力机制类似，但在解码器中，解码器的多头自注意力机制是掩蔽（Masked）的，防止在预测下一个单词时看到未来的信息。
- 编码器-解码器多头注意力机制（Encoder-Decoder Attention）
  
  该注意力机制允许解码器访问编码器的输出，这样解码器就可以根据编码器生成的上下文向量来生成输出序列。
- 前馈神经网络（Feed-Forward Neural Network, FFN）
  
  核心组件
  
  下面，我们来详细描述一下 Transformer 中的核心组件。

1.输入嵌入

输入嵌入是将输入文本序列中的单词或符号映射为高维向量的过程。

在 Transformer 模型中，文本首先被标记化为单词或子词，然后每个标记被映射为一个固定长度的向量。

这些向量通常是通过查找嵌入矩阵（embedding matrix）得到的，该矩阵是在训练过程中学习得到的。

输入嵌入的作用是将离散的符号转换为连续的、可以直接输入到神经网络中的向量表示，使得模型能够处理和理解输入数据。

2.位置编码

位置编码（Positional Encoding）是 Transformer 模型中的一个关键组件，用于在模型中引入序列位置信息。

由于 Transformer 模型不使用传统的循环神经网络（RNN）结构，它无法像这些传统模型那样通过其结构直接捕获输入数据的位置信息。因此，需要通过位置编码来显式地提供序列中的位置信息。

位置编码通常使用正弦和余弦函数来生成。

对于位置 pos 和嵌入维度中的第 $2i$ 个维度

$PE(pos,2i)=sin(\frac{pos}{10000_{}^{2i/d_{model}}})$

对于位置 pos 和嵌入维度中的第 $2i + 1$ 个维度：

$PE(pos,2i+1)=cos(\frac{pos}{10000_{}^{2i/d_{model}}})$

其中：

$pos$ 是位置索引。
$i$ 是维度索引。
$d_{model}$ 是嵌入向量的维度。

3.自主力机制

自注意力机制是 Transformer 的核心创新之一。

它允许模型在计算某个位置的输出时，考虑输入序列中所有其他位置的信息。

具体地，对于每个输入位置，自注意力机制会计算该位置与其他所有位置的相似度（通过点积操作），并使用这些相似度作为权重来加权求和其他位置的输入表示。

自注意力机制的关键步骤包括：

Query、Key、Value 向量的生成

对输入嵌入进行线性变换，生成三个不同的向量，即查询向量（Query）、键向量（Key）和值向量（Value）。

每个输入向量 $x_{i}$ ，通过三个线性变换分别映射为查询向量 $Q_{i}$ 、键向量 $K_{i}$ 和值向量 $V_{i}$ 。

这些向量用于后续的注意力计算。

$Q_{i}=W_{Q}*x_{i}$ ， $K_{i}=W_{K}*x_{i}$ ， $V_{i}=W_{V}*x_{i}$

其中， $W_{Q}$ 、 $W_{K}$ 和 $W_{V}$ 是可学习的权重矩阵。
注意力得分的计算

通过点积计算查询向量与所有键向量之间的相似度，得到注意力得分矩阵。

对于每个查询向量 $Q_{i}$ ，通过点积的方式计算它与所有键向量 $K_{i}$ 的相似度，得到注意力分数。

$Attention Score(i,j)=Q_{i}*K_{j}^{T}$

为了稳定训练过程，这些分数会除以，其中是键向量的维度。

$Scale Attention Score(i,j)=\frac{Q_{i}*K_{j}^{T}}{\sqrt{d_{k}}}$
加权求和

使用Softmax函数将注意力得分转换为权重，然后对所有值向量进行加权求和，得到最终的输出表示。

$\alpha _{ij}=Softmax(\frac{Q_{i}*K_{j}^{T}}{\sqrt{d_{k}}})$

$Attention Output(i)=\sum_{i}\alpha_{ij}*V_{j}$

4.多头注意力机制

多头注意力机制是对自注意力机制的扩展。

通过并行地执行多次自注意力机制，可以让模型从不同的角度（即不同的“头”）学习输入序列中的信息。

每个头都有自己独立的查询、键和值的线性变换，然后分别执行自注意力操作，最后将这些头的输出进行拼接，并通过线性变换生成最终的多头注意力输出。

具体来说，假设有 h 个注意力头，每个头分别计算如下：

$head_{i}=Attendtion(QW_{i}^{Q},KW_{i}^{K},VW_{i}^{V})$

其中， $W_{i}^{Q}$ , $W_{i}^{K}$ , $W_{i}^{V}$ 是第 i 个头的查询、键和值的权重矩阵。

然后，将所有头的输出连接起来，并通过线性变换：

$MultiHead(Q,K,V)=Concat(head_{1},head_{2},...,head_{h})W_{}^{O}$

其中， $W_{}^{O}$ 是输出的权重矩阵。

多头注意力机制的优点在于它能够捕捉到不同的语义关系和特征，从而增强模型的表达能力。

5.前馈神经网络

每个编码器和解码器层中的前馈神经网络是一个两层的全连接神经网络，作用是对每个位置的表示进行独立的非线性变换。

公式表示如下：

$FFN(x)=ReLU(xW_{1}+b_{1})W_{2}+b_{2}$

其中， $W_{1}$ 和 $W_{2}$ 是权重矩阵， $b_{1}$ 和 $b_{2}$ 是偏置向量。

6. 层归一化和残差连接

为了防止深层网络的梯度消失问题，Transformer 在每个子层后使用了残差连接，并紧跟层归一化。

$Output=LaerNorm(x+SubLayer(x))$

其中，SubLayer(x) 可以是多头注意力机制或前馈神经网络的输出。

7.掩码多头自注意力

在标准的多头注意力机制中，每个位置的查询（Query）会与所有位置的键（Key）进行点积计算，得到注意力分数，然后与值（Value）加权求和，生成最终的输出。

然而，在解码器中，生成序列时不能访问未来的信息。因此需要使用掩码（Mask）机制来屏蔽掉未来位置的信息。

具体来说，在计算注意力得分时，对未来的位置进行屏蔽，将这些位置的得分设为负无穷大，使得 Softmax 归一化后的权重为零。

8.编码器-解码器多头注意力

在解码器中的 Multi-head Attention 也叫做 Encoder-Decoder Attention，它的 Query 来自解码器的 self-attention，而 Key、Value 则是编码器的输出。

案例代码

下面是一个使用 PyTorch 实现 Transformer 模型的简单示例代码。

该示例展示了如何构建一个基本的 Transformer 模型并使用它进行序列到序列的任务，例如机器翻译。

import torch
import torch.nn as nn
import torch.optim as optim
import math

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super(PositionalEncoding, self).__init__()
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return x

class TransformerModel(nn.Module):
    def __init__(self, input_dim, output_dim, d_model=512, nhead=8, num_encoder_layers=6, dim_feedforward=2048, dropout=0.1):
        super(TransformerModel, self).__init__()
        self.model_type = 'Transformer'
        self.embedding = nn.Embedding(input_dim, d_model)
        self.pos_encoder = PositionalEncoding(d_model)
        encoder_layers = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, num_encoder_layers)
        self.d_model = d_model
        self.decoder = nn.Linear(d_model, output_dim)
        self.init_weights()

    def init_weights(self):
        initrange = 0.1
        self.embedding.weight.data.uniform_(-initrange, initrange)
        self.decoder.bias.data.zero_()
        self.decoder.weight.data.uniform_(-initrange, initrange)

    def forward(self, src, src_mask):
        src = self.embedding(src) * math.sqrt(self.d_model)
        src = self.pos_encoder(src)
        output = self.transformer_encoder(src, src_mask)
        output = self.decoder(output)
        return output

def generate_square_subsequent_mask(sz):
    mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
    mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
    return mask

# Example usage:
input_dim = 1000  # Vocabulary size
output_dim = 1000  # Output size
seq_length = 10  # Length of the sequence

# Create the model
model = TransformerModel(input_dim=input_dim, output_dim=output_dim)

# Example data
src = torch.randint(0, input_dim, (seq_length, 32))  # (sequence_length, batch_size)
src_mask = generate_square_subsequent_mask(seq_length)

# Forward pass
output = model(src, src_mask)
print(output.shape)  # Expected output: [sequence_length, batch_size, output_dim]

# Define a simple loss and optimizer for training
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Example training loop
for epoch in range(10):  # Number of epochs
    optimizer.zero_grad()
    output = model(src, src_mask)
    loss = criterion(output.view(-1, output_dim), src.view(-1))
    loss.backward()
    optimizer.step()
    print(f"Epoch {epoch+1}, Loss: {loss.item()}")