ARTICLE DETAIL

资讯详情

深耕网站建设与运营推广的一线实战洞察。

首页/资讯中心/资讯详情

从零实现Transformer语言模型：CS336作业详解与PyTorch实战

发布时间：2026/8/11 3:49:21 拓冰企业网站定制
从零实现Transformer语言模型：CS336作业详解与PyTorch实战

1. 从作业到实战：为什么CS336的Transformer作业值得深挖

如果你正在学习自然语言处理，或者对当下大语言模型的底层架构感到好奇，那么“Transformer”这个词你一定不陌生。它早已不是2017年那篇论文里的学术概念，而是成为了驱动GPT、BERT、LLaMA等几乎所有主流大模型的引擎。斯坦福大学的CS336课程，作为一门深入探讨大规模语言模型的课程，其第一份作业就直指核心——动手实现一个Transformer语言模型。这绝不仅仅是一份“作业”，而是一张通往理解现代AI核心的“地图”。很多教程会告诉你Transformer有自注意力机制，有前馈网络，但当你真正打开代码编辑器，从零开始构建nn.Linear层、计算softmax、处理张量维度时，才会遇到那些理论推导中不会提及的“魔鬼细节”：比如为什么我们的梯度会爆炸？位置编码到底该怎么加到词向量里？训练时一个不起眼的掩码设置错误，为什么会导致模型完全学不到东西？

这份作业的价值，就在于它强迫你从“用户”和“理论听众”的角色，转变为“建造者”。你将亲手搭建编码器（Encoder）和解码器（Decoder）的每一个模块，包括多头自注意力（Multi-Head Attention）、逐位置前馈网络（Position-wise Feed-Forward Network）以及至关重要的层归一化（LayerNorm）和残差连接（Add & Norm）。在这个过程中，你会被迫去理解Q, K, V矩阵的物理意义，而不仅仅是背诵公式；你会去思考为什么使用缩放点积注意力（Scaled Dot-Product Attention）而不是普通的点积；你会真切地感受到“梯度流”是如何通过残差连接保持健康的。我完成这份作业以及后续在工业界部署优化Transformer模型的经验告诉我，只有经过这种从零到一的构建，你才能具备真正的调试能力和直觉，当模型输出一片混沌或者损失不降时，你才知道该从哪个环节入手排查。接下来，我将结合CS336作业的核心要求与工业级实践中的关键点，带你深入Transformer的构建细节、训练技巧以及那些容易踩坑的地方。

2. 架构蓝图拆解：亲手组装Transformer的每一个齿轮

在开始写代码之前，我们必须像建筑师审视蓝图一样，彻底理解Transformer的完整架构。原论文《Attention Is All You Need》中的图示是经典的，但对于实现而言，我们需要一个更面向编程的、模块化的视角。

2.1 核心组件：从嵌入层到输出层

一个完整的Transformer语言模型（例如GPT风格的Decoder-only模型）通常是一个堆叠的解码器层。对于CS336作业，你可能需要实现一个用于语言建模的Transformer，其核心数据流如下：

  1. 输入处理：输入是一串单词索引（Token IDs）。首先通过一个词嵌入层（Embedding Layer）将每个索引转换为一个稠密的向量。紧接着，必须加上位置编码（Positional Encoding），这是Transformer理解序列顺序的关键，因为自注意力机制本身是置换不变的。这里第一个坑就来了：位置编码是直接加到词嵌入向量上，而不是拼接。output = embedding + positional_encoding。

  2. 解码器层堆叠：输入嵌入（已加位置编码）会依次通过N个相同的解码器层。每一层都包含两个核心子层：

    • 掩码多头自注意力层：这是Transformer的灵魂。它允许序列中的每个位置“关注”该位置之前的所有位置（通过一个下三角掩码实现，防止信息泄露到未来）。其输出是经过注意力加权后的上下文向量。
    • 逐位置前馈网络：这是一个应用于每个位置独立的小型全连接神经网络（通常是两个线性变换加一个ReLU激活）。它用于对自注意力层的输出进行非线性变换和升维/降维。
    • Add & Norm：每个子层都被一个残差连接包裹，然后进行层归一化。即LayerNorm(x + Sublayer(x))。这里的顺序至关重要：原论文使用的是“后归一化”，即先进行残差连接，再归一化。但后来很多模型（如GPT-2）采用了“前归一化”或“RMSNorm”等变体，这在实现时需要明确。

  3. 输出层：最后一个解码器层的输出，通过一个线性投影层（通常与词嵌入层共享权重以节省参数并可能提升效果）映射回词汇表大小。最后接一个Softmax函数，得到下一个词的概率分布。

