企业官网建设流程全解析

手撕这个词，在深度学习圈子里传了好几年了。所谓“手撕”，就是不看现成的nn.Linear、nn.Conv2d这类封装好的模块，自己用最底层的 PyTorch 张量运算把模型、损失、优化器一个个实现出来。HappyTorch 就是个干这事儿的开源练习项目——它不教你“怎么用框架调包”，而是逼着你把线性层、卷积、注意力、训练循环一层层拆开、写透。我用这套思路把 PyTorch 重新过了一遍之后，只能说：看过一百遍源码，不如亲手撕一遍网络。这篇文章会从项目设计逻辑、环境准备、核心模块的“手撕”顺序，到训练循环搭建和踩坑实录，完整盘一遍。

如果你正在学深度学习，或者已经能用 PyTorch 跑通分类任务，但总觉得“框架太黑盒”、面试遇到手推公式就发虚，那 HappyTorch 这套练习刚好对症。它适合两类人：一是刚学完吴恩达或鱼书、想把理论落到代码的入门者，二是用框架写了半年以上项目、想回头巩固底层原理的进阶者。前者能靠它建立整个训练链路的心智模型，后者能靠它查漏补缺，把“会用”变成“懂用”。

1. 为什么我坚持“手撕”是入门深度学习最快的路

说实话，2024 年之后的深度学习生态已经非常完善了。想跑一个 ResNet，PyTorch 官方一行torchvision.models.resnet18()就能搞定；想训练一个 Transformer，HuggingFace 的接口比写作文还快。那为什么还有一堆人——包括我自己——回过头来用 HappyTorch 这类项目做“手撕练习”？

1.1 “手撕”到底撕的是什么

我先说结论：手撕不是否定框架，而是撕掉“框架替你挡掉的那层认知障碍”。

拿nn.Linear举例。你调它的时候，输入一个[B, in_features]的张量，出来一个[B, out_features]的张量，中间发生了什么？很多人知道是x @ W.T + b，但再往下问：反向传播的时候梯度怎么流回去？W的梯度是x.T @ grad_output还是grad_output.T @ x？b的梯度是所有样本梯度求和还是求平均？这些细节，你用过一百次nn.Linear都不一定会注意到。

HappyTorch 的核心价值，就是把这些细节变成一道道“必须亲手写出来”的练习题。你写完一个Linear的前向和反向，输出用autograd.gradcheck做验证，那一刻你对“参数”“梯度”“计算图”这几个词的理解，和之前完全不同。

1.2 调包侠和懂原理的人，差在哪一层

我不是说调包不对。实际项目里，该用nn.Sequential就用，该调Transformers就调，效率优先。但调包和懂原理之间有一层关键的 gap：你知不知道哪里容易出错、为什么错、怎么改。

举一个我真实遇到的例子。有人用nn.CrossEntropyLoss训分类模型，发现 loss 一开始是 2.3 左右，然后慢慢下降，训练曲线很“标准”。可当他手写交叉熵的时候，发现“标准”不是必然的——如果不做 log_softmax 的数值稳定性处理，指数运算很容易溢出，loss 直接变 NaN。这种“为什么官方实现要这么写”的答案，只有亲手实现一遍才能刻进脑子里。

再者，面试场景越来越卷，手推公式已经是常规操作了。但面试官问“你怎么用代码实现反向传播”，光会推公式不够，还得推成代码。HappyTorch 这类项目本质上就是把“会推”变成“会写”。

1.3 HappyTorch 的学习路径设计

我梳理了一下这类手撕练习的核心路径，基本上是四层递进：

• 第一层：把基础算子（线性层、激活、损失）手写出来，验证反向传播正确性
• 第二层：手写优化器（SGD、动量、Adam），理解学习率和权重衰减
• 第三层：手撕经典结构（CNN、ResNet 块、自注意力），理解维度如何流动
• 第四层：自己搭一个完整的训练循环，包括初始化、断点续训、日志记录、分布式入口

