企业官网建设流程全解析

简介：这份深度学习理论与实战PyTorch实现资源包，面向希望系统入门并进阶深度学习的学习者，尤其适合需要从Python基础过渡到PyTorch框架、再深入CNN、LSTM、GAN与强化学习等方向的开发者。包内视频与代码配套齐全，涵盖Python基础、PyTorch基础等入门课程，以及神经网络、卷积神经网络、循环神经网络、生成对抗网络和强化学习等进阶内容，省去四处搜集课程与源码的麻烦。压缩包整体约626.93MB，以视频课程与配套代码为主要文件类型，视频用于跟随讲解理解原理，代码则便于动手复现与调试实验。目前已有1513人学习下载，说明其内容组织具备一定参考价值。学习者可借助完整课程体系与可运行源码，逐步掌握从环境搭建、模型定义到训练调参的完整流程，并在CNN、LSTM、GAN与强化学习等典型任务中积累实战经验，形成可迁移的深度学习工程能力。

1. 拿到「深度学习理论与实战PyTorch实现.zip」先别急着解压：这份资料到底该按什么顺序啃

很多人拿到一个叫「深度学习理论与实战PyTorch实现.zip」的压缩包，第一反应是解压、翻目录、找main.py跑一下，然后发现报错、缺包、显存不够，最后把它扔进硬盘角落。我见过太多这样的案例，包括我自己早期也是这么干的。问题不在资料本身，而在于没有先想清楚：这份资料是「理论书 + 代码实现」的混合体，它的正确打开方式不是从头读到尾，也不是直接跑代码，而是先建立一条「理论概念 → PyTorch API → 最小可运行实验 → 完整项目」的映射链。

这份资料适合谁？如果你已经会 Python 基础语法，知道for循环和函数怎么写，但看到nn.Module、autograd、DataLoader就发怵，那它正好卡在你的学习区。如果你已经能跑通 MNIST 分类，但说不清loss.backward()到底干了什么，这份资料也能帮你把「调包」变成「理解」。但如果你连 Python 列表推导式都写不利索，建议先补语言基础，否则 PyTorch 的报错会让你怀疑人生。

我一般会把这类资料拆成三条线并行推进：第一条线是理论线，搞清楚每个算法解决什么问题、输入输出是什么、损失函数为什么长那样；第二条线是 API 线，把理论里的数学符号对应到 PyTorch 的Tensor、Module、Optimizer上；第三条线是实验线，用最小数据集（比如随机生成的张量或 sklearn 的 iris）先跑通前向传播，再逐步加数据加载、训练循环、验证。三条线拧在一起，才不会出现「理论看懂了但代码写不出」或者「代码跑通了但不知道在干嘛」的割裂。

接下来的章节，我会按这个顺序展开：先讲环境搭建和版本匹配这个最容易翻车的地方，再讲怎么用 PyTorch 实现一个最小可训练的模型，然后深入数据管道和训练循环的细节，接着是 CNN、RNN、Transformer 这些常见结构的 PyTorch 写法，最后给出一套排查训练不收敛的实战技巧。每一章都尽量落到可复现的命令和代码上，不堆概念。

2. 环境搭建与版本匹配：PyTorch 安装教程里不会告诉你的五个细节

2.1 为什么你的pip install torch装完却用不了 GPU

很多人照着 PyTorch 安装教程超详细版一步步敲命令，装完import torch没问题，但torch.cuda.is_available()返回False。最常见的原因不是驱动没装，而是 pip 默认给你装了 CPU 版本。PyTorch 从 1.13 开始把 CUDA 版本和 CPU 版本分开发布，如果你直接pip install torch，在没有额外指定 index-url 的情况下，大概率拿到的是 CPU-only 的 wheel。

正确的做法是先确认你的显卡驱动支持的 CUDA 最高版本。在终端运行nvidia-smi，看右上角显示的CUDA Version，比如12.4，那你可以装 CUDA 12.1 或 11.8 的 PyTorch 构建。然后去 PyTorch 官网的 previous versions 页面找到对应的安装命令，通常长这样：

# 以 CUDA 11.8 为例，从官方 wheel 源安装 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

