使用 Pytorch 从头开始构建 Transformer

一、说明

二、输入嵌入

2.1 __init__()方法目的

2.2 super()

三、PositionalEncoding 类

四、位置编码的工作原理

4.1 总体过程

4.2 数学公式

五、LayerNormalization 类

5.1 过程描述

5.2 例子

六、FeedForwardBlock 类

6.1 总体描述

6.2 数学公式

七、MultiHeadAttentionBlock类

7.1. 自注意力机制

7.2. 多头注意力

八、ResidualConnection 类

九、EncoderBlock 类

十、DecoderBlock 类

十一、解码器类

十二、ProjectionLayer 类

十三、Transformer 类

十四、构建 Transformer 方法

一、说明

在今天的博客中，我们将了解 Transformer 的架构。Transformer 通过引入一种通过注意力机制捕获序列内依赖关系的新机制，彻底改变了自然语言处理 (NLP) 领域。让我们分解一下，使用 PyTorch 从头开始实现它。

来源：论文

import torch
import torch.nn as nn
import math

torch：主要的 PyTorch 库。
torch.nn：提供神经网络组件。
math：提供数学函数。

二、输入嵌入

它允许将原始句子转换为 X 维的向量（原始 Transformer 模型使用 512 作为基本版本的维度（d_model）大小，而较大版本的 d_model = 1024。）。

来源：作者

`2.1 init()`方法目的

该方法的主要目的__init__()是：

初始化对象的状态（即为对象的属性设置初始值）。
定义神经网络模块将使用的层和组件。
确保在创建对象时执行所有必要的设置或初始化代码。

`2.2 super()`

该super()函数用于调用父类的方法。

super()返回超类的临时对象，允许您调用其方法。
对于super().__init__()，它调用__init__父类的方法（nn.Module）。

在继承的上下文中使用super()尤其重要，因为它可以确保基类的初始化代码运行，设置子类可能依赖的任何必要的内部结构和属性。


class InputEmbeddings(nn.Module):

    def __init__(self, d_model: int, vocab_size: int) -> None:
        super().__init__()
        self.d_model = d_model
        self.vocab_size = vocab_size
        self.embedding = nn.Embedding(vocab_size, d_model)

    def forward(self, x):
        # (batch, seq_len) --> (batch, seq_len, d_model)
        # Multiply by sqrt(d_model) to scale the embeddings according to the paper
        return self.embedding(x) * math.sqrt(self.d_model)

nn.Embedding(vocab_size, d_model)：这会创建一个嵌入层，将索引（通常代表单词）映射到一个d_model维向量。嵌入层是随机初始化的，这些向量是在训练过程中学习的。因此，给定一个数字，它每次都会为您提供相同的向量。要了解更多信息，请参阅此链接。
self.embedding(x)：这里，x是标记索引的张量。嵌入层查找中每个标记索引的向量x。例如，如果x是 [0, 1, 2]，它会查找索引 0、1 和 2 的向量。
* math.sqrt(self.d_model)：这会将嵌入按的平方根缩放d_model。这通常是为了在嵌入通过网络时保持其方差，从而有助于训练稳定性。要了解更多信息，请参阅论文第 3.4节。

三、PositionalEncoding 类

位置编码是 Transformer 模型中的关键组成部分，它可以帮助模型理解句子中每个单词的位置。由于 Transformer 本身并不像 RNN（循环神经网络）那样以顺序方式处理标记，因此它们需要一种方法来整合标记的顺序。这是通过位置编码实现的，位置编码是添加到词嵌入中的向量。

来源：作者

以下是位置编码的工作原理及其重要性的解释：

位置编码的重要性

Transformer 同时处理整个 token 序列，这可以实现高效的并行计算，但也意味着它们缺乏有关 token 顺序的信息。位置编码提供了一种引入这种顺序信息的方法。

四、位置编码的工作原理

4.1 总体过程

嵌入大小：位置编码向量的大小与词嵌入的大小相同，通常为 512 维（在原始 Transformer 模型的情况下）。这确保位置信息可以无缝添加到嵌入中，而无需改变其维度。
创建位置编码：位置编码向量旨在表示序列中每个单词的位置。这些向量是使用不同频率的正弦和余弦函数的组合创建的。这使得模型能够以平滑和连续的方式学习和区分不同的位置。
添加位置编码：一旦生成位置编码向量，它们就会逐个元素添加到相应的词嵌入中。这种组合表示结合了来自词嵌入的语义信息和来自位置编码的位置信息。