这四层走完之后，你会发现再看任何开源项目，都能迅速定位“它在哪一层做了什么样的技术决策”。HappyTorch 的价值，不是给你一个完美框架，而是给你一套刻意练习的路线。

2. 环境准备：别在第一步浪费人生

手撕练习对硬件要求不算高，但环境装不对，后面全是坑。很多朋友问“为什么我的 PyTorch 装了用不了 GPU”“为什么import torch报错”，基本上都是版本匹配的问题。

2.1 用 conda 建一个干净的环境

我个人现在不管哪个项目，上来第一件事都是conda create -n happytorch python=3.10。不是 Python 版本越新越好，PyTorch 对 Python 3.13 的支持要慢半拍，3.9 到 3.11 之间最稳妥。

conda create -n happytorch python=3.10 -y conda activate happytorch

注意环境名就叫happytorch，后面所有练习都在这个环境里做，别直接装在 base 环境里。原因很简单：你后面可能要装onnx、tensorboard、jupyter这些依赖，还有可能实验别的框架，环境隔离能省掉无数“怎么这个库和我另一个项目的冲突了”的问题。

2.2 PyTorch 安装与 CUDA 版本匹配

手撕练习阶段，CPU 版本其实完全够用。Yes，你没看错，纯 CPU 就能把反向传播原理验证完。但既然要跑 CNN、Transformer，GPU 还是香。

安装命令别乱抄，直接去 PyTorch 官网的get-started页面选自己的系统、包管理器、CUDA 版本，拿生成好的命令。比如 Linux + pip + CUDA 12.4 通常是：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

装完之后一定验证一下：

import torch print(torch.__version__) print(torch.cuda.is_available()) print(torch.cuda.get_device_name(0))

torch.cuda.is_available()是True才算结束。这里我踩过一个大坑：系统里nvidia-smi显示 CUDA 版本很高，比如 12.8，但 PyTorch 编译的版本可能还没跟上。不需要焦虑，PyTorch 的 CUDA 版本和驱动版本是向下兼容的，驱动够新就行，关键是 PyTorch 的 wheel 选对。

2.3 给手撕练习配一个顺手的调试环境

手撕代码和写“框架工程代码”不一样，你经常要打印中间张量的 shape、梯度值、loss 曲线。我建议：

• 代码工作区用 VS Code + Python 插件，调试方便，断点打在自定义backward里是非常有效的排查方式
• 另开一个终端跑jupyter lab，用来快速验证小公式和画训练曲线
• 准备一个torch.autograd.gradcheck的脚本文件，手写模块每写完一块都要跑它做验证

我们在后面的章节里会反复用到gradcheck，它是手撕练习的“裁判员”。你手写的Linear是否真的走通了反向传播，gradcheck会给你一个True或False，比你自己推一万遍公式还可靠。

提示：gradcheck的用法是torch.autograd.gradcheck(LinearFunc, (x, weight, bias))，它会用数值微分和你的解析梯度做对比。新手务必学会它，它相当于你手撕网络的单元测试框架。

2.4 “全 GPU 环境”不一定最优

再补充一个经验：手撕练习阶段，跑个 MNIST 用 CPU 也就几分钟。别一开始就折腾分布式、混合精度、TensorRT——那些都是框架层面的事，等原理通了、能力够了再上。

我在练习时习惯设置os.environ["CUDA_VISIBLE_DEVICES"] = ""，强制用 CPU 跑小型实验，这样调试和打印中间结果都不会受异步 GPU 执行影响。需要真训练的时候再放开 GPU，逻辑清楚、调试轻松。

3. 从零手撕核心模块，这个顺序最稳

现在进入正菜。HappyTorch 类项目最核心的一部分，就是手写基础算子。我按由易到难的顺序，把线性层、激活函数、损失函数、优化器一一过一遍，顺带说清楚每一步背后的原理。

3.1 线性层：先搞懂权重和梯度的矩阵形状

