PyTorch深度学习入门指南：从张量到模型训练的核心技术与实践

1. 从零上手PyTorch：为什么它是深度学习入门的首选框架

如果你刚开始接触深度学习，或者从其他框架迁移过来，大概率会听到身边人反复提到PyTorch这个名字。它到底是什么？简单说，PyTorch是一个开源的深度学习框架，核心能力是帮你用Python代码搭建神经网络、自动计算梯度、并在GPU上高效跑训练。它解决的核心问题是：让研究者不用手写反向传播、不用手动管理显存，把精力集中在模型结构设计和实验迭代上。

我最初接触深度学习时用的是静态图框架，每次调试都要先定义完整计算图再运行，想看中间某个张量的值非常麻烦。转到PyTorch之后，最直观的感受就是“像写普通Python一样写模型”——你可以随时打印、随时断点、随时改结构，这种动态图的交互体验对新手极其友好。这也是为什么过去几年里，PyTorch在学术论文实现和工业原型开发中占据了主流位置。

这篇文章适合谁看？如果你满足以下任意一条，接下来的内容会对你有直接帮助：完全零基础想入门深度学习；用过其他框架但被静态图折磨过；已经会跑Demo但说不清autograd到底怎么工作；想系统梳理PyTorch核心模块和常见坑。我会从张量、自动求导、模型搭建、训练循环、GPU迁移、数据加载、模型保存这几个核心环节逐一拆解，每个环节都补充我实际踩过的坑和验证过的做法。

需要提前说明的是，PyTorch版本迭代很快，本文基于2.x版本的稳定API来写，涉及具体版本差异的地方我会单独标注。另外，文章里的代码都是可以直接复制运行的完整片段，不是伪代码，你可以边看边在本地或云端环境里试。

2. 张量：PyTorch里一切数据的基本载体

2.1 张量到底是什么，和NumPy数组有什么区别

张量（Tensor）是PyTorch中最基础的数据结构。如果你用过NumPy，可以把张量理解成“升级版的ndarray”——它多了两个关键能力：一是可以在GPU上运行，二是支持自动求导。这两个能力正是深度学习训练的核心需求。

创建一个张量的方式有很多，最常用的是从Python列表或NumPy数组转换：

import torch import numpy as np # 从列表创建 a = torch.tensor([[1, 2], [3, 4]]) print(a) # tensor([[1, 2], # [3, 4]]) # 从NumPy数组创建 np_arr = np.array([1.0, 2.0, 3.0]) b = torch.from_numpy(np_arr) print(b) # tensor([1., 2., 3.]) # 创建全零、全一、随机张量 zeros = torch.zeros(2, 3) ones = torch.ones(2, 3) randn = torch.randn(2, 3) # 标准正态分布

这里有个细节值得注意：torch.from_numpy创建的张量和原NumPy数组共享内存。也就是说，你修改其中一个，另一个也会变。这个特性有时候很有用（避免拷贝开销），但如果不清楚这一点，调试时会出现“我明明没改这个变量，它怎么变了”的困惑。如果需要独立副本，用torch.tensor(np_arr)或者.clone()。

张量的数据类型（dtype）也是新手容易忽略的点。默认情况下，torch.tensor([1, 2, 3])创建的是int64类型，而神经网络里的权重和输入通常是float32。如果你把int64张量直接送进模型，会报类型不匹配的错误。养成习惯：涉及计算的张量显式指定dtype=torch.float32。

2.2 张量的形状操作：view、reshape、permute的区别

形状操作是PyTorch里用得最频繁也最容易出错的部分。先区分几个容易混淆的API：

view和reshape的区别值得单独说。view要求张量在内存中是连续的（contiguous），如果之前做过permute或transpose，张量可能变得不连续，此时view会报错。reshape则会自动处理，必要时先拷贝一份再变形。我的建议是：不确定的时候直接用reshape，虽然可能多一次拷贝，但不会报错。如果对性能极其敏感且确认张量连续，再用view。

x = torch.randn(2, 3, 4) print(x.shape) # torch.Size([2, 3, 4]) # 展平后两维 y = x.reshape(2, 12) print(y.shape) # torch.Size([2, 12]) # 交换维度 z = x.permute(2, 0, 1) print(z.shape) # torch.Size([4, 2, 3]) # 增加batch维 img = torch.randn(3, 224, 224) batch = img.unsqueeze(0) print(batch.shape) # torch.Size([1, 3, 224, 224])

