1. 为什么2026年还值得从PyTorch开始学深度学习

如果你最近才开始接触深度学习，面对TensorFlow、JAX、PaddlePaddle这些名字有点懵，我的建议很直接：从PyTorch入手。这不是因为它完美无缺，而是因为它在“学得懂”和“用得上”之间找到了一个非常舒服的平衡点。你写出来的代码长什么样，运行起来就大概是什么逻辑，不需要先在脑子里编译一遍静态图。这对零基础的人来说，少了一层认知负担。

我见过太多人卡在环境搭建这一步就放弃了。明明是想学模型、跑项目，结果三天都在跟版本号、驱动、包管理器较劲。所以这篇内容我会把环境搭建拆得足够细，细到你知道每一步为什么这么做，而不是复制粘贴一堆命令然后祈祷它能跑。环境搭好之后，我会带你理解PyTorch的核心框架逻辑，最后用一个完整的实战项目把前面所有东西串起来。全程不废话，能动手的地方绝不多说理论，但该讲清楚的原理一个不落。

这篇文章适合谁？完全没碰过深度学习的人、被环境问题劝退过的人、看过一些教程但知识点散落一地的人，以及想从其他框架转过来的人。你不需要提前会Linux，不需要懂CUDA，甚至不需要数学特别好——需要的是你愿意跟着敲一遍代码。

2. 环境搭建：从一台干净电脑到能跑PyTorch

2.1 先想清楚：你到底需要什么样的环境

很多人一上来就问“PyTorch怎么装”，但真正该先问的是“我打算在哪跑”。这个问题的答案直接决定了后面所有步骤。我把常见的选择列出来，你对号入座。

我的建议是：如果你现在连Python都没装过，先用Windows + Anaconda + CPU版跑通整个流程。等你确定要认真训练模型了，再折腾GPU环境。不要一上来就挑战最难的配置，那样很容易在第一步就耗尽耐心。

2.2 Anaconda安装与环境隔离的正确姿势

Anaconda的价值不在于它自带了Python，而在于它的虚拟环境管理。你可以把它理解成给每个项目单独准备一个房间，房间里放什么版本的Python、什么版本的库，互不干扰。没有这个隔离机制，你迟早会遇到“装了A项目的依赖，B项目跑不起来了”这种破事。

安装Anaconda本身没什么难度，官网下载对应系统的安装包，一路下一步就行。Windows下记得勾选“Add Anaconda to PATH”，虽然安装器会建议你不勾，但勾上之后命令行里直接用conda会方便很多。如果忘了勾，后面手动加也行，只是多一步。

装完之后打开终端（Windows用Anaconda Prompt，Mac/Linux用普通终端），先确认conda可用：

conda --version

看到版本号就说明没问题。接下来创建一个专门用于PyTorch的环境：

conda create -n pytorch-learn python=3.10

这里我指定Python 3.10，原因是它在兼容性上比较稳，主流深度学习库都支持得很好。3.11、3.12也不是不行，但偶尔会遇到某些包还没跟上。新手没必要追最新版本，稳定比新功能重要。

创建完成后激活环境：

conda activate pytorch-learn

激活之后你会发现命令行前面多了(pytorch-learn)的标识，说明后续所有操作都在这个环境里进行，不会污染系统其他部分。

注意：每次重新打开终端，都需要重新执行conda activate pytorch-learn才能进入这个环境。忘了激活是新手最常犯的错误之一，表现为“明明装了PyTorch却提示找不到模块”。

2.3 PyTorch安装：CPU版和GPU版的区别与选择

到了真正装PyTorch这一步。官方推荐的安装方式是去PyTorch官网的get-started页面，根据你的系统、包管理器、Python版本、CUDA版本生成对应的安装命令。但很多人到了这个页面就懵了，因为选项太多。

我先说CPU版的安装，这是最简单的：

pip install torch torchvision torchaudio

这三行分别对应PyTorch核心库、计算机视觉工具库、音频处理库。对于入门学习，这三个基本够用。安装完成后验证一下：

import torch print(torch.__version__) print(torch.cuda.is_available())

如果输出类似2.x.x的版本号，并且cuda.is_available()返回False，说明CPU版装好了。返回False是正常的，因为你装的就是CPU版。

