PyTorch深度学习入门：环境搭建、Tensor基础与训练实战

如果你点进这篇文章，多半是准备入坑深度学习，或者已经在坑边缘疯狂试探，搜了一圈“pytorch”“深度学习基础”“环境搭建”之后，发现信息又多又碎，不知道从哪里下手。我当年也是这么过来的，从下载Python到配CUDA，再到第一行import torch跑通，中间踩的坑比代码写的都多。现在回头看，PyTorch之所以能成为深度学习研究和工业落地的首选框架之一，核心就两个字：灵活。动态计算图让调试变得像写普通Python一样直觉化，autograd把反向传播从“手动微积分噩梦”里解放出来，nn.Module又给了你一套足够规整又不至于死板的建模接口。

这篇文章不打算写成一本文档手册，而是按照我自己从零到一跑通一个完整项目的路径来梳理：怎么把环境装好、张量是什么东西、模型怎么写、训练循环怎么搭、以及那些教材里不会明说但几乎每个人都会踩的坑。不管你是刚下载Python的新手，还是已经跑过几个MNIST但想系统补一遍基础的老手，按这个顺序往下走，心里会踏实很多。

1. 心法先行：学PyTorch之前，先想清楚深度学习在干什么

先说一个很多人忽略的问题：你上手学PyTorch之前，有没有想过深度学习到底在解决一个什么问题？我见过太多人一上来就装环境、调API，跑通了一个demo之后却连“模型为什么能变好”都说不清楚。这样学下来的结果是——换个数据集、换个任务，立刻就不会了。

深度学习本质上是在做一件事：从大量数据里自动学出一个函数映射。把一张图片变成“猫”还是“狗”的标签，把一段文字变成“积极”还是“消极”的情感判断，把一个历史序列变成未来的预测值——这些都是函数映射关系。传统方法需要人手工设计特征，告诉程序该看图片的哪个角落；深度学习不需要，它通过多层非线性变换自动提取特征，你只需要给它数据和标签，它自己迭代着优化出那组映射关系。

那怎么优化呢？这就牵出监督学习的核心闭环：前向传播算损失、反向传播求梯度、梯度下降更新参数。模型先“瞎猜”一个输出，跟真实标签一比，肯定差得很远，这个差距用一个函数量化出来就是损失值；然后通过链式法则计算出每个参数的调整方向，也就是梯度；最后顺着梯度的反方向迈一小步更新参数。循环往复，模型就越来越准。

PyTorch这个框架帮你做的，恰恰就是这个闭环里最重复、最容易出错的部分。自动求导机制把从损失到每个参数的梯度计算全部自动化，你再也不用手动去推导链式法则的每一项，也没必要自己写矩阵求导公式。它把整个流程抽象成了一套原语：Tensor承载数据，nn.Module承载模型结构，autograd承载梯度计算，Optimizer承载参数更新，DataLoader负责把数据一口一口喂给模型。

我建议你在动手敲代码之前，先把这个闭环在脑子里画一遍。不用画得多细，能说清楚“损失值从哪来、梯度往哪去、参数怎么变”就够了。这个思考过程决定了你后面调参、改结构、排查问题的时候是明明白白地改，还是瞎试一通碰运气。

2. 环境准备：CUDA、conda和PyTorch的版本匹配博弈

环境搭建大概是最能劝退新手的一关了。热搜词里“pytorch安装”“ubuntu 安装pytorch”“cuda和pytorch”“pytorch环境搭建wsl”常年霸榜，说明大家被版本问题折磨得不轻。这个步骤说难不难，但确实有它的逻辑在，捋顺了就是一马平川。

2.1 为什么一定要用conda来建虚拟环境

我见过不少新手直接在系统全局Python里pip install torch，装完之后开始跑代码，跑着跑着发现另一个项目需要TensorFlow，两个框架对Python版本和依赖库的要求互相打架，最后把自己环境搞得一团糟。这不是菜不菜的问题，是你不了解Python生态的脏乱差。