注意：permute之后如果要做view，必须先调用.contiguous()，否则会报“view size is not compatible”的错误。这个坑我在处理图像通道转换时踩过不止一次。

2.3 广播机制：让不同形状的张量能一起运算

广播（Broadcasting）是PyTorch里非常强大但也容易产生隐蔽bug的机制。规则很简单：从最后一个维度开始对齐，维度大小相等或其中一个为1时才能广播。但实际写代码时，经常出现“我以为会广播成A形状，结果成了B形状”的情况。

a = torch.randn(3, 1, 5) b = torch.randn(1, 4, 5) c = a + b print(c.shape) # torch.Size([3, 4, 5])

上面这个例子中，a的维度是(3,1,5)，b是(1,4,5)，从后往前对齐：最后一维都是5，匹配；中间维1和4，广播成4；最前维3和1，广播成3。最终结果是(3,4,5)。

广播用好了能省很多显式扩展的代码，但用不好会出现“形状对不上但没报错，结果全错”的情况。我的经验是：在关键计算前后打印形状，尤其是涉及损失函数计算时。比如做分类任务，模型输出形状是(batch, num_classes)，标签形状是(batch)，如果直接相减会广播成(batch, batch)，这不是你想要的。正确做法是用CrossEntropyLoss，它内部会处理维度对齐。

3. autograd：PyTorch自动求导的工作机制与实操要点

3.1 计算图是怎么动态构建的

PyTorch的核心竞争力之一就是自动求导（autograd）。理解它的工作方式，能帮你避免很多“梯度为None”“梯度爆炸”之类的困惑。

当你对一个requires_grad=True的张量做任何运算时，PyTorch会在后台记录这个运算，构建一张计算图。这张图是动态的——每次前向传播都会重新构建。这和静态图框架有本质区别：静态图先定义再运行，动态图边运行边定义。

x = torch.tensor([2.0, 3.0], requires_grad=True) y = x ** 2 z = y.sum() z.backward() print(x.grad) # tensor([4., 6.])

上面这段代码中，x是叶子节点，y和z是中间节点。调用z.backward()时，PyTorch沿着计算图反向传播，计算出z对x的梯度，存在x.grad里。数学上，z = x1² + x2²，对x1的偏导是2x1=4，对x2是2x2=6，结果正确。

关键点：只有叶子节点（自己创建的、不是运算结果的张量）的梯度会被保留。中间节点的梯度默认不保存，因为保存所有中间梯度会消耗大量显存。如果你确实需要某个中间节点的梯度，可以调用.retain_grad()。

3.2 梯度累积与清零：为什么你的梯度越加越大

新手最常见的错误之一：忘记清零梯度。PyTorch的梯度是累积的，也就是说，如果你在训练循环里不调用optimizer.zero_grad()，上一次的梯度会和这一次的叠加，导致参数更新完全错误。

# 错误示范：忘记清零 for data, target in dataloader: output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() # 缺少 optimizer.zero_grad() # 正确做法 for data, target in dataloader: optimizer.zero_grad() # 先清零 output = model(data) loss = criterion(output, target) loss.backward() optimizer.step()

为什么PyTorch设计成累积而不是自动清零？因为有些场景确实需要累积梯度，比如显存不够时，可以用小batch多次前向再统一更新，模拟大batch的效果。这种设计给了灵活性，但代价是新手容易忘。

提示：optimizer.zero_grad()和model.zero_grad()效果类似，但推荐用前者，因为它只清零优化器管理的参数，更精确。在PyTorch 2.x中，还可以用optimizer.zero_grad(set_to_none=True)，把梯度设为None而不是0，据说能略微提升性能。

3.3 禁用梯度追踪：推理时为什么要用torch.no_grad

训练时需要计算梯度，但推理（预测）时不需要。如果推理时还开着梯度追踪，会白白消耗显存和计算资源。用torch.no_grad()上下文管理器可以临时关闭：

model.eval() with torch.no_grad(): for data in test_loader: output = model(data) # 这里不会构建计算图，省显存

另一个常见场景是迁移学习时冻结部分层。你可以把不需要训练的参数的requires_grad设为False：

for param in model.features.parameters(): param.requires_grad = False

这样反向传播时不会计算这些参数的梯度，既省显存又加速。但要注意：如果你冻结了所有层只训练最后一层，优化器里只传可训练参数会更高效：

optimizer = torch.optim.Adam( filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3 )

4. 模型搭建：从nn.Module到实际可用的网络结构

4.1 nn.Module的约定与常见写法