4.2 数学公式

class PositionalEncoding(nn.Module):

    def __init__(self, d_model: int, seq_len: int, dropout: float) -> None:
        super().__init__()
        self.d_model = d_model
        self.seq_len = seq_len
        self.dropout = nn.Dropout(dropout)
        # Create a matrix of shape (seq_len, d_model)
        pe = torch.zeros(seq_len, d_model)
        # Create a vector of shape (seq_len)
        position = torch.arange(0, seq_len, dtype=torch.float).unsqueeze(1) # (seq_len, 1)
        # Create a vector of shape (d_model)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) # (d_model / 2)
        # Apply sine to even indices
        pe[:, 0::2] = torch.sin(position * div_term) # sin(position * (10000 ** (2i / d_model))
        # Apply cosine to odd indices
        pe[:, 1::2] = torch.cos(position * div_term) # cos(position * (10000 ** (2i / d_model))
        # Add a batch dimension to the positional encoding
        pe = pe.unsqueeze(0) # (1, seq_len, d_model)
        # Register the positional encoding as a buffer
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + (self.pe[:, :x.shape[1], :]).requires_grad_(False) # (batch, seq_len, d_model)
        return self.dropout(x)

__init__方法：

d_model使用（嵌入的维度）、seq_len（最大序列长度）和dropout（丢失率）进行初始化。
创建一个形状为（seq_len, d_model）的矩阵，然后位置变量计算分子，div_term 计算分母（我们已经在对数空间中计算了它以确保数值稳定性。更多信息请参考此链接。
使用正弦和余弦函数创建位置编码矩阵pe来编码位置信息。在嵌入每个单词时，偶数位置使用正弦，奇数位置使用余弦。
因为会有一批句子，所以我们需要将批次维度添加到张量（pe = pe.unsqueeze（0）），形状现在将变成（seq_len，d_model）到（1，seq_len，d_model）
用于register_buffer存储pe但不使其成为可学习的参数。

forward方法：

将位置编码添加到输入嵌入x并应用 dropout。我们还告诉模型不要学习这些 pos 编码，因为它们是固定的并且将始终相同requires_grad_(False)。

五、LayerNormalization 类

层归一化是一种通过对每个训练示例的特征输入进行归一化来改进深度神经网络训练的技术。它有助于稳定学习过程、改善收敛并减少对参数仔细初始化的依赖。

5.1 过程描述

理解输入 x

词嵌入：在 Transformer 模型中，句子中的每个单词或标记都会转换为固定大小（例如 512 维）的密集向量（嵌入）。这些嵌入捕获有关单词的语义信息。
句子表示：句子表示为这些词嵌入的序列。
这些向量是多维表示，捕捉单词含义和句法作用的各个方面。
词嵌入的维度（例如 512 个维度）被称为“特征”。
每个特征对应单词表示的特定方面。这些方面可能包括句法角色、语义含义、上下文用法等。
在 Transformer 模型中应用层归一化时，输入 x 通常是一个形状为 ( batch_size,seq_len,d_model)的三维张量，其中：
batch_size：一批中的句子或序列的数量。
seq_len：每个句子或序列中的标记数。
d_model：词嵌入的维数（例如 512）。

5.2 例子

考虑这样的例子：你有一批句子，每个句子由一系列词嵌入表示：

# Create dummy input with shape (batch_size, seq_len, d_model)
input_data = torch.randn(32, 10, 512)  # 32 sentences, each with 10 tokens, each token represented by a 512-dimensional embedding

这里：

输入张量 x 中的每个元素对应于句子中一个单词的嵌入。
层规范化将应用于每个词嵌入的最后一个维度（嵌入维度，或者我们可以说是特征）。

跨特征规范化：

对于每个标记嵌入（大小为 d_model 的向量），计算其特征的平均值和方差。
通过减去平均值并除以标准差来对嵌入进行标准化。
该过程针对每个标记独立完成，确保每个标记的嵌入根据其自身的特征值进行规范化。

来源：GPT 3.5 Turbo

参数：Gamma（γ）和Beta（β）

Gamma (γ)：这是一个可学习的尺度参数。标准化后，数据以零为中心，方差为单位。Gamma 参数允许模型缩放标准化数据。
Beta (β)：这是一个可学习的偏移参数。使用 gamma 缩放数据后，beta 参数允许模型偏移标准化数据。