2.2 自注意力机制：不仅仅是Q, K, V的矩阵乘法

自注意力公式Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V看起来简洁，但实现时充满细节。

  • Q, K, V的由来：输入序列X（形状为[batch_size, seq_len, d_model]）会分别通过三个不同的线性层（W_q,W_k,W_v）投影，得到Q、K、V。这里的关键是，这三个线性层是独立的可学习参数，它们让模型学会从不同视角（查询、键、值）来解读输入信息。
  • 缩放因子sqrt(d_k)：为什么需要缩放？因为点积QK^T的结果的方差会随着维度d_k的增大而增大。方差过大会导致Softmax函数的梯度非常小（因为Softmax会将大部分概率质量集中到某一个值上），这被称为“梯度消失”。缩放操作就是为了保持点积后的方差稳定在1左右，确保训练稳定性。
  • 多头注意力：与其做一个大的d_model维度的注意力，不如将d_model分割成h个头，每个头在降维后的子空间（d_k = d_v = d_model / h）中独立计算注意力。最后将所有头的输出拼接起来，再通过一个线性层W_o融合。这样做的直觉是让模型能够同时关注来自不同表示子空间的信息，例如一个头关注语法，另一个头关注指代关系。

2.3 位置编码：让模型感知“顺序”

Transformer没有循环或卷积结构，因此必须显式地注入序列的顺序信息。原论文使用了正弦和余弦函数：

PE(pos, 2i) = sin(pos / 10000^(2i/d_model))PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

这种编码的优点是能够扩展到训练时未见过的序列长度（具有一定的外推性），并且能通过三角函数公式让模型轻易地学习到相对位置关系。在实现时，你需要为序列的每一个位置（0到seq_len-1）计算一个d_model维的向量。一个常见的实现错误是维度不匹配：确保你的位置编码矩阵形状是[seq_len, d_model]，而词嵌入矩阵是[batch_size, seq_len, d_model]，这样才能直接相加。

注意：在现代实践中，许多模型（如GPT）使用可学习的位置编码（nn.Embedding(max_seq_len, d_model)），这在小数据上可能更容易拟合，但丧失了外推性。作业中可能要求实现正弦版本以理解其原理。

3. 关键模块实现：用PyTorch搭建Transformer

理论清晰后，我们进入实战环节。我将用PyTorch框架，分模块实现一个用于语言建模的Transformer解码器。这是CS336作业的核心部分。

3.1 构建缩放点积注意力与多头注意力

首先，实现最基础的缩放点积注意力函数。

import torch import torch.nn as nn import torch.nn.functional as F import math class ScaledDotProductAttention(nn.Module): def __init__(self, dropout=0.1): super().__init__() self.dropout = nn.Dropout(dropout) def forward(self, q, k, v, mask=None): # q, k, v: [batch_size, num_heads, seq_len, d_k] d_k = q.size(-1) # 计算注意力分数: [batch_size, num_heads, seq_len, seq_len] attn_scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k) # 应用掩码（如因果掩码） if mask is not None: # 将mask中为True的位置（需要被屏蔽）置为一个非常大的负数，softmax后概率为0 attn_scores = attn_scores.masked_fill(mask == 0, -1e9) # 计算注意力权重 attn_weights = F.softmax(attn_scores, dim=-1) attn_weights = self.dropout(attn_weights) # 加权求和得到输出 output = torch.matmul(attn_weights, v) # [batch_size, num_heads, seq_len, d_v] return output, attn_weights

接下来，实现多头注意力模块。这里需要特别注意张量的形状变换。