PyTorch搭建模型的标准方式是继承nn.Module，在__init__里定义层，在forward里定义计算流程。这个约定看起来简单，但有几个细节决定了你的模型能不能正常工作。

import torch.nn as nn class SimpleNet(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super().__init__() # 必须调用 self.fc1 = nn.Linear(input_dim, hidden_dim) self.relu = nn.ReLU() self.fc2 = nn.Linear(hidden_dim, output_dim) def forward(self, x): x = self.fc1(x) x = self.relu(x) x = self.fc2(x) return x

几个关键点：第一，super().__init__()必须调用，否则PyTorch无法正确注册子模块，会导致参数不被优化器识别。第二，层要定义为实例属性（self.xxx），不能放在列表里直接赋值，否则不会被注册。如果确实需要动态创建多层，用nn.ModuleList而不是普通list：

# 错误：普通list不会注册参数 self.layers = [nn.Linear(10, 10) for _ in range(3)] # 正确：ModuleList会注册 self.layers = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])

第三，forward方法的名字不能改，PyTorch内部通过这个名字调用。你调用model(x)时，实际执行的是model.__call__(x)，而__call__内部会调用forward，并处理一些hook逻辑。

4.2 常用层的选择：Linear、Conv2d、BatchNorm、Dropout

不同任务需要不同的层组合。全连接网络用nn.Linear，图像任务用nn.Conv2d，序列任务用nn.LSTM或nn.Transformer。这里重点说几个容易用错的层。

nn.BatchNorm2d在训练和推理时的行为不同：训练时用当前batch的均值和方差做归一化，并更新running统计量；推理时用running统计量。所以推理前必须调用model.eval()，否则batch size很小时结果会不稳定。这个坑我在部署模型时遇到过——训练时准确率很高，推理时一塌糊涂，最后发现是忘了切eval模式。

nn.Dropout同样在训练和推理时行为不同。训练时随机置零，推理时不做任何事。所以model.train()和model.eval()的切换不是可选项，是必须项。

model.train() # 训练前调用 # ... 训练代码 ... model.eval() # 推理前调用 with torch.no_grad(): # ... 推理代码 ...

4.3 参数初始化：默认初始化够用吗

PyTorch的层有默认初始化，比如nn.Linear用Kaiming均匀初始化。大多数情况下默认值够用，但某些场景下自定义初始化能加速收敛或避免梯度问题。

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

model.apply会递归遍历所有子模块，对匹配的层执行初始化函数。这个写法比手动遍历简洁得多。需要注意的是，初始化要在模型创建后、训练前做，且不要覆盖预训练权重（迁移学习时只初始化新加的层）。

5. 训练循环的完整拆解与GPU迁移实操

5.1 一个标准训练循环包含哪些步骤

训练循环是深度学习代码的核心。一个完整的训练循环包含：前向传播、计算损失、反向传播、参数更新、梯度清零。这五步的顺序不能乱。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = SimpleNet(784, 256, 10).to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) for epoch in range(num_epochs): model.train() for data, target in train_loader: data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() # 每个epoch结束后可以做验证 model.eval() with torch.no_grad(): # 验证代码 pass

这里有几个实操细节。第一，data.to(device)和target.to(device)必须做，否则模型在GPU上、数据在CPU上会报错。第二，optimizer.zero_grad()放在前向之前还是之后？放在之前更常见，但放在loss.backward()之后、optimizer.step()之前也可以。关键是不要漏。第三，如果用了BatchNorm或Dropout，训练和验证的模式切换必须正确。

5.2 GPU迁移：哪些东西需要to(device)

新手常问：到底哪些东西需要搬到GPU上？答案是：模型参数、输入数据、标签、以及任何参与计算的张量。不需要搬的是：损失函数（它没有参数）、优化器（它管理的是模型参数，参数已经在GPU上了）。

# 模型搬到GPU model = model.to(device) # 数据搬到GPU（在训练循环里） data = data.to(device) target = target.to(device) # 新建的张量如果要参与计算，也要指定device mask = torch.ones_like(target).to(device)

一个容易忽略的点：如果你在forward里创建了新张量（比如位置编码、mask），这些张量默认在CPU上，和GPU上的其他张量运算会报错。解决办法是用torch.zeros(..., device=x.device)或.to(x.device)显式指定。

注意：model.to(device)是原地操作还是返回新对象？对于nn.Module，.to()是原地修改并返回self。但对于张量，.to()返回新张量（除非dtype和device都没变）。这个差异导致model = model.to(device)和model.to(device)效果一样，但data = data.to(device)必须赋值，否则原张量没变。