注意--index-url后面跟的是 PyTorch 自己的 wheel 仓库，不是 PyPI。如果你用了国内镜像源加速，要确认镜像源同步了 PyTorch 的 CUDA wheel，否则还是会装成 CPU 版。装完后用下面这段代码验证：

import torch print(torch.__version__) # 应该带 +cu118 后缀 print(torch.cuda.is_available()) # True 才说明 GPU 可用 print(torch.cuda.get_device_name(0)) # 显示显卡型号

如果torch.__version__显示2.x.x+cpu，那就是装错了，先pip uninstall torch torchvision torchaudio再重装。

2.2 Python 和 PyTorch 版本对应关系：别用 3.12 配 1.x

Python 和 PyTorch 版本对应是个硬约束。PyTorch 1.x 系列最高支持到 Python 3.9 左右，PyTorch 2.0 开始支持 3.8 到 3.11，PyTorch 2.2 之后才逐步支持 3.12。如果你用 Python 3.12 去装 PyTorch 1.13，pip 会直接告诉你找不到匹配的版本。我一般建议用 Python 3.10 或 3.11，这两个版本兼容性最好，绝大多数深度学习库都跟上了。

用 conda 管理环境时，可以这样建一个干净的环境：

# 创建名为 dl 的环境，指定 Python 3.10 conda create -n dl python=3.10 conda activate dl # 再按上面的 pip 命令装 PyTorch

如果你在 WSL 里搭环境，注意 WSL2 的 CUDA 支持需要 Windows 端驱动版本足够新，并且不要在 WSL 里再装一遍显卡驱动，直接用 Windows 主机的驱动即可。AMD 显卡用户（比如 7900XTX）在 WSL 下跑 PyTorch 目前主要靠 ROCm，但 ROCm 对 WSL 的支持有限，常见做法是回到 Linux 原生环境或者用 DirectML 后端，性能会有折损，这一点要有心理预期。

2.3 验证安装是否真的能用：跑一个最小训练循环

装完环境别只看import torch成不成功，跑一个最小训练循环才能暴露问题。下面这段代码创建一个线性回归任务，用 GPU 训练 100 步，能跑通说明环境基本没问题：

import torch import torch.nn as nn # 选择设备，有 GPU 就用 GPU device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 构造数据：y = 2x + 1 加噪声 x = torch.randn(1000, 1, device=device) y = 2 * x + 1 + 0.1 * torch.randn(1000, 1, device=device) # 定义模型、损失、优化器 model = nn.Linear(1, 1).to(device) criterion = nn.MSELoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 训练循环 for step in range(100): pred = model(x) loss = criterion(pred, y) optimizer.zero_grad() loss.backward() optimizer.step() if step % 20 == 0: print(f"step {step}, loss {loss.item():.4f}") # 查看学到的参数，应该接近 2 和 1 print(model.weight.item(), model.bias.item())

这段代码的关键点：device统一管理张量位置，model.to(device)把参数搬到 GPU，optimizer.zero_grad()清空上一轮梯度，loss.backward()计算梯度，optimizer.step()更新参数。如果这五步顺序错了，比如忘了zero_grad()，梯度会累加，loss 会爆炸。如果loss一直不下降，先检查学习率是不是太大，再检查数据有没有搬到同一个设备上。

提示：在 WSL 下如果torch.cuda.is_available()返回 False，先确认 Windows 端nvidia-smi能看到显卡，再确认 WSL 里nvidia-smi也能看到。如果 WSL 里看不到，说明驱动映射有问题，重启 WSL 或更新 Windows 驱动通常能解决。

3. 从张量到训练循环：PyTorch 实战里最容易写错的四个地方

3.1 张量维度对不齐：CNN 里最常见的 shape 报错

PyTorch 的报错信息里，RuntimeError: mat1 and mat2 shapes cannot be multiplied和Expected 4D input出现频率极高。根源是张量维度没对齐。比如你定义一个全连接层nn.Linear(784, 10)，输入必须是(batch, 784)的二维张量，但如果你从 CNN 的卷积层出来，张量是(batch, channel, height, width)四维的，直接喂给全连接层就会报错。

正确的做法是在卷积层和全连接层之间加一个展平操作：

