1. 这不是教程，是带你看懂第一行PyTorch CNN代码的“显微镜”

你点开这篇文章，大概率正坐在电脑前，刚装好Python，conda环境里还飘着几个没搞懂的warning，终端里敲pip install torch时手心有点出汗——不是因为热，是因为怕。怕报错，怕看不懂，怕别人早跑出三条街了，你还在import torch这行卡住。别慌，我试过。三年前第一次跑通MNIST的CNN，我在model = Net()这行注释里写了整整八行字：“这里到底创建了啥？参数在哪初始化？forward函数真能自动调用？”——结果发现，那八行字全写错了。

这篇文章不叫“PyTorch入门教程”，它是一份逐行解剖报告。我们只盯住一个最经典、最干净、最没有干扰项的案例：用PyTorch写一个CNN识别MNIST手写数字。全文不跳步、不省略、不甩术语就走，每一行代码都回答三个问题：它在做什么？为什么非得这么写？如果改掉会怎样？比如x = x.view(-1, 28*28)这行，很多教程只说“展平成一维”，但没人告诉你：-1不是魔法，是PyTorch帮你算batch size；28*28硬编码在这里，恰恰暴露了模型对输入尺寸的强依赖；而一旦你把图片换成32×32，这行就得重写——这不是bug，是设计契约。

适合谁读？如果你能写出print("Hello World")，但看到nn.Sequential(nn.Linear(784, 128), nn.ReLU(), nn.Linear(128, 10))时心里发毛；如果你查过nn.Conv2d文档却还是分不清in_channels和out_channels哪个对应卷积核数量；如果你调试时打印x.shape发现从(64, 1, 28, 28)变成(64, 32, 26, 26)就彻底懵圈——那你就是这篇文章唯一指定读者。我们不讲“深度学习有多伟大”，只解决你此刻光标停在那一行代码上时，脑子里冒出来的那个具体问题。

核心关键词已经刻进标题里：PyTorch、CNN、MNIST、逐行分析。它们不是标签，而是坐标——定位你在技术地图上的真实位置。接下来所有内容，都从这个坐标原点出发，一毫米一毫米地往前推。

2. 整体结构设计：为什么必须从__init__开始读，而不是forward

2.1 初学者最大的认知陷阱：把模型当“函数”来读

绝大多数新手第一次看CNN代码，本能地从def forward(self, x):开始往下捋。这就像拆一台发动机，先拧开油箱盖看汽油，再摸排气管温度，最后才去翻曲轴箱——顺序完全反了。PyTorch的CNN不是线性执行流，而是一个状态机+计算图的混合体。forward只是触发计算的扳机，真正定义“机器长什么样”的，是__init__里那一串nn.Conv2d、nn.MaxPool2d的实例化过程。

我带过十几期零基础训练营，统计过学员卡点数据：73%的人在forward里被x = self.conv1(x)卡住，追问下去，92%的人根本没意识到self.conv1这个对象本身就有可学习参数（weight和bias），更不知道它的weight.shape直接决定了卷积核数量和感受野大小。他们以为conv1是个黑盒函数，输入张量，输出张量，中间发生了什么？不重要。错。参数初始化方式、权重形状、梯度流向，全在__init__里埋好了伏笔。

所以我们的阅读路径必须倒过来：先看__init__如何构建网络骨架，再看forward如何驱动数据流经这个骨架，最后看train()循环如何用损失函数反向雕刻每一块骨头。这种逆向阅读法，不是为了炫技，而是匹配PyTorch的设计哲学——模型即对象，对象即计算图。

2.2 为什么选MNIST？它干净得像一张白纸

有人问：现在都用ResNet、ViT了，为啥还死磕MNIST？答案很实在：因为它足够小，小到你能把整个网络的每一层输出尺寸，心算出来。我们来现场验算：

• 输入：(batch_size, 1, 28, 28)
• conv1 = nn.Conv2d(1, 32, 3, 1)→ 输出(batch_size, 32, 26, 26)
  （公式：output_size = (input_size - kernel_size + 2*padding) / stride + 1，这里padding=0, stride=1）
• pool1 = nn.MaxPool2d(2, 2)→ 输出(batch_size, 32, 13, 13)
  （26÷2=13，整除，无余数）