手撕的第一个模块永远是Linear，因为它是全连接网络的最小单元，也是看清“矩阵维度怎么流转”的钥匙。

class Linear: def __init__(self, in_features, out_features): self.weight = torch.randn(in_features, out_features) * 0.01 self.bias = torch.zeros(out_features) self.grad_weight = torch.zeros_like(self.weight) self.grad_bias = torch.zeros_like(self.bias) self.x = None def forward(self, x): self.x = x return x @ self.weight + self.bias def backward(self, grad_output): self.grad_weight = self.x.T @ grad_output self.grad_bias = grad_output.sum(dim=0) grad_input = grad_output @ self.weight.T return grad_input

这里有一个非常容易混的点：grad_weight = self.x.T @ grad_output还是grad_output @ self.x.T？取决于你weight存的维度。我习惯让weight的 shape 是[in_features, out_features]，前向计算是x @ weight，那反向的时候就是x.T @ grad_output。如果你喜欢 PyTorch 官方风格的[out_features, in_features]，那前向就变成x @ weight.T，梯度写法也对应变化。

关键不是背公式，而是记住最基础的维度法则：前向是[B, in] x [in, out]，反向梯度流的形状必须和原输入一致。写完后用gradcheck验证，通过了就说明前后向完全自洽。

3.2 激活函数：反向传播里的“门控”逻辑

ReLU 的反向传播很好写，就是“输入大于 0 的位置梯度不变，否则置零”。但很多人在这步会犯一个低级错误——把mask存在了forward里，而forward里的x每次都被新输入覆盖，导致梯度出问题。

class ReLU: def __init__(self): self.mask = None def forward(self, x): self.mask = x > 0 return x * self.mask def backward(self, grad_output): return grad_output * self.mask

Sigmoid 稍微多一步公式：

class Sigmoid: def __init__(self): self.out = None def forward(self, x): self.out = 1 / (1 + torch.exp(-x)) return self.out def backward(self, grad_output): return grad_output * self.out * (1 - self.out)

注意：我建议所有手写模块里，forward都要把 forward 过程中的中间量存下来（比如self.out、self.mask），因为backward要用。如果forward和backward分成两次调用，中间量丢了，梯度就断了。

3.3 交叉熵损失：别因为数值不稳定翻车

手写交叉熵是很多人的噩梦，难点不在公式，而在数值稳定性。公式是-log(softmax(x)[class_index])，如果x里有个很大的分数，比如 100，exp(100)直接溢出成inf，算出来的 loss 就废了。

正确做法是把log_softmax写成x - x.max(dim=1, keepdim=True).values - torch.log(torch.exp(x - max).sum(...))，也就是经典的减去最大值技巧。

class CrossEntropyLoss: def forward(self, logits, targets): shifted = logits - logits.max(dim=1, keepdim=True).values exp_logits = torch.exp(shifted) log_probs = shifted - torch.log(exp_logits.sum(dim=1, keepdim=True)) batch_size = logits.shape[0] loss = -log_probs[range(batch_size), targets].mean() self.log_probs = log_probs self.targets = targets self.batch_size = batch_size return loss def backward(self): probs = torch.exp(self.log_probs) grad_logits = probs.clone() grad_logits[range(self.batch_size), self.targets] -= 1 return grad_logits / self.batch_size

这个反向就是“softmax 输出的概率矩阵，把命中的那个类别位置减 1，再除以 batch size”。如果这个推导你亲手写出来过一遍，以后看任何分类任务的梯度传播，脑子里会非常通透。

3.4 优化器：SGD 和 Adam 背后的“参数更新哲学”

手撕优化器相对前面几个简单些，但它是理解“权重衰减”“动量”的最佳入口。

class SGD: def __init__(self, params, lr=0.01, weight_decay=0.0): self.params = params self.lr = lr self.weight_decay = weight_decay def step(self): for param in self.params: grad = param.grad + self.weight_decay * param.data param.data -= self.lr * grad def zero_grad(self): for param in self.params: param.grad = None