class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads, dropout=0.1): super().__init__() assert d_model % num_heads == 0, "d_model must be divisible by num_heads" self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_heads self.d_v = d_model // num_heads # 定义Q, K, V的线性投影层和最后的输出层 self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, d_model) self.w_v = nn.Linear(d_model, d_model) self.w_o = nn.Linear(d_model, d_model) self.attention = ScaledDotProductAttention(dropout) self.dropout = nn.Dropout(dropout) self.layer_norm = nn.LayerNorm(d_model) def forward(self, x, mask=None): # x: [batch_size, seq_len, d_model] batch_size, seq_len, _ = x.size() # 1. 线性投影并分头 q = self.w_q(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) k = self.w_k(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) v = self.w_v(x).view(batch_size, seq_len, self.num_heads, self.d_v).transpose(1, 2) # q, k, v: [batch_size, num_heads, seq_len, d_k] # 2. 计算缩放点积注意力 attn_output, attn_weights = self.attention(q, k, v, mask) # attn_output: [batch_size, num_heads, seq_len, d_v] # 3. 合并多头 attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model) # attn_output: [batch_size, seq_len, d_model] # 4. 输出投影 output = self.w_o(attn_output) output = self.dropout(output) # 5. 残差连接与层归一化 (Post-LN) output = self.layer_norm(x + output) return output, attn_weights

实现要点与避坑：

  • view和transpose：分头操作需要熟练运用张量变形。注意transpose后需要使用.contiguous()确保内存连续，否则后续的view操作可能会报错。
  • 掩码生成：对于语言模型，需要生成一个下三角因果掩码（Causal Mask），防止当前位置看到未来的信息。
    def generate_causal_mask(seq_len): # 生成一个下三角矩阵，对角线及以下为1，以上为0 mask = torch.tril(torch.ones(seq_len, seq_len)).bool() # 需要适配多头注意力的维度 [1, 1, seq_len, seq_len] return mask.unsqueeze(0).unsqueeze(0)
  • 注意力权重：返回attn_weights对于模型可视化和调试非常有用。

3.2 构建前馈网络与解码器层

逐位置前馈网络相对简单，但要注意激活函数和中间维度（通常为d_model的4倍）。

class PositionwiseFeedForward(nn.Module): def __init__(self, d_model, d_ff, dropout=0.1): super().__init__() self.linear1 = nn.Linear(d_model, d_ff) self.linear2 = nn.Linear(d_ff, d_model) self.dropout = nn.Dropout(dropout) self.activation = nn.GELU() # 原论文用ReLU，现代模型常用GELU或Swish def forward(self, x): # x: [batch_size, seq_len, d_model] return self.linear2(self.dropout(self.activation(self.linear1(x))))

现在，我们可以组装一个完整的解码器层。

class DecoderLayer(nn.Module): def __init__(self, d_model, num_heads, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads, dropout) self.feed_forward = PositionwiseFeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, causal_mask): # 第一个子层：掩码自注意力 (Post-LN结构) attn_output, attn_weights = self.self_attn(x, causal_mask) # 第二个子层：前馈网络 ff_output = self.feed_forward(attn_output) ff_output = self.dropout(ff_output) output = self.norm2(attn_output + ff_output) return output, attn_weights

3.3 组装完整模型：嵌入、位置编码与输出

最后，我们将所有模块组合成完整的Transformer语言模型。