现在说GPU版。如果你有NVIDIA显卡，想让训练速度提升几倍甚至几十倍，就需要装CUDA版。这里的关键是版本对齐：显卡驱动支持的CUDA版本、你安装的CUDA Toolkit版本、PyTorch编译时用的CUDA版本，三者要兼容。

先查显卡驱动支持的CUDA版本：

nvidia-smi

右上角会显示“CUDA Version: xx.x”，这是驱动支持的最高CUDA版本。然后去PyTorch官网选择不超过这个版本的CUDA。比如显示12.1，你可以选CUDA 11.8或12.1的PyTorch。

对应的安装命令大概长这样：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

装完后再跑一次验证：

import torch print(torch.cuda.is_available()) print(torch.cuda.get_device_name(0))

如果返回True并且打印出你的显卡型号，恭喜你，GPU环境通了。

实操心得：如果你用conda装PyTorch，有时候会遇到conda源里版本更新不及时的问题。我的习惯是优先用pip装PyTorch，conda只用来管理Python版本和环境隔离。这样版本更新更快，出问题也更容易排查。

2.4 验证环境是否真正可用：跑一个最小训练循环

装完不验证等于没装。我习惯用一个极简的训练循环来确认整个链路是通的。下面这段代码创建一个简单的线性回归任务，用PyTorch训练它拟合一条直线：

import torch import torch.nn as nn import torch.optim as optim # 准备数据：y = 2x + 1 加上一点噪声 x = torch.randn(100, 1) y = 2 * x + 1 + 0.1 * torch.randn(100, 1) # 定义模型 model = nn.Linear(1, 1) criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.01) # 训练 for epoch in range(200): optimizer.zero_grad() output = model(x) loss = criterion(output, y) loss.backward() optimizer.step() if (epoch + 1) % 50 == 0: print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}') # 查看学到的参数 print(f'Weight: {model.weight.item():.4f}, Bias: {model.bias.item():.4f}')

如果最后输出的Weight接近2、Bias接近1，说明你的PyTorch环境完全正常，可以开始后续学习了。这段代码虽然简单，但包含了深度学习的完整流程：数据准备、模型定义、损失函数、优化器、前向传播、反向传播、参数更新。后面所有复杂的模型，本质上都是这个循环的扩展。

3. PyTorch框架核心概念拆解

3.1 Tensor：一切数据的基本单位

PyTorch里的Tensor和NumPy的ndarray很像，但多了两个关键能力：可以在GPU上运行，可以自动求导。你可以把Tensor理解成“带记忆的多维数组”——它不仅存数据，还知道这个数据是怎么算出来的，这样才能在反向传播时自动计算梯度。

创建Tensor的方式很多，最常用的是从Python列表或NumPy数组转换：

import torch import numpy as np # 从列表创建 a = torch.tensor([[1, 2], [3, 4]]) # 从NumPy创建 b = torch.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) # 创建特殊Tensor c = torch.zeros(3, 4) d = torch.ones(2, 3) e = torch.randn(5, 5) # 标准正态分布 f = torch.arange(0, 10, 2) # 类似range

Tensor和NumPy数组之间可以自由转换，但要注意：如果Tensor在GPU上，转成NumPy需要先移到CPU。这个细节在实际项目中经常遇到，比如你想用matplotlib画图，就得先把Tensor转成NumPy。

Tensor的维度概念非常重要。标量是0维，向量是1维，矩阵是2维，图像数据通常是3维（通道、高、宽）或4维（批次、通道、高、宽）。很多新手报错都是因为维度对不上，比如模型期望输入是[batch, features]，你传了个[features]进去，就会出问题。养成随时打印tensor.shape的习惯，能省下大量调试时间。

3.2 Autograd：自动求导是怎么工作的

PyTorch最核心的机制之一就是Autograd。简单说，你在Tensor上做的每一个操作，PyTorch都会默默记录下来，形成一张计算图。当你调用.backward()时，它沿着这张图反向走一遍，自动算出每个参数的梯度。

x = torch.tensor(2.0, requires_grad=True) y = x ** 2 + 3 * x + 1 y.backward() print(x.grad) # 输出 7.0，因为 dy/dx = 2x + 3 = 7

requires_grad=True是告诉PyTorch“这个变量需要跟踪梯度”。模型参数默认就是True，而输入数据通常是False，因为我们不需要对输入求导。