• conv2 = nn.Conv2d(32, 64, 3, 1)→ 输出(batch_size, 64, 11, 11)
• pool2 = nn.MaxPool2d(2, 2)→ 输出(batch_size, 64, 5, 5)
• fc1 = nn.Linear(64*5*5, 128)→ 输入维度必须是64×5×5=1600

看到没？所有数字都是整数，没有四舍五入，没有向上取整。这意味着当你在forward里打印x.shape，结果和你心算的一模一样。这种确定性，是初学者建立信心的基石。换成CIFAR-10（32×32），第二层池化后尺寸是(32-3+0)/2+1=15.5——PyTorch会向下取整为15，但新手根本意识不到这个隐含规则，只会觉得“怎么又对不上了”。

2.3 代码骨架的四个不可删减模块

一个能跑通的PyTorch CNN，必须包含且仅需以下四个模块，缺一不可。很多教程把数据加载、训练循环塞进同一文件，导致初学者分不清哪些是CNN专属逻辑，哪些是通用训练框架。我们把它剥离开：

1. 数据准备模块：负责下载MNIST、做归一化、转成Tensor、封装DataLoader
2. 模型定义模块：class Net(nn.Module)，含__init__和forward
3. 训练配置模块：优化器选择、损失函数定义、学习率设定
4. 训练执行模块：epoch循环、batch迭代、loss计算、反向传播、参数更新

这四个模块的边界，就是你理解深度学习工程化的第一道分水岭。比如transforms.Normalize((0.1307,), (0.3081,))这行，初学者常误以为是模型的一部分，其实它属于数据准备模块——归一化操作发生在数据送入模型之前，目的是让输入分布更稳定，和CNN结构毫无关系。把它和nn.Conv2d混在一起看，只会徒增困惑。

3. 核心代码逐行解析：从import到model.train()

3.1 第一行import：为什么必须是torch，而不是pytorch

import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision import datasets, transforms

这五行import，藏着PyTorch最底层的设计逻辑。注意：是import torch，不是import pytorch。PyTorch是项目名，torch才是Python包名——这个细节暗示了它的定位：一个张量计算库，而非一个封闭的“深度学习平台”。torch.nn是神经网络模块，torch.nn.functional是函数式接口，两者区别至关重要：

• nn.Conv2d是类，实例化后成为模型的一部分，有可学习参数（weight/bias）
• F.conv2d是函数，每次调用都要手动传入weight和bias，适合动态卷积或自定义操作

初学者常混淆nn.ReLU()和F.relu()。前者是模块，需要在__init__里定义，然后在forward里调用；后者是函数，直接在forward里用。选哪个？看需求：如果ReLU后面要接Dropout，用nn.Dropout()模块更清晰；如果只是简单激活，F.relu(x)更轻量。但千万别写nn.ReLU(x)——这是语法错误，因为nn.ReLU是类，不是函数。

torchvision.datasets和transforms是数据处理专用模块。datasets.MNIST不是简单的图片读取器，它内置了自动下载、校验、解压逻辑。你传入root='./data'，它会在该目录下建./data/MNIST/raw/存原始二进制文件，./data/MNIST/processed/存处理后的Tensor缓存。这种设计避免了每次运行都重新下载，但新手常因磁盘空间不足或网络问题卡在download=True这一步——解决方案不是重装库，而是手动下载http://yann.lecun.com/exdb/mnist/里的四个.gz文件，放到raw/目录下，再把download=True改成download=False。

3.2 数据加载：transforms.Compose的链式调用不是语法糖

transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])

Compose看起来像管道操作符，但它的本质是函数组合器。ToTensor()把PIL Image转成[0,1]范围的float32 Tensor，Normalize再把它映射到均值0、标准差1的分布。关键点在于：Normalize的参数(0.1307,)和(0.3081,)不是随便写的，它们是MNIST训练集的全局均值和标准差（计算自60000张图）。你可以在任意一张图上验证：

# 随便取一张图 img, _ = datasets.MNIST('./data', train=True, download=True)[0] print(img.mean(), img.std()) # 输出约0.1307, 0.3081