import torch import torch.nn as nn class SimpleCNN(nn.Module): def __init__(self): super().__init__() # 输入 1 通道，输出 8 通道，卷积核 3x3 self.conv = nn.Conv2d(1, 8, kernel_size=3, padding=1) self.pool = nn.MaxPool2d(2) # 经过两次池化，28x28 变成 7x7，通道数 8 self.fc = nn.Linear(8 * 7 * 7, 10) def forward(self, x): x = self.pool(torch.relu(self.conv(x))) # (B,8,14,14) x = self.pool(torch.relu(self.conv(x))) # (B,8,7,7) x = x.view(x.size(0), -1) # 展平成 (B, 392) x = self.fc(x) # (B, 10) return x model = SimpleCNN() dummy = torch.randn(4, 1, 28, 28) # batch=4, 1通道, 28x28 print(model(dummy).shape) # 应该是 torch.Size([4, 10])

x.view(x.size(0), -1)里的-1是让 PyTorch 自动推断剩余维度，x.size(0)保留 batch 维度。注意view要求张量在内存里连续，如果前面做了permute或transpose，需要先.contiguous()。另一个容易忽略的点是padding=1，没有它的话 28x28 经过 3x3 卷积会变成 26x26，再池化两次就变成 6x6，全连接层的输入维度就对不上了。

3.2 训练循环里的zero_grad和detach：不写会出玄学问题

训练循环的骨架看起来简单，但有两个地方不写就会出问题。第一个是optimizer.zero_grad()。PyTorch 的梯度默认是累加的，如果你不在每轮开始前清零，梯度会越加越大，loss 会震荡甚至变成 NaN。第二个是验证阶段要用torch.no_grad()包起来，否则验证集的前向传播也会建计算图，显存会越用越多，跑几个 epoch 就 OOM。

def train_one_epoch(model, loader, optimizer, criterion, device): model.train() # 切换到训练模式，影响 Dropout 和 BatchNorm total_loss = 0 for x, y in loader: x, y = x.to(device), y.to(device) pred = model(x) loss = criterion(pred, y) optimizer.zero_grad() # 清空上一轮梯度 loss.backward() # 反向传播计算梯度 optimizer.step() # 更新参数 total_loss += loss.item() return total_loss / len(loader) @torch.no_grad() # 验证阶段不建计算图 def evaluate(model, loader, criterion, device): model.eval() # 切换到评估模式 total_loss = 0 for x, y in loader: x, y = x.to(device), y.to(device) pred = model(x) total_loss += criterion(pred, y).item() return total_loss / len(loader)

model.train()和model.eval()的区别在于 Dropout 层和 BatchNorm 层的行为。训练时 Dropout 随机置零，BatchNorm 用当前 batch 的统计量；评估时 Dropout 不生效，BatchNorm 用训练阶段累积的 running mean 和 running var。如果你忘了切换，验证集的 loss 会忽高忽低，看起来像玄学，其实是模式没切对。

3.3 DataLoader 的num_workers和pin_memory：设对了训练快一倍

DataLoader有两个参数对训练速度影响很大：num_workers和pin_memory。num_workers控制用几个子进程加载数据，设成 0 表示在主进程加载，设成 4 或 8 可以并行加载。但设太大也会出问题，比如在 Windows 或 WSL 下，num_workers大于 0 可能因为多进程启动方式导致卡死，常见做法是设成 0 或者 2 先试。

pin_memory=True会把数据加载到锁页内存，从 CPU 搬到 GPU 时更快。这个参数在 GPU 训练时建议打开，CPU 训练时无所谓。

from torch.utils.data import DataLoader, TensorDataset # 假设 train_x, train_y 是张量 train_ds = TensorDataset(train_x, train_y) train_loader = DataLoader( train_ds, batch_size=64, shuffle=True, num_workers=2, # WSL 下建议先试 0 或 2 pin_memory=True, # GPU 训练时打开 drop_last=True # 丢弃最后一个不完整的 batch )

drop_last=True在 batch 大小不整除数据集大小时有用，避免最后一个 batch 只有一两个样本导致 BatchNorm 报错。如果你做的是分类任务且类别不平衡，shuffle=True要打开，否则模型会学到样本顺序的偏差。