这里有个容易踩的坑：每次反向传播前要清零梯度。因为PyTorch默认会累积梯度，如果你不清零，第二次backward时梯度会加上第一次的，导致结果错误。这就是为什么训练循环里总有optimizer.zero_grad()这一行。

# 错误示范：不清零梯度 for epoch in range(2): output = model(x) loss = criterion(output, y) loss.backward() # 忘记 zero_grad，梯度会累积

注意：optimizer.zero_grad()和model.zero_grad()效果类似，但前者更规范，因为它只清零优化器管理的参数。用哪个取决于你的代码风格，但一定要有。

3.3 nn.Module：搭建模型的积木

PyTorch定义模型的标准方式是继承nn.Module。这个类提供了两个关键功能：自动注册参数、提供forward接口。你只需要在__init__里定义层，在forward里定义数据怎么流过这些层。

import torch.nn as nn class SimpleNet(nn.Module): def __init__(self): super().__init__() self.fc1 = nn.Linear(784, 256) self.relu = nn.ReLU() self.fc2 = nn.Linear(256, 10) def forward(self, x): x = self.fc1(x) x = self.relu(x) x = self.fc2(x) return x model = SimpleNet() print(model)

打印模型会看到每一层的结构。nn.Module会自动追踪所有子模块和参数，所以model.parameters()能拿到所有需要优化的权重。

实际项目中，模型往往更复杂，会有卷积层、池化层、BatchNorm、Dropout等。但组织方式是一样的：在__init__里声明，在forward里连接。我建议新手养成一个习惯：每加一层就在纸上画一下数据形状怎么变，这样能避免维度不匹配的问题。

3.4 DataLoader：批量加载数据的标准方案

真实项目里数据量通常很大，不可能一次性全部加载到内存。Dataset和DataLoader就是解决这个问题的。Dataset负责定义“一条数据长什么样、怎么取”，DataLoader负责“怎么批量取、要不要打乱、用几个进程取”。

from torch.utils.data import Dataset, DataLoader class MyDataset(Dataset): def __init__(self, data, labels): self.data = data self.labels = labels def __len__(self): return len(self.data) def __getitem__(self, idx): return self.data[idx], self.labels[idx] dataset = MyDataset(torch.randn(1000, 10), torch.randint(0, 2, (1000,))) dataloader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=0) for batch_x, batch_y in dataloader: print(batch_x.shape, batch_y.shape) break

num_workers在Windows下建议设为0，否则容易出多进程相关的问题。在Linux下可以设成4或8来加速数据加载。shuffle=True在训练时几乎总是需要的，它能打乱数据顺序，防止模型学到“顺序”这种无关特征。

4. 完整项目实战：手写数字识别从零到部署

4.1 项目目标与技术选型

这个实战项目做MNIST手写数字识别。别嫌它简单，它是深度学习界的“Hello World”，包含了完整流程：数据加载、模型定义、训练、评估、保存、加载、推理。把这套流程跑通，换成CIFAR-10、猫狗分类、甚至自定义数据集，代码结构几乎不用大改。

技术选型上，我用一个简单的卷积神经网络（CNN）。为什么不用全连接网络？因为图像数据用CNN效果更好，而且能顺便理解卷积、池化这些概念。数据集直接用torchvision.datasets.MNIST，它会自动下载，省去手动准备数据的麻烦。

4.2 数据准备与预处理

import torch from torchvision import datasets, transforms from torch.utils.data import DataLoader # 定义预处理：转成Tensor并归一化 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # 下载并加载训练集和测试集 train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

Normalize里的两个数字是MNIST数据集的均值和标准差，这是经过统计得出的。归一化的目的是让数据分布更接近标准正态，训练更稳定。对于其他数据集，你需要自己算均值和标准差，或者用ImageNet的统计值作为近似。

4.3 模型定义：一个轻量级CNN

import torch.nn as nn import torch.nn.functional as F class Net(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(1, 32, 3, 1) self.conv2 = nn.Conv2d(32, 64, 3, 1) self.dropout1 = nn.Dropout(0.25) self.dropout2 = nn.Dropout(0.5) self.fc1 = nn.Linear(9216, 128) self.fc2 = nn.Linear(128, 10) 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)

这个网络结构不复杂，但包含了CNN的典型组件：卷积层提取特征、ReLU引入非线性、池化层降维、Dropout防止过拟合、全连接层做分类。log_softmax配合后面的NLLLoss使用，这是PyTorch里处理分类任务的常见组合。