Anaconda或者Miniconda的虚拟环境，相当于给每个项目开了一间独立房间。房间里的Python版本、第三方包版本都是独立的，A项目把numpy 1.24搞烂了，B项目还是用自己房间里的1.21，互不干扰。对于深度学习这种依赖满天飞的领域来说，虚拟环境不是可选项，是必需品。

建议直接用Miniconda就够了，Anaconda自带一堆你用不上的包，白白占几个G的磁盘空间。装完之后第一件事是换国内源，不然下载速度能让你怀疑人生。用清华源就行，在用户目录下执行：

conda config --set show_channel_urls yes conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/

然后创建一个专门跑深度学习的虚拟环境，Python版本直接选3.10或者3.11，PyTorch对这两个版本支持很稳：

conda create -n dl python=3.10 conda activate dl

从此以后，所有跟PyTorch有关的操作都在这间叫dl的房间里进行，再也不用心惊胆战担心把系统搞坏。

2.2 CUDA到底该装哪个版本：一个简单可靠的选择方法

CUDA版本问题堪称“重灾区”。很多人一上来就装最新版CUDA，结果PyTorch官方还没适配，编译时报错，然后陷入“升级显卡驱动—装新版CUDA—却发现PyTorch要老版本—卸载重装—cuDNN又不对”的无限循环。

这里分享一个最省心的策略：先选PyTorch的版本，再反推需要什么CUDA。PyTorch在安装时会附带自己编译好的CUDA运行时库，你根本不需要单独安装完整版CUDA Toolkit。真正需要做的就两件事：确认显卡驱动够新，然后安装对应cu版本的PyTorch。

先看自己的NVIDIA驱动支持到什么CUDA版本：

nvidia-smi

右上角会显示CUDA Version，这个是驱动支持的上限。然后去PyTorch官网的Get Started页面，选好你的操作系统、包管理器、Python版本，直接复制它给你的安装命令。比如当前稳定版官方推荐：

conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

把这行命令跑完，PyTorch就带着自己的CUDA 12.1运行时进入你的环境了，跟系统里的CUDA根本不影响。装完之后怎么验证是否生效？在Python里跑：

import torch print(torch.__version__) # PyTorch版本 print(torch.cuda.is_available()) # CUDA是否可用，最关键的验证 print(torch.cuda.get_device_name(0)) # 显卡名称

如果打印出来显卡名称，说明GPU加速已经可用了。如果torch.cuda.is_available()返回的是False，多半是因为你装的PyTorch是CPU版本，直接卸掉换带cuda标识的版本就行：pip uninstall torch然后重新pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121。

2.3 训练跑不动？先用CPU把程序跑通，再切换到GPU

一个不少人会踩的坑是：一上来就非得把GPU环境弄好才肯开始写模型。结果卡了两天CUDA，一行深度学习代码都没写。

我的建议是：先用CPU版本把全流程跑通，再切GPU。第一天就把PyTorch CPU版装好，拿小数据集（比如MNIST、CIFAR-10的子集）把模型写好、训练循环写顺，确认逻辑没问题了，再回头配GPU环境。CPU版本的安装极其简单：

pip install torch torchvision

等程序逻辑没问题了，再换GPU版本，代码一行都不用改，只需要在程序开头写上：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device)

这才是稳妥的推进路径，不要被“必须一步到位”的心态耽误学习进度。

3. Tensor张量：PyTorch的数据心脏与计算基石

环境好了，接下来就要接触PyTorch的核心数据结构——Tensor。可以把它理解成带GPU加速能力的、能自动追踪计算过程的NumPy数组。你过去用NumPy能做的所有事情——切片、拼接、转置、数学运算——Tensor几乎都能做，而且还有两个NumPy不具备的神级特性：自动求导和GPU加速。

3.1 创建张量与数据转换的几种正确姿势

创建一个Tensor的方法有很多，我给你列一下最常用的：