3.4 损失函数和输出层不匹配：CrossEntropyLoss 前面不要加 Softmax

这是新手最容易踩的坑之一。nn.CrossEntropyLoss内部已经包含了LogSoftmax和NLLLoss，所以模型的最后一层应该是原始 logits，不要加nn.Softmax。如果你加了 Softmax，再传给 CrossEntropyLoss，相当于做了两次 Softmax，梯度会变得很小，训练几乎不动。

# 正确写法：最后一层直接输出 logits class Classifier(nn.Module): def __init__(self, in_dim, num_classes): super().__init__() self.fc = nn.Linear(in_dim, num_classes) # 不加 Softmax def forward(self, x): return self.fc(x) criterion = nn.CrossEntropyLoss() # 内部处理 Softmax

如果你做的是二分类，可以用nn.BCEWithLogitsLoss，它内部包含 Sigmoid，同样不要在模型里加 Sigmoid。只有当你需要概率值做展示时，才在推理阶段手动加torch.sigmoid或torch.softmax，训练阶段不要加。

注意：如果你从其他框架转过来，习惯了在最后一层加 Softmax，在 PyTorch 里要改掉这个习惯。判断方法很简单：看 loss 是不是从第一个 epoch 就几乎不变，如果是，先检查是不是多加了 Softmax。

4. CNN、RNN、Transformer 的 PyTorch 实现：从 MNIST 到注意力机制的落地路径

4.1 CNN 识别恶意软件图像：把二进制转成灰度图的完整流程

深度学习模型 CNN 识别恶意软件是一个典型的实战项目。思路是把可执行文件的二进制字节序列按固定宽度转成灰度图，然后用 CNN 做分类。这个做法在 Malimg 数据集上很常见，准确率能到 95% 以上。下面是一个最小实现：

import numpy as np import torch import torch.nn as nn def binary_to_image(file_path, width=256): """把二进制文件转成灰度图，每行 width 个字节""" with open(file_path, "rb") as f: data = f.read() # 补齐到 width 的整数倍 remainder = len(data) % width if remainder != 0: data += b"\x00" * (width - remainder) arr = np.frombuffer(data, dtype=np.uint8) img = arr.reshape(-1, width) # 高度自动推断 return img class MalwareCNN(nn.Module): def __init__(self, num_classes): super().__init__() self.features = nn.Sequential( nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.AdaptiveAvgPool2d((4, 4)) # 自适应池化，避免尺寸计算 ) self.classifier = nn.Linear(64 * 4 * 4, num_classes) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) return self.classifier(x)

关键点是AdaptiveAvgPool2d((4, 4))，它把任意尺寸的特征图池化成 4x4，这样全连接层的输入维度就固定了，不用手动算每层之后的尺寸。二进制转图像时，width一般取 256 或 512，太小会丢失模式，太大图像会很高，训练慢。数据增强可以用随机裁剪和水平翻转，但要注意翻转后字节顺序变了，可能影响语义，常见做法是只做随机裁剪。

4.2 LSTM 做时序预测：PyTorch LSTM 源码里的 batch_first 陷阱

PyTorch 的nn.LSTM默认batch_first=False，也就是说输入张量的形状是(seq_len, batch, input_size)。如果你习惯(batch, seq_len, input_size)，一定要设batch_first=True，否则维度对不上，报错信息还不直观。