class TransformerLanguageModel(nn.Module): def __init__(self, vocab_size, seq_len, d_model, num_layers, num_heads, d_ff, dropout=0.1): super().__init__() self.seq_len = seq_len self.d_model = d_model # 词嵌入 self.token_embedding = nn.Embedding(vocab_size, d_model) # 位置编码（正弦版本） self.pos_encoding = self._create_positional_encoding(seq_len, d_model) # 解码器层堆叠 self.layers = nn.ModuleList([ DecoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers) ]) self.final_norm = nn.LayerNorm(d_model) # 输出层：通常与词嵌入权重共享 self.output_projection = nn.Linear(d_model, vocab_size) # 权重共享 self.output_projection.weight = self.token_embedding.weight self.dropout = nn.Dropout(dropout) def _create_positional_encoding(self, seq_len, d_model): pe = torch.zeros(seq_len, d_model) position = torch.arange(0, seq_len).unsqueeze(1).float() 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) # [1, seq_len, d_model] 便于广播 return nn.Parameter(pe, requires_grad=False) # 固定位置编码，不参与训练 def forward(self, input_ids): # input_ids: [batch_size, seq_len] batch_size, seq_len = input_ids.size() assert seq_len <= self.seq_len, "输入序列长度超过模型最大长度" # 1. 词嵌入 + 位置编码 token_embeds = self.token_embedding(input_ids) * math.sqrt(self.d_model) # 缩放嵌入 pos_embeds = self.pos_encoding[:, :seq_len, :] x = self.dropout(token_embeds + pos_embeds) # 2. 生成因果掩码 causal_mask = generate_causal_mask(seq_len).to(input_ids.device) # 3. 通过所有解码器层 all_attn_weights = [] for layer in self.layers: x, attn_weights = layer(x, causal_mask) all_attn_weights.append(attn_weights) # 4. 最终层归一化 x = self.final_norm(x) # 5. 输出投影（共享权重） logits = self.output_projection(x) # [batch_size, seq_len, vocab_size] return logits, all_attn_weights

关键实现细节：

  • 嵌入缩放：在将词嵌入与位置编码相加前，通常会将词嵌入乘以sqrt(d_model)，以使其与位置编码的尺度相匹配。
  • 权重共享：将输出层的权重与输入嵌入层的权重绑定，是一种常见的正则化技术，可以减少参数量，并可能提升模型性能，特别是在小数据集上。
  • 位置编码缓存：预先计算好最大长度seq_len的位置编码并注册为不训练的参数nn.Parameter(..., requires_grad=False)，避免每次前向传播都重新计算。

4. 训练与调试：让模型真正“学会”说话

搭建好模型只是第一步，让模型通过训练学会生成连贯文本才是真正的挑战。这部分涉及数据准备、损失函数、优化器选择以及一系列训练技巧。

4.1 数据准备与批处理

对于语言模型，训练数据通常是大量的纯文本。我们需要将其处理成模型可以消化的格式。

  1. 分词：使用BPE（Byte-Pair Encoding）或WordPiece等分词器将文本转化为子词（Subword）索引序列。CS336作业可能会提供一个简单的字符级或单词级分词器。
  2. 构建数据集：我们需要创建输入-目标对。对于自回归语言模型，给定一个序列[x1, x2, ..., xT]，输入是[x1, x2, ..., x{T-1}]，目标是[x2, x3, ..., xT]（即预测下一个词）。
  3. 批处理与填充：为了高效利用GPU，需要将多个不等长的序列打包成一个批次。通常的做法是填充（Padding）到该批次中最长序列的长度，并在计算损失时忽略填充位置（使用ignore_index参数）。
from torch.utils.data import Dataset, DataLoader class TextDataset(Dataset): def __init__(self, texts, tokenizer, seq_len): self.seq_len = seq_len self.data = [] for text in texts: tokens = tokenizer.encode(text) # 假设返回一个索引列表 # 将长文本切成seq_len+1长度的片段（+1是为了创建目标） for i in range(0, len(tokens) - seq_len, seq_len): chunk = tokens[i:i+seq_len+1] if len(chunk) == seq_len + 1: self.data.append(chunk) def __len__(self): return len(self.data) def __getitem__(self, idx): chunk = self.data[idx] input_ids = torch.tensor(chunk[:-1], dtype=torch.long) target_ids = torch.tensor(chunk[1:], dtype=torch.long) return input_ids, target_ids def collate_fn(batch): # batch是一个列表，每个元素是(input_ids, target_ids)元组 inputs, targets = zip(*batch) # 填充到批次内最大长度 inputs_padded = torch.nn.utils.rnn.pad_sequence(inputs, batch_first=True, padding_value=0) targets_padded = torch.nn.utils.rnn.pad_sequence(targets, batch_first=True, padding_value=-100) # 用-100填充，损失函数会忽略 return inputs_padded, targets_padded

