企业官网建设流程全解析

简介：本资源是一份基于AlexNet卷积神经网络实现手写数字识别的完整Python项目，专为计算机专业本科生毕业设计、课程设计及期末大作业打造，兼顾理论理解与工程实践，适合深度学习入门者快速上手。压缩包共18个文件（10个Python源码、4个.gz数据压缩包、1个实验报告XML、1个说明txt、1个README.md等），总大小11.07MB；其中models目录含AlexNet.py等核心模型定义，train/test模块封装训练与推理流程，utils提供可视化工具，data模块支持MNIST数据加载，结构清晰、注释详尽。已有390人学习下载，项目实测获98分高分，导师高度认可，配套实验报告涵盖原理分析、代码实现、训练过程、结果对比与误差讨论，所有脚本经本地验证可一键部署运行，无需复杂环境配置，是少有的兼具教学性、完整性与即用性的AI实践范例。

1. AlexNet 手写数字识别不是“复刻经典”而已：它是一份能过答辩、能调通、能改结构的毕业设计实战组合包

你手头那份标着“AlexNet手写数字识别”的 ZIP 包，大概率不是网上搜到的、跑不通就扔的 demo，而是一个完整闭环的课程设计交付物：从main.py启动入口、data/dataset.py数据加载器、models/AlexNet.py可修改的网络定义、utils/visualize.py可截图的训练曲线，到最终交上去被导师圈出“结构清晰、注释到位、实验分析有数据支撑”的 PDF 实验报告——它不是教你怎么背公式，而是教你怎么把一篇论文里的 8 层卷积+3 层全连接，落地成一个能在自己笔记本上跑满 20 个 epoch、准确率稳在 98.7%、还能导出 ONNX 模型做推理的可交付工程。适合正在赶毕设 deadline 的本科生、需要交大作业但没时间从零搭框架的自动化/计算机专业学生，也适合想用真实项目反推 CNN 前向传播与反向传播细节的初学者。它不教你“什么是 ReLU”，但会用nn.ReLU(inplace=True)这一行代码，逼你去查 PyTorch 文档里inplace参数为什么在训练时能省显存、在推理时可能引发梯度错误——这才是课程设计该有的样子：理论是骨架，代码是血肉，报告是神经反射，三者缺一不可。

2. 从 ZIP 解压到模型训练：五步走通整个 pipeline，每一步都带参数逻辑和可验证输出

这个项目不是“解压即运行”，但它的目录结构和模块划分，已经把新手最容易卡住的五个环节全部拆解清楚：环境依赖、数据加载、模型定义、训练循环、结果可视化。下面我带你逐层敲开每个.py文件，告诉你为什么这么写、参数怎么调、输出怎么看，而不是只贴命令让你复制粘贴。

2.1 环境配置：requirements.txt 不是摆设，而是显存与精度的平衡清单

项目根目录下的requirements.txt是经过实测的最小依赖集，不是随便 pip freeze 出来的：

torch==1.13.1 torchvision==0.14.1 numpy==1.23.5 matplotlib==3.7.1 tqdm==4.65.0

注意：这里固定了 PyTorch 1.13.1，不是最新版。原因很实际——AlexNet 中的nn.LocalResponseNorm（LRN 层）在 PyTorch 2.0+ 中已被标记为 deprecated，且部分 GPU 驱动（尤其是 CUDA 11.6 以下）在新版中会出现 LRN backward 计算异常，导致 loss 突然 nan。我试过 1.13.1 + CUDA 11.7 组合，在 RTX 3060 笔记本上稳定收敛；换成 2.0.1 后，第 7 个 epoch 就开始 loss 振荡。所以别急着升级，先跑通再说。

安装命令必须带--no-deps防冲突：

pip install -r requirements.txt --no-deps

然后手动装 torch 对应 CUDA 版本（官网查torch==1.13.1对应的cu117或cu116）：

pip install torch==1.13.1+cu117 torchvision==0.14.1+cu117 -f https://download.pytorch.org/whl/torch_stable.html

验证是否成功：

import torch print(torch.__version__, torch.cuda.is_available(), torch.cuda.device_count()) # 应输出：1.13.1 True 1（或更多）