这里有个细节值得说：L2 正则化在实现上和权重衰减很像，但严格说不是完全一回事。最正宗的 L2 正则是在 loss 里加正则项，反向传播时梯度里自然多出lambda * w；而权重衰减是在更新参数时直接减掉一小部分权重。两者对标准 SGD 是等价的，但对 Adam 不等价。这就是为什么很多人在 PyTorch 里调Adam时会发现weight_decay和理论不一致——因为 Adam 的动量机制会和 L2 梯度发生耦合。

手撕完 SGD 后，建议顺手撕一个带动量的版本和一个 Adam：

class Adam: def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8): self.params = list(params) self.lr = lr self.betas = betas self.eps = eps self.t = 0 self.m = [torch.zeros_like(p.data) for p in self.params] self.v = [torch.zeros_like(p.data) for p in self.params] def step(self): self.t += 1 for i, p in enumerate(self.params): grad = p.grad self.m[i] = self.betas[0] * self.m[i] + (1 - self.betas[0]) * grad self.v[i] = self.betas[1] * self.v[i] + (1 - self.betas[1]) * (grad ** 2) m_hat = self.m[i] / (1 - self.betas[0] ** self.t) v_hat = self.v[i] / (1 - self.betas[1] ** self.t) p.data -= self.lr * m_hat / (torch.sqrt(v_hat) + self.eps)

当你亲手写完 Adam 之后，你就明白为什么它有三个超参要调、为什么初始学习率不能太大、为什么它在稀疏梯度上表现好。这些东西，只看文档是体会不到的。

实操心得：手撕优化器不要贪多，SGD 写一个、Adam 写一个就够了。写完在一个极简的y = wx + b回归任务上训练 20 步，看 loss 是不是单调下降。如果下降得很顺利，你的优化器基本没问题。

4. 手撕 CNN、ResNet 和注意力：从“算子”跨到“架构”

基础算子写完，手撕练习就进到了第二个阶段：实现经典网络结构。这一阶段的目标不是从零写一个 GPU 算子，而是用你已经写好的“基础原件”组装出可用的网络结构，并理解维度为什么这样流动。

4.1 手写二维卷积：im2col 是最直观的思路

很多人一听手写 CNN 就觉得可怕，觉得要写底层卷积循环。其实不必那么底层——你可以用 PyTorch 的unfold或im2col实现卷积的核心逻辑，把一个“滑窗计算”问题变成“矩阵乘法”问题。

def conv2d_forward(x, weight, bias, stride=1, padding=0): B, C_in, H, W = x.shape C_out, C_in, k_h, k_w = weight.shape H_out = (H + 2 * padding - k_h) // stride + 1 W_out = (W + 2 * padding - k_w) // stride + 1 x_pad = torch.nn.functional.pad(x, (padding, padding, padding, padding)) cols = torch.nn.functional.unfold( x_pad, kernel_size=(k_h, k_w), dilation=1, padding=0, stride=stride ) # [B, C_in*k_h*k_w, L] w_matrix = weight.view(C_out, -1) # [C_out, C_in*k_h*k_w] out = w_matrix @ cols # [C_out, L] out = out.view(B, C_out, H_out, W_out) return out + bias.view(1, -1, 1, 1)

这个实现思路有一个名字叫 im2col，本质是把卷积过程中每个窗口内的数据“摊平”成矩阵的列，然后用一个大矩阵乘法一次算完所有位置的卷积响应。它牺牲了内存（把数据复制成了多份），换来了计算的高效率，你要是以后去读 Caffe 或者老版 PyTorch，都能看到它的影子。

手写卷积的价值在于，你会瞬间明白一个深度学习中非常核心的概念：参数共享。同一个 kernel 在整张图上滑来滑去，用的都是同一组权重，这正是 CNN 参数比全连接少几个数量级的原因。

4.2 残差块是“深度学习工程师的基本功”