class LSTMPredictor(nn.Module): def __init__(self, input_size, hidden_size, num_layers, output_size): super().__init__() self.lstm = nn.LSTM( input_size, hidden_size, num_layers, batch_first=True, # 输入形状 (B, T, F) dropout=0.2 if num_layers > 1 else 0 ) self.fc = nn.Linear(hidden_size, output_size) def forward(self, x): # x: (B, T, F) out, (h_n, c_n) = self.lstm(x) # 取最后一个时间步的输出 last = out[:, -1, :] return self.fc(last)

dropout只在num_layers > 1时生效，单层 LSTM 设了也没用。取最后一个时间步用out[:, -1, :]，不要用h_n[-1]，因为h_n是最后一层的隐藏状态，形状是(num_layers, B, hidden_size)，取h_n[-1]得到的是(B, hidden_size)，结果一样但语义不如out[:, -1, :]清晰。如果序列有 padding，最后一个时间步可能是 padding，需要用 mask 取实际最后一个有效步。

4.3 从零实现一个注意力模块：seq2seq 里的通用写法

Transformer 的核心是自注意力，但 seq2seq 里常用的注意力模块更简单。下面是一个通用的加性注意力实现，输入是解码器当前状态和编码器所有输出，输出是加权后的上下文向量：

import torch import torch.nn as nn import torch.nn.functional as F class AdditiveAttention(nn.Module): def __init__(self, enc_dim, dec_dim, attn_dim): super().__init__() self.W_enc = nn.Linear(enc_dim, attn_dim, bias=False) self.W_dec = nn.Linear(dec_dim, attn_dim, bias=False) self.v = nn.Linear(attn_dim, 1, bias=False) def forward(self, dec_state, enc_outputs, mask=None): # dec_state: (B, dec_dim) # enc_outputs: (B, T, enc_dim) # 计算注意力分数 score = self.v(torch.tanh( self.W_enc(enc_outputs) + self.W_dec(dec_state).unsqueeze(1) )).squeeze(-1) # (B, T) if mask is not None: score = score.masked_fill(mask == 0, -1e9) attn_weights = F.softmax(score, dim=-1) # (B, T) context = torch.bmm(attn_weights.unsqueeze(1), enc_outputs) # (B,1,enc_dim) return context.squeeze(1), attn_weights

masked_fill把 padding 位置的分数设成负无穷，softmax 之后这些位置的权重接近 0。torch.bmm做 batch 矩阵乘法，attn_weights.unsqueeze(1)形状是(B, 1, T)，enc_outputs是(B, T, enc_dim)，乘完得到(B, 1, enc_dim)。这个模块可以直接插到 seq2seq 的解码器里，每步解码时调用一次。

4.4 把 PyTorch 模型转 ONNX：部署前的最后一步

训练完的模型要部署到 C++ 或移动端，常见做法是转成 ONNX。PyTorch 提供了torch.onnx.export，但有几个参数要注意：

import torch model.eval() # 转 ONNX 前必须切到评估模式 dummy_input = torch.randn(1, 1, 28, 28) # 和实际输入形状一致 torch.onnx.export( model, dummy_input, "model.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}}, opset_version=12 # 一般用 11 或 12 )

dynamic_axes把 batch 维度设成动态，这样导出的 ONNX 模型可以接受任意 batch 大小。opset_version不要设太高，有些推理引擎不支持最新的 opset。转完后用onnxruntime验证一下输出是否和 PyTorch 一致：

import onnxruntime as ort import numpy as np sess = ort.InferenceSession("model.onnx") onnx_out = sess.run(None, {"input": dummy_input.numpy()})[0] torch_out = model(dummy_input).detach().numpy() print(np.allclose(onnx_out, torch_out, atol=1e-5)) # 应该是 True

如果输出不一致，先检查model.eval()有没有加，再检查有没有自定义算子不支持。LSTM 和注意力模块转 ONNX 时容易出问题，常见做法是把动态控制流改成静态图，或者用torch.jit.trace先 trace 一遍看哪里断了。

5. 训练不收敛、显存爆炸、loss 变 NaN：PyTorch 实战排查清单

5.1 loss 变成 NaN：从学习率和梯度裁剪查起

现象：训练几个 step 后 loss 突然变成 NaN，之后一直是 NaN。原因通常是学习率太大导致梯度爆炸，或者数据里有 NaN。解决步骤：先把学习率调小 10 倍，比如从 0.01 降到 0.001；如果还不行，加梯度裁剪：

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

这行放在loss.backward()之后、optimizer.step()之前。max_norm一般设 1.0 或 5.0。另外检查输入数据有没有 NaN，用torch.isnan(x).any()查一下。如果是混合精度训练，GradScaler没用好也会出 NaN，先关掉 AMP 跑一遍确认。

5.2 显存爆炸：用torch.cuda.memory_summary定位泄漏点

现象：训练几个 epoch 后 OOM，或者验证阶段显存越用越多。原因通常是验证阶段没加torch.no_grad()，或者把带梯度的张量存进了列表。排查方法是在 OOM 前打印显存摘要：

print(torch.cuda.memory_summary(device=None, abbreviated=False))

看Allocated memory和Reserved memory的差值，如果 Reserved 远大于 Allocated，说明有碎片。常见解决：验证和推理包torch.no_grad()；不要用loss.item()之外的张量做日志，loss本身带计算图，存多了会泄漏；DataLoader的num_workers太大也会占显存，调小试试。

5.3 训练 loss 下降但验证 loss 上升：过拟合的四个信号

现象：训练集准确率一直涨，验证集准确率涨到某个点后开始跌。这是典型过拟合。四个信号：训练 loss 持续下降，验证 loss 先降后升；训练准确率和验证准确率差距越来越大；验证 loss 的波动变大；模型在训练集上几乎完美。解决办法按优先级：加数据增强、加 Dropout、加权重衰减、减小模型容量。权重衰减在优化器里设：

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)