注意 - Gamma 是乘法而 Beta 是加法，为什么我们使用它们？
因为我们希望模型在需要放大这些值时能够放大这些值。模型将学习以某种方式将这个 gamma 乘以这些值，以放大它想要放大的值。

class LayerNormalization(nn.Module):

    def __init__(self, features: int, eps:float=10**-6) -> None:
        super().__init__()
        self.eps = eps
        self.alpha = nn.Parameter(torch.ones(features)) # alpha is a learnable parameter
        self.bias = nn.Parameter(torch.zeros(features)) # bias is a learnable parameter

    def forward(self, x):
        # x: (batch, seq_len, hidden_size)
         # Keep the dimension for broadcasting
        mean = x.mean(dim = -1, keepdim = True) # (batch, seq_len, 1)
        # Keep the dimension for broadcasting
        std = x.std(dim = -1, keepdim = True) # (batch, seq_len, 1)
        # eps is to prevent dividing by zero or when std is very small
        return self.alpha * (x - mean) / (std + self.eps) + self.bias__init__ method:

用较小的 epsilon 值进行初始化，eps以防止被零除。
alpha将（尺度参数）和bias（移位参数）定义为可学习参数。（nn.Parameter使它们可学习）

在层规范化文献中通常表示gamma为beta

forward方法：

x通过减去平均值并除以标准差来标准化输入，然后应用alpha和bias。

六、FeedForwardBlock 类

6.1 总体描述

FeedForward 基本上是一个全连接层，Transformer 在编码器和解码器中都使用该层。它由两个线性变换组成，中间有一个 ReLU 激活。这有助于为模型添加非线性，使其能够学习更复杂的模式。

线性层：self.linear_1和self.linear_2是线性变换，将输入投影到更高维空间（d_ff）并返回到原始维数（d_model）。[您将在下面的代码中看到这一点]

6.2 数学公式

给定来自前一层的输入 x，前馈网络执行以下操作：

应用线性变换：x1 = W1x+b1
应用 ReLU 激活：x2 = ReLU(x1)
应用另一个线性变换：y = W2x2+b2

这里，W1 和 W2 是权重矩阵，b1 和 b2 是偏差向量。

class FeedForwardBlock(nn.Module):

    def __init__(self, d_model: int, d_ff: int, dropout: float) -> None:
        super().__init__()
        self.linear_1 = nn.Linear(d_model, d_ff) # w1 and b1
        self.dropout = nn.Dropout(dropout)
        self.linear_2 = nn.Linear(d_ff, d_model) # w2 and b2

    def forward(self, x):
        # (batch, seq_len, d_model) --> (batch, seq_len, d_ff) --> (batch, seq_len, d_model)
        return self.linear_2(self.dropout(torch.relu(self.linear_1(x))))

__init__方法：

用d_model（输入维度）、d_ff（前馈层的维度）和dropout（丢失率）进行初始化。
定义两个线性层，中间有一个 ReLU（torch.relu(x)将非线性引入模型）、激活和 dropout（self.dropout(x)通过在训练期间随机将一部分输入单元设置为零来防止过度拟合）。

forward方法：

应用第一个线性层、ReLU 激活、dropout，然后应用第二个线性层。

七、MultiHeadAttentionBlock类

多头注意力是 Transformer 架构的核心组件，使模型能够同时关注输入序列的不同部分。让我们分析一下多头注意力的工作原理以及它为何如此重要。

7.1. 自注意力机制

在理解多头注意力之前，理解自注意力至关重要。自注意力机制允许序列中的每个位置关注所有其他位置，从而提供这些位置的加权和。这有助于模型捕获依赖关系，而不管它们在序列中的距离如何。

自注意力过程