4.4 训练循环与参数选择

import torch.optim as optim device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = Net().to(device) optimizer = optim.Adam(model.parameters(), lr=0.001) criterion = nn.NLLLoss() def train(epoch): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() if batch_idx % 100 == 0: print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)}] Loss: {loss.item():.6f}') for epoch in range(1, 6): train(epoch)

这里选Adam优化器，学习率0.001。Adam对新手比较友好，不太需要精细调学习率。训练5个epoch，MNIST上准确率通常能到99%左右。如果你用SGD，可能需要手动调学习率衰减，对新手来说麻烦一些。

4.5 模型评估与保存加载

def test(): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) output = model(data) test_loss += criterion(output, target).item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader) print(f'Test Loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({100. * correct / len(test_loader.dataset):.2f}%)') test() # 保存模型 torch.save(model.state_dict(), 'mnist_cnn.pt') # 加载模型 model_new = Net().to(device) model_new.load_state_dict(torch.load('mnist_cnn.pt')) model_new.eval()

model.eval()和torch.no_grad()是评估时的标准操作。前者把Dropout和BatchNorm切到推理模式，后者关闭梯度计算节省内存。保存模型推荐用state_dict()而不是整个模型对象，这样加载时更灵活，也不容易因为代码结构变化而出错。

5. 常见问题与排查技巧实录

5.1 环境类问题速查

5.2 训练类问题排查

Loss不下降：先检查学习率是不是太大或太小。太大导致震荡，太小导致几乎不动。然后检查数据有没有归一化，标签有没有对齐。最后确认模型输出和损失函数是否匹配，比如多分类用CrossEntropyLoss时模型不要加softmax。

Loss下降但准确率不涨：可能是过拟合，训练集表现好但测试集差。加Dropout、加数据增强、减小模型复杂度都可以试。也可能是评估代码写错了，比如忘了model.eval()。

训练速度慢：确认数据在GPU上、模型在GPU上。用num_workers加速数据加载。如果GPU利用率低，可能是数据加载成了瓶颈。

避坑技巧：我习惯在训练前先跑一个batch，打印输入和输出的形状、loss的初始值。如果初始loss是log(类别数)附近（比如10分类约2.3），说明模型初始化正常。如果loss是0或者特别大，说明有问题，不用等训练完就能发现。

5.3 我踩过的三个真实坑

第一个坑：在Windows上用num_workers>0导致程序卡死。后来查资料发现是Windows下多进程的实现方式和Linux不同，改成0就好了。如果你在Windows上训练，建议先用0跑通，确认没问题再尝试调大。

第二个坑：保存模型时用了torch.save(model)而不是torch.save(model.state_dict())。后来代码改了模型结构，加载旧模型直接报错。从那以后我只保存state_dict，加载时先实例化新模型再load_state_dict。

第三个坑：忘了在评估前加model.eval()，Dropout还在随机丢弃神经元，导致测试结果波动很大。这个错误很隐蔽，因为代码不报错，只是结果不对。养成习惯：训练前model.train()，评估前model.eval()。

6. 从入门到进阶的后续路线

环境搭好了，框架理解了，项目也跑通了，接下来往哪走？我的建议是不要急着看新模型，先把MNIST这个项目改一改。换成CIFAR-10数据集，调整网络结构适应3通道输入，观察准确率变化。然后试着加数据增强，比如随机裁剪、随机翻转，看能不能提升效果。再试着把训练过程可视化，用TensorBoard或matplotlib画loss曲线和准确率曲线。

这些改动都不难，但能让你真正理解每个组件的作用。等你把CNN玩熟了，再去看RNN、Transformer、GAN这些，会发现底层逻辑是一样的：定义模型、准备数据、写训练循环、调参优化。PyTorch的生态很丰富，torchvision做视觉、torchaudio做音频、torchtext做文本，需要哪个学哪个。

我个人在实际操作中的体会是，深度学习入门最难的不是数学，也不是编程，而是把整个流程跑通一遍。一旦你亲手训练出一个能用的模型，后面的事情就顺了。环境搭建那一步卡住的人最多，但只要你按上面的步骤走一遍，把每个环节都验证到位，后面就是不断重复和扩展的过程。最后分享一个小技巧：把你跑通的代码整理成一个模板，下次新项目直接复制过来改数据和模型，能省下大量时间。