{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6cd99759-6edf-44cf-94bc-b8e23fb060f5",
   "metadata": {},
   "source": [
    "# 动手实现 Transformer\n",
    "\n",
    "> ![模型架构图](../assets/20241023202539.png)\n",
    ">\n",
    "> 《[Transformer 论文精读](https://github.com/Hoper-J/AI-Guide-and-Demos-zh_CN/blob/master/PaperNotes/Transformer%20论文精读.md)》\n",
    "\n",
    "当前代码文件将从零开始构建 Transformer（PyTorch 版），建议结合文章进行理解。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "900cd475-50fe-4c40-89f4-9f1992ad6641",
   "metadata": {},
   "source": [
    "# 导入库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "32f2efe0-bec1-4b47-b595-7d187e184573",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import math\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d2d6714-ba07-45f7-822f-89004f914787",
   "metadata": {},
   "source": [
    "# 子模块"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e878aefc-3014-4f1d-b060-1881d555d2ff",
   "metadata": {},
   "source": [
    "## 缩放点积注意力机制\n",
    "\n",
    "> ![缩放点积注意力机制](../assets/image-20241024010439683.png)\n",
    "\n",
    "给定查询矩阵 $Q$、键矩阵 $K$ 和值矩阵 $V$, 其注意力输出的数学表达式如下：\n",
    "\n",
    "$$\n",
    "\\text{Attention}(Q, K, V) = \\text{Softmax}\\left(\\frac{Q K^\\top}{\\sqrt{d_k}}\\right) V\n",
    "$$\n",
    "\n",
    "- **$Q$（Query）**: 用于查询的向量矩阵。\n",
    "- **$K$（Key）**: 表示键的向量矩阵，用于与查询匹配。\n",
    "- **$V$（Value）**: 值矩阵，注意力权重最终会作用在该矩阵上。\n",
    "- **$d_k$**: 键或查询向量的维度。\n",
    "\n",
    "> 理解 Q、K、V 的关键在于代码，它们实际上是通过线性变换从输入序列生成的，“故事”的延伸更多是锦上添花。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "579ac151-68dc-4900-b4b9-a0b85de0fa0c",
   "metadata": {},
   "source": [
    "### 代码实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d06f5849-0ca2-4813-a980-0601d6e4a811",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scaled_dot_product_attention(Q, K, V, mask=None):\n",
    "    \"\"\"\n",
    "    缩放点积注意力计算。\n",
    "    \n",
    "    参数:\n",
    "        Q: 查询矩阵 (batch_size, seq_len_q, embed_size)\n",
    "        K: 键矩阵 (batch_size, seq_len_k, embed_size)\n",
    "        V: 值矩阵 (batch_size, seq_len_v, embed_size)\n",
    "        mask: 掩码矩阵，用于屏蔽不应该关注的位置 (可选)\n",
    "\n",
    "    返回:\n",
    "        output: 注意力加权后的输出矩阵\n",
    "        attention_weights: 注意力权重矩阵\n",
    "    \"\"\"\n",
    "    embed_size = Q.size(-1)  # embed_size\n",
    "    \n",
    "    # 计算点积并进行缩放\n",
    "    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(embed_size)\n",
    "\n",
    "    # 如果提供了掩码矩阵，则将掩码对应位置的分数设为 -inf\n",
    "    if mask is not None:\n",
    "        scores = scores.masked_fill(mask == 0, float('-inf'))\n",
    "\n",
    "    # 对缩放后的分数应用 Softmax 函数，得到注意力权重\n",
    "    attention_weights = F.softmax(scores, dim=-1)\n",
    "\n",
    "    # 加权求和，计算输出\n",
    "    output = torch.matmul(attention_weights, V)\n",
    "    \n",
    "    return output, attention_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2119dce1-6068-431f-9ce0-4ce79c1f099f",
   "metadata": {},
   "source": [
    "### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7d6a396f-a49e-4e46-b596-2cb60625d525",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "掩码矩阵 (下三角):\n",
      "tensor([[1., 0., 0.],\n",
      "        [1., 1., 0.],\n",
      "        [1., 1., 1.]])\n",
      "\n",
      "注意力权重矩阵:\n",
      "tensor([[[[1.0000, 0.0000, 0.0000],\n",
      "          [0.5846, 0.4154, 0.0000],\n",
      "          [0.2771, 0.3745, 0.3484]],\n",
      "\n",
      "         [[1.0000, 0.0000, 0.0000],\n",
      "          [0.5960, 0.4040, 0.0000],\n",
      "          [0.4905, 0.0164, 0.4931]]],\n",
      "\n",
      "\n",
      "        [[[1.0000, 0.0000, 0.0000],\n",
      "          [0.1829, 0.8171, 0.0000],\n",
      "          [0.5957, 0.2515, 0.1528]],\n",
      "\n",
      "         [[1.0000, 0.0000, 0.0000],\n",
      "          [0.1707, 0.8293, 0.0000],\n",
      "          [0.2848, 0.3710, 0.3442]]]])\n"
     ]
    }
   ],
   "source": [
    "# 示例参数\n",
    "batch_size = 2\n",
    "num_heads = 2\n",
    "seq_len_q = 3  # 查询序列长度\n",
    "seq_len_k = 3  # 键序列长度\n",
    "head_dim = 4\n",
    "\n",
    "# 模拟查询矩阵 Q 和键值矩阵 K, V\n",
    "Q = torch.randn(batch_size, num_heads, seq_len_q, head_dim)\n",
    "K = torch.randn(batch_size, num_heads, seq_len_k, head_dim)\n",
    "V = torch.randn(batch_size, num_heads, seq_len_k, head_dim)\n",
    "\n",
    "# 生成下三角掩码矩阵 (1, 1, seq_len_q, seq_len_k)，通过广播应用到所有头\n",
    "mask = torch.tril(torch.ones(seq_len_q, seq_len_k)).unsqueeze(0).unsqueeze(0)  # mask.shape (seq_len_q, seq_len_k) -> (1, 1, seq_len_q, seq_len_k)\n",
    "\n",
    "# 执行缩放点积注意力，并应用下三角掩码\n",
    "output, attn_weights = scaled_dot_product_attention(Q, K, V, mask)\n",
    "\n",
    "# 打印结果\n",
    "print(\"掩码矩阵 (下三角):\")\n",
    "print(mask[0, 0])\n",
    "\n",
    "print(\"\\n注意力权重矩阵:\")\n",
    "print(attn_weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c944951c-f9f4-478d-9286-035c66fe01d1",
   "metadata": {},
   "source": [
    "## 多头注意力机制（Multi-Head Attention）\n",
    "\n",
    "多头注意力机制在 Transformer 中发挥着与卷积神经网络（CNN）中的**卷积核**（Kernel）类似的作用。CNN 使用多个不同的卷积核在空间域上捕捉不同的局部特征，而 Transformer 的多头注意力通过**多个头**（Head）并行地关注输入数据在不同维度上的依赖关系。\n",
    "\n",
    "### 数学表达\n",
    "\n",
    "假设我们有 $h$ 个头，每个头拥有独立的线性变换矩阵 $W_i^Q, W_i^K, W_i^V$（分别作用于查询、键和值的映射），每个头的计算如下：\n",
    "\n",
    "$$\n",
    "\\text{head}_i = \\text{Attention}(Q W_i^Q, K W_i^K, V W_i^V)\n",
    "$$\n",
    "\n",
    "这些头的输出将沿最后一维拼接（**Concat**），并通过线性变换矩阵 $W^O$ 映射回原始嵌入维度（`embed_size`）：\n",
    "\n",
    "$$\n",
    "\\text{MultiHead}(Q, K, V) = \\text{Concat}(\\text{head}_1, \\dots, \\text{head}_h) W^O\n",
    "$$\n",
    "\n",
    "- **$h$**：注意力头的数量。\n",
    "- **$W^O$**：拼接后所通过的线性变换矩阵，用于将多头的输出映射回原始维度。  \n",
    "\n",
    "> ![Encoder](../assets/image-20241027191251526.png)\n",
    ">\n",
    "> 映射回原始维度的主要目的是为了实现残差连接（Residual Connection），即：\n",
    ">\n",
    "> $x + \\text{SubLayer}(x)$\n",
    ">\n",
    "> 你将发现其他模块（如自注意力模块、多头注意力机制和前馈网络）的输出层大多都是一样的维度，这是因为只有当输入 $x$ 的形状与经过层变换后的输出 $\\text{SubLayer}(x)$ 的形状一致时，才能按预期的进行逐元素相加（element-wise addition），否则会导致张量维度不匹配，需要额外的变换操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe207d3f-5564-44b3-8134-39f659fbbac1",
   "metadata": {},
   "source": [
    "### 代码实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "46387b63-80c9-490b-bc6e-da9ca1dc7fd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, d_model, h):\n",
    "        \"\"\"\n",
    "        多头注意力机制：每个头单独定义线性层。\n",
    "        \n",
    "        参数:\n",
    "            d_model: 输入序列的嵌入维度。\n",
    "            h: 注意力头的数量。\n",
    "        \"\"\"\n",
    "        super(MultiHeadAttention, self).__init__()\n",
    "        assert d_model % h == 0, \"d_model 必须能被 h 整除。\"\n",
    "\n",
    "        self.d_model = d_model\n",
    "        self.h = h\n",
    "\n",
    "        # “共享”的 Q, K, V 线性层\n",
    "        self.w_q = nn.Linear(d_model, d_model)\n",
    "        self.w_k = nn.Linear(d_model, d_model)\n",
    "        self.w_v = nn.Linear(d_model, d_model)\n",
    "\n",
    "        # 输出线性层，将多头拼接后的输出映射回 d_model\n",
    "        self.fc_out = nn.Linear(d_model, d_model)\n",
    "\n",
    "    def forward(self, q, k, v, mask=None):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "        \n",
    "        参数:\n",
    "            q: 查询矩阵 (batch_size, seq_len_q, d_model)\n",
    "            k: 键矩阵 (batch_size, seq_len_k, d_model)\n",
    "            v: 值矩阵 (batch_size, seq_len_v, d_model)\n",
    "            mask: 掩码矩阵 (batch_size, 1, seq_len_q, seq_len_k)\n",
    "\n",
    "        返回:\n",
    "            out: 注意力加权后的输出\n",
    "        \"\"\"\n",
    "        batch_size = q.size(0)\n",
    "        \n",
    "        # 获取查询和键值的序列长度\n",
    "        seq_len_q = q.size(1)\n",
    "        seq_len_k = k.size(1)\n",
    "\n",
    "        # 将线性变换后的“共享”矩阵拆分为多头，调整维度为 (batch_size, h, seq_len, d_k)\n",
    "        # d_k 就是每个注意力头的维度\n",
    "        Q = self.w_q(q).view(batch_size, seq_len_q, self.h, -1).transpose(1, 2)\n",
    "        K = self.w_k(k).view(batch_size, seq_len_k, self.h, -1).transpose(1, 2)\n",
    "        V = self.w_v(v).view(batch_size, seq_len_k, self.h, -1).transpose(1, 2)\n",
    "\n",
    "        # 执行缩放点积注意力\n",
    "        scaled_attention, _ = scaled_dot_product_attention(Q, K, V, mask)\n",
    "\n",
    "        # 合并多头并还原为 (batch_size, seq_len_q, d_model)\n",
    "        concat_out = scaled_attention.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)\n",
    "\n",
    "        # 通过输出线性层\n",
    "        out = self.fc_out(concat_out)  # (batch_size, seq_len_q, d_model)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dd5b1c2-9a32-43fb-acc3-0ce22f1038a3",
   "metadata": {},
   "source": [
    "## Position-wise Feed-Forward Networks（FFN）\n",
    "\n",
    "> ![Position-wise Feed-Forward Networks](../assets/image-20241028151143736.png)\n",
    "\n",
    "### 数学表达\n",
    "\n",
    "> ![FFN](../assets/image-20241028151815767.png)\n",
    "\n",
    "在编码器-解码器架构中，另一个看起来“大一点”的模块就是 Feed Forward，它在每个位置 $i$ 上的计算可以表示为：\n",
    "\n",
    "$$\n",
    "\\text{FFN}(x_i) = \\text{max}(0, x_i W_1 + b_1) W_2 + b_2\n",
    "$$\n",
    "\n",
    "其中：\n",
    "\n",
    "- $x_i \\in \\mathbb{R}^{d_{\\text{model}}}$ 表示第 $i$ 个位置的输入向量。 \n",
    "- $W_1 \\in \\mathbb{R}^{d_{\\text{model}} \\times d_{\\text{ff}}}$ 和 $W_2 \\in \\mathbb{R}^{d_{\\text{ff}} \\times d_{\\text{model}}}$ 是两个线性变换的权重矩阵。\n",
    "- $b_1 \\in \\mathbb{R}^{d_{\\text{ff}}}$ 和 $b_2 \\in \\mathbb{R}^{d_{\\text{model}}}$ 是对应的偏置向量。\n",
    "- $\\text{max}(0, \\cdot)$ 是 **ReLU 激活函数**，用于引入非线性。\n",
    "\n",
    "Position-wise 实际是线性层本身的一个特性，在线性层中，每个输入向量（对应于序列中的一个位置，比如一个词向量）都会通过相同的权重矩阵进行线性变换，这意味着每个位置的处理是相互独立的，逐元素这一点可以看成 kernel_size=1 的卷积核扫过一遍序列。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2531c9-3b1f-44eb-826b-934ad6f37384",
   "metadata": {},
   "source": [
    "#### 代码实现\n",
    "\n",
    "所以 FFN 本质就是两个线性变换之间嵌入了一个 **ReLU** 激活函数，实现起来非常简单。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dce31f71-b9dc-4370-a494-4778e4b935ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionwiseFeedForward(nn.Module):\n",
    "    def __init__(self, d_model, d_ff, dropout=0.1):\n",
    "        \"\"\"\n",
    "        位置前馈网络。\n",
    "        \n",
    "        参数:\n",
    "            d_model: 输入和输出向量的维度\n",
    "            d_ff: FFN 隐藏层的维度，或者说中间层\n",
    "            dropout: 随机失活率（Dropout），即随机屏蔽部分神经元的输出，用于防止过拟合\n",
    "        \n",
    "        （实际上论文并没有确切地提到在这个模块使用 dropout，所以注释）\n",
    "        \"\"\"\n",
    "        super(PositionwiseFeedForward, self).__init__()\n",
    "        self.w_1 = nn.Linear(d_model, d_ff)  # 第一个线性层\n",
    "        self.w_2 = nn.Linear(d_ff, d_model)  # 第二个线性层\n",
    "        #self.dropout = nn.Dropout(dropout)   # Dropout 层\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 先经过第一个线性层和 ReLU，然后经过第二个线性层\n",
    "        return self.w_2(self.w_1(x).relu())  #self.w_2(self.dropout(self.w_1(x).relu()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aede17cb-960b-4453-ae19-6047654cab24",
   "metadata": {},
   "source": [
    "## 残差连接（Residual Connection）和层归一化（Layer Normalization, LayerNorm）\n",
    "\n",
    "在 Transformer 架构中，**残差连接**（Residual Connection）与**层归一化**（LayerNorm）结合使用，统称为 **Add & Norm** 操作。\n",
    "\n",
    "### Add（残差连接，Residual Connection）\n",
    "\n",
    "> **ResNet**\n",
    "> Deep Residual Learning for Image Recognition | [arXiv 1512.03385](https://arxiv.org/pdf/1512.03385)\n",
    ">\n",
    "> **简单，但有效。**\n",
    "\n",
    "残差连接是一种跳跃连接（Skip Connection），它将层的输入直接加到输出上（观察架构图中的箭头），对应的公式如下：\n",
    "\n",
    "$$\n",
    "\\text{Output} = \\text{SubLayer}(x) + x\n",
    "$$\n",
    "\n",
    "这种连接方式有效缓解了**深层神经网络的梯度消失**问题。\n",
    "\n",
    "#### Q: 为什么可以缓解梯度消失？\n",
    "\n",
    "首先，我们需要了解什么是梯度消失。\n",
    "\n",
    "在深度神经网络中，参数的梯度通过反向传播计算，其公式为：\n",
    "\n",
    "$$\n",
    "\\frac{\\partial \\mathcal{L}}{\\partial W} = \\frac{\\partial \\mathcal{L}}{\\partial h_n} \\cdot \\frac{\\partial h_n}{\\partial h_{n-1}} \\cdot \\ldots \\cdot \\frac{\\partial h_1}{\\partial W}\n",
    "$$\n",
    "当网络层数增加时，**链式法则**中的梯度相乘可能导致梯度值越来越小（梯度消失）或越来越大（梯度爆炸），使得模型难以训练和收敛。\n",
    "\n",
    "假设输出层的损失为 $\\mathcal{L}$，且 $\\text{SubLayer}(x)$ 表示为 $F(x)$。在没有残差连接的情况下，梯度通过链式法则计算为：\n",
    "$$\n",
    "\\frac{\\partial \\mathcal{L}}{\\partial x} = \\frac{\\partial \\mathcal{L}}{\\partial F(x)} \\cdot \\frac{\\partial F(x)}{\\partial x}\n",
    "$$\n",
    "如果 $\\frac{\\partial F(x)}{\\partial x}$ 的绝对值小于 1，那么随着层数的增加，梯度会呈快速缩小，导致梯度消失。\n",
    "\n",
    "引入残差连接后，输出变为 $F(x) + x$，其梯度为：\n",
    "$$\n",
    "\\frac{\\partial \\mathcal{L}}{\\partial x} = \\frac{\\partial \\mathcal{L}}{\\partial (x + F(x))} \\cdot (1 + \\frac{\\partial F(x)}{\\partial x})\n",
    "$$\n",
    "这里，包含了一个常数项 1，这意味着即使 $\\frac{\\partial F(x)}{\\partial x}$ 很小，梯度仍然可以有效地反向传播，缓解梯度消失问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dd90c58-ca5d-4d8a-9a99-e304ad9d5094",
   "metadata": {},
   "source": [
    "#### 代码实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "db50649b-17c6-4524-bcdc-c6cae27538b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualConnection(nn.Module):\n",
    "    def __init__(self, dropout=0.1):\n",
    "        \"\"\"\n",
    "        残差连接，用于在每个子层后添加残差连接和 Dropout。\n",
    "        \n",
    "        参数:\n",
    "            dropout: Dropout 概率，用于在残差连接前应用于子层输出，防止过拟合。\n",
    "        \"\"\"\n",
    "        super(ResidualConnection, self).__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "\n",
    "    def forward(self, x, sublayer):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "        \n",
    "        参数:\n",
    "            x: 残差连接的输入张量，形状为 (batch_size, seq_len, d_model)。\n",
    "            sublayer: 子层模块的函数，多头注意力或前馈网络。\n",
    "\n",
    "        返回:\n",
    "            经过残差连接和 Dropout 处理后的张量，形状为 (batch_size, seq_len, d_model)。\n",
    "        \"\"\"\n",
    "        # 将子层输出应用 dropout，然后与输入相加（参见论文 5.4 的表述或者本文「呈现」部分）\n",
    "        return x + self.dropout(sublayer(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c8e21a7-dbe7-4277-93c4-8af067956eee",
   "metadata": {},
   "source": [
    "### Norm（层归一化，Layer Normalization）\n",
    "\n",
    "> Layer Normalization | [arXiv 1607.06450](https://arxiv.org/pdf/1607.06450)\n",
    "\n",
    "**层归一化**（LayerNorm）是一种归一化技术，用于提升训练的稳定性和模型的泛化能力。\n",
    "\n",
    "#### Q: BatchNorm 和 LayerNorm 的区别\n",
    "\n",
    "如果你听说过 **Batch Normalization (BatchNorm)**，或许会疑惑于二者的区别。\n",
    "\n",
    "假设输入张量的形状为 **(batch_size, feature_size)**，其中 `batch_size=32`，`feature_size=512`。\n",
    "\n",
    "- **batch_size**：表示批次中的样本数量。  \n",
    "- **feature_size**：表示每个样本的特征维度，即每个样本包含 512 个特征。\n",
    "\n",
    "这里的一行对应于一个样本，一列对应于一种特征属性。\n",
    "\n",
    "- BatchNorm 基于一个**批次**（batch）内的所有样本，针对**特征维度**（列）进行归一化，即在每一列（相同特征或嵌入维度上的 batch_size 个样本）上计算均值和方差。\n",
    "\n",
    "  - 对第 $j$ 列（特征）计算均值和方差：\n",
    "\n",
    "    $$\n",
    "    \\mu_j = \\frac{1}{\\text{batch\\_size}} \\sum_{i=1}^{\\text{batch\\_size}} x_{i,j}, \\quad \n",
    "    \\sigma^2_j = \\frac{1}{\\text{batch\\_size}} \\sum_{i=1}^{\\text{batch\\_size}} (x_{i,j} - \\mu_j)^2\n",
    "    $$\n",
    "\n",
    "- LayerNorm 基于**每个样本的所有特征**，针对**样本自身**（行内所有特征）进行归一化，即在每一行（一个样本的 embed_size 个特征）上计算均值和方差。\n",
    "\n",
    "  - 对第 $i$ 行（样本）计算均值和方差：\n",
    "\n",
    "    $$\n",
    "    \\mu_i = \\frac{1}{\\text{feature\\_size}} \\sum_{j=1}^{\\text{feature\\_size}} x_{i,j}, \\quad \n",
    "    \\sigma^2_i = \\frac{1}{\\text{feature\\_size}} \\sum_{j=1}^{\\text{feature\\_size}} (x_{i,j} - \\mu_i)^2\n",
    "    $$\n",
    "\n",
    "用表格说明：\n",
    "\n",
    "| 操作          | 处理维度                       | 解释                         |\n",
    "| ------------- | ------------------------------ | ---------------------------- |\n",
    "| **BatchNorm** | 对列（特征维度）归一化         | 每个特征在所有样本中的归一化 |\n",
    "| **LayerNorm** | 对行（样本内的特征维度）归一化 | 每个样本的所有特征一起归一化 |\n",
    "\n",
    "> BatchNorm 和 LayerNorm 在视频中也有讲解：[Transformer论文逐段精读【论文精读】25:40 - 32:04 部分](https://www.bilibili.com/video/BV1pu411o7BE/?share_source=copy_web&vd_source=e46571d631061853c8f9eead71bdb390&t=1540)，不过需要注意的是在 26:25 处应该除以的是标准差而非方差，且视频中将三维情况下的 LayerNorm 画成了切面，这一点与 Transformer 的实现可能存在出入。\n",
    ">\n",
    "> ![BN vs LN](../assets/image-20241028172742399.png)\n",
    ">\n",
    "> 图中下方为二维情况，对应上表：BatchNorm 对列（特征）归一化，LayerNorm 对行（样本）归一化。\n",
    ">\n",
    "> 对于三维张量，比如图示的 (batch_size, seq_len, feature_size)，BatchNorm 固定特征索引 $j$，对 `[:, :, j]`（所有样本在所有位置上的第 $j$ 个特征）计算均值和方差；LayerNorm 则固定 batch 索引 $i$ 和 seq 索引 $j$，仅对 `[i, j, :]`（单个 token 的所有特征）计算均值和方差，而非对 seq 和 feature 形成的平面做归一化，对应「代码实现」部分的 `dim=-1`。\n",
    "\n",
    "#### LayerNorm 的计算过程\n",
    "\n",
    "假设输入向量为 $x = (x_1, x_2, \\dots, x_d)$, LayerNorm 的计算步骤如下：\n",
    "\n",
    "1. **计算均值和方差**：\n",
    "   对输入的所有特征求均值 $\\mu$ 和方差 $\\sigma^2$：\n",
    "\n",
    "   $$\n",
    "   \\mu = \\frac{1}{d} \\sum_{j=1}^{d} x_j, \\quad \n",
    "   \\sigma^2 = \\frac{1}{d} \\sum_{j=1}^{d} (x_j - \\mu)^2\n",
    "   $$\n",
    "\n",
    "2. **归一化公式**：\n",
    "   将输入特征 $\\hat{x}_i$ 进行归一化：\n",
    "\n",
    "   $$\n",
    "   \\hat{x}_i = \\frac{x_i - \\mu}{\\sqrt{\\sigma^2 + \\epsilon}}\n",
    "   $$\n",
    "\n",
    "   其中, $\\epsilon$ 是一个很小的常数（比如 1e-9），用于防止除以零的情况。\n",
    "\n",
    "3. **引入可学习参数**：\n",
    "   归一化后的输出乘以 $\\gamma$ 并加上 $\\beta$, 公式如下：\n",
    "\n",
    "   $$\n",
    "   \\text{Output} = \\gamma \\hat{x} + \\beta\n",
    "   $$\n",
    "\n",
    "   其中 $\\gamma$ 和 $\\beta$ 是可学习的参数，用于进一步调整归一化后的输出。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612252e5-64dc-4969-ac93-190648fa35c8",
   "metadata": {},
   "source": [
    "#### 代码实现\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f239e531-408b-4e1f-8b34-f03aaaf25005",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LayerNorm(nn.Module):\n",
    "    def __init__(self, feature_size, epsilon=1e-9):\n",
    "        \"\"\"\n",
    "        层归一化，用于对最后一个维度进行归一化。\n",
    "        \n",
    "        参数:\n",
    "            feature_size: 输入特征的维度大小，即归一化的特征维度。\n",
    "            epsilon: 防止除零的小常数。\n",
    "        \"\"\"\n",
    "        super(LayerNorm, self).__init__()\n",
    "        self.gamma = nn.Parameter(torch.ones(feature_size))  # 可学习缩放参数，初始值为 1\n",
    "        self.beta = nn.Parameter(torch.zeros(feature_size))  # 可学习偏移参数，初始值为 0\n",
    "        self.epsilon = epsilon\n",
    "\n",
    "    def forward(self, x):\n",
    "        mean = x.mean(dim=-1, keepdim=True)\n",
    "        var = x.var(dim=-1, keepdim=True, unbiased=False)\n",
    "        return self.gamma * (x - mean) / torch.sqrt(var + self.epsilon) + self.beta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "184f530c-94a3-4734-b749-716c5dfa89ad",
   "metadata": {},
   "source": [
    "#### 澄清：LayerNorm 最后的缩放与线性层 (nn.Linear) 的区别\n",
    "\n",
    "见过线性层源码但不熟悉乘法运算符的同学可能会有一个错误的困惑：\n",
    "\n",
    "**最后不就是线性层的实现吗，为什么不直接用 `nn.Linear((x - mean) / torch.sqrt(var + self.epsilon))` 实现呢？**\n",
    "\n",
    "乍一看，LayerNorm 的计算过程确实与 `nn.Linear` 有些相似：LayerNorm 对归一化后的输出进行了缩放（乘以 $\\gamma$）和偏移（加上 $\\beta$），但这两者的核心作用和参数运算方式存在**本质的不同**，接下来逐一澄清：\n",
    "\n",
    "1. `self.gamma * x` 实际上是逐元素缩放操作而非对输入做线性组合。\n",
    "\n",
    "2. self.gamma 的 shape 为 `(feature_size,)` 而非 `(feature_size, feature_size)`。\n",
    "\n",
    "3. 线性层的公式为: $\\text{Output} = x W^T + b$, 代码实现为：\n",
    "\n",
    "   ```python\n",
    "   # 初始化的 shape 是二维的\n",
    "   self.weight = nn.Parameter(torch.randn(out_features, in_features))  # 权重矩阵\n",
    "   self.bias = nn.Parameter(torch.zeros(out_features))  # 偏置向量\n",
    "   \n",
    "   # 计算\n",
    "   def forward(self, x):\n",
    "   \treturn torch.matmul(x, self.weight.T) + self.bias\n",
    "   ```\n",
    "\n",
    "LayerNorm 是 `* `逐元素乘积，nn.Linear 是 `torch.matmul()` 矩阵乘法，运行代码：\n",
    "\n",
    "```python\n",
    "import torch\n",
    "\n",
    "# 创建两个张量 A 和 B\n",
    "A = torch.tensor([[1, 2], [3, 4]])  # 形状 (2, 2)\n",
    "B = torch.tensor([[5, 6], [7, 8]])  # 形状 (2, 2)\n",
    "\n",
    "### 1. 逐元素乘法\n",
    "elementwise_product = A * B  # 对应位置元素相乘\n",
    "print(\"逐元素乘法 (A * B) 的结果：\\n\", elementwise_product)\n",
    "\n",
    "### 2. 矩阵乘法\n",
    "matrix_product = torch.matmul(A, B)  # 矩阵乘法\n",
    "print(\"矩阵乘法 (torch.matmul(A, B)) 的结果：\\n\", matrix_product)\n",
    "\n",
    "```\n",
    "\n",
    "**输出**：\n",
    "\n",
    "```sql\n",
    "逐元素乘法 (A * B) 的结果：\n",
    " tensor([[ 5, 12],\n",
    "        [21, 32]])\n",
    "矩阵乘法 (torch.matmul(A, B)) 的结果：\n",
    " tensor([[19, 22],\n",
    "        [43, 50]])\n",
    "```\n",
    "\n",
    "可以看到二者并不是一个操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e00ce89-fd4f-4414-a77b-1adc5347fb95",
   "metadata": {},
   "source": [
    "### Add & Norm\n",
    "\n",
    "**操作步骤**：\n",
    "\n",
    "1. **残差连接**：将输入直接与子层的输出相加。\n",
    "2. **层归一化**：对相加后的结果进行归一化。\n",
    "\n",
    "公式如下：\n",
    "\n",
    "$$\n",
    "\\text{Output} = \\text{LayerNorm}(x + \\text{SubLayer}(x))\n",
    "$$\n",
    "\n",
    "其中, $\\text{SubLayer}(x)$ 表示 Transformer 中的某个子层（如自注意力层或前馈网络层）的输出，因此，Add & Norm 操作也被称为“子层连接”，它在每个子层的输出上应用残差和归一化。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5552be63-e7dd-46ad-af24-2ef8c4a4e43a",
   "metadata": {},
   "source": [
    "#### 代码实现\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0a5c7381-1b0e-43c7-9a07-473651249a3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SublayerConnection(nn.Module):\n",
    "    def __init__(self, feature_size, dropout=0.1, epsilon=1e-9):\n",
    "        \"\"\"\n",
    "        子层连接，包括残差连接和层归一化，应用于 Transformer 的每个子层。\n",
    "\n",
    "        参数:\n",
    "            feature_size: 输入特征的维度大小，即归一化的特征维度。\n",
    "            dropout: 残差连接中的 Dropout 概率。\n",
    "            epsilon: 防止除零的小常数。\n",
    "        \"\"\"\n",
    "        super(SublayerConnection, self).__init__()\n",
    "        self.residual = ResidualConnection(dropout)  # 使用 ResidualConnection 进行残差连接\n",
    "        self.norm = LayerNorm(feature_size, epsilon)  # 层归一化\n",
    "\n",
    "    def forward(self, x, sublayer):\n",
    "        # 将子层输出应用 dropout 后经过残差连接后再进行归一化，可见本文「呈现」部分\n",
    "        return self.norm(self.residual(x, sublayer))\n",
    "\n",
    "# 或者直接在 AddNorm 里面实现残差连接\n",
    "class SublayerConnection(nn.Module):\n",
    "    \"\"\"\n",
    "        子层连接的另一种实现方式，残差连接直接在该模块中实现。\n",
    "\n",
    "        参数:\n",
    "            feature_size: 输入特征的维度大小，即归一化的特征维度。\n",
    "            dropout: 残差连接中的 Dropout 概率。\n",
    "            epsilon: 防止除零的小常数。\n",
    "        \"\"\"\n",
    "    def __init__(self, feature_size, dropout=0.1, epsilon=1e-9):\n",
    "        super(SublayerConnection, self).__init__()\n",
    "        self.norm = LayerNorm(feature_size, epsilon)\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "\n",
    "    def forward(self, x, sublayer):\n",
    "        # 将子层输出应用 dropout 后经过残差连接后再进行归一化，可见本文「呈现」部分\n",
    "        return self.norm(x + self.dropout(sublayer(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53ab0526-1b15-4197-bd82-5117743b69af",
   "metadata": {},
   "source": [
    "## 嵌入（Embeddings）\n",
    "\n",
    "> ![Embedding](../assets/image-20241029172114093.png)\n",
    "\n",
    "在 Transformer 模型中，**嵌入层**（Embedding Layer） 是处理输入和输出数据的关键步骤，因为模型实际操作的是**张量**（tensor），而非**字符串**（string）。在将输入文本传递给模型之前，首先需要进行**分词**（tokenization），即将文本拆解为多个 **token**，随后这些 token 会被映射为对应的 **token ID**，从而转换为模型可理解的数值形式。此时，数据的形状为 `(seq_len,)`，其中 `seq_len` 表示输入序列的长度。\n",
    "\n",
    "### Q: 为什么需要嵌入层？\n",
    "\n",
    "因为 token ID 只是整数标识符，彼此之间没有内在联系。如果直接使用这些整数，模型可能在训练过程中学习到一些模式，但无法充分捕捉词汇之间的语义关系，这显然不足以支撑起现在的大模型。\n",
    "\n",
    "举个简单的例子来理解“语义”关系：像“猫”和“狗”在向量空间中的表示应该非常接近，因为它们都是宠物；“男人”和“女人”之间的向量差异可能代表性别的区别。此外，不同语言的词汇，如“男人”（中文）和“man”（英文），如果在相同的嵌入空间中，它们的向量也会非常接近，反映出跨语言的语义相似性。同时，【“女人”和“woman”（中文-英文）】与【“男人”和“man”（中文-英文）】之间的差异也可能非常相似。\n",
    "\n",
    "对于模型而言，没有语义信息就像我们小时候刚开始读英语阅读报：“这些字母拼起来是什么？不知道。这些单词在说什么？不知道。”囫囵吞枣看完后去做题：“嗯，昨天对答案的时候，A 好像多一点，其他的差不多，那多选一点 A，其他平均分 :)。”\n",
    "\n",
    "所以，为了让模型捕捉到 token 背后复杂的语义（Semantic meaning）关系，我们需要将离散的 token ID 映射到一个高维的连续向量空间（Continuous, dense）。这意味着每个 token ID 会被转换为一个**嵌入向量**（embedding vector），期望通过这种方式让语义相近的词汇在向量空间中距离更近，使模型能更好地捕捉词汇之间的关系。当然，简单的映射无法做到这一点，因此需要“炼丹”——是的，嵌入层是可以训练的。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33fd5502-b383-411a-b0a4-748f7cd8be29",
   "metadata": {},
   "source": [
    "### 代码实现\n",
    "\n",
    "- **`nn.Embedding`**：创建嵌入层，将词汇表中的每个 token ID 映射为对应的嵌入向量。\n",
    "\n",
    "- **`vocab_size`**：词汇表的大小。\n",
    "\n",
    "- **`d_model`**：嵌入向量的维度大小。\n",
    "\n",
    "**特殊设计**\n",
    "\n",
    "> ![3.4](../assets/image-20241029173230358.png)\n",
    "\n",
    "- **缩放嵌入（Scaled Embedding）**：将嵌入层的输出（参数）乘以 $\\sqrt{d_{\\text{model}}}$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "69f590b4-e76c-4c63-b602-c59d85e59027",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Embeddings(nn.Module):\n",
    "    \"\"\"\n",
    "    嵌入，将 token ID 转换为固定维度的嵌入向量，并进行缩放。\n",
    "\n",
    "    参数:\n",
    "        vocab_size: 词汇表大小。\n",
    "        d_model: 嵌入向量的维度。\n",
    "    \"\"\"\n",
    "    def __init__(self, vocab_size, d_model):\n",
    "        super(Embeddings, self).__init__()\n",
    "        self.embed = nn.Embedding(vocab_size, d_model)\n",
    "        self.scale_factor = math.sqrt(d_model)\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "\n",
    "        参数:\n",
    "            x: 输入张量，形状为 (batch_size, seq_len)，其中每个元素是 token ID。\n",
    "\n",
    "        返回:\n",
    "            缩放后的嵌入向量，形状为 (batch_size, seq_len, d_model)。\n",
    "        \"\"\"\n",
    "        return self.embed(x) * self.scale_factor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6ae7918-0754-41ad-b1ee-6120af83cd5f",
   "metadata": {},
   "source": [
    "### Q: 什么是 nn.Embedding()？和 nn.Linear() 的区别是什么？\n",
    "\n",
    "其实非常简单，`nn.Embedding()` 就是从权重矩阵中查找与输入索引对应的行，类似于查找表操作，而 `nn.Linear()` 进行线性变换。直接对比二者的 `forward()` 方法：\n",
    "\n",
    "```python\n",
    "# Embedding\n",
    "def forward(self, input):\n",
    "\treturn self.weight[input]  # 没错，就是返回对应的行\n",
    "\n",
    "# Linear\n",
    "def forward(self, input):\n",
    "\ttorch.matmul(input, self.weight.T) + self.bias\n",
    "```\n",
    "\n",
    "运行下面的代码来验证：\n",
    "\n",
    "```python\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "# 设置随机种子\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# nn.Embedding() 权重矩阵形状为 (num_embeddings, embedding_dim)\n",
    "num_embeddings = 5  # 假设有 5 个 token\n",
    "embedding_dim = 3   # 每个 token 对应 3 维嵌入\n",
    "\n",
    "# 初始化嵌入层\n",
    "embedding = nn.Embedding(5, 3)\n",
    "\n",
    "# 整数索引\n",
    "input_indices = torch.tensor([0, 2, 4])\n",
    "\n",
    "# 查找嵌入\n",
    "output = embedding(input_indices)\n",
    "\n",
    "# 打印结果\n",
    "print(\"权重矩阵：\")\n",
    "print(embedding.weight.data)\n",
    "print(\"\\nEmbedding 输出：\")\n",
    "print(output)\n",
    "```\n",
    "\n",
    "**输出**：\n",
    "\n",
    "```sql\n",
    "权重矩阵：\n",
    "tensor([[ 0.3367,  0.1288,  0.2345],\n",
    "[ 0.2303, -1.1229, -0.1863],\n",
    "[ 2.2082, -0.6380,  0.4617],\n",
    "[ 0.2674,  0.5349,  0.8094],\n",
    "[ 1.1103, -1.6898, -0.9890]])\n",
    "\n",
    "Embedding 输出：\n",
    "tensor([[ 0.3367,  0.1288,  0.2345],\n",
    "[ 2.2082, -0.6380,  0.4617],\n",
    "[ 1.1103, -1.6898, -0.9890]], grad_fn=<EmbeddingBackward0>)\n",
    "```\n",
    "\n",
    "**要点**：\n",
    "\n",
    "- **权重矩阵**：嵌入层的权重矩阵，其形状为 `(num_embeddings, embedding_dim)`，熟悉线性层的同学可以理解为 `(in_features, out_features)`。\n",
    "- **Embedding 输出**：根据输入索引，从权重矩阵中提取对应的嵌入向量（行）。\n",
    "  - 在例子中，输入索引 `[0, 2, 4]`，因此输出了权重矩阵中第 0、2、4 行对应的嵌入向量。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b38c1284-2bf4-471c-b868-f22131ecf3d7",
   "metadata": {},
   "source": [
    "## Softmax\n",
    "\n",
    "> ![Softmax](../assets/image-20241030161359558.png)\n",
    "\n",
    "在 Transformer 模型中，**Softmax** 函数不仅在计算**注意力权重**时用到，在预测阶段的输出处理环节也会用到，因为预测 token 的过程可以看成是**多分类问题**。\n",
    "\n",
    "**Softmax** 函数是一种常用的激活函数，能够将任意实数向量转换为**概率分布**，确保每个元素的取值范围在 [0, 1] 之间，并且所有元素的和为 1。其数学定义如下：\n",
    "$$\n",
    "\\text{Softmax}(x_i) = \\frac{e^{x_i}}{\\sum_{j} e^{x_j}}\n",
    "$$\n",
    "\n",
    "其中：\n",
    "\n",
    "- $x_i$ 表示输入向量中的第 $i$ 个元素。\n",
    "- $\\text{Softmax}(x_i)$ 表示输入 $x_i$ 转换后的概率。\n",
    "\n",
    "我们可以把 Softmax 看作一种**归一化的指数变换**。相比于简单的比例归一化 $\\frac{x_i}{\\sum_j x_j}$，Softmax 通过指数变换放大数值间的差异，让较大的值对应更高的概率，同时避免了负值和数值过小的问题。\n",
    "\n",
    "### 代码实现\n",
    "\n",
    "实际使用时可以直接调用 `nn.Softmax()`，这里手动实现一个简单的 Softmax 函数，并与 `nn.Softmax()` 的结果进行对比，以加深公式的印象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7dc53432-a55f-4224-9be6-6b413f1f80b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "根据公式实现的 Softmax 结果： tensor([0.0900, 0.2447, 0.6652])\n",
      "nn.Softmax 的结果： tensor([0.0900, 0.2447, 0.6652])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "def softmax(x):\n",
    "    exp_x = torch.exp(x)\n",
    "    sum_exp_x = torch.sum(exp_x, dim=-1, keepdim=True)\n",
    "    return exp_x / sum_exp_x\n",
    "\n",
    "# 测试向量\n",
    "x = torch.tensor([1.0, 2.0, 3.0])\n",
    "\n",
    "# 根据公式实现的 Softmax\n",
    "result = softmax(x)\n",
    "\n",
    "# 使用 nn.Softmax\n",
    "softmax = nn.Softmax(dim=-1)\n",
    "nn_result = softmax(x)\n",
    "\n",
    "print(\"根据公式实现的 Softmax 结果：\", result)\n",
    "print(\"nn.Softmax 的结果：\", nn_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3fdb71e-1720-403b-b902-2b5b56dfd2b8",
   "metadata": {},
   "source": [
    "## 位置编码（Positional Encoding）\n",
    "\n",
    "> ![Positional Encoding](../assets/image-20241030195425650.png)\n",
    "\n",
    "在 Transformer 模型中，由于不是循环（RNN）结构，模型本身无法捕捉输入序列中元素的位置信息。回顾一下注意力机制的计算过程，**得分**（score）是通过查询向量（query）和键向量（key）之间的内积得到的，生成的注意力权重（attention weights）也只是基于这些内积结果，这个操作不会捕捉到位置信息。\n",
    "\n",
    "举个例子，把序列 `[\"A\", \"B\", \"C\"]` 改成 `[\"B\", \"A\", \"C\"]`，得到的输出也会是原来的结果按同样顺序打乱后的形式，假设原输出为 `[Z_A, Z_B, Z_C]`，打乱后的输出将变为 `[Z_B, Z_A, Z_C]`。\n",
    "\n",
    "所以如果嵌入向量本身不包含位置信息，就意味着**输入元素的顺序不会影响输出的权重计算，模型无法从中捕捉到序列的顺序信息**，换句话说，只是输出的位置跟着对应变化，但对应的计算结果不会改变，可以用一句诗概括当前的现象：「天涯若比邻」。\n",
    "\n",
    "为了解决这个问题，Transformer 引入了**位置编码（Positional Encoding）**：为每个位置生成一个向量，这个向量与对应的嵌入向量相加，从而在输入中嵌入位置信息。\n",
    "\n",
    "在原始论文中，Transformer 使用的是固定位置编码（Positional Encoding），其公式如下：\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "PE_{(pos, 2i)} &= \\sin\\left(\\frac{pos}{10000^{2i/d_{\\text{model}}}}\\right), \\\\\n",
    "PE_{(pos, 2i+1)} &= \\cos\\left(\\frac{pos}{10000^{2i/d_{\\text{model}}}}\\right).\n",
    "\\end{aligned}\n",
    "$$\n",
    "其中：\n",
    "\n",
    "- $pos$ 表示位置索引（Position）。\n",
    "- $i$ 表示维度索引。\n",
    "- $d_{\\text{model}}$ 是嵌入向量的维度。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3a61ab0-9724-4abd-b955-a8c3cc8d8862",
   "metadata": {},
   "source": [
    "### 代码实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cde54ab0-5410-42ef-bcb5-3a49fc6c95db",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "    def __init__(self, d_model, dropout=0.1, max_len=5000):\n",
    "        \"\"\"\n",
    "        位置编码，为输入序列中的每个位置添加唯一的位置表示，以引入位置信息。\n",
    "\n",
    "        参数:\n",
    "            d_model: 嵌入维度，即每个位置的编码向量的维度。\n",
    "            dropout: 位置编码后应用的 Dropout 概率。\n",
    "            max_len: 位置编码的最大长度，适应不同长度的输入序列。\n",
    "        \"\"\"\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)  # 正如论文 5.4 节所提到的，需要将 Dropout 应用在 embedding 和 positional encoding 相加的时候\n",
    "        \n",
    "        # 创建位置编码矩阵，形状为 (max_len, d_model)\n",
    "        pe = torch.zeros(max_len, d_model)\n",
    "        position = torch.arange(0, max_len).unsqueeze(1)  # 位置索引 (max_len, 1)\n",
    "        \n",
    "        # 计算每个维度对应的频率\n",
    "        div_term = torch.exp(\n",
    "            torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model)\n",
    "        )\n",
    "        \n",
    "        # 将位置和频率结合，计算 sin 和 cos\n",
    "        pe[:, 0::2] = torch.sin(position * div_term)  # 偶数维度\n",
    "        pe[:, 1::2] = torch.cos(position * div_term)  # 奇数维度\n",
    "        \n",
    "        # 增加一个维度，方便后续与输入相加，形状变为 (1, max_len, d_model)\n",
    "        pe = pe.unsqueeze(0)\n",
    "        \n",
    "        # 将位置编码注册为模型的缓冲区，不作为参数更新\n",
    "        self.register_buffer('pe', pe)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "\n",
    "        参数:\n",
    "            x: 输入序列的嵌入向量，形状为 (batch_size, seq_len, d_model)。\n",
    "\n",
    "        返回:\n",
    "            加入位置编码和 Dropout 后的嵌入向量，形状为 (batch_size, seq_len, d_model)。\n",
    "        \"\"\"\n",
    "        # 取出与输入序列长度相同的部分位置编码，并与输入相加\n",
    "        x = x + self.pe[:, :x.size(1), :]\n",
    "        \n",
    "        # 应用 dropout\n",
    "        return self.dropout(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9500472-ff55-40bc-892f-6d46e0ea83f5",
   "metadata": {},
   "source": [
    "### 可视化\n",
    "\n",
    "位置编码在维度 4、5、6 和 7 上的变化：\n",
    "\n",
    "![positional_encoding](../assets/positional_encoding.png)\n",
    "\n",
    "你可以使用下面的代码来可视化其他的维度并保存图片到本地。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "98b8fe67-cea2-462b-97e1-15f55cab3ed2",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def visualize_positional_encoding():\n",
    "    # 初始化位置编码类，设置嵌入向量维度为20，dropout 概率为0，最大序列长度为100\n",
    "    pe = PositionalEncoding(20, dropout=0, max_len=100)\n",
    "    # 使用全零张量进行前向传播，形状为(1, 100, 20)，这样返回的值就是位置编码\n",
    "    y = pe.forward(torch.zeros(1, 100, 20))\n",
    "\n",
    "    # 设置图形大小为 12x6\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    # 可视化第 4 到第 7 维的编码值\n",
    "    for dim in [4, 5, 6, 7]:\n",
    "        plt.plot(range(100), y[0, :, dim].numpy(), label=f'Dimension {dim}')\n",
    "    \n",
    "    # 设置图形标题、坐标轴标签和网格\n",
    "    plt.title(\"Positional Encoding Visualization\")\n",
    "    plt.xlabel(\"Position\")\n",
    "    plt.ylabel(\"Encoding Value\")\n",
    "    plt.legend(title=\"Dimensions\")\n",
    "    plt.grid(True)\n",
    "\n",
    "    # 将图像保存为 PNG 格式\n",
    "    plt.savefig(\"positional_encoding.png\", format=\"png\", dpi=300, bbox_inches='tight')\n",
    "    plt.show()\n",
    "\n",
    "# 可视化位置编码并进行保存\n",
    "visualize_positional_encoding()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dc35c72-f843-4460-bf12-abf74b9154c9",
   "metadata": {},
   "source": [
    "## 输入处理\n",
    "\n",
    "> ![image-20241102111054720](../assets/image-20241102111054720.png)\n",
    "\n",
    "在完成嵌入和位置编码的代码后，就可以实现编码器和解码器的输入处理。二者处理代码的主体完全一致，只是 `vocab_size` 根据实际情况可能会有所不同。\n",
    "\n",
    "### 编码器输入处理\n",
    "\n",
    "> ![image-20241102111130473](../assets/image-20241102111130473.png)\n",
    "\n",
    "编码器的输入由输入嵌入（Input Embedding）和位置编码（Positional Encoding）组成，在机器翻译任务中，还可以称为源语言嵌入（Source Embedding）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dfc9afb7-1958-4f82-97fb-257db16bcf98",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SourceEmbedding(nn.Module):\n",
    "    def __init__(self, src_vocab_size, d_model, dropout=0.1):\n",
    "        \"\"\"\n",
    "        源序列嵌入，将输入的 token 序列转换为嵌入向量并添加位置编码。\n",
    "\n",
    "        参数:\n",
    "            src_vocab_size: 源语言词汇表的大小\n",
    "            d_model: 嵌入向量的维度\n",
    "            dropout: 在位置编码后应用的 Dropout 概率\n",
    "        \"\"\"\n",
    "        super(SourceEmbedding, self).__init__()\n",
    "        self.embed = Embeddings(src_vocab_size, d_model)  # 词嵌入层\n",
    "        self.positional_encoding = PositionalEncoding(d_model, dropout)  # 位置编码层\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "\n",
    "        参数:\n",
    "            x: 源语言序列的输入张量，形状为 (batch_size, seq_len_src)，其中每个元素是 token ID。\n",
    "\n",
    "        返回:\n",
    "            添加位置编码后的嵌入向量，形状为 (batch_size, seq_len_src, d_model)。\n",
    "        \"\"\"\n",
    "        x = self.embed(x)  # 生成词嵌入 (batch_size, seq_len_src, d_model)\n",
    "        return self.positional_encoding(x)  # 加入位置编码\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f430e07a-39d1-4598-ad76-082c8a579ca1",
   "metadata": {},
   "source": [
    "### 解码器输入处理\n",
    "\n",
    "> ![image-20241102111231882](../assets/image-20241102111231882.png)\n",
    "\n",
    "解码器的输入由输出嵌入（Output Embedding）和位置编码（Positional Encoding）组成，在机器翻译这个任务中也可以称为目标语言嵌入（Target Embedding），为了避免与最终输出混淆，使用 `TargetEmbedding` 进行实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9640d21a-beb1-4811-981c-948932881dbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TargetEmbedding(nn.Module):\n",
    "    def __init__(self, tgt_vocab_size, d_model, dropout=0.1):\n",
    "        \"\"\"\n",
    "        目标序列嵌入，将目标序列的 token ID 转换为嵌入向量并添加位置编码。\n",
    "\n",
    "        参数:\n",
    "            tgt_vocab_size: 目标语言词汇表的大小\n",
    "            d_model: 嵌入向量的维度\n",
    "            dropout: 在位置编码后应用的 Dropout 概率\n",
    "        \"\"\"\n",
    "        super(TargetEmbedding, self).__init__()\n",
    "        self.embed = Embeddings(tgt_vocab_size, d_model)  # 词嵌入层\n",
    "        self.positional_encoding = PositionalEncoding(d_model, dropout)  # 位置编码层\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "\n",
    "        参数:\n",
    "            x: 目标序列的输入张量，形状为 (batch_size, seq_len_tgt)，其中每个元素是 token ID。\n",
    "\n",
    "        返回:\n",
    "            添加位置编码后的嵌入向量，形状为 (batch_size, seq_len_tgt, d_model)。\n",
    "        \"\"\"\n",
    "        x = self.embed(x)  # 生成词嵌入 (batch_size, seq_len_tgt, d_model)\n",
    "        return self.positional_encoding(x)  # 加入位置编码"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d918e4fa-9649-4c45-8c7e-1a20a8ed6177",
   "metadata": {},
   "source": [
    "## 掩码\n",
    "\n",
    "在 Transformer 模型中，掩码用于控制注意力机制中哪些位置需要被忽略，本文在之前讲解过为什么需要掩码机制，在这里我们将分别实现它们。\n",
    "\n",
    "### 填充掩码（Padding Mask）\n",
    "\n",
    "填充掩码用于在注意力计算时屏蔽填充 `<PAD>` 位置，防止模型计算注意力权重的时候考虑这些无意义的位置，在编码器的自注意力中使用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c006a806-c725-4e02-a35f-cdf30a1aee05",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_padding_mask(seq, pad_token=0):\n",
    "    # seq 的形状为 (batch_size, seq_len)\n",
    "    mask = (seq != pad_token).unsqueeze(1).unsqueeze(2)  # (batch_size, 1, 1, seq_len)\n",
    "    return mask  # 在注意力计算时，填充值为 0 的位置会被屏蔽"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c35b559-8842-4d49-aac5-1e330fc8a35e",
   "metadata": {},
   "source": [
    "**注意**：这里接受的参数为 pad_token_id，这意味着掩码操作在嵌入操作前，也就是分词（tokenize）然后映射为 Token IDs 后进行。\n",
    "\n",
    "#### 示例\n",
    "\n",
    "假设我们有以下两个序列，经过分词和映射后："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9cedfd9b-9375-496a-8ae8-3153edd3e925",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[[ True,  True,  True, False, False]]],\n",
      "\n",
      "\n",
      "        [[[ True,  True, False, False, False]]]])\n"
     ]
    }
   ],
   "source": [
    "seq = torch.tensor([[5, 7, 9, 0, 0], [8, 6, 0, 0, 0]])  # 0 表示 <PAD>\n",
    "print(create_padding_mask(seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a3245d9-e002-4ac6-ac1c-10416529238d",
   "metadata": {},
   "source": [
    "### 未来信息掩码（Look-ahead Mask）\n",
    "\n",
    "未来信息掩码用于在解码器中屏蔽未来的位置，防止模型在预测下一个词时“偷看”答案（训练时），在解码器中使用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "04194914-47dc-494b-a6cd-c09adde9f234",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_look_ahead_mask(size):\n",
    "    mask = torch.tril(torch.ones(size, size)).type(torch.bool)  # 下三角矩阵\n",
    "    return mask  # (seq_len, seq_len)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c274ccb0-a293-48f1-8017-fde1cb96d0d9",
   "metadata": {},
   "source": [
    "#### 示例\n",
    "\n",
    "对于序列长度 5："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "736f8fbe-b8ac-4cfe-a99f-3c0f7d60bc22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ True, False, False, False, False],\n",
      "        [ True,  True, False, False, False],\n",
      "        [ True,  True,  True, False, False],\n",
      "        [ True,  True,  True,  True, False],\n",
      "        [ True,  True,  True,  True,  True]])\n"
     ]
    }
   ],
   "source": [
    "print(create_look_ahead_mask(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "167a5e22-909e-4854-9b02-769fda248efb",
   "metadata": {},
   "source": [
    "### 组合掩码\n",
    "\n",
    "在实际应用中，我们需要将填充掩码和未来信息掩码进行组合，以同时实现两种掩码的效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a353df7c-afe3-43a3-b646-21f86d7e5cda",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_decoder_mask(tgt_seq, pad_token=0):\n",
    "    padding_mask = create_padding_mask(tgt_seq, pad_token)  # (batch_size, 1, 1, seq_len_tgt)\n",
    "    look_ahead_mask = create_look_ahead_mask(tgt_seq.size(1)).to(tgt_seq.device)  # (seq_len_tgt, seq_len_tgt)\n",
    "\n",
    "    combined_mask = look_ahead_mask.unsqueeze(0) & padding_mask  # (batch_size, 1, seq_len_tgt, seq_len_tgt)\n",
    "    return combined_mask"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db08f889-3179-4b17-8094-8fcf186a83cd",
   "metadata": {},
   "source": [
    "#### 示例\n",
    "\n",
    "假设目标序列 `tgt_seq` 为："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "18818e34-35e3-4f74-9c8e-3c1655b1927c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[[ True, False, False, False, False],\n",
      "          [ True,  True, False, False, False],\n",
      "          [ True,  True,  True, False, False],\n",
      "          [ True,  True,  True,  True, False],\n",
      "          [ True,  True,  True,  True, False]]]])\n"
     ]
    }
   ],
   "source": [
    "tgt_seq = torch.tensor([[1, 2, 3, 4, 0]])  # 0 表示 <PAD>\n",
    "print(create_decoder_mask(tgt_seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66634a2a-e295-4603-80ae-92cc0958b8b1",
   "metadata": {},
   "source": [
    "# 子层模块\n",
    "\n",
    "## 编码器层 （Encoder Layer）\n",
    "\n",
    "> ![Encoder](../assets/image-20241028204711949.png)\n",
    "\n",
    "**组件**：\n",
    "\n",
    "- 多头自注意力（Multi-Head Self-Attention）\n",
    "- 前馈神经网络（Feed Forward）\n",
    "- 残差连接和层归一化（Add & Norm），或称之为子层连接（SublayerConnection）\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff78c62f-c857-43fe-be23-85e8487795a3",
   "metadata": {},
   "source": [
    "### 代码实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "579aeb66-271b-4593-bcfa-84abbe33d87b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderLayer(nn.Module):\n",
    "    def __init__(self, d_model, h, d_ff, dropout):\n",
    "        \"\"\"\n",
    "        编码器层。\n",
    "        \n",
    "        参数:\n",
    "            d_model: 嵌入维度\n",
    "            h: 多头注意力的头数\n",
    "            d_ff: 前馈神经网络的隐藏层维度\n",
    "            dropout: Dropout 概率\n",
    "        \"\"\"\n",
    "        super(EncoderLayer, self).__init__()\n",
    "        self.self_attn = MultiHeadAttention(d_model, h)  # 多头自注意力（Multi-Head Self-Attention）\n",
    "        self.feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout)  # 前馈神经网络\n",
    "        \n",
    "        # 定义两个子层连接，分别用于多头自注意力和前馈神经网络（对应模型架构图中的两个残差连接）\n",
    "        self.sublayers = nn.ModuleList([SublayerConnection(d_model, dropout) for _ in range(2)])\n",
    "        self.d_model = d_model\n",
    "\n",
    "    def forward(self, x, src_mask):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "\n",
    "        参数:\n",
    "            x: 输入张量，形状为 (batch_size, seq_len, d_model)。\n",
    "            src_mask: 源序列掩码，用于自注意力。\n",
    "\n",
    "        返回:\n",
    "            编码器层的输出，形状为 (batch_size, seq_len, d_model)。\n",
    "        \"\"\"\n",
    "        x = self.sublayers[0](x, lambda x: self.self_attn(x, x, x, src_mask))  # 自注意力子层\n",
    "        x = self.sublayers[1](x, self.feed_forward)  # 前馈子层\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c429535-d2e8-4b5c-b5f6-3a46ce5b4771",
   "metadata": {},
   "source": [
    "## 解码器层（Decoder Layer）\n",
    "\n",
    "> ![Decoder](../assets/image-20241101224129307.png)\n",
    "\n",
    "**组件**：\n",
    "\n",
    "- 掩码多头自注意力（Masked Multi-Head Self-Attention）\n",
    "- 多头交叉注意力（Multi-Head Cross-Attention）\n",
    "- 前馈神经网络（Feed Forward）\n",
    "- 残差连接和归一化（Add & Norm），或称之为子层连接（SublayerConnection）\n",
    "\n",
    "### 代码实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9fc67f7f-f36b-4929-9417-c20825c159fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderLayer(nn.Module):\n",
    "    def __init__(self, d_model, h, d_ff, dropout):\n",
    "        \"\"\"\n",
    "        解码器层。\n",
    "        \n",
    "        参数:\n",
    "            d_model: 嵌入维度\n",
    "            h: 多头注意力的头数\n",
    "            d_ff: 前馈神经网络的隐藏层维度\n",
    "            dropout: Dropout 概率\n",
    "        \"\"\"\n",
    "        super(DecoderLayer, self).__init__()\n",
    "        self.self_attn = MultiHeadAttention(d_model, h)  # 掩码多头自注意力（Masked Multi-Head Self-Attention）\n",
    "        self.cross_attn = MultiHeadAttention(d_model, h)  # 多头交叉注意力（Multi-Head Cross-Attention）\n",
    "        self.feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout)  # 前馈神经网络\n",
    "        \n",
    "        # 定义三个子层连接，分别用于掩码多头自注意力、多头交叉注意力和前馈神经网络（对应模型架构图中的三个残差连接）\n",
    "        self.sublayers = nn.ModuleList([SublayerConnection(d_model, dropout) for _ in range(3)])\n",
    "        self.d_model = d_model\n",
    "\n",
    "    def forward(self, x, memory, src_mask, tgt_mask):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "        参数:\n",
    "            x: 解码器输入 (batch_size, seq_len_tgt, d_model)\n",
    "            memory: 编码器输出 (batch_size, seq_len_src, d_model)\n",
    "            src_mask: 源序列掩码，用于交叉注意力\n",
    "            tgt_mask: 目标序列掩码，用于自注意力\n",
    "        返回:\n",
    "            x: 解码器层的输出\n",
    "        \"\"\"\n",
    "        # 第一个子层：掩码多头自注意力（Masked Multi-Head Self-Attention）\n",
    "        x = self.sublayers[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))\n",
    "        \n",
    "        # 第二个子层：交叉多头注意力（Multi-Head Cross-Attention），使用编码器的输出 memory\n",
    "        x = self.sublayers[1](x, lambda x: self.cross_attn(x, memory, memory, src_mask))\n",
    "        \n",
    "        # 第三个子层：前馈神经网络\n",
    "        x = self.sublayers[2](x, self.feed_forward)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ec07ef1-0a6e-442b-9d30-a7d0d98df84e",
   "metadata": {},
   "source": [
    "## 编码器（Encoder）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c400b455-cab7-4b27-a023-25f4348b0407",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self, d_model, N, h, d_ff, dropout=0.1):\n",
    "        \"\"\"\n",
    "        编码器，由 N 个 EncoderLayer 堆叠而成。\n",
    "        \n",
    "        参数:\n",
    "            d_model: 嵌入维度\n",
    "            N: 编码器层的数量\n",
    "            h: 多头注意力的头数\n",
    "            d_ff: 前馈神经网络的隐藏层维度\n",
    "            dropout: Dropout 概率\n",
    "        \"\"\"\n",
    "        super(Encoder, self).__init__()\n",
    "        self.layers = nn.ModuleList([\n",
    "            EncoderLayer(d_model, h, d_ff, dropout) for _ in range(N)\n",
    "        ])\n",
    "        # 如果改用 Pre-Norm，需要在 __init__ 添加 self.norm = LayerNorm(d_model)，并将 forward 最后改为 return self.norm(x)\n",
    "\n",
    "    def forward(self, x, mask):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "        \n",
    "        参数:\n",
    "            x: 输入张量 (batch_size, seq_len, d_model)\n",
    "            mask: 输入掩码\n",
    "        \n",
    "        返回:\n",
    "            编码器的输出\n",
    "        \"\"\"\n",
    "        for layer in self.layers:\n",
    "            x = layer(x, mask)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e3f8ff6-7e40-4424-8941-2431efa99e6e",
   "metadata": {},
   "source": [
    "## 解码器（Decoder）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ad821e6f-9a46-46e8-9bb2-45b4585cf157",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(self, d_model, N, h, d_ff, dropout=0.1):\n",
    "        \"\"\"\n",
    "        解码器，由 N 个 DecoderLayer 堆叠而成。\n",
    "        \n",
    "        参数:\n",
    "            d_model: 嵌入维度\n",
    "            N: 解码器层的数量\n",
    "            h: 多头注意力的头数\n",
    "            d_ff: 前馈神经网络的隐藏层维度\n",
    "            dropout: Dropout 概率\n",
    "        \"\"\"\n",
    "        super(Decoder, self).__init__()\n",
    "        self.layers = nn.ModuleList([\n",
    "            DecoderLayer(d_model, h, d_ff, dropout) for _ in range(N)\n",
    "        ])\n",
    "        # 如果改用 Pre-Norm，需要在 __init__ 添加 self.norm = LayerNorm(d_model)，并将 forward 最后改为 return self.norm(x)\n",
    "\n",
    "    def forward(self, x, memory, src_mask, tgt_mask):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "        \n",
    "        参数:\n",
    "            x: 解码器输入 (batch_size, seq_len_tgt, d_model)\n",
    "            memory: 编码器的输出 (batch_size, seq_len_src, d_model)\n",
    "            src_mask: 用于交叉注意力的源序列掩码\n",
    "            tgt_mask: 用于自注意力的目标序列掩码\n",
    "            \n",
    "        返回:\n",
    "            解码器的输出\n",
    "        \"\"\"\n",
    "        for layer in self.layers:\n",
    "            x = layer(x, memory, src_mask, tgt_mask)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9935f179-cb92-4260-ba68-047e7d66ce99",
   "metadata": {},
   "source": [
    "# 完整模型\n",
    "\n",
    "> ![模型架构图](../assets/20241023202539.png)\n",
    "\n",
    "**完整组件**：\n",
    "\n",
    "- **输入嵌入和位置编码**：\n",
    "  - `SourceEmbedding`：对源序列进行嵌入并添加位置编码。\n",
    "  - `TargetEmbedding`：对目标序列进行嵌入并添加位置编码。\n",
    "\n",
    "- **多头注意力和前馈网络**：\n",
    "\n",
    "  - `MultiHeadAttention`：多头注意力机制。\n",
    "  - `PositionwiseFeedForward`：位置前馈网络。\n",
    "\n",
    "- **编码器和解码器**：\n",
    "\n",
    "  - `Encoder`：由多个 `EncoderLayer` 堆叠而成。\n",
    "  - `Decoder`：由多个 `DecoderLayer` 堆叠而成。\n",
    "\n",
    "- **输出层**：\n",
    "\n",
    "  - `fc_out`：线性层，将解码器的输出映射到目标词汇表维度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2a571327-9da0-41e3-9abb-2be3e49e07a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Transformer(nn.Module):\n",
    "    def __init__(self, src_vocab_size, tgt_vocab_size, d_model, N, h, d_ff, dropout=0.1):\n",
    "        \"\"\"\n",
    "        Transformer 模型，由编码器和解码器组成。\n",
    "\n",
    "        参数:\n",
    "            src_vocab_size: 源语言词汇表大小\n",
    "            tgt_vocab_size: 目标语言词汇表大小\n",
    "            d_model: 嵌入维度\n",
    "            N: 编码器和解码器的层数\n",
    "            h: 多头注意力的头数\n",
    "            d_ff: 前馈神经网络的隐藏层维度\n",
    "            dropout: Dropout 概率\n",
    "        \"\"\"\n",
    "        super(Transformer, self).__init__()\n",
    "\n",
    "        # 输入嵌入和位置编码，src 对应于编码器输入，tgt 对应于解码器输入\n",
    "        self.src_embedding = SourceEmbedding(src_vocab_size, d_model, dropout)\n",
    "        self.tgt_embedding = TargetEmbedding(tgt_vocab_size, d_model, dropout)  # 共享：self.tgt_embedding = self.src_embedding\n",
    "\n",
    "        # 编码器和解码器\n",
    "        self.encoder = Encoder(d_model, N, h, d_ff, dropout)\n",
    "        self.decoder = Decoder(d_model, N, h, d_ff, dropout)\n",
    "\n",
    "        # 输出线性层\n",
    "        self.fc_out = nn.Linear(d_model, tgt_vocab_size)\n",
    "\n",
    "    def forward(self, src, tgt):\n",
    "        \"\"\"\n",
    "        前向传播函数。\n",
    "\n",
    "        参数:\n",
    "            src: 源序列输入 (batch_size, seq_len_src)\n",
    "            tgt: 目标序列输入 (batch_size, seq_len_tgt)\n",
    "\n",
    "        返回:\n",
    "            Transformer 的输出（未经过 Softmax）\n",
    "        \"\"\"\n",
    "        # 生成掩码\n",
    "        src_mask = create_padding_mask(src)\n",
    "        tgt_mask = create_decoder_mask(tgt)\n",
    "\n",
    "        # 编码器\n",
    "        enc_output = self.encoder(self.src_embedding(src), src_mask)\n",
    "\n",
    "        # 解码器\n",
    "        dec_output = self.decoder(self.tgt_embedding(tgt), enc_output, src_mask, tgt_mask)\n",
    "\n",
    "        # 输出层\n",
    "        output = self.fc_out(dec_output)\n",
    "\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd886389-5d69-4a47-9306-6555c563fdf7",
   "metadata": {},
   "source": [
    "### 实例化\n",
    "\n",
    "使用 Transformer base 的参数配置来实例化模型并打印模型架构："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "79c88ba8-255f-4343-b52f-64872bafe353",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transformer(\n",
      "  (src_embedding): SourceEmbedding(\n",
      "    (embed): Embeddings(\n",
      "      (embed): Embedding(5000, 512)\n",
      "    )\n",
      "    (positional_encoding): PositionalEncoding(\n",
      "      (dropout): Dropout(p=0.1, inplace=False)\n",
      "    )\n",
      "  )\n",
      "  (tgt_embedding): TargetEmbedding(\n",
      "    (embed): Embeddings(\n",
      "      (embed): Embedding(5000, 512)\n",
      "    )\n",
      "    (positional_encoding): PositionalEncoding(\n",
      "      (dropout): Dropout(p=0.1, inplace=False)\n",
      "    )\n",
      "  )\n",
      "  (encoder): Encoder(\n",
      "    (layers): ModuleList(\n",
      "      (0-5): 6 x EncoderLayer(\n",
      "        (self_attn): MultiHeadAttention(\n",
      "          (w_q): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (w_k): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (w_v): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (fc_out): Linear(in_features=512, out_features=512, bias=True)\n",
      "        )\n",
      "        (feed_forward): PositionwiseFeedForward(\n",
      "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
      "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
      "        )\n",
      "        (sublayers): ModuleList(\n",
      "          (0-1): 2 x SublayerConnection(\n",
      "            (norm): LayerNorm()\n",
      "            (dropout): Dropout(p=0.1, inplace=False)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (decoder): Decoder(\n",
      "    (layers): ModuleList(\n",
      "      (0-5): 6 x DecoderLayer(\n",
      "        (self_attn): MultiHeadAttention(\n",
      "          (w_q): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (w_k): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (w_v): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (fc_out): Linear(in_features=512, out_features=512, bias=True)\n",
      "        )\n",
      "        (cross_attn): MultiHeadAttention(\n",
      "          (w_q): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (w_k): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (w_v): Linear(in_features=512, out_features=512, bias=True)\n",
      "          (fc_out): Linear(in_features=512, out_features=512, bias=True)\n",
      "        )\n",
      "        (feed_forward): PositionwiseFeedForward(\n",
      "          (w_1): Linear(in_features=512, out_features=2048, bias=True)\n",
      "          (w_2): Linear(in_features=2048, out_features=512, bias=True)\n",
      "        )\n",
      "        (sublayers): ModuleList(\n",
      "          (0-2): 3 x SublayerConnection(\n",
      "            (norm): LayerNorm()\n",
      "            (dropout): Dropout(p=0.1, inplace=False)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (fc_out): Linear(in_features=512, out_features=5000, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# 定义词汇表大小（根据数据集）\n",
    "src_vocab_size = 5000  # 源语言词汇表大小\n",
    "tgt_vocab_size = 5000  # 目标语言词汇表大小\n",
    "\n",
    "# 使用 Transformer base 参数\n",
    "d_model = 512      # 嵌入维度\n",
    "N = 6              # 编码器和解码器的层数\n",
    "h = 8              # 多头注意力的头数\n",
    "d_ff = 2048        # 前馈神经网络的隐藏层维度\n",
    "dropout = 0.1      # Dropout 概率\n",
    "\n",
    "# 实例化模型\n",
    "model = Transformer(\n",
    "    src_vocab_size=src_vocab_size,\n",
    "    tgt_vocab_size=tgt_vocab_size,\n",
    "    d_model=d_model,\n",
    "    N=N,\n",
    "    h=h,\n",
    "    d_ff=d_ff,\n",
    "    dropout=dropout\n",
    ")\n",
    "\n",
    "# 打印模型架构\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cfb72d4-32ad-4aca-99de-db8150a707b4",
   "metadata": {},
   "source": [
    "### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0bc7d783-0170-495f-8b9e-6544ec5ad4a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Source embedding shape: torch.Size([32, 10, 512])\n",
      "Encoder output shape: torch.Size([32, 10, 512])\n",
      "Target embedding shape: torch.Size([32, 15, 512])\n",
      "Decoder output shape: torch.Size([32, 15, 512])\n",
      "Final output shape: torch.Size([32, 15, 5000])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "# 假设\n",
    "batch_size = 32\n",
    "seq_len_src = 10\n",
    "seq_len_tgt = 15\n",
    "\n",
    "# 构造输入\n",
    "src = torch.randint(0, 100, (batch_size, seq_len_src))  # (batch_size, seq_len_src)\n",
    "tgt = torch.randint(0, 100, (batch_size, seq_len_tgt))  # (batch_size, seq_len_tgt)\n",
    "\n",
    "# 获取掩码用于打印编码器和解码器的输出\n",
    "src_mask = create_padding_mask(src)\n",
    "tgt_mask = create_decoder_mask(tgt)\n",
    "\n",
    "# 模型最终输出\n",
    "output = model(src, tgt)\n",
    "\n",
    "# 打印各部分的输出形状\n",
    "print(\"Source embedding shape:\", model.src_embedding(src).shape)  # (batch_size, seq_len_src, d_model)\n",
    "print(\"Encoder output shape:\", model.encoder(model.src_embedding(src), src_mask).shape)  # (batch_size, seq_len_src, d_model)\n",
    "print(\"Target embedding shape:\", model.tgt_embedding(tgt).shape)  # (batch_size, seq_len_tgt, d_model)\n",
    "print(\"Decoder output shape:\", model.decoder(model.tgt_embedding(tgt), model.encoder(model.src_embedding(src), src_mask), src_mask, tgt_mask).shape)  # (batch_size, seq_len_tgt, d_model)\n",
    "print(\"Final output shape:\", output.shape)  # (batch_size, seq_len_tgt, tgt_vocab_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd92b3c1-072d-4ab7-ab86-8ac139a3825e",
   "metadata": {},
   "source": [
    "### PyTorch 官方实现\n",
    "\n",
    "> **关于 `nn.Transformer` 末尾的 `(norm): LayerNorm(...)`**\n",
    ">\n",
    "> `nn.Transformer` 的 Encoder 和 Decoder 末尾各多一层 `norm`（post-norm 的情况下）。PyTorch 社区对此有一些讨论（见 issues： [#24930](https://github.com/pytorch/pytorch/issues/24930)、[#50086](https://github.com/pytorch/pytorch/issues/50086)、[#74092](https://github.com/pytorch/pytorch/issues/74092) 及 PR [#74237](https://github.com/pytorch/pytorch/pull/74237)），最终作者因为考虑到向后兼容没有接受。\n",
    ">\n",
    "> 本文因为无需向后兼容 :)，不再重复这层 `norm` 让读者困惑（[issue#20](https://github.com/Hoper-J/AI-Guide-and-Demos-zh_CN/issues/20)）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "167f90cc-4578-4a84-8b04-bdb8cd3374f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transformer(\n",
      "  (encoder): TransformerEncoder(\n",
      "    (layers): ModuleList(\n",
      "      (0-5): 6 x TransformerEncoderLayer(\n",
      "        (self_attn): MultiheadAttention(\n",
      "          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n",
      "        )\n",
      "        (linear1): Linear(in_features=512, out_features=2048, bias=True)\n",
      "        (dropout): Dropout(p=0.1, inplace=False)\n",
      "        (linear2): Linear(in_features=2048, out_features=512, bias=True)\n",
      "        (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
      "        (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
      "        (dropout1): Dropout(p=0.1, inplace=False)\n",
      "        (dropout2): Dropout(p=0.1, inplace=False)\n",
      "      )\n",
      "    )\n",
      "    (norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
      "  )\n",
      "  (decoder): TransformerDecoder(\n",
      "    (layers): ModuleList(\n",
      "      (0-5): 6 x TransformerDecoderLayer(\n",
      "        (self_attn): MultiheadAttention(\n",
      "          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n",
      "        )\n",
      "        (multihead_attn): MultiheadAttention(\n",
      "          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n",
      "        )\n",
      "        (linear1): Linear(in_features=512, out_features=2048, bias=True)\n",
      "        (dropout): Dropout(p=0.1, inplace=False)\n",
      "        (linear2): Linear(in_features=2048, out_features=512, bias=True)\n",
      "        (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
      "        (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
      "        (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
      "        (dropout1): Dropout(p=0.1, inplace=False)\n",
      "        (dropout2): Dropout(p=0.1, inplace=False)\n",
      "        (dropout3): Dropout(p=0.1, inplace=False)\n",
      "      )\n",
      "    )\n",
      "    (norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "\n",
    "# 使用 Transformer base 参数\n",
    "d_model = 512      # 嵌入维度\n",
    "N = 6              # 编码器和解码器的层数\n",
    "h = 8              # 多头注意力的头数\n",
    "d_ff = 2048        # 前馈神经网络的隐藏层维度\n",
    "dropout = 0.1      # Dropout 概率\n",
    "\n",
    "model = nn.Transformer(\n",
    "    d_model=d_model,\n",
    "    nhead=h,\n",
    "    num_encoder_layers=N,\n",
    "    num_decoder_layers=N,\n",
    "    dim_feedforward=d_ff,\n",
    "    dropout=dropout,\n",
    "    batch_first=True\n",
    ")\n",
    "\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbb4af80-a2a2-472f-9f0b-4007c2a02e80",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}