为什么必须归一化？因为CNN第一层卷积核的权重，通常用torch.nn.init.kaiming_normal_初始化，其理论前提是输入数据均值为0、方差为1。如果输入是[0,255]的uint8，权重更新会极不稳定——我实测过，不归一化时，第一个epoch的loss从1000直降到200，第二个epoch就震荡到500，再也下不去。归一化不是锦上添花，是让梯度下降算法能正常工作的必要条件。

3.3 模型定义：__init__里的每一行都在画建筑蓝图

class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 32, 3, 1) self.conv2 = nn.Conv2d(32, 64, 3, 1) self.dropout1 = nn.Dropout2d(0.25) self.dropout2 = nn.Dropout2d(0.5) self.fc1 = nn.Linear(9216, 128) self.fc2 = nn.Linear(128, 10)

逐行拆解：

• super(Net, self).__init__()：这是PyTorch的强制要求，不是Python的普通继承。它触发nn.Module的初始化，注册后续定义的所有子模块（conv1、conv2等）到self._modules字典中。漏掉这行，你的模型在model.parameters()里将一无所获——所有参数都不会被优化器捕获。

• self.conv1 = nn.Conv2d(1, 32, 3, 1)：四个参数依次是in_channels,out_channels,kernel_size,stride。in_channels=1对应MNIST的灰度单通道；out_channels=32表示这一层会产生32个特征图（feature map），每个图由一个3×3卷积核扫描输入生成。kernel_size=3意味着卷积核是3×3像素，这是经验法则：小核（3×3）比大核（7×7）参数少、感受野叠加更灵活。stride=1表示每次移动1像素，保证特征图尺寸衰减最慢。

• self.dropout1 = nn.Dropout2d(0.25)：注意是Dropout2d，不是Dropout。因为输入是4D张量(N,C,H,W)，Dropout2d会随机置零整个通道（C维），而Dropout只置零元素。对CNN而言，通道级dropout更合理——它强迫网络不依赖单一特征图，提升鲁棒性。

• self.fc1 = nn.Linear(9216, 128)：这里的9216是关键。前面我们心算过，经过两次卷积和池化，输出尺寸是(batch, 64, 5, 5)，展平后就是64×5×5=1600。但代码里写的是9216？错。这是旧版代码的遗留bug——9216=64×12×12，对应的是未池化前的尺寸。正确写法必须是64*5*5，或者用torch.numel(x)动态计算。我见过太多人复制粘贴这段代码，训练时loss不降，debug半天才发现是这里写死了错误尺寸。

3.4 forward函数：数据流经网络的实时监控日志

def forward(self, x): x = self.conv1(x) x = F.relu(x) x = self.conv2(x) x = F.relu(x) x = F.max_pool2d(x, 2) x = self.dropout1(x) x = torch.flatten(x, 1) x = self.fc1(x) x = F.relu(x) x = self.dropout2(x) x = self.fc2(x) return F.log_softmax(x, dim=1)

这才是真正的“逐行分析”现场。我们按执行顺序，记录每一步的x.shape变化：

1. x = self.conv1(x)：输入(64,1,28,28)→ 输出(64,32,26,26)

   提示：conv1.weight.shape是(32,1,3,3)，32个卷积核，每个核处理1个输入通道，尺寸3×3

2. x = F.relu(x)：形状不变，仍是(64,32,26,26)，但所有负值变0

   注意：F.relu是in-place操作吗？不是。它返回新Tensor，原x不变。想节省内存用F.relu_(x)（带下划线）

3. x = self.conv2(x)：(64,32,26,26)→(64,64,24,24)

   为什么不是26→24？因为conv2的kernel_size=3，26-3+1=24，这里没写padding，所以尺寸收缩

4. x = F.relu(x)：形状不变

5. x = F.max_pool2d(x, 2)：(64,64,24,24)→(64,64,12,12)

   max_pool2d默认stride=kernel_size，所以2×2池化，步长也是2，尺寸减半

6. x = self.dropout1(x)：形状不变，但约25%的通道被置零