输入向量：假设我们有一系列输入向量 X=[x1,x2,…,xn]，其中每个 x i 都是一个 d 维向量。
查询、键、值矩阵：对于每个输入向量 xi，我们计算三个向量：查询 qi、键 ki 和值 vi。这些是使用学习到的线性变换获得的：
Q`= XWQ、K` = XWK、V` = XWV

其中 WQ、WK、WV 是学习到的权重矩阵。

缩放点积注意力：注意力得分是使用查询和键向量计算的。得分决定了每个位置应该对其他位置给予多少关注：

这里，dk 是关键向量的维度，除以 √dk 是一个缩放因子，以防止点积变得过大。

7.2. 多头注意力

多头注意力机制扩展了自注意力机制，允许模型联合关注来自不同位置的不同表示子空间的信息。该模型不再执行单个注意力函数，而是并行执行 hhh 个注意力函数（头）。

多头注意力机制

多重线性投影：对输入向量进行 h 次线性投影，以创建多组查询、键和值：

每个头部的缩放点积注意力：每组查询、键和值用于计算注意力分数和输出

注意力头的连接： hhh 注意力头的输出被连接起来：

其中 WO 是一个学习到的权重矩阵，用于将连接的输出投影回所需的维度。

来源：作者

多头注意力机制的好处

增强的表征能力：通过同时关注序列的不同部分，模型可以捕捉更复杂的关系。
减少信息丢失：多个头确保即使某些头无法捕获某些依赖关系，其他头也可能成功，从而提供更强大的表示。

class MultiHeadAttentionBlock(nn.Module):

    def __init__(self, d_model: int, h: int, dropout: float) -> None:
        super().__init__()
        self.d_model = d_model # Embedding vector size
        self.h = h # Number of heads
        # Make sure d_model is divisible by h
        assert d_model % h == 0, "d_model is not divisible by h"

        self.d_k = d_model // h # Dimension of vector seen by each head
        self.w_q = nn.Linear(d_model, d_model, bias=False) # Wq
        self.w_k = nn.Linear(d_model, d_model, bias=False) # Wk
        self.w_v = nn.Linear(d_model, d_model, bias=False) # Wv
        self.w_o = nn.Linear(d_model, d_model, bias=False) # Wo
        self.dropout = nn.Dropout(dropout)

    @staticmethod
    def attention(query, key, value, mask, dropout: nn.Dropout):
        d_k = query.shape[-1]
        # Just apply the formula from the paper
        # (batch, h, seq_len, d_k) --> (batch, h, seq_len, seq_len)
        attention_scores = (query @ key.transpose(-2, -1)) / math.sqrt(d_k)
        if mask is not None:
            # Write a very low value (indicating -inf) to the positions where mask == 0
            attention_scores.masked_fill_(mask == 0, -1e9)
        attention_scores = attention_scores.softmax(dim=-1) # (batch, h, seq_len, seq_len) # Apply softmax
        if dropout is not None:
            attention_scores = dropout(attention_scores)
        # (batch, h, seq_len, seq_len) --> (batch, h, seq_len, d_k)
        # return attention scores which can be used for visualization
        return (attention_scores @ value), attention_scores

    def forward(self, q, k, v, mask):
        query = self.w_q(q) # (batch, seq_len, d_model) --> (batch, seq_len, d_model)
        key = self.w_k(k) # (batch, seq_len, d_model) --> (batch, seq_len, d_model)
        value = self.w_v(v) # (batch, seq_len, d_model) --> (batch, seq_len, d_model)

        # (batch, seq_len, d_model) --> (batch, seq_len, h, d_k) --> (batch, h, seq_len, d_k)
        query = query.view(query.shape[0], query.shape[1], self.h, self.d_k).transpose(1, 2)
        key = key.view(key.shape[0], key.shape[1], self.h, self.d_k).transpose(1, 2)
        value = value.view(value.shape[0], value.shape[1], self.h, self.d_k).transpose(1, 2)

        # Calculate attention
        x, self.attention_scores = MultiHeadAttentionBlock.attention(query, key, value, mask, self.dropout)
        
        # Combine all the heads together
        # (batch, h, seq_len, d_k) --> (batch, seq_len, h, d_k) --> (batch, seq_len, d_model)
        x = x.transpose(1, 2).contiguous().view(x.shape[0], -1, self.h * self.d_k)

        # Multiply by Wo
        # (batch, seq_len, d_model) --> (batch, seq_len, d_model)  
        return self.w_o(x)

让我们理解上面的代码，并逐一分析为什么我们要执行这些步骤：线性投影、重塑和转置、缩放点积注意、重塑和连接以及最终线性层。

__init__方法：

使用d_model（模型的维度）、h（注意力头的数量）和dropout（丢失率）进行初始化。
确保d_model能被整除h。
w_q为查询（）、键（w_k）、值（w_v）和输出（）定义线性层w_o。

attention静态方法：

计算缩放点积注意力。
如果提供则应用掩码，计算注意力分数的 softmax，并可选择应用 dropout。

forward方法：

线性投影：

query = self.w_q(q) key = self.w_k(k) value = self.w_v(v)
这些行使用可学习权重矩阵 Wq、Wk 和 Wv 对输入张量 q、k 和 v 进行线性变换。这是计算注意力机制的查询、键和值向量的第一步。

2. 重塑和转置多头注意力机制：

query = query.view(query.shape[0], query.shape[1], self.h, self.d_k).transpose(1, 2) key = key.view(key.shape[0], key.shape[1], self.h, self.d_k).transpose(1, 2) value = value.view(value.shape[0], value.shape[1], self.h, self.d_k).transpose(1, 2)
在这里，我们重塑和转置查询、键和值张量，以准备进行多头注意。
query.view(query.shape[0], query.shape[1], self.h, self.d_k)将张量重塑为具有与头数（h）对应的单独维度。维度变为(Batch, Seq_len, h, d_k)。
.transpose(1, 2)交换序列长度和头部尺寸，得到形状为的张量(Batch, h, Seq_len, d_k)。
这使得每个注意力头能够分别处理其各自d_model维度的部分。

3.缩放点积注意力机制：

x, self.attention_scores = MultiHeadAttentionBlock.attention(query, key, value, mask, self.dropout)
此行调用静态方法attention来计算注意力分数和加权值的总和。
该attention方法使用查询、键、值张量和掩码执行缩放点积注意。

4.重塑和连接头部：

x = x.transpose(1, 2).contiguous().view(x.shape[0], -1, self.h * self.d_k)
x.transpose(1, 2)将形状从改变(Batch, h, Seq_len, d_k)回(Batch, Seq_len, h, d_k)。
.contiguous().view(x.shape[0], -1, self.h * self.d_k)重塑张量以组合头部维度，得到的形状为(Batch, Seq_len, d_model)，其中为d_model = h * d_k。
contiguous()确保张量的内存布局是连续的，这对于某些操作的效率非常重要。

5.最终线性层：

return self.w_o(x)
此行使用权重矩阵 WoW_oWo 应用最终的线性变换。
输出的形状为(Batch, Seq_len, d_model)，与输入的形状相同。

什么是 Mask？

在提供的MultiHeadAttentionBlock类中，方法中使用的掩码类型attention可以是填充掩码或前瞻掩码（因果掩码），具体取决于调用方法时如何应用它forward。掩码作为参数传递给方法forward，然后在attention静态方法中使用它。

填充掩码：用于确保输入序列中的填充标记不会影响注意力机制。将填充标记添加到序列中以确保它们在批次内的长度相同，但这些标记不包含有意义的信息，在训练和推理期间应被模型忽略。通过将填充标记的注意力分数设置为非常大的负值来确保填充标记不会影响注意力机制，从而有效地忽略它们。用于：Transformer 模型的编码器和解码器块。

编码器：防止注意力机制考虑输入序列中的填充标记。

解码器：

自我注意力：防止目标序列中的填充标记影响注意力机制。

编码器-解码器注意力：防止输入序列中的填充标记影响对编码器输出的注意力。

填充遮罩示例：

考虑一批长度不同、已经填充的序列：python


import torch
# Example input sequences (batch_size=2, seq_len=5)
input_sequences = [
    [1, 2, 3, 0, 0],  # Sequence 1, padded with 0s
    [4, 5, 6, 7, 8]   # Sequence 2, no padding
]
# Convert to tensor
input_tensor = torch.tensor(input_sequences)
# Create a padding mask where 1 indicates a valid position and 0 indicates padding
padding_mask = (input_tensor != 0).unsqueeze(1).unsqueeze(2)
print("Input Tensor:")
print(input_tensor)
print("Padding Mask:")
print(padding_mask)
#output
Input Tensor:
tensor([[1, 2, 3, 0, 0],
        [4, 5, 6, 7, 8]])

Padding Mask:
tensor([[[[ True,  True,  True, False, False]]],
        [[[ True,  True,  True,  True,  True]]]])

前瞻掩码（因果掩码）：其目的是确保在训练和推理期间，输出序列中的每个位置只能关注它之前的位置和当前位置，而不能关注任何未来的位置。这在自回归任务中至关重要，例如语言建模和文本生成，其中模型根据前面的标记预测序列中的下一个标记。用于：Transformer 模型的解码器块。

解码器中前瞻掩码的示例：

import torch
# Create a look-ahead mask
seq_len = 5
look_ahead_mask = torch.triu(torch.ones((seq_len, seq_len)), diagonal=1).bool()
print("Look-Ahead Mask:")
print(look_ahead_mask)

Look-Ahead Mask:
tensor([[False,  True,  True,  True,  True],
        [False, False,  True,  True,  True],
        [False, False, False,  True,  True],
        [False, False, False, False,  True],
        [False, False, False, False, False]])

在这个面具里：

这些True值代表不应关注的位置（未来位置）。
这些False值代表可以关注的位置（当前和过去的位置）。

八、ResidualConnection 类

残差连接的目的：残差连接或跳过连接用于帮助训练深度神经网络，使梯度更容易在网络中流动。它们本质上是“跳过”一个或多个层，直接将一个层的输入连接到堆栈下方另一层的输出。这有助于缓解梯度消失的问题，并允许更有效地训练非常深的网络。

Transformer中的典型结构：

在 Transformer 模型中，残差连接与层归一化一起使用。在多头注意层或前馈层之后，将层的原始输入添加回输出（应用该层之后），然后应用层归一化。

class ResidualConnection(nn.Module):
    def __init__(self, dropout: float) -> None:
        super().__init__()
        self.dropout = nn.Dropout(dropout)
        self.norm = LayerNormalization()

    def forward(self, x, sublayer):
        return x + self.dropout(sublayer(self.norm(x)))

__init__方法：

dropout用（辍学率）初始化。
定义 dropout 和 layer normalization。

forward方法：

应用层规范化、dropout，并添加输入x（残差连接）。

九、EncoderBlock 类

现在我们将创建包含一个多头注意力、两个 Add 和 Norm 以及一个前馈层的编码器块。

class EncoderBlock(nn.Module):
    def __init__(self, self_attention_block: MultiHeadAttentionBlock, feed_forward_block: FeedForwardBlock, dropout: float) -> None:
        super().__init__()
        self.self_attention_block = self_attention_block
        self.feed_forward_block = feed_forward_block
        self.residual_connections = nn.ModuleList([ResidualConnection(dropout) for _ in range(2)])

    def forward(self, x, src_mask):
        x = self.residual_connections[0](x, lambda x: self.self_attention_block(x, x, x, src_mask))
        x = self.residual_connections[1](x, self.feed_forward_block)
        return x

__init__方法：

用self_attention_block( 的一个实例MultiHeadAttentionBlock)、feed_forward_block( 的一个实例FeedForwardBlock) 和进行初始化dropout。
为自我注意和前馈块创建两个残差连接。

forward方法：

应用带有残差连接的自注意力模块。因此，我们在这里应用带有残差连接的自注意力模块。在这里，自注意力模块将输入 xxx 作为查询 (q)、键 (k) 和值 (v)，这就是它被称为“自注意力”的原因。本质上，输入 x 用于关注自身。这意味着句子中的每个单词都会与同一句子中的每个其他单词进行交互。
在解码器中，由于交叉注意力的存在，注意力机制的工作方式有所不同。在交叉注意力中，查询来自解码器，而键和值来自编码器。这使得解码器能够专注于编码器产生的输入序列的相关部分，而不是只关注自己的输出。
因此，自我注意力可以实现句子内的交互，而交叉注意力可以促进编码器的输出和解码器的输入之间的交互。
应用带有残差连接的前馈块。

class Encoder(nn.Module):
    def __init__(self, layers: nn.ModuleList) -> None:
        super().__init__()
        self.layers = layers
        self.norm = LayerNormalization()

    def forward(self, x, mask):
        for layer in self.layers:
            x = layer(x, mask)
        return self.norm(x)

十、DecoderBlock 类

该类DecoderBlock表示 Transformer 解码器的单个块。每个解码器块包含一个自注意力机制、一个交叉注意力机制（关注编码器的输出）和一个前馈网络，所有这些都被残差连接和层规范化所包围。

class DecoderBlock(nn.Module):
    def __init__(self, self_attention_block: MultiHeadAttentionBlock, cross_attention_block: MultiHeadAttentionBlock, feed_forward_block: FeedForwardBlock, dropout:float)->None:
        super().__init__()
        self.self_attention_block = self_attention_block
        self.cross_attention_block = cross_attention_block
        self.feed_forward_block = feed_forward_block
        self.residual_connections = nn.ModuleList([ResidualConnection(dropout) for _ in range(3)])

    def forward(self, x, encoder_output, src_mask, tgt_mask):
        x = self.residual_connections[0](x, lambda x: self.self_attention_block(x,x,x,tgt_mask))
        x = self.residual_connections[1](x, lambda x: self.cross_attention_block(x, encoder_output, encoder_output, src_mask))
        x = self.residual_connections[2](x, self.feed_forward_block)
        return x

__init__方法：

参数：
self_attention_blockMultiHeadAttentionBlock：自我注意力的实例。
cross_attention_block：MultiHeadAttentionBlock交叉注意力的实例。
feed_forward_block：的实例FeedForwardBlock。
dropout：正则化的 Dropout 率。

self.residual_connectionsResidualConnection：解码器块中每个子层的三个实例的列表。

forward方法：

参数：

x：输入张量（解码器输入）。
encoder_output：编码器的输出。
src_mask：源掩码，用于防止模型关注源输入中的填充标记。
tgt_mask：目标掩码，以防止模型关注目标序列中的未来标记（前瞻掩码）。

十一、解码器类

该类Decoder由一堆解码器块组成。它按顺序将这些块应用于输入，然后执行层规范化步骤。

class Decoder(nn.Module):

    def __init__(self, features: int, layers: nn.ModuleList) -> None:
        super().__init__()
        self.layers = layers
        self.norm = LayerNormalization(features)

    def forward(self, x, encoder_output, src_mask, tgt_mask):
        for layer in self.layers:
            x = layer(x, encoder_output, src_mask, tgt_mask)
        return self.norm(x)

__init__方法

参数：

features：输入和输出的特征数量（维数）。
layersDecoderBlock：组成解码器的实例列表。

属性：

self.layers：存储解码器块的列表。
self.norm：将层规范化应用于解码器堆栈的输出。

forward方法

参数：

x：输入张量（解码器输入）。
encoder_output：编码器的输出。
src_mask：源掩码，用于防止模型关注源输入中的填充标记。
tgt_mask：目标掩码，以防止模型关注目标序列中的未来标记（前瞻掩码）。

十二、ProjectionLayer 类

该类ProjectionLayer用于将高维向量（解码器的输出）转换为词汇表上的逻辑。此投影通常是 Transformer 模型解码器中的最后一层。

__init__方法

参数：

d_model：模型内部表示的维数（即隐藏大小）。
vocab_size：词汇表的大小，表示可能的输出标记的数量。

属性：

self.proj：nn.Linear从d_model维度到vocab_size维度映射的一个实例。

该层接收形状为的张量(batch_size, seq_len, d_model)，并对序列中的每个位置应用线性变换，得到形状为的张量(batch_size, seq_len, vocab_size)。然后可以使用该张量计算序列中每个位置的词汇表概率分布。

forward方法

参数：

x：形状为的张量(batch_size, seq_len, d_model)，其中batch_size是批次中的序列数，seq_len是每个序列的长度，d_model是模型隐藏状态的维数。

self.proj(x)：应用线性变换将d_model- 维向量投影到vocab_size序列中每个位置的 - 维 logit 中。

class ProjectionLayer(nn.Module):

    def __init__(self, d_model, vocab_size) -> None:
        super().__init__()
        self.proj = nn.Linear(d_model, vocab_size)

    def forward(self, x) -> None:
        # (batch, seq_len, d_model) --> (batch, seq_len, vocab_size)
        return self.proj(x)

这ProjectionLayer是 Transformer 模型的关键部分，因为它将模型的内部高维表示转换为适合预测词汇表中的标记的格式。此类通常用在解码器的末尾，以生成可使用 softmax 函数转换为词汇表概率的对数。

十三、Transformer 类

该类Transformer封装了整个 Transformer 模型，集成了编码器和解码器组件以及嵌入层和位置编码。以下是该类每个部分的详细说明：

class Transformer(nn.Module):

    def __init__(self, encoder: Encoder, decoder: Decoder, src_embed: InputEmbeddings, tgt_embed: InputEmbeddings, src_pos: PositionalEncoding, tgt_pos: PositionalEncoding, projection_layer: ProjectionLayer) -> None:
        super().__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.src_embed = src_embed
        self.tgt_embed = tgt_embed
        self.src_pos = src_pos
        self.tgt_pos = tgt_pos
        self.projection_layer = projection_layer

    def encode(self, src, src_mask):
        # (batch, seq_len, d_model)
        src = self.src_embed(src)
        src = self.src_pos(src)
        return self.encoder(src, src_mask)
    
    def decode(self, encoder_output: torch.Tensor, src_mask: torch.Tensor, tgt: torch.Tensor, tgt_mask: torch.Tensor):
        # (batch, seq_len, d_model)
        tgt = self.tgt_embed(tgt)
        tgt = self.tgt_pos(tgt)
        return self.decoder(tgt, encoder_output, src_mask, tgt_mask)
    
    def project(self, x):
        # (batch, seq_len, vocab_size)
        return self.projection_layer(x)

参数：

encoder：类的实例Encoder，负责对源序列进行编码。
decoder：类的实例Decoder，负责解码编码表示并生成输出序列。
src_embedInputEmbeddings：用于嵌入源序列标记的实例。
tgt_embedInputEmbeddings：用于嵌入目标序列标记的实例。
src_posPositionalEncoding：向源嵌入添加位置信息的实例。
tgt_posPositionalEncoding：向目标嵌入添加位置信息的实例。
projection_layerProjectionLayer：将解码器输出投影到词汇表大小的一个实例。

encode方法

参数：

src：形状为的源序列张量(batch_size, seq_len)。
src_mask：用于处理源序列中的填充标记的源掩码张量。

执行：

将源嵌入应用于输入张量src。
将位置编码添加到嵌入的源张量。
将结果张量与源掩码一起传递通过编码器。

输出：返回形状的源序列的编码表示(batch_size, seq_len, d_model)。

decode方法

参数：

encoder_output：来自编码器的源序列的编码表示。
src_mask：编码过程中使用的源掩码张量。
tgt：形状为的目标序列张量(batch_size, seq_len)。
tgt_mask：目标掩码张量，用于处理目标序列中的填充和未来标记。

执行：

将目标嵌入应用于输入张量tgt。
将位置编码添加到嵌入的目标张量。
将结果张量与编码器输出和相应的掩码一起传递通过解码器。

输出：返回形状的目标序列的解码表示(batch_size, seq_len, d_model)。

project方法

参数：

x：形状为的解码器的输出张量(batch_size, seq_len, d_model)。

执行：

应用投影层将d_model维度输出映射到vocab_size维度逻辑。

输出：返回形状为的 logits 张量(batch_size, seq_len, vocab_size)。

十四、构建 Transformer 方法

build_transformer通过将 Transformer 的各个组件（例如嵌入层、位置编码、编码器和解码器块以及最终的投影层）组合在一起，构建完整的 Transformer 模型。

def build_transformer(src_vocab_size: int, tgt_vocab_size: int, src_seq_len: int, tgt_seq_len: int, d_model: int=512, N: int=6, h: int=8, dropout: float=0.1, d_ff: int=2048) -> Transformer:
    # Create the embedding layers
    src_embed = InputEmbeddings(d_model, src_vocab_size)
    tgt_embed = InputEmbeddings(d_model, tgt_vocab_size)

    # Create the positional encoding layers
    src_pos = PositionalEncoding(d_model, src_seq_len, dropout)
    tgt_pos = PositionalEncoding(d_model, tgt_seq_len, dropout)
    
    # Create the encoder blocks
    encoder_blocks = []
    for _ in range(N):
        encoder_self_attention_block = MultiHeadAttentionBlock(d_model, h, dropout)
        feed_forward_block = FeedForwardBlock(d_model, d_ff, dropout)
        encoder_block = EncoderBlock(d_model, encoder_self_attention_block, feed_forward_block, dropout)
        encoder_blocks.append(encoder_block)

    # Create the decoder blocks
    decoder_blocks = []
    for _ in range(N):
        decoder_self_attention_block = MultiHeadAttentionBlock(d_model, h, dropout)
        decoder_cross_attention_block = MultiHeadAttentionBlock(d_model, h, dropout)
        feed_forward_block = FeedForwardBlock(d_model, d_ff, dropout)
        decoder_block = DecoderBlock(d_model, decoder_self_attention_block, decoder_cross_attention_block, feed_forward_block, dropout)
        decoder_blocks.append(decoder_block)
    
    # Create the encoder and decoder
    encoder = Encoder(d_model, nn.ModuleList(encoder_blocks))
    decoder = Decoder(d_model, nn.ModuleList(decoder_blocks))
    
    # Create the projection layer
    projection_layer = ProjectionLayer(d_model, tgt_vocab_size)
    
    # Create the transformer
    transformer = Transformer(encoder, decoder, src_embed, tgt_embed, src_pos, tgt_pos, projection_layer)
    
    # Initialize the parameters
    for p in transformer.parameters():
        if p.dim() > 1:
            nn.init.xavier_uniform_(p)
    
    return transformer

这是完整代码笔记本的 URL —链接

感谢您的耐心希望这会有所帮助，在下一篇博客中我将分享如何将它用于任何一个用例。