5.3 混合精度训练：省显存提速的实用技巧

当模型较大或batch size受限时，混合精度训练（AMP）能显著省显存并提速。原理是用float16做前向和反向，用float32维护主权重。

from torch.cuda.amp import autocast, GradScaler scaler = GradScaler() for data, target in train_loader: data, target = data.to(device), target.to(device) optimizer.zero_grad() with autocast(): output = model(data) loss = criterion(output, target) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

GradScaler的作用是放大loss，防止float16下梯度下溢。scaler.step会先检查梯度是否有inf/nan，有则跳过这一步更新。这套组合在PyTorch 2.x里已经比较稳定，实测在支持Tensor Core的GPU上能有1.5到2倍加速。

6. 数据加载与预处理：Dataset和DataLoader的正确用法

6.1 自定义Dataset的两种写法

PyTorch的数据加载围绕两个类：Dataset和DataLoader。Dataset负责定义“一条数据长什么样”，DataLoader负责批量加载、打乱、并行。

自定义Dataset需要实现__len__和__getitem__：

from torch.utils.data import Dataset class MyDataset(Dataset): def __init__(self, features, labels, transform=None): self.features = features self.labels = labels self.transform = transform def __len__(self): return len(self.labels) def __getitem__(self, idx): x = self.features[idx] y = self.labels[idx] if self.transform: x = self.transform(x) return x, y

如果数据是图像文件路径，__getitem__里读文件、做增强、返回张量。这里有个性能陷阱：如果每个__getitem__都做很重的预处理，DataLoader的并行加载会被拖慢。解决办法是把轻量操作放__getitem__，重量操作（如解码大图）用缓存或提前处理。

6.2 DataLoader的num_workers和pin_memory怎么设

DataLoader有几个参数直接影响训练速度：

num_workers不是越大越好。每个worker是一个独立进程，启动和通信有开销。实测在大多数机器上，4到8个worker比较合适。如果设为0，表示在主进程加载，调试时方便但速度慢。

pin_memory=True会把数据放到锁页内存，从CPU传到GPU时更快。但只有在GPU训练时才有意义，CPU训练时设了反而浪费。

6.3 常见数据增强的PyTorch实现

图像任务里，数据增强是提升泛化能力的关键。torchvision.transforms提供了常用增强：

from torchvision import transforms train_transform = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.2, contrast=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])

ToTensor()把PIL图像或NumPy数组转成张量，并把像素值从[0,255]缩放到[0,1]。Normalize用ImageNet的均值和标准差做标准化，如果你用预训练模型，这一步必须和预训练时一致。自己从零训练时，可以算自己数据集的均值和方差。

提示：验证集和测试集不要用随机增强，只用Resize、ToTensor、Normalize。否则每次评估结果都在变，无法比较。

7. 模型保存与加载：state_dict的取舍与跨设备迁移

7.1 保存state_dict还是整个模型

PyTorch有两种保存方式：保存整个模型对象，或只保存参数（state_dict）。推荐后者。

# 推荐：只保存参数 torch.save(model.state_dict(), 'model.pth') # 加载 model = SimpleNet(784, 256, 10) model.load_state_dict(torch.load('model.pth')) model.eval()

保存整个模型（torch.save(model, 'model.pth')）的问题是：它依赖模型类的定义路径，换个项目结构或重构代码后可能加载失败。state_dict只包含张量，和代码结构解耦，更稳健。

加载时有个常见坑：如果保存时用了DataParallel或DistributedDataParallel，state_dict的key会多一个module.前缀。加载到单卡模型时需要去掉：

state_dict = torch.load('model.pth') new_state_dict = {k.replace('module.', ''): v for k, v in state_dict.items()} model.load_state_dict(new_state_dict)

7.2 跨设备加载：CPU保存GPU加载，或反过来

torch.load默认把张量加载到保存时的设备。如果保存时在GPU，加载时没有GPU会报错。用map_location指定：

# GPU保存，CPU加载 model.load_state_dict(torch.load('model.pth', map_location='cpu')) # CPU保存，GPU加载 model.load_state_dict(torch.load('model.pth', map_location='cuda'))

更通用的写法是map_location=device，其中device是你前面定义好的设备变量。这样代码在有无GPU的机器上都能跑。

7.3 保存训练状态：断点续训要存什么