ResNet 是面试高频，也是手撕练习的经典项目。HappyTorch 里一般会参考torchvision的实现方式，但你要自己写一遍：

class BasicBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, 1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.shortcut = nn.Sequential() if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, 1, stride, bias=False), nn.BatchNorm2d(out_channels) ) def forward(self, x): out = torch.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) return torch.relu(out)

注意shortcut的设计条件：只有在“步长不为 1”或“通道数变化”的时候，才需要额外的 1x1 卷积去对齐维度，否则直接恒等相加。很多人初学会在这一步搞错，导致维度不匹配报错。建议把 ResNet18 完整写完后，用torchsummary打印每一层的输出 shape，确认整个网络的维度流。

手撕 ResNet 的隐含收益很大：你会搞懂为什么stride=2通常放在残差块的第一层卷积上，为什么 1x1 卷积可以改变通道数而不增加太多计算量，为什么 BN 层要放在卷积之后、激活之前。

4.3 自注意力机制和 Transformer：领域的“通用积木”

如果你练到注意力这块，基本已经超越“入门”水平了。手撕注意力不需要砸一个 6 层的 Transformer，关键是写一个单头自注意力，把 Q、K、V 的映射和缩放点积吃透。

class ScaledDotProductAttention: def __init__(self, d_model): self.d_model = d_model 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) def forward(self, x): Q = self.w_q(x) K = self.w_k(x) V = self.w_v(x) scores = Q @ K.transpose(-2, -1) / (self.d_model ** 0.5) attn = torch.softmax(scores, dim=-1) return attn @ V

看完这段代码，你会理解为什么 Transformer 要除以sqrt(d_model)：如果不做这个缩放，点积的方差随维度增大而增大，softmax 会变得非常“尖锐”，梯度趋近于零。这就是那个著名的“为什么 attention is all you need 要 scale”的答案。

如果还有余力，把多头注意力也撕一遍：把d_model拆成num_heads份，每个头独立做自注意力，最后拼接再过一个线性层。写完之后再去看nn.MultiheadAttention的实现，就会发现官方代码你已经能看懂七七八八了。

5. 标准训练循环：手撕完模型，还得会“开火”

模型写好了，但训练跑不起来等于零。这一节讲的是“训练循环的标准底座”，也就是深度学习项目里最常用的那套模板，HappyTorch 里也会提供一个可参考的版本。它包含初始化、训练、验证、保存断点、加载恢复这五个部分。

5.1 写一个通用的 train_one_epoch

不要为了“炫技”把训练循环写得很花哨，工程师的基本功是“朴素且正确”。一个标准 epoch 大概长这样：

def train_one_epoch(model, dataloader, optimizer, criterion, device): model.train() total_loss, total_correct, total_num = 0.0, 0, 0 for x, y in dataloader: x, y = x.to(device), y.to(device) optimizer.zero_grad() logits = model(x) loss = criterion(logits, y) loss.backward() optimizer.step() total_loss += loss.item() * y.size(0) total_correct += (logits.argmax(dim=1) == y).sum().item() total_num += y.size(0) return total_loss / total_num, total_correct / total_num

这里有一个细节很多人不注意：loss.item()是一个标量，如果直接累加，得到的是这个 batch 的 loss，会和 batch size 有关；我每次都乘上y.size(0)，最后除以总样本数，得到的是训练集上的平均 loss。这样多个 batch 之间才能公平比较。

验证集循环几乎一样，唯一的区别是model.eval()和with torch.no_grad()。eval()是告诉模型里的 BN 和 Dropout 切换行为，no_grad()是不构建计算图、不存梯度。两个都写，少一个都可能出问题。

5.2 权重初始化：不是“随便给个数”就行

手撕完线性层之后，很多人的初始化代码是torch.randn直接乘个 0.01。这个在小网络上能跑，但一到深层网络，梯度在反向传播时会被连乘得非常小（梯度消失）或者非常大（梯度爆炸）。

规范的初始化策略是：