import torch # 从Python列表创建 a = torch.tensor([1, 2, 3]) # 一维张量，dtype默认是int64 b = torch.tensor([[1.0, 2.0], [3.0, 4.0]]) # 二维张量，2x2矩阵 # 常用初始化方式 zeros = torch.zeros(3, 4) # 全零矩阵 ones = torch.ones(2, 3) # 全一矩阵 rand = torch.randn(5, 5) # 标准正态分布随机值 arange = torch.arange(0, 10, 2) # [0, 2, 4, 6, 8] # 需要梯度的张量 x = torch.tensor([2.0], requires_grad=True)

在实际项目中，你更多时候是把NumPy数组转换成Tensor：

import numpy as np np_data = np.array([[1, 2], [3, 4]]) tensor_data = torch.from_numpy(np_data) # 注意：共享内存，修改会互相影响 # 回转NumPy back_to_numpy = tensor_data.numpy()

这里有个容易踩的暗坑：torch.from_numpy()返回的张量与原始NumPy数组共享底层内存。你在PyTorch里改了数值，NumPy里也跟着变。有些场景你需要这个特性（省内存、避免拷贝），但更多时候这种隐式共享会导致难以排查的bug。如果你不想让它共享，加一行.clone()就行。

3.2 张量运算：维度匹配是核心

Tensor运算本质上就是矩阵运算，所以维度匹配是重中之重。下面这几个API你是躲不掉的：

x = torch.randn(4, 3) # 4行3列 w = torch.randn(3, 5) # 3行5列 out = torch.matmul(x, w) # 矩阵乘法，结果是(4, 5)

用torch.matmul()或者@运算符做矩阵乘法，用torch.mm()做二维矩阵乘法，二维以上的批量矩阵乘法用torch.bmm()。元素对应相乘用的是*运算符，也就是点积乘，形状必须完全一致，用法完全不同，别搞混。

形状操作三件套也必须要熟练：

x = torch.randn(2, 3, 4) x.view(-1, 4) # 展平成(6, 4)，-1是自动推断维度 x.reshape(3, 8) # 类似view，但更灵活 x.permute(2, 0, 1) # 维度重排，(4, 2, 3)

view和reshape看起来相似，但底层逻辑不同。view要求张量在内存中是连续存储的，如果之前做过多步转置操作，view会直接报错；reshape不要求连续性，它在必要时会拷贝数据。日常使用，无脑用reshape更省心。

3.3 requires_grad与autograd：反向传播的地基

Tensor最重要、也最区别于NumPy的特性，就是能追踪计算图并用autograd完成自动微分。下面这段代码是理解整个机制的最小范例：

x = torch.tensor([3.0], requires_grad=True) y = x ** 2 z = y * 4 + 2 z.backward() # 反向传播，计算所有requires_grad为True的张量的梯度 print(x.grad) # d(z)/dx = 8x = 24

z.backward()执行之后，x.grad里存放的就是损失函数相对于x的偏导数。你会看到x.grad的值是24，因为z = 4x^2 + 2，导数是8x，在x=3处就是24。自动求导的背后是一张记录所有运算关系的计算图，PyTorch的动态图机制决定了这张图是每次前向传播时实时搭建的，所以你可以随意用if语句、for循环控制计算流程，这在处理变长序列、动态结构模型时极其重要，也是PyTorch敢说“debug和写Python一样简单”的底气所在。

再强调一点：只有浮点类型的张量才能开requires_grad=True，整数张量会报错。另外backward()默认只在叶子节点（最初定义的那些张量）上累积梯度，非叶子节点的梯度默认不保留，这就是为什么你在调试中间变量梯度时会看到None。

4. nn.Module：把模型组织成积木

单个Tensor解决的是“数值运算”问题，但一个深度学习模型动辄十几个层、几万个参数，如果全用原生Tensor手动管理，代码会膨胀到失控。所以PyTorch提供了一个高层封装：nn.Module。这是PyTorch里最核心、最常用的一个类，你自己的任何模型都应该是它的子类。

4.1 自定义网络的规范写法

一个标准的多层感知机（MLP）写法如下：