如果训练时间很长，需要断点续训，除了模型参数，还要保存优化器状态、当前epoch、学习率调度器状态等：

checkpoint = { 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'loss': loss, } torch.save(checkpoint, 'checkpoint.pth') # 恢复 checkpoint = torch.load('checkpoint.pth') model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) scheduler.load_state_dict(checkpoint['scheduler_state_dict']) start_epoch = checkpoint['epoch'] + 1

优化器状态里包含动量、二阶矩估计等，不恢复的话续训初期会有波动。学习率调度器的状态也要恢复，否则学习率会从头开始。

8. 几个我实际踩过的坑和对应的排查思路

8.1 损失不下降：从数据、模型、超参三个方向排查

损失不下降是最常见的问题。我的排查顺序是：先看数据，再看模型，最后调超参。

数据方面：检查输入是否归一化、标签是否对齐、有没有全零或全一的异常样本。我遇到过一次损失卡在2.3不动，最后发现是数据加载时特征和标签错位了——__getitem__里返回的顺序写反了。

模型方面：检查输出维度是否匹配类别数、有没有忘记加激活函数、BatchNorm的running统计量是否正常更新。一个快速验证方法是：用随机数据过一遍模型，看输出形状和数值范围是否合理。

超参方面：学习率太大导致震荡，太小导致下降慢。可以先用一个很小的子集（比如100条数据）过拟合，如果连这个小数据集都过拟合不了，说明模型或代码有问题，而不是超参问题。

8.2 显存溢出：batch size、梯度累积、检查点

显存溢出（OOM）的解决思路按优先级排：先减小batch size，再用梯度累积模拟大batch，最后考虑梯度检查点（gradient checkpointing）。

梯度累积的写法：

accumulation_steps = 4 optimizer.zero_grad() for i, (data, target) in enumerate(train_loader): output = model(data) loss = criterion(output, target) / accumulation_steps loss.backward() if (i + 1) % accumulation_steps == 0: optimizer.step() optimizer.zero_grad()

注意loss要除以累积步数，否则梯度会放大。梯度检查点用torch.utils.checkpoint，以计算换显存，适合特别大的模型。

8.3 训练和验证结果差异大：模式切换与数据泄漏

训练准确率95%，验证准确率60%，这种差距通常有几个原因：忘了切model.eval()导致Dropout和BatchNorm行为不对；验证集用了训练集的增强；数据泄漏（验证集样本出现在训练集里）。

排查方法：先确认model.eval()和torch.no_grad()都加了；再检查验证集的transform是否只有确定性的操作；最后检查数据划分是否有重叠。我见过一次是因为用随机划分时没设种子，每次运行划分不同，导致某次验证集恰好和训练集重叠。

8.4 多卡训练的常见配置错误

用DataParallel时，模型要用nn.DataParallel(model)包一层，然后.to(device)。但DataParallel有个问题：它要求batch size能被卡数整除，且主卡显存占用更高。更推荐用DistributedDataParallel，但配置复杂一些。

一个常见错误是：包了DataParallel之后，保存的state_dict带module.前缀，加载到单卡模型时报key不匹配。解决办法就是前面说的替换key前缀。

9. 学习路径与版本迁移的几点个人建议

如果你是零基础，我的建议是按这个顺序推进：先花两天把张量操作和autograd搞熟，写几个小例子验证梯度计算；然后手写一个全连接网络在MNIST上跑通；接着学Dataset和DataLoader，把数据管道搭起来；最后再上卷积网络和迁移学习。不要一上来就看Transformer，基础不牢后面全是坑。

版本迁移方面，PyTorch 2.x引入了torch.compile，能自动优化模型执行速度。用法很简单：

model = torch.compile(model)

实测在Transformer类模型上有明显加速，但首次编译有开销，且不是所有模型都支持。建议在稳定版本上先跑通，再尝试torch.compile。

另外，PyTorch 2.x里一些旧API被标记为deprecated，比如torch.symeig、torch.lstsq等。如果你从旧代码迁移，留意warning信息，按提示替换成新API。大多数情况下，官方迁移指南能覆盖90%的场景。

最后分享一个我常用的调试技巧：在训练循环里加一个断言，检查loss是否为nan或inf。一旦出现，立即中断并打印当前batch的信息。这比训练完发现模型废了再回头查要高效得多。

if torch.isnan(loss) or torch.isinf(loss): print(f"Loss is {loss} at batch {i}") break

这个习惯帮我省了很多时间，尤其是在调学习率和混合精度的时候。