• 线性层/卷积层：用 Kaiming 初始化（配合 ReLU），或者 Xavier 初始化（配合 tanh/sigmoid）
• BN 层：weight初始化为 1，bias初始化为 0
• 最后一层分类层：可以用较小的标准差初始化，避免一开始 logits 差异过大，影响早期 loss

PyTorch 里写法很简单：

def init_weights(m): if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.zeros_(m.bias) elif isinstance(m, nn.BatchNorm2d): nn.init.ones_(m.weight) nn.init.zeros_(m.bias) model.apply(init_weights)

你写手撕练习的时候，会天然理解为什么需要这个步骤——因为你手写的Linear一开始没有初始化策略，跑一个 10 层网络可能直接 loss 飞掉。好的工具是torch.nn.init，它把“数学上推导出的最优随机范围”封装好了，你只需要知道每个函数对应什么激活函数即可。

5.3 学习率调度、断点续训和日志记录

训练循环不止是 for 循环。一个真正能用到实际项目的训练底座，还要有：

• 学习率调度器：torch.optim.lr_scheduler.CosineAnnealingLR或ReduceLROnPlateau。前者适合大训练轮次，后者适合不知道确切总步数的情况
• 断点续训：每若干个 epoch 保存model.state_dict()、optimizer.state_dict()、当前 epoch、当前最优指标到.pt文件。恢复训练时加载这些字典，而不是从头再来
• TensorBoard：用torch.utils.tensorboard.SummaryWriter记录 train loss、val loss、accuracy、learning rate，方便观察过拟合

checkpoint = { 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'best_acc': best_acc, 'config': config, } torch.save(checkpoint, 'checkpoint.pt')

恢复的时候注意一件事：optimizer的state_dict里保存了动量或 Adam 的一阶二阶矩，如果不恢复，模型参数虽然加载了，但优化器状态丢了，训练曲线会有一个明显的“下坠再恢复”的过程。很多训练中断后恢复效果变差，原因就是只加载了 model 的权重、没加载 optimizer。

6. 手撕后的翻车现场：常见问题与排查技巧

手撕练习最容易出现的问题，和用框架写项目遇到的问题不完全一样。这一节我把自己踩过的坑和排查思路整理成一版速查表，全是真实经验，不一定写在教科书里。

6.1 梯度爆炸、梯度消失和 NaN loss

现象：训练几轮后 loss 突然变成nan，或者直接inf。

常见原因按概率排序：

1. 数值不稳定：交叉熵没做 max-subtraction，logits 里出现大数
2. 学习率过大：尤其手写 Adam 时lr超过 1e-3，二阶矩校正跟不上
3. 手工实现的反向传播有 bug：某个位置梯度符号反了或形状错了

排查方法：在 loss.backward 之前手动打印torch.isnan(logits).any()、torch.isinf(logits).any()，用二分法定位哪个模块出了问题。如果手写了自定义层，则优先检查gradcheck是否通过。

一个我在实际训练中反复使用的技巧：把学习率默认调低到1e-4试跑 20 个 step，如果没有任何 NaN，说明前向和梯度大方向是对的，再一次一次往上加。千万不要一上来就用1e-2这种激进数值。

6.2 过拟合和 L2 正则化的实现细节

过拟合的判断标准是：train loss 持续下降，但 val loss 不再下降甚至上升。缓解手段常规是数据增强、Dropout、早停、正则化。

关于 L2 正则化在 PyTorch 里的实现，我看很多人写博客都有误解。PyTorch 的optimizer里的weight_decay参数，在 SGD 上等价于把 L2 正则梯度加进去，但 Adam 里并不完全等价。如果你要严格的 L2 正则，建议手动在 loss 里加一项：

l2_lambda = 1e-4 l2_reg = sum(p.pow(2.0).sum() for p in model.parameters() if p.requires_grad) loss = loss + l2_lambda * l2_reg

手撕优化器的阶段，你自己写一遍之后会彻底看懂这个差异。有一个很不禁夸的细节：在weight_decay很高的时候（比如 0.1），模型的更新方向可能完全被正则项主导，训练曲线早期会出现“先升后降”的假象，这不是 bug，是正则效果在起作用。

6.3 CIFAR-10 加载和预处理中的那些小坑

热词里出现了“pytorch 加载 cifar10”，这确实是个高频问题。最大的坑是：torchvision.datasets.CIFAR10下载的数据集是 PIL Image，直接进模型是不行的，需要先ToTensor()归一化到[0, 1]，再 Normalize 到([0.4914, 0.4822, 0.4465], [0.2470, 0.2435, 0.2616])——这个均值和方差是 CIFAR-10 数据集的统计值，不要凭感觉写。

另外一个常见 bug 是DataLoader的num_workers在 Windows 下容易报错。解决办法要么设成 0，要么放在if __name__ == '__main__'里。这个细节不致命，但能节约你一小时。

6.4 手写模块 debug 的铁律

最后分享一个手撕练习特别有用的 debug 铁律：

每写一个模块，立刻用一个随机输入跑gradcheck。不要等写了五个模块再一起验证，那样出 bug 了你根本不知道是哪个模块的问题。

gradcheck是任何手工实现反向传播模块的“安全网”。它默认用双精度计算数值差分，如果你的模型里有float16或者某些层对精度非常敏感，可能误差偏大，这时候可以设置eps或使用torch.autograd.gradgradcheck做高阶检查。

6.5 关于“作业和项目怎么配着练”的路径建议

如果你手头正好在刷吴恩达深度学习的课后题，或者跟着鱼书在学，HappyTorch 完全可以和这些教材配套：吴恩达作业偏“填空”，鱼书偏“从零推导”，HappyTorch 偏“用 PyTorch 从头构建并验证”。建议按“看理论 → 看官方代码 → 自己关掉官方实现重新写 → 用 gradcheck 验证”四步走，这样既有输入也有输出，遗忘曲线会平缓很多。

我自己在练到第三层的时候，经常遇到一个情况：某个模块明明逻辑推着没问题，但输出就是不对。这时候别急着怀疑人生，去查三个东西：前向里有没有in-place操作覆盖了中间量、backward里返回梯度的形状是否和前向输入一致、optimizer.zero_grad()有没有写进循环里。这三个问题占了我所有 debug 时间的七成。

7. 这套练习做完之后，我最大的变化是什么

我不太爱写鸡汤式的总结，但有一点真的很想分享给大家。学深度学习，最快乐的一瞬间不是模型涨点，也不是跑通一个大项目，而是你发现自己看到一个陌生网络结构时，脑子里的状态从“这是什么黑科技”变成了“哦，这不就是那几个部件的组合”。

HappyTorch 练习到后期，我看torchvision里的实现已经不需要查文档了，因为nn.Sequential也好、BasicBlock也好，甚至FPN也好，本质都是你在手撕练习里反复玩过的那些积木。ResNet 不过就是“卷积 + BN + ReLU + 捷径”，Transformer 不过就是“注意力 + 残差 + LayerNorm + FFN”，所谓的创新，绝大多数情况下是把积木换种方式拼起来。

所以如果你现在确实在看 PyTorch 文档却总觉得隔层纱，或者下次面试大概率会被人问“手推反向传播”，我的建议很直接：拿一个周末，把线性层、ReLU、交叉熵、SGD、卷积、残差块、自注意力挨个手撕一遍，不要依赖官方nn模块，然后看着 loss 曲线稳定下降。那个过程带给你的底层理解，是刷十个视频教程都换不来的。

最后再补一个实用小技巧：手撕代码的仓库里，一定要把自己写的模块和官方模块做成“可切换”的接口。比如你写了个MyLinear，可以在一个USE_MY_MODULES = True开关下，整个网络自动换成手撕版本训练。这个开关能在你怀疑“是不是我手撕的有 bug”的时候，一秒钟验证出来——比手动替换所有模块要省事太多。