import torch.nn as nn import torch.nn.functional as F class MLP(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super().__init__() self.fc1 = nn.Linear(input_dim, hidden_dim) self.fc2 = nn.Linear(hidden_dim, output_dim) def forward(self, x): x = self.fc1(x) x = F.relu(x) # 中间层要加激活函数，否则堆再多线性层也等价于一层 x = self.fc2(x) return x model = MLP(784, 128, 10) print(model)

nn.Linear是线性层，参数是(in_features, out_features)，它内部自己初始化了权重矩阵和偏置。你只需要在__init__里定义各层模块，在forward里定义前向传播的顺序，PyTorch就会自动把所有可学习参数收集到model.parameters()里，优化器直接拿着这个列表就能更新，你根本不需要手动管理每个参数。

4.2 卷积网络的组件：torch.nn里最常用的积木块

做图像任务绕不开卷积神经网络（CNN）。nn.Conv2d的参数是四元组：输入通道数、输出通道数、卷积核大小、步长/填充等。

import torch.nn as nn # 一个简单的卷积块：卷积 -> 池化 -> 激活 conv_block = nn.Sequential( nn.Conv2d(3, 16, kernel_size=3, padding=1), # 输入RGB三通道，输出16个特征图 nn.ReLU(), nn.MaxPool2d(2) # 长宽各减半 )

这里有个经常让新手犯迷糊的问题：为什么Conv2d之后要接Relu？因为卷积运算是线性的，多个线性运算堆叠起来还是线性变换，那再怎么加深网络，表达能力也跟单层无差。激活函数引入非线性，网络才能拟合复杂的函数映射。所以“卷积→归一化→激活”是CNN的基本组合拳。

用nn.Sequential可以把一长串层串联起来，省去写forward的麻烦，代码也直观。但当模型结构出现分支、多输入多输出的时候，Sequential就不够用了，还是得回到手写forward，这也是nn.Module最灵活的地方。

4.3 已封装好的经典网络：torchvision.models的合理用法

除了自己搭积木，也可以站在巨人的肩膀上。torchvision.models里内置了ResNet、VGG、DenseNet等预训练好的经典模型，一行代码就能加载：

import torchvision.models as models # 加载预训练ResNet18，这里的pretrained=True表示使用ImageNet上训练好的权重 model = models.resnet18(pretrained=True) # 修改最后一层，适配自己的分类数（比如10类） model.fc = nn.Linear(model.fc.in_features, 10)

迁移学习是深度学习中最实用的技巧之一。新任务跟ImageNet的语义特征有一定共通性，预训练模型已经学会了轮廓、纹理、边缘等基础特征，把它拿过来微调比自己从零训练省力得多，收敛也快得多。这也是很多竞赛项目、工业落地项目的基本套路。

5. 跑通一个完整训练闭环：损失函数、优化器与训练循环

模型定义好只是第一步，真正让模型“学习”起来的是训练循环。我见过太多人背下了代码却不懂每一行在干什么，这篇帮你把每个角色的职责彻底拆开。

5.1 损失函数与优化器的选择逻辑

损失函数衡量的是模型的预测值和真实答案之间的差距，不同任务要选不同损失函数：

优化器这边最常用的是torch.optim.Adam和torch.optim.SGD。Adam自带自适应学习率，对新手极其友好，不用太刻意调参就能稳定收敛；SGD加上动量之后在复杂模型上往往最终效果更好，但对学习率更敏感，需要配学习率衰减策略。初学者建议直接从Adam开始，设学习率lr=1e-3，等跑通流程再精细调优。

5.2 训练循环到底在干什么：step by step拆解

把数据和模型都准备好了，接下来就是训练的主战场。来，走一遍标准训练循环的每一步：

import torch import torch.nn as nn from torch.utils.data import DataLoader # 假设你已经有了model、train_loader、optimizer、criterion optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss() model.train() # 切换到训练模式，对Dropout和BatchNorm的行为有影响 for epoch in range(30): running_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) # 1. 前向传播：输入模型，得到输出 outputs = model(images) # 2. 计算损失 loss = criterion(outputs, labels) # 3. 梯度清零：这一步是新手最容易忘的！ optimizer.zero_grad() # 4. 反向传播：计算梯度 loss.backward() # 5. 参数更新：沿负梯度方向走一步 optimizer.step() running_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.4f}")

每一步背后都有它的逻辑，挨个看一下：

optimizer.zero_grad()为什么必需？因为PyTorch的梯度是累积在tensor.grad里的，不主动清零，上一轮的梯度会和本轮的梯度累加在一起，参数更新方向直接就错了。这个问题隐蔽性极强，损失曲线不降还上下窜，多半就是少写了这一行。

loss.backward()做什么？前面说过了，它顺着计算图从损失往回走，逐层算出每个参数的梯度。这是PyTorch的autograd替你完成的，你只负责调用它。

optimizer.step()做什么？就是依据optimizer内部维护的算法（比如Adam的一阶二阶矩估计）和当前梯度，去调整模型的参数值。momentum、weight_decay这些都在step()里发挥作用。

model.train()和model.eval()的区别是：训练模式下Dropout层会随机丢弃神经元、BatchNorm层会使用当前批次的均值方差来归一化；评估模式下Dropout不丢弃、BatchNorm使用训练阶段累计的全局统计量。评估时忘了切换模式，是导致测试指标虚高或虚低的常见原因之一。

5.3 数据加载：为什么要用DataLoader而不是直接喂全部数据

你可能会想：为什么不把全部数据一次性塞给模型？因为显存容不下，而且训练的本质是基于抽样梯度估计的迭代优化，一次性看全部数据反而容易陷入局部最优，遍历式的小批量梯度下降让更新路径更有随机性，泛化效果通常更好。

DataLoader本质上就是一个小工具，把数据集按指定batch大小切成一份份，在迭代时一份份地吐出来：

from torch.utils.data import Dataset, DataLoader from torchvision import datasets, transforms # 对图像做数据增强：随机翻转、归一化 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # torchvision自带CIFAR-10数据集 train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) # batch_size=64：每次送入64张图片 train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=2) for epoch in range(10): for images, labels in train_loader: # 每个batch的shape是(64, 3, 32, 32) # 这里的images是[batch_size, channels, height, width] pass

shuffle=True为什么重要？如果数据顺序有规律，比如前一半全是猫、后一半全是狗，模型在连续多个batch里只看到猫，梯度方向会持续偏斜，学出来一个“偏科”的模型。打乱顺序让每个batch都是随机混合的，训练更稳定。

5.4 完整实战：从零训练一个CIFAR-10分类器

走一遍完整的最小可执行项目，我保证这段代码你跑完之后对整个流程的理解会上一个层级。CIFAR-10是经典的60K张32x32彩色图像分类任务，10个类别，适合做入门实战。假设你已有dl环境，并且已安装GPU版PyTorch：

import torch import torch.nn as nn import torchvision import torchvision.transforms as transforms from torch.utils.data import DataLoader # 设备选择 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print(f"Using device: {device}") # 数据预处理 transform = transforms.Compose([ transforms.RandomHorizontalFlip(), # 随机水平翻转，一种数据增强 transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ]) # 加载训练集/测试集 train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) train_loader = DataLoader(train_set, batch_size=64, shuffle=True, num_workers=2) test_loader = DataLoader(test_set, batch_size=64, shuffle=False, num_workers=2) # 定义一个小型CNN class SimpleCNN(nn.Module): def __init__(self): super().__init__() self.conv_stack = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2) ) self.classifier = nn.Sequential( nn.Flatten(), nn.Linear(128 * 4 * 4, 256), nn.ReLU(), nn.Linear(256, 10) ) def forward(self, x): x = self.conv_stack(x) x = self.classifier(x) return x model = SimpleCNN().to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) # 训练 for epoch in range(10): model.train() total_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() total_loss += loss.item() print(f"Epoch {epoch+1}, loss: {total_loss/len(train_loader):.4f}") # 测试 model.eval() correct = 0 total = 0 with torch.no_grad(): # 推理阶段不需要梯度，省内存且加速 for images, labels in test_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs, 1) # 取每个样本得分最高的类别 total += labels.size(0) correct += (predicted == labels).sum().item() print(f"Test Accuracy: {100 * correct / total:.2f}%")

这里有一个非常关键的细节：with torch.no_grad()。训练时autograd要记录所有操作来构建计算图，但推理时你不需要梯度，不关掉的话，每一次前向传播都会白白构建一张计算图，显存消耗巨大、速度还慢。这一步几乎是所有新手都会忽略的，一定要养成习惯。

这个小网络加上10个epoch，在CIFAR-10上大约能到70%左右的准确率。别嫌低，这已经证明了整个深度学习闭环跑通了。后续想提升，可以做数据增强、换ResNet等预训练模型、加学习率衰减、调超参，那都是后话。

6. 避坑指南：那些教材不会写但实战必踩的雷

深度学习项目最大的痛点不在“原理不懂”，而在“明明代码看着都对，就是跑不出结果”。接下来把我自己踩过、也看别人踩过无数次的问题集中盘点一下，你会少走一个月弯路。

6.1 CUDA相关报错：从“真没装好”到“显示存不足”

报错一：RuntimeError: Found no NVIDIA driver on your system

这是驱动层面的问题，跟PyTorch没关系。在终端跑一下nvidia-smi，如果提示command not found，说明NVIDIA驱动没装或者没挂上。装驱动的时候注意：不要冲动下载最新版驱动，建议直接去NVIDIA官网，按你的显卡型号和操作系统选择对应版本，安装完毕重启再验证nvidia-smi能看到显卡信息。

报错二：CUDA out of memory

显存爆了，这是训练时的老朋友。最常见的缓解操作：调小batch_size，比如从64降到32甚至16；减小图片输入尺寸；模型过大就换个小模型。还有一个小技巧：在代码里加一行torch.cuda.empty_cache()，能把PyTorch预留但尚未释放的显存碎片清出来。不过这只算应急手段，根本解法还是控制单batch的显存开销。

报错三：AssertionError: Torch not compiled with CUDA enabled

这是你在CPU版PyTorch下调用.cuda()或.to(device)时报的错。解决方法就是换个带CUDA的PyTorch版本重装。装完后torch.cuda.is_available()必须是True，这是你判断环境是否OK的黄金标准。

6.2 数据维度bug：一眼就能定位的常用方法

维度不匹配大概是新手报错率最高的类型。RuntimeError: mat1 and mat2 shapes cannot be multiplied——线性层输入维度跟输出维度对不上。这种错误看一眼后几十行堆栈也许能找到问题，但更快的排查方式是在forward里加几行打印：

def forward(self, x): print(f"input shape: {x.shape}") x = self.conv_stack(x) print(f"after conv: {x.shape}") x = self.classifier(x) return x

打一次，你就能直观看到经过卷积池化堆叠之后，特征图变成了什么形状，从而知道Linear层的输入维度该填多少。这个办法虽然笨，但定位维度问题极其高效。看到真实形状之后再删掉print，正式训练。

6.3 损失不下降的排查链路

模型训练了很久，损失就是一条平线，这种挫败感谁经历谁知道。按下面顺序排查能覆盖绝大多数情况：

第一，确认optimizer.zero_grad()有没有写。梯度累积导致的震荡或不动，比你想的常见。第二，确认模型和数据都在同一个设备上，一个在GPU一个在CPU会直接报设备错误，但有时候你把模型放在了GPU、输入却忘了.to(device)，报错信息会晚一步才表现出来。第三，检查学习率：太大导致loss溢出为NAN，太小导致几乎不更新。试试调大或者调小几个数量级观察变化。第四，查看数据标签是否正常，有没有中心错位、很多错误的样本。第五，如果训练集本身就极度不均衡，比如99%都是A类，模型可能直接“躺平”全部预测A，损失不降但准确率看着还行，这时候要检查分类权重或改用加权损失。

6.4 过拟合与欠拟合的判定与基本对策

如何判断模型处于过拟合还是欠拟合？一个实用办法是比较训练集loss和验证集loss的差距。训练集loss持续下降，验证集loss先降后升，出现过拟合；两个loss都高居不下，那大概率是欠拟合或者模型容量不够。

应对欠拟合，可以加深网络、加宽通道、增加训练轮次，也可以优化数据预处理质量。应对过拟合，优先考虑：加Dropout层、在Optimizer里设置weight_decay、做数据增强、用早停法（当验证集loss连续几个epoch不降就停止）、或者换预训练模型做迁移学习。

6.5 训练速度慢？把这几板斧依次用上

刚开始很多人习惯直接model.to(device)把模型搬GPU，但忘了把数据也搬过去，结果程序很慢或者直接报错。另外DataLoader的num_workers设为0或过小时，数据预处理会成为瓶颈，GPU一直在等CPU喂数据。在Windows上num_workers设置大了容易报内存错误，建议设为2到4；在Linux服务器上可以设到8甚至更多。

还有一个很多人不知道的小细节：pin_memory=True配合DataLoader，可以在GPU训练时把页锁定内存的数据传输加速，训练速度能有可见的提升。在显存允许范围内把batch_size调大，GPU利用率上去了，训练总时长也会缩短。另外尽量别用Python自带的循环去迭代张量做运算，在GPU上下文里直接用原生向量化操作，是最核心的性能准则。

7. 入门之后：从玩具模型到实战项目，接下来该怎么走

跑通了CIFAR-10，你可能觉得自己已经入门了，但离真正“会用”还有一段路。下一步该学什么，这里帮你规划一条靠谱的进阶路径。

第一，把经典论文里的模型吃透。不用看太深，重点是“它们为什么这样设计”。ResNet为什么要引入残差连接？因为网络加深到一定程度后梯度消失、训练退化，残差连接让梯度能够顺畅地跳过层直接回传。Transformer为什么用自注意力？因为它可以不管序列元素之间的距离，一步建模任意位置间的相关性。这些设计思想会直接影响你后面做模型选型和结构改进。

第二，动手做一个小型项目。推荐方向：人脸表情识别、中文文本情感分类、自己的图片集分类、语音命令识别。规模不用大，两三千张图、一两万条文本就够。关键是让你完整走一遍数据采集、清洗、标注、训练、评估、部署的流程。跟用现成数据集的最大区别是：你必须亲手处理脏数据，这恰恰是工业级深度学习最日常的部分。

第三，学会看曲线。训练时要养成记录训练指标的习惯，最低限度要打印训练loss和验证loss/准确率。每次改完参数，对比两条曲线的形态变化，慢慢你就有了“手感”。这个能力没法靠刷论坛获得，只能靠自己的实验积累。

第四，了解模型部署的基本路径。训练出来的模型最终要让人用，就要把PyTorch模型转成ONNX、TorchScript或者TensorRT格式。这些转换流程在热搜词里也高频出现，比如“pytorch转onnx”，本质上是为了跨平台推理和加速。入门阶段不用深究，但至少要知道有这回事。

第五，盘点一下你的工具箱：tensorboard或wandb用来做训练可视化、torchsummary打印模型参数总量、torchinfo展示每一层的输入输出形状。这些小工具能大幅提升你把代码跑通的效率。

说了这么多，其实最核心的永远是同一件事：动手跑起来，把上面的代码自己在电脑上敲一遍。PyTorch不会因为你读了三篇文章就自动进入你的脑子里，它只会因为你亲手把import torch到model.eval()这段流程走通了，才真正变成你的工具。

我在实际跑这些基础项目时有个体会：遇到异常报错时，别急着复制报错去搜索引擎，先自己读一遍堆栈信息，从最后一条开始往前看，通常错误根源就藏在你写的那几行代码里。这个习惯养成了，你再也不会被环境问题、维度问题、设备问题反复折磨。把这套基础打牢，后面无论是图像、文本、语音还是强化学习，你都能按同一个闭环快速切入——因为不管任务怎么变，数据、模型、损失函数、优化器、训练循环这五块积木的组合逻辑是不变的。剩下的，就是拿着这套底层能力，去一个个项目里打磨手感了。