4.2 损失函数、优化器与学习率调度

  • 损失函数：使用交叉熵损失（CrossEntropyLoss）。关键点：ignore_index参数应设置为填充符的索引（如0），这样填充位置不会贡献梯度。
    criterion = nn.CrossEntropyLoss(ignore_index=0)
  • 优化器：AdamW优化器是目前训练Transformer的标配。它修正了Adam中权重衰减（L2正则化）的实现，能更好地防止过拟合。
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=0.01)
  • 学习率调度：使用带热启动的余弦退火调度器（CosineAnnealingLR with Warmup）非常有效。训练初期线性增加学习率（热启动），有助于稳定训练；随后按余弦曲线下降。
    from torch.optim.lr_scheduler import LambdaLR def get_cosine_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps): def lr_lambda(current_step): if current_step < num_warmup_steps: return float(current_step) / float(max(1, num_warmup_steps)) progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps)) return max(0.0, 0.5 * (1.0 + math.cos(math.pi * progress))) return LambdaLR(optimizer, lr_lambda)

4.3 训练循环与梯度裁剪

训练循环的框架是标准的，但有几个针对Transformer的特殊处理。

model.train() for epoch in range(num_epochs): for batch_idx, (input_ids, target_ids) in enumerate(train_loader): input_ids, target_ids = input_ids.to(device), target_ids.to(device) optimizer.zero_grad() logits, _ = model(input_ids) # logits: [batch, seq_len, vocab] # 计算损失时，需要将logits和targets reshape成2D和1D loss = criterion(logits.view(-1, logits.size(-1)), target_ids.view(-1)) loss.backward() # 梯度裁剪：防止梯度爆炸，对Transformer训练至关重要 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() scheduler.step() if batch_idx % 100 == 0: print(f'Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item():.4f}')

梯度裁剪：由于Transformer层数深，梯度在反向传播时可能变得非常大（爆炸）。clip_grad_norm_函数将所有参数的梯度拼接成一个向量，如果其范数超过max_norm（通常设为0.5到1.0），就将其按比例缩放。这是稳定训练的必要步骤。

4.4 常见训练问题与调试技巧

即使代码没有语法错误，模型也可能不学习。以下是一些排查思路：

  • 损失不下降（Nan/Inf）：

    1. 检查数据：确保输入中没有异常值（如非常大的索引）。检查分词器是否在词汇表范围内。
    2. 检查梯度：在loss.backward()之后、optimizer.step()之前，打印几个关键参数的梯度范数。如果出现NaN或极大值，问题可能出在注意力分数计算（未加掩码导致softmax溢出）或初始化。
    3. 降低学习率：尝试将初始学习率降低一个数量级（如从1e-4降到1e-5）。
    4. 检查损失函数：确保ignore_index设置正确，填充位置没有被计入损失。

  • 模型输出毫无意义（重复或乱码）：

    1. 过拟合：在很小的数据集上，模型可能很快记住训练集。观察验证集损失，如果训练损失持续下降而验证损失上升，就是过拟合。需要增加Dropout率、使用更强的权重衰减或获取更多数据。
    2. 欠拟合/架构问题：模型容量可能不足（d_model或num_layers太小），无法捕捉数据中的模式。可以尝试增大模型。
    3. 温度参数：在推理时（生成文本），从模型输出的logits中采样前会除以一个温度（Temperature）参数。温度=1.0是标准设置。温度过高（>1.0）输出更随机、多样但可能不连贯；温度过低（<1.0）输出更确定但可能重复、枯燥。如果训练时正常但推理时输出差，可以调整温度。

  • 训练速度慢：

    1. 激活检查点：对于层数很深的模型，可以使用torch.utils.checkpoint来节省显存，以换取更长的计算时间（时间换空间）。
    2. 混合精度训练：使用torch.cuda.amp进行自动混合精度训练，可以显著减少显存占用并加快训练速度。
    3. 检查数据加载：确保数据加载不是瓶颈（使用DataLoader的num_workers参数）。

5. 超越作业：从玩具模型到实用化思考

完成一个能跑通的Transformer模型是了不起的成就，但距离一个实用、高效的语言模型还有距离。这部分分享一些从作业项目到工业级应用需要思考的方向。

5.1 效率优化：Flash Attention与KV缓存