weight_decay一般从 1e-4 或 1e-5 试起。如果加了正则还过拟合，说明模型太大，砍掉几层或者减小隐藏维度。

5.4 GPU 利用率低：num_workers和 batch size 的平衡

现象：nvidia-smi显示 GPU 利用率只有 20% 到 30%，训练速度慢。原因通常是数据加载成了瓶颈。先看 CPU 利用率，如果某个核跑满，说明num_workers不够；如果 CPU 利用率也低，说明 batch size 太小。调整顺序：先把num_workers从 0 调到 4 或 8，再把batch_size翻倍直到显存快满。注意batch_size变大后学习率也要相应调大，一般线性缩放或开方缩放。

5.5 模型不学习：检查标签、初始化和学习率

现象：loss 从第一个 epoch 就几乎不变，准确率等于随机猜。排查顺序：先看标签有没有对齐，比如图像和标签错位；再看最后一层初始化，PyTorch 默认初始化通常没问题，但如果你自定义了层，可能初始化太小导致梯度消失；最后看学习率，太小会导致不学习，太大导致震荡。一个快速验证方法是把学习率设成 1e-3 跑 10 个 step，看 loss 有没有变化。如果还没变化，用一个小数据集（比如 100 个样本）过拟合一下，模型能过拟合说明网络结构没问题，问题在数据或训练配置。

提示：排查训练问题时，我习惯先在一个极小的数据集上跑，关掉所有正则和数据增强，确认模型能过拟合。如果能过拟合，再逐步加回正则和增强；如果不能，问题在模型结构或训练循环本身。

6. 把「深度学习理论与实战PyTorch实现」变成自己的东西：一套可复用的学习节奏

学完前面几章，你应该能跑通一个完整的 PyTorch 项目了。但「能跑通」和「能自己写」之间还有一段距离。我自己的习惯是，每学完一个模块，就把它从项目里拆出来，写成一个独立的.py文件，只保留最核心的 20 行代码，然后试着不看原代码默写一遍。默写不出来的地方，就是没真正理解的地方。

具体节奏可以这样安排：第一周只做环境搭建和最小训练循环，把zero_grad、backward、step的顺序刻进肌肉记忆；第二周实现 CNN 和 LSTM，重点搞懂维度变换，每写一个view或permute就打印一次 shape；第三周实现注意力模块和 Transformer 的编码器层，对照论文里的公式逐行翻译成 PyTorch；第四周做一次完整的项目，从数据加载到训练到导出 ONNX，走通全流程。

验证自己有没有学懂，有一个很实用的方法：拿一个训练好的模型，把某一层的权重手动改掉，看输出怎么变。比如把nn.Linear的weight设成全 0，输出应该变成只有 bias 的结果。如果能预测出改动后的输出，说明你对前向传播的理解到位了。另一个方法是把loss.backward()去掉，看参数会不会更新，答案是不会，因为梯度没算。这些实验花不了几分钟，但能帮你把「黑匣子」拆开。

我踩过最大的坑是贪多。看到 Transformer、扩散模型、强化学习都想学，结果每个都只学了皮毛。后来我强迫自己一个月只啃一个方向，把 PyTorch 官方教程里的对应章节逐行跑一遍，再自己改几个参数看效果。慢就是快，这句话在深度学习里特别成立。希望帮到你。

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