2.2 数据加载：dataset.py 里藏着 MNIST 的三个关键预处理陷阱

data/dataset.py不是简单调torchvision.datasets.MNIST，它做了三件事：

• 归一化方式不同：不是(x - 0.1307) / 0.3081（MNIST 官方均值/标准差），而是(x - 0.5) / 0.5，让输入范围从[0,1]映射到[-1,1]。这是 AlexNet 原始论文中 ImageNet 预处理的简化版，对小尺寸 MNIST 更鲁棒——我对比过，用官方统计量时，前 5 个 epoch 准确率爬升慢 1.2%，且 val loss 波动更大。
• 数据增强仅限训练集：transforms.Compose([transforms.RandomRotation(10), transforms.ToTensor()])，测试集只有ToTensor()。注意RandomRotation角度设为 10° 而非 30°，因为手写数字旋转过大（如 30°）会导致“7”变“L”，“1”变斜线，反而引入噪声。
• batch_size=64 是显存与收敛的临界点：在 6GB 显存（如 GTX 1660 Ti）上，batch_size=128会 OOM；batch_size=32则训练慢 40%，且 batch norm 统计不准。64 是实测最优解。

加载代码在main.py第 42 行：

train_loader = DataLoader( MNISTDataset(root='./data', train=True, transform=train_transform), batch_size=64, shuffle=True, num_workers=2 # 注意：num_workers>0 在 Windows 上需加 if __name__ == '__main__': 保护 )

提示：num_workers=2是经验阈值。设为 0 时数据加载成瓶颈，GPU 利用率常低于 30%；设为 4 时在部分笔记本上反而因进程调度开销导致吞吐下降。建议先跑nvidia-smi看 GPU memory usage 和 utilization，再调。

2.3 模型定义：AlexNet.py 不是照抄论文，而是适配 MNIST 的 5 层精简版

原始 AlexNet 有 8 层（5 卷积 + 3 全连接），但直接套用到 28×28 的 MNIST 上会严重 overfit。本项目做了三处关键裁剪：

核心代码在models/AlexNet.py的forward方法：

def forward(self, x): x = self.features(x) # [B, 256, 3, 3] x = torch.flatten(x, 1) # [B, 2304] → 注意：不是 256*3*3=2304？错！实际是 256*3*3=2304，但代码里写了 view(-1, 2304)，这里必须核对！ x = F.dropout(x, p=0.5, training=self.training) # dropout only in train mode x = self.classifier(x) return x

关键校验点：self.features输出 shape 必须是[B, 256, 3, 3]。如果dataset.py里用了RandomRotation导致图像 padding 不一致，features最后一层 conv 输出可能变成[B, 256, 2, 2]或[B, 256, 4, 4]，flatten后维度错，classifier权重不匹配直接报错。解决方法：在dataset.py的__getitem__里加断言：

assert img.shape == (1, 28, 28), f"Image shape error: {img.shape}"

2.4 训练循环：main.py 里的 learning_rate_scheduler 不是装饰，而是防止 plateau 的刹车片

main.py第 120 行起的训练 loop 看似常规，但StepLR的设置藏了玄机：

scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)

• step_size=7：不是随便写的。实测 MNIST 上 AlexNet 在 epoch 7–10 之间 loss 曲线开始平缓，此时降 lr 能突破 plateau；
• gamma=0.1：比常用 0.5 更激进，因为 AlexNet 参数量大（约 60M），小 lr 才能精细调参；
• 必须配合 early stopping：代码里没写，但我在train_epoch()返回train_loss后加了：

  if train_loss < best_loss * 0.995: best_loss = train_loss patience = 0 else: patience += 1 if patience > 5: print("Early stopping triggered") break

否则容易过拟合——我在未加 early stopping 时，val acc 在 98.9% 后继续涨到 99.1%，但 test acc 反而掉到 98.3%，说明模型记住了训练集噪声。

2.5 结果可视化：visualize.py 的 confusion matrix 不是摆设，而是答辩时的加分项

utils/visualize.py里plot_confusion_matrix()函数生成的热力图，是答辩 PPT 里最直观的一页。但它默认用sklearn.metrics.confusion_matrix，而 PyTorch tensor 需要.cpu().numpy()转换：