原生的注意力计算复杂度是序列长度的平方（O(n²)），这对于长文本是致命的。Flash Attention是一种通过巧妙利用GPU内存层次结构（SRAM vs HBM）来加速注意力计算并减少内存占用的算法。在PyTorch 2.0及以上版本中，可以通过torch.nn.functional.scaled_dot_product_attention来调用高度优化的注意力实现，它通常会自动使用Flash Attention（如果可用）。

# 使用PyTorch的高效注意力实现替换自定义的ScaledDotProductAttention attn_output = F.scaled_dot_product_attention(q, k, v, attn_mask=causal_mask, dropout_p=dropout_p)

另一个重要的推理优化技术是KV缓存。在自回归生成文本时（每次生成一个词），模型需要重复计算之前所有位置的Key和Value，这是巨大的浪费。KV缓存将之前时间步计算出的K和V存储起来，在生成新词时只需计算当前步的Q和更新后的K、V，将复杂度从O(n²)降低到O(n)。

5.2 模型缩放与初始化

Transformer的性能强烈依赖于规模（模型参数量、数据量、计算量）。但简单地堆叠层数可能导致优化困难。Pre-LN（将层归一化放在残差连接之前）相比原论文的Post-LN通常能带来更稳定的训练，尤其是在深层网络中。一些现代模型架构（如LLaMA）就采用了Pre-LN。

参数初始化也至关重要。常见的方案有：

  • Xavier/Glorot初始化：适用于线性层和嵌入层。
  • Kaiming/He初始化：适用于使用ReLU激活函数的层后的线性层。
  • 专门针对Transformer的初始化：例如，将注意力投影层的权重初始化为非常小的值（如标准差0.02），有助于训练初期稳定。

在PyTorch中，可以自定义一个初始化函数：

def init_weights(module): if isinstance(module, nn.Linear): nn.init.xavier_normal_(module.weight) if module.bias is not None: nn.init.constant_(module.bias, 0) elif isinstance(module, nn.Embedding): nn.init.normal_(module.weight, mean=0, std=0.02) model.apply(init_weights)

5.3 评估与文本生成

训练完成后，如何评估你的语言模型？

  1. 困惑度：这是语言模型最常用的评估指标。困惑度（Perplexity, PPL）是交叉熵损失的指数。PPL = exp(loss)。困惑度越低，模型对数据的预测越确定，通常意味着模型越好。在验证集上计算困惑度是监控训练进程的好方法。
  2. 生成文本质量：定量指标之外，定性评估同样重要。使用不同的解码策略（如贪婪解码、束搜索、Top-k采样、Top-p采样）生成文本，观察其流畅性、连贯性和创造性。

一个简单的贪婪解码生成函数：

def generate_text(model, tokenizer, prompt, max_len=50, temperature=1.0): model.eval() with torch.no_grad(): input_ids = tokenizer.encode(prompt) generated = input_ids.copy() for _ in range(max_len): inputs = torch.tensor([generated], dtype=torch.long).to(device) logits, _ = model(inputs) # 取最后一个位置的logits next_token_logits = logits[0, -1, :] / temperature # 贪婪解码：选择概率最大的词 next_token_id = torch.argmax(next_token_logits).item() generated.append(next_token_id) # 简单停止条件（遇到结束符） if next_token_id == tokenizer.eos_token_id: break return tokenizer.decode(generated)

完成CS336作业一的旅程，就像亲手组装并启动了一台精密的发动机。你不再只是知道它有“自注意力”这个部件，而是清楚地知道每一根“导线”（梯度）如何流动，每一个“螺栓”（参数）如何影响整体运转。这份从零构建的经验，是理解后续如BERT的编码器、GPT的解码器、T5的编码器-解码器架构，乃至MoE、混合专家系统等更复杂变体的坚实基础。当你再阅读一篇新的Transformer改进论文时，你会本能地去想：“这个改进模块，我该插在原来架构的哪个位置？它的反向传播路径是怎样的？”——这种直觉和动手能力，正是这份作业带给你的最宝贵的财富。在实际项目中，你可能不会再从零开始写Transformer，但这份深入底层的理解，会让你在模型选型、调试、优化乃至创新时，都拥有无可替代的优势。

网站建设 企业官网 运营推广
返回列表