7. x = torch.flatten(x, 1)：(64,64,12,12)→(64, 64*12*12) = (64,9216)

   这里暴露了前面提到的bug！正确应为F.max_pool2d(x, 2)后尺寸是(64,64,12,12)，但按我们心算的路径，应该是(64,64,5,5)。矛盾点在哪？在conv2之后少了一次池化！标准MNIST CNN是conv1→relu→pool1→conv2→relu→pool2，而这段代码漏了pool1。所以实际路径是：conv1→relu→conv2→relu→pool2，pool2作用于(24,24)得(12,12)，flatten后确实是9216。这说明：代码里的数字是对的，但结构和经典描述不一致——这就是逐行分析的价值，它逼你发现文档和实现的偏差。

8. x = self.fc1(x)：(64,9216)→(64,128)

9. x = F.relu(x)：形状不变

10. x = self.dropout2(x)：约50%元素置零

11. x = self.fc2(x)：(64,128)→(64,10)

12. return F.log_softmax(x, dim=1)：(64,10)→(64,10)，但值域变为log概率

最后一行F.log_softmax是重点。为什么不用F.softmax？因为nn.CrossEntropyLoss内部已包含softmax，如果forward里再算一次，就是双重softmax，会导致梯度爆炸。log_softmax配合nn.NLLLoss（Negative Log Likelihood Loss）才是标准搭配，数值更稳定。

3.5 训练循环：optimizer.step()不是魔法，是梯度应用指令

model = Net() optimizer = optim.Adadelta(model.parameters(), lr=1.0) scheduler = StepLR(optimizer, step_size=1, gamma=0.7) for epoch in range(1, 14 + 1): model.train() for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() output = model(data) loss = F.nll_loss(output, target) loss.backward() optimizer.step()

这段循环里，optimizer.zero_grad()和loss.backward()之间的关系，是初学者最大盲区。zero_grad()不是清空模型，而是清空所有参数的grad属性。每个nn.Parameter都有.grad字段，存储本次batch计算出的梯度。如果不清空，第二次backward()的梯度会累加到第一次的梯度上，导致参数更新错误。

loss.backward()的实质，是调用loss这个标量Tensor的backward()方法，触发反向传播引擎，从loss节点开始，沿着计算图（computation graph）回溯，计算每个参数对loss的偏导数，并存入.grad。这个过程完全自动，但前提是：所有参与计算的Tensor，其requires_grad=True（model.parameters()默认满足）。

optimizer.step()则是读取每个参数的.grad，按优化算法（这里是Adadelta）计算更新量，然后执行param = param - update。它不关心梯度怎么来的，只负责应用。

我踩过的坑：曾把optimizer.zero_grad()放在for batch_idx循环外，结果第一个epoch loss狂降，第二个epoch直接nan——因为梯度累加，参数更新幅度过大。还有一次，model.eval()后忘了切回model.train()，Dropout失效，测试准确率虚高，部署时惨遭打脸。

4. 实操过程与避坑指南：从跑通到调优的完整路径

4.1 环境准备：conda vs pip，版本锁定是生死线

PyTorch对CUDA版本极其敏感。我推荐用conda安装，因为conda能同时管理Python和CUDA toolkit：

# 创建独立环境，指定Python版本 conda create -n pytorch_mnist python=3.8 conda activate pytorch_mnist # 安装PyTorch（以CUDA 11.3为例） conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch

为什么强调cudatoolkit=11.3？因为PyTorch二进制包是针对特定CUDA版本编译的。如果你系统装的是CUDA 11.7，但pip install的PyTorch是11.3编译的，torch.cuda.is_available()会返回False。用nvidia-smi查驱动支持的最高CUDA版本，再上PyTorch官网查对应安装命令，这是铁律。

验证安装：

import torch print(torch.__version__) # 应输出如 '1.12.1+cu113' print(torch.cuda.is_available()) # 应输出True print(torch.cuda.device_count()) # 应输出GPU数量

注意：torch.version.cuda显示的是PyTorch编译时链接的CUDA版本，torch.cuda.get_version()显示的是当前可用的CUDA运行时版本，二者必须兼容。不兼容时，is_available()返回False，但不会报错，极易被忽略。

4.2 数据加载调试：三行代码定位90%的数据问题

数据问题占新手调试时间的70%。用这三行快速诊断：

# 1. 查看数据集长度 train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) print(len(train_dataset)) # 应为60000 # 2. 取第一张图，检查shape和dtype img, label = train_dataset[0] print(img.shape, img.dtype, label) # 应为torch.Size([1, 28, 28]) torch.float32 5 # 3. 可视化确认 import matplotlib.pyplot as plt plt.imshow(img.squeeze(), cmap='gray') plt.title(f'Label: {label}') plt.show()

常见问题：

• img.shape是[3,28,28]？说明transform里用了ToTensor()但没配Grayscale()，MNIST被当彩色图读了
• img.dtype是torch.uint8？说明ToTensor()没生效，可能transform顺序错了
• plt.imshow一片黑？因为ToTensor()已将像素缩放到[0,1]，cmap='gray'能正确显示

4.3 模型结构可视化：用print(model)不如用torchsummary

print(model)只显示模块层级，看不出参数量和内存占用。装torchsummary：

pip install torchsummary

然后：

from torchsummary import summary summary(model, input_size=(1, 28, 28))

输出示例：

---------------------------------------------------------------- Layer (type) Output Shape Param # ================================================================ Conv2d-1 [-1, 32, 26, 26] 320 ReLU-2 [-1, 32, 26, 26] 0 Conv2d-3 [-1, 64, 24, 24] 18,496 ReLU-4 [-1, 64, 24, 24] 0 MaxPool2d-5 [-1, 64, 12, 12] 0 Dropout2d-6 [-1, 64, 12, 12] 0 Flatten-7 [-1, 9216] 0 Linear-8 [-1, 128] 1,179,776 ReLU-9 [-1, 128] 0 Dropout2d-10 [-1, 128] 0 Linear-11 [-1, 10] 1,290 LogSoftmax-12 [-1, 10] 0 ================================================================ Total params: 1,199,882 Trainable params: 1,199,882 Non-trainable params: 0 ----------------------------------------------------------------

重点关注Param #列。Linear-8有117万参数，占总量99%，说明全连接层是参数大户。如果想压缩模型，应该先动这里，而不是去改卷积核数量。

4.4 训练过程监控：loss曲线是唯一的真理

不要只看最终准确率。在训练循环里加实时监控：

train_losses = [] train_accs = [] for epoch in range(1, 14 + 1): model.train() epoch_loss = 0 correct = 0 for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() output = model(data) loss = F.nll_loss(output, target) loss.backward() optimizer.step() epoch_loss += loss.item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() avg_loss = epoch_loss / len(train_loader) acc = 100. * correct / len(train_loader.dataset) train_losses.append(avg_loss) train_accs.append(acc) print(f'Epoch {epoch}: Loss {avg_loss:.4f}, Acc {acc:.2f}%')

典型健康曲线：

• Loss：从3.0开始，10个epoch内降到0.05以下，全程单调下降
• Acc：从10%（随机猜）开始，10个epoch内升到99%以上

异常信号：

• Loss震荡剧烈（±0.5）：学习率太大，调小10倍
• Loss缓慢下降（10个epoch只降0.1）：学习率太小，调大10倍
• Acc卡在92%不上升：可能是Dropout率太高，或网络容量不足

我实测过，把Dropout2d(0.25)改成Dropout2d(0.7)，Acc永远卡在95%——因为网络学不会任何东西，全靠随机。

5. 常见问题与排查技巧实录：那些让我熬夜到三点的Bug

5.1 “RuntimeError: mat1 and mat2 shapes cannot be multiplied” —— 展平尺寸错位

现象：self.fc1(x)报错，提示mat1: (64x9216), mat2: (1600x128)
原因：fc1的输入维度设为1600，但x的实际shape是(64,9216)
排查步骤：

1. 在forward里print(x.shape)，定位出问题的层
2. 回溯计算：conv1输出26×26，conv2输出24×24，max_pool2d后12×12，64*12*12=9216，确认fc1的输入应为9216
3. 修改self.fc1 = nn.Linear(9216, 128)

根本解法：不用硬编码，用torch.numel()动态计算：

x = torch.flatten(x, 1) self.fc1 = nn.Linear(x.numel() // x.size(0), 128) # x.size(0)是batch_size

5.2 “ValueError: Expected input batch_size (64) to match target batch_size (32)” —— DataLoader的batch_size不一致

现象：F.nll_loss(output, target)报错，output是64×10，target是32维
原因：train_loader的batch_size=64，但某次迭代时数据不足64，DataLoader自动缩减batch，而target没同步调整
真相：这是PyTorch DataLoader的默认行为，但nll_loss要求output和target第一维严格相等
解决方案：设置drop_last=True，丢弃最后一个不完整batch：

train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=64, shuffle=True, drop_last=True # 关键！ )

5.3 “CUDA out of memory” —— 显存爆炸的静默杀手

现象：训练几轮后突然报错，显存占用从2GB飙到12GB
原因：model.eval()后忘了model.train()，Dropout和BatchNorm失效，但梯度计算仍在进行，中间变量缓存不释放
排查命令：

# Linux/macOS实时监控 nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits

终极方案：在训练循环里加显存清理：

for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() output = model(data) loss = F.nll_loss(output, target) loss.backward() optimizer.step() # 强制清理GPU缓存 if torch.cuda.is_available(): torch.cuda.empty_cache()

5.4 “Accuracy stuck at 10%” —— 学习率设置的致命误区

现象：10个epoch后Acc始终≈10%，和随机猜一样
原因：学习率设为lr=0.001，但Adadelta的默认lr是1.0，0.001太小，参数几乎不动
验证方法：打印optimizer.param_groups[0]['lr']，确认是否为你设定的值
正确做法：Adadelta是自适应学习率，不需要手动调lr，用默认1.0即可。如果换Adam，再设lr=0.001。

5.5 “Test accuracy is 99.5%, but real images fail” —— 归一化不一致

现象：在MNIST测试集上准确率99.5%，但自己手写数字拍照识别全错
原因：测试时用了transforms.Normalize((0.1307,), (0.3081,))，但手写图没做同样归一化
解决方案：预处理必须完全一致。对手写图：

# 1. 转灰度、缩放28x28、转Tensor # 2. 手动归一化：img = (img - 0.1307) / 0.3081

我做过实验：用手机拍一张白纸黑字的“5”，不归一化时模型输出[0.9,0.01,...]，归一化后变成[0.02,0.95,...]——差了一个数量级。归一化不是可选项，是生产部署的必选项。

6. 进阶思考：从MNIST到真实项目的思维跃迁

跑通MNIST只是起点。真正的挑战在于：如何把这套思维迁移到复杂场景？分享三个关键跃迁点：

6.1 从“固定尺寸”到“动态尺寸”：图像预处理的范式升级

MNIST强制28×28，但真实世界图片尺寸千变万化。解决方案不是暴力resize，而是保持长宽比的填充（padding）：

# 先resize短边到256，再center crop 224 transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])

这里的mean/std是ImageNet统计值，不是MNIST的。记住：归一化参数必须和训练数据同源，混用等于自杀。

6.2 从“单任务”到“多任务”：损失函数的组合艺术

MNIST只有分类，但真实项目常需多目标。比如车牌识别：既要分类字符（'A','B'...），又要回归坐标（x,y,w,h）。损失函数不能简单相加：

# 错误：等权重相加，两个loss量纲不同 total_loss = cls_loss + reg_loss # 正确：用可学习权重平衡 cls_weight = nn.Parameter(torch.tensor(1.0)) reg_weight = nn.Parameter(torch.tensor(1.0)) total_loss = cls_weight * cls_loss + reg_weight * reg_loss

这样网络会自动学习哪个任务更重要。

6.3 从“本地训练”到“云上部署”：模型序列化的黄金法则

训练完的.pt文件不能直接部署。必须：

1. model.eval()：关闭Dropout/BatchNorm
2. torch.no_grad()：禁用梯度计算，节省内存
3. model.cpu()：转CPU，避免GPU依赖
4. torch.jit.script(model)：转TorchScript，脱离Python解释器

model.eval() example = torch.rand(1, 1, 28, 28) # 构造示例输入 traced_script_module = torch.jit.trace(model, example) traced_script_module.save("mnist_model.pt")

这个.pt文件可在C++、Java、iOS、Android上直接加载，这才是工业级交付。

最后再分享一个小技巧：每次写完forward函数，立刻在下面加一行assert x.shape[1] == 10（对MNIST）。这行断言不会影响训练，但一旦网络结构改动导致输出维度不对，它会第一时间报错，而不是让你在nll_loss里抓瞎。这种防御性编程习惯，是我从三次线上事故里换来的教训。