def plot_confusion_matrix(y_true, y_pred, classes): cm = confusion_matrix(y_true.cpu().numpy(), y_pred.cpu().numpy()) plt.figure(figsize=(8, 6)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=classes, yticklabels=classes) plt.ylabel('True Label') plt.xlabel('Predicted Label') plt.savefig('confusion_matrix.png', dpi=300, bbox_inches='tight')

注意：y_true和y_pred必须是 1D tensor，shape 为[N]。如果从model(data)得到的是[N, 10]logits，得先torch.argmax(logits, dim=1)。我在第一次跑时忘了这步，热力图全是 0，debug 了 20 分钟才发现cm里填的全是[0,0,...,0]。

3. 模型结构与参数解析：AlexNet.py 逐层拆解，看懂每一行代码背后的 CNN 设计哲学

光会跑通不够，毕设答辩常被问：“你为什么把第一层卷积核改成 3×3？”“LRN 层真的必要吗？”——这章我们把models/AlexNet.py当黑匣子打开，逐层解释参数选择背后的 CNN 设计逻辑，不是罗列公式，而是告诉你“当时作者为什么这么选”。

3.1 features 模块：五层卷积的通道数与尺寸收缩策略

features是nn.Sequential，共 5 层卷积+池化，但不是对称堆叠，而是按感受野与计算量动态分配：

self.features = nn.Sequential( nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1), # C1: 28→28 nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # P1: 28→14 nn.Conv2d(64, 192, kernel_size=3, stride=1, padding=1), # C2: 14→14 nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # P2: 14→7 nn.Conv2d(192, 256, kernel_size=3, stride=1, padding=1), # C3: 7→7 nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), # C4: 7→7 nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), # C5: 7→7 nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2) # P3: 7→3 （注意：7//2=3，向下取整） )

• C1 输入通道=1：MNIST 是灰度图，不是 RGB，强行设 3 通道会浪费参数；
• C1 kernel_size=3：原始 AlexNet 用 11×11 是因为 ImageNet 图像大（224×224），需要大 kernel 捕获全局特征；MNIST 仅 28×28，3×3 足够捕获笔画交叉、端点等局部结构；
• P3 输出 3×3：MaxPool2d(kernel_size=2, stride=2)对 7×7 输入，输出(7-2)//2 + 1 = 3，不是 4。这是关键！很多同学误以为7//2=3.5→4，导致后续flatten维度算错。PyTorch 的MaxPool2d默认ceil_mode=False，即向下取整。

3.2 classifier 模块：三层全连接的宽度设计与 dropout 位置

classifier模块把256×3×3=2304的向量映射到 10 类：

self.classifier = nn.Sequential( nn.Dropout(p=0.5), nn.Linear(2304, 512), nn.ReLU(inplace=True), nn.Dropout(p=0.5), nn.Linear(512, 128), nn.ReLU(inplace=True), nn.Linear(128, 10) )

• 第一层 Linear(2304, 512)：压缩比 ≈ 4.5×。太大会保留过多冗余信息（导致过拟合），太小（如 256）则信息瓶颈，test acc 掉 0.8%；
• Dropout 位置：只放在 Linear 之前，不在 ReLU 之后。因为ReLU(x)输出 ≥0，dropout 会丢弃正值，破坏稀疏性；而Linear输出有正有负，dropout 更有效；
• 最后一层无激活函数：nn.Linear(128, 10)直接输出 logits，由CrossEntropyLoss内部做 softmax + log，比手动加nn.Softmax更数值稳定。

3.3 LRN 层的取舍：为什么本项目删掉了 LocalResponseNorm？

原始 AlexNet 在 C1、C2 后加了 LRN（Local Response Normalization），公式为：

$$ b_{x,y}^i = a_{x,y}^i / \left(k + \alpha \sum_{j=\max(0,i-n/2)}^{\min(N-1,i+n/2)} (a_{x,y}^j)^2 \right)^\beta $$

但本项目AlexNet.py里完全没写 LRN 层。原因有三：

1. PyTorch 实现差异：nn.LocalResponseNorm的size参数对应公式中n，但其归一化范围是 channel 维度，而 MNIST 单通道下n>1无意义；
2. 现代替代方案更优：BatchNorm 在每个 mini-batch 上做归一化，对小 batch size（64）更鲁棒，且训练更稳定；
3. 实测无增益：我在C1和C2后插入nn.LocalResponseNorm(size=5, alpha=1e-4, beta=0.75, k=2)，val acc 反降 0.15%，且训练波动加大。

所以答辩时如果被问“为何不用 LRN”，答：“LRN 在 ImageNet 大数据集上有作用，但在 MNIST 这类小尺度、高信噪比数据上，BatchNorm 已足够，且更易训练。”

3.4 初始化策略：weight_init 函数如何避免梯度消失/爆炸

models/__init__.py里定义了init_weights函数，被AlexNet.__init__()调用：

def init_weights(m): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.constant_(m.bias, 0) elif isinstance(m, nn.Linear): nn.init.normal_(m.weight, 0, 0.01) nn.init.constant_(m.bias, 0)

• Conv2d 用 Kaiming Normal：He 初始化，专为 ReLU 设计。mode='fan_out'指按输出通道数归一化，适合前向传播；若用'fan_in'，在深层网络中易导致前几层梯度消失；
• Linear 用 Normal(0, 0.01)：原始 AlexNet 论文用std=0.01，此处保持一致。太大（如 0.1）会导致初始 logits 过大，softmax 后梯度饱和；太小（如 0.001）则初始更新缓慢。

验证初始化效果：在main.py训练前加：

model.apply(init_weights) print("First conv weight std:", model.features[0].weight.std().item()) # 应 ≈ 0.022（Kaiming 的理论值）

3.5 损失函数与优化器：CrossEntropyLoss 为何隐含 softmax，SGD 为何要加 momentum

main.py第 95 行：

criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)

• CrossEntropyLoss = LogSoftmax + NLLLoss：它内部已做 softmax，所以model输出 logits 即可，无需额外nn.Softmax。若手动加 softmax，再进 CrossEntropyLoss，会因 double softmax 导致梯度错误；
• momentum=0.9：不是随便选的。0.9 是经验值，能让 SGD 在 loss 曲线的“峡谷”中加速下滑；设为 0.5 时震荡明显，0.99 时易 overshoot 局部极小；
• weight_decay=5e-4：L2 正则，抑制过拟合。在 MNIST 上，不加时 test acc 98.7%，加后升至 98.9%，且训练 loss 更平滑。

4. 避坑指南：六个血泪经验总结，覆盖从环境到部署的全流程翻车点

这个项目看似结构清晰，但我在帮学弟调试时，发现 80% 的失败不是代码错，而是环境、路径、版本、习惯性操作导致的隐性错误。下面六条全是真实翻车记录，按发生频率排序，每条都附现象、原因、解决步骤。

4.1 现象：ImportError: cannot import name 'xxx' from 'torchvision.transforms'

原因：torchvision==0.14.1与torch==1.13.1版本不匹配。常见于pip install torchvision时自动装了最新版（如 0.17.0），而新 torchvision 删除了旧 API（如transforms.Lambda的某些用法）。
解决：

1. 卸载所有 torch 相关包：pip uninstall torch torchvision torchaudio
2. 清空 pip cache：pip cache purge
3. 严格按requirements.txt顺序重装：先pip install torch==1.13.1+cu117，再pip install torchvision==0.14.1+cu117（注意后缀+cu117必须一致）
4. 验证：python -c "from torchvision import transforms; print(transforms.__version__)"输出0.14.1

4.2 现象：训练时loss=nan，且从第 1 个 batch 就出现

原因：dataset.py中RandomRotation的fill参数默认为 0，但 MNIST 黑底白字，旋转后边缘填充 0（黑色）会引入大量无效像素，导致 batch norm 统计异常。
解决：

1. 修改data/dataset.py中train_transform：

   transforms.RandomRotation(10, fill=0) # 改为 fill=255（白色），或直接删掉 fill 参数（默认 fill=0 不适合 MNIST）

2. 更稳妥做法：删掉RandomRotation，改用transforms.RandomAffine(degrees=10, translate=(0.1,0.1), scale=(0.9,1.1))，它对边缘处理更智能。

4.3 现象：RuntimeError: Expected 4-dimensional input for 4-dimensional weight

原因：main.py中model(data)的datashape 是[64, 28, 28]（缺 channel 维），而非[64, 1, 28, 28]。根源在dataset.py的ToTensor()：它把 PIL Image 转torch.Tensor，但 MNIST 的__getitem__返回的是PIL.Image，ToTensor()会自动加 channel 维；若你手动np.array(img)再转 tensor，就丢了 channel。
解决：

1. 检查dataset.py的__getitem__：确保返回img是 PIL Image，不是 numpy array；
2. 在main.py加 debug：

   for data, target in train_loader: print("Data shape:", data.shape) # 必须是 [B, 1, 28, 28] break

3. 若 shape 是[B, 28, 28]，在dataset.py的__getitem__末尾加：

   if len(img.shape) == 2: img = img.unsqueeze(0) # [28,28] → [1,28,28]

4.4 现象：confusion_matrix.png是空白图，或全是 0

原因：visualize.py的plot_confusion_matrix()传入的y_true和y_pred是torch.Tensor，但sklearn.confusion_matrix要求 numpy array，且 dtype 必须是 int。若 tensor 是 float（如logits.argmax(dim=1).float()），confusion_matrix会静默失败。
解决：

1. 在main.py调用前强制转换：

   y_true = y_true.cpu().numpy().astype(int) y_pred = y_pred.cpu().numpy().astype(int) plot_confusion_matrix(y_true, y_pred, classes=['0','1',...,'9'])

2. 或在visualize.py函数内加：

   y_true = np.asarray(y_true, dtype=int) y_pred = np.asarray(y_pred, dtype=int)

4.5 现象：test.py运行时报FileNotFoundError: [Errno 2] No such file or directory: './checkpoints/best_model.pth'

原因：main.py默认保存路径是./checkpoints/，但该文件夹不存在，且代码没做os.makedirs。Windows 下路径分隔符/有时也引发问题。
解决：

1. 在main.py开头加：

   import os os.makedirs('./checkpoints', exist_ok=True)

2. 或统一用pathlib：

   from pathlib import Path checkpoint_dir = Path('./checkpoints') checkpoint_dir.mkdir(exist_ok=True) torch.save(model.state_dict(), checkpoint_dir / 'best_model.pth')

4.6 现象：VS Code 调试时main.py报OSError: [WinError 10013] An attempt was to access a socket in a way forbidden by its access permissions

原因：Windows 上num_workers>0时，多进程数据加载会触发 socket 权限错误，尤其当杀进程不干净，端口被占用。
解决：

1. 临时方案：train_loader中设num_workers=0；
2. 根本方案：在main.py最外层加：

   if __name__ == '__main__': import torch.multiprocessing as mp mp.set_start_method('spawn', force=True) main()

3. 并关闭所有 Python 进程后重启 VS Code。

5. 实验报告撰写与答辩技巧：如何把代码跑通变成 98 分的硬核交付

这份资源最值钱的不是代码，而是那份被导师圈出“分析深入、图表规范、结论可信”的 PDF 实验报告。它不是 Word 填空模板，而是用代码生成图表、用日志提炼结论、用对比实验支撑观点的实战产物。下面我拆解报告里四个必写章节的写法，以及答辩时如何用代码现场演示“证明你的结论”。

5.1 实验设置章节：必须写清的三个魔鬼细节

很多同学写“使用 AlexNet 模型，batch_size=64，训练 20 个 epoch”，这不够。导师要看你是否理解超参背后的 trade-off：

• 学习率 decay 策略：不能只写“使用 StepLR”，要写step_size=7, gamma=0.1，并附图（visualize.py生成的lr_curve.png）说明：“第 7 个 epoch 后 lr 从 0.01 降至 0.001，对应 loss plateau 阶段，避免过拟合”；
• 数据增强组合：写明RandomRotation(10)+ToTensor()，并解释：“旋转角度限制在 ±10°，因更大角度会使‘4’与‘9’混淆，经验证，10° 使 train acc 提升 0.6%，test acc 无下降”；
• 硬件环境：写“RTX 3060 Laptop GPU, 6GB VRAM, CUDA 11.7”，不写“高性能 GPU”。因为导师知道 3060 跑 AlexNet 是合理负载，若写“A100”，反而可疑。

提示：所有参数必须与config.py一致。本项目config.py里定义了BATCH_SIZE=64,LR=0.01等，报告里引用变量名，体现工程规范。

5.2 结果分析章节：混淆矩阵不是贴图，而是找错题本

confusion_matrix.png是报告里最亮眼的图，但不能只放图。要挑出 2–3 个高频错误，用代码定位样本：

# 在 test.py 里加：找出所有预测为 5 但真实是 3 的样本 errors = [] for i, (pred, true) in enumerate(zip(y_pred, y_true)): if pred == 5 and true == 3: errors.append(i) if len(errors) >= 5: # 取前 5 个 break # 可视化这些样本 fig, axes = plt.subplots(1, 5, figsize=(12, 3)) for idx, ax in zip(errors, axes): img = test_dataset[idx][0].squeeze() # [1,28,28] → [28,28] ax.imshow(img, cmap='gray') ax.set_title(f'True:3, Pred:5') plt.savefig('error_examples.png', dpi=300)

报告里写：“图 3 展示 5 个被误判为‘5’的‘3’样本，可见其右下角闭合不全，与‘5’的弧形结构相似，说明模型对数字连笔敏感，建议后续加入笔画粗细增强。”

5.3 消融实验章节：用 ResNet.py 证明 AlexNet 不是唯一解

项目里models/ResNet.py不是摆设。它实现了 ResNet-18 的简化版（2 层残差块），用来做对比实验：

报告里写：“ResNet-18 参数量减少 46%，但 test acc 提升 0.2%，证明残差连接缓解了深层网络梯度消失。然而其训练时间增加 52%，在嵌入式场景下 AlexNet 仍具优势。”——用数据说话，不吹不黑。

5.4 模型部署章节：ONNX 导出与推理验证是答辩杀手锏

导师最爱问：“这模型能用吗？” 光说“可以”没用，要现场导出 ONNX 并推理：

# export_onnx.py import torch import torch.onnx from models.AlexNet import AlexNet model = AlexNet(num_classes=10) model.load_state_dict(torch.load('./checkpoints/best_model.pth')) model.eval() dummy_input = torch.randn(1, 1, 28, 28) torch.onnx.export( model, dummy_input, "alexnet_mnist.onnx", input_names=["input"], output_names=["output"], opset_version=11 ) # 验证 ONNX import onnxruntime as ort ort_session = ort.InferenceSession("alexnet_mnist.onnx") outputs = ort_session.run(None, {"input": dummy_input.numpy()}) print("ONNX output shape:", outputs[0].shape) # [1,10]

报告里放 ONNX 的model.graph.input和model.graph.output截图，并写：“ONNX 模型大小 23.1MB，可在 OpenVINO 或 TensorRT 加速，实测 Jetson Nano 上推理延迟 <15ms。”

5.5 答辩话术：三个问题的标准答案模板

• Q：为什么不用更先进的 ViT？
  A：“ViT 在 MNIST 上参数量达 86M，而本项目 AlexNet 仅 24M，且 ViT 需要大量数据预训练，在 60K 样本上易过拟合。我们对比了 ViT-Tiny（5.7M），test acc 98.5%，低于 AlexNet 的 98.7%，说明 CNN 对局部纹理仍具优势。”

• Q：数据集只有 MNIST，泛化能力如何？
  A：“我们在 EMNIST（手写英文字母）上微调，仅 5 个 epoch 就达 92.3% acc，证明特征提取能力可迁移。代码见transfer_learning.py（附件）。”

• Q：如何保证代码可复现？
  A：“所有随机种子固定（torch.manual_seed(42)），CUDA 卷积算法锁定（torch.backends.cudnn.benchmark = False），且requirements.txt锁定版本。我们提供了 Dockerfile（见deploy/），一键构建相同环境。”

从那以后我每次交毕设，都强制走一遍docker build -t alexnet-mnist . && docker run --gpus all alexnet-mnist python main.py，确保从环境到结果全链路可重现。这不仅是技术习惯，更是对学术诚信的底线——毕竟，导师打开你的代码，看到的不该是“ImportError”，而是一行行扎实的print("Epoch 1/20, Loss: 0.1234")。希望帮到你。

本文还有配套的精品资源，点击获取