大家好 我是南木，后台被问得最多的问题之一就是： “零基础学PyTorch，看官方文档像看天书，怎么办？” “跟着教程敲代码能跑通，但换个任务就卡壳，问题出在哪？” “学了两周张量操作，还是不会搭神经网络，是不是没天赋？”
其实，PyTorch入门难，不是因为你笨，而是方法错了——很多人一上来就死磕API文档，或者对着复杂模型代码硬啃，结果越学越懵。作为带过200+新手入门的过来人，我发现：零基础学PyTorch，最有效的路径是“先会用，再懂原理”，就像学开车时先练倒车入库，再研究发动机原理。
今天就把我总结的“30天入门PyTorch计划”拆解开，从环境搭建到实战项目，每个阶段该学什么、练什么、避什么坑，全给你讲清楚。按这个节奏走，30天内搞定基础操作+搭出第一个神经网络，完全没问题。
文章开始之前 这里给大家整理了一份适合零基础入门的学习资料包 需要的同学 扫描下方二维码自取即可
一、先搞懂：PyTorch到底是个啥？为什么学它？
在开始之前，先花5分钟搞懂“为什么要学PyTorch”，避免盲目跟风。
PyTorch是一个深度学习框架，简单说就是“帮你快速实现神经网络的工具”。它的核心优势是：
简单直观：代码风格和Python一样“灵活”，想改网络结构、调参数，改几行代码就行（对比TensorFlow早期的静态图，PyTorch的动态图对新手太友好）；生态强大：几乎所有顶会论文的代码都用PyTorch实现，复现别人的模型、用预训练模型（如BERT、ResNet）改改就能用；就业刚需：算法岗面试基本要求“熟练使用PyTorch”，大厂算法工程师的日常工作也离不开它。
对零基础来说，PyTorch的“低门槛”和“高灵活性”是最大优势——你不需要懂太多数学，就能快速跑通一个模型，建立学习信心。
二、准备阶段：这3样东西，学之前必须搞定
工欲善其事，必先利其器。正式学PyTorch前，花1-2天把这3件事做好，能避免80%的入门坑。
1. 电脑配置：别被“GPU刚需论”吓住
很多人纠结“没有NVIDIA显卡能不能学PyTorch”，结论是：完全能学。
初期学基础操作（张量、神经网络），CPU足够用（就是训练慢点，但跑通代码没问题）；后期想练GPU加速，再考虑配NVIDIA显卡（支持CUDA），入门级的RTX 3060就够了；实在没条件，用Google Colab（免费GPU）也能练手（后面会讲怎么用）。
2. 安装PyTorch：3步搞定，别折腾
推荐用Anaconda管理环境（避免包冲突），安装步骤：
第1步：装Anaconda
去Anaconda官网下载对应系统的安装包（Windows选64位，Mac选M1/M2版）；安装时勾上“Add Anaconda to PATH”（自动添加环境变量，新手必勾），其他默认下一步。
第2步：创建虚拟环境
打开终端（Windows用Anaconda Prompt，Mac用终端），输入：
conda create -n pytorch_env python=3.9
conda activate pytorch_env # 激活环境（命令行前出现(pytorch_env)就对了）
pytorch_env是环境名，随便起；Python选3.8或3.9（兼容性最好，3.10+可能有些库不支持）。
第3步：装PyTorch
打开PyTorch官网，根据你的情况选参数：
系统（Windows/macOS/Linux）；安装方式（Conda）；语言（Python）；计算平台：有NVIDIA显卡选“CUDA 11.7”（最新版可能不稳定），没有就选“CPU”； 复制官网生成的命令（比如CPU版）：conda install pytorch torchvision torchaudio cpuonly -c pytorch
粘贴到终端运行，等待安装完成（10-20分钟，国内网络慢可以换清华源，方法附在文末避坑清单）。
验证是否安装成功
终端输入python进入Python交互环境，再输入：
import torch
print(torch.__version__) # 打印版本号，如2.0.0
没报错就说明安装成功了。
3. 编辑器：推荐PyCharm Community（免费够用）
去PyCharm官网下载“Community”版（免费）；安装时勾上“Add launchers dir to PATH”，方便启动；首次打开时，在“Project Interpreter”里选择我们创建的“pytorch_env”环境（让PyCharm用这个环境的Python和库）。
三、第1周：吃透“张量操作”，PyTorch的“基石”
张量（Tensor）是PyTorch的“基本数据单位”，就像NumPy的数组、Python的列表。所有神经网络的输入、参数、输出都是张量，这部分学不透，后面搭模型肯定卡壳。
目标：1周内掌握“创建张量→基本操作→形状变换”，能独立完成“用张量实现简单的矩阵运算”。
必学知识点（附代码案例）
1. 张量的创建（3个最常用方法）
import torch
# 方法1：从Python列表创建
a = torch.tensor([1, 2, 3]) # 1维张量（向量）
b = torch.tensor([[1, 2], [3, 4]]) # 2维张量（矩阵）
print(a.shape) # 输出torch.Size([3])，看形状
print(b.dtype) # 输出torch.int64，看数据类型
# 方法2：创建全0/全1张量（指定形状）
c = torch.zeros((2, 3)) # 2行3列全0张量
d = torch.ones((3, 3)) # 3行3列全1张量
# 方法3：从NumPy数组转换（深度学习中加载数据常用）
import numpy as np
np_arr = np.array([[1, 2], [3, 4]])
e = torch.from_numpy(np_arr) # 转成张量
2. 张量的基本操作（和NumPy很像，别怕）
# 索引和切片（取数据）
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(x[0, 1]) # 取第0行第1列，输出2
print(x[:, 1:3]) # 取所有行，第1-2列（左闭右开），输出[[2,3],[5,6]]
# 数学运算
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
print(a + b) # 加法，输出tensor([5,7,9])
print(a * b) # 乘法，输出tensor([4,10,18])
print(torch.matmul(a.reshape(1,3), b.reshape(3,1))) # 矩阵乘法，输出tensor([[32]])
# 数据类型转换（常用）
x = torch.tensor([1, 2, 3], dtype=torch.int32)
x_float = x.to(torch.float32) # 转成float32（神经网络常用float32）
3. 形状变换（神经网络中最常用，必须练熟）
x = torch.tensor([[1, 2, 3], [4, 5, 6]]) # 形状(2,3)
# reshape：改变形状（元素总数不变）
x1 = x.reshape(3, 2) # 变成(3,2)，输出[[1,2],[3,4],[5,6]]
x2 = x.reshape(-1, 6) # -1表示自动计算，变成(1,6)，输出[[1,2,3,4,5,6]]
# squeeze/unsqueeze：增减维度（加括号）
x3 = x.unsqueeze(0) # 在第0维加一个维度，形状(1,2,3)
x4 = x3.squeeze(0) # 去掉第0维，变回(2,3)
# 转置（矩阵常用）
x5 = x.t() # 2维张量转置，形状(3,2)
练习任务：用张量实现“线性回归”的预测
不用神经网络，直接用张量操作实现： 已知线性关系y = 2*x + 3，给定x的张量，计算y的预测值。
x = torch.tensor([1.0, 2.0, 3.0]) # 输入
w = torch.tensor(2.0) # 权重
b = torch.tensor(3.0) # 偏置
y_pred = w * x + b # 预测值
print(y_pred) # 应该输出tensor([5., 7., 9.])
避坑点：
别死记硬背API，遇到不会的操作，搜“PyTorch 实现XX功能”（比如“PyTorch 矩阵乘法”），用多了自然记住；注意张量的数据类型，神经网络通常用float32，用int会报错；形状不匹配是最常见的错，多打印shape看维度（比如矩阵乘法要求前一个的列数=后一个的行数）。
四、第2周：掌握“自动求导”，神经网络的“发动机”
神经网络能“学习”，靠的是反向传播算法——通过计算损失对参数的梯度，不断调整参数让损失变小。PyTorch的autograd模块能自动算梯度，这是它的核心功能之一。
目标：理解“计算图”“梯度”的概念，会用backward()求梯度，能独立完成“用自动求导实现线性回归的参数更新”。
必学知识点（附代码案例）
1. 计算图与梯度追踪
PyTorch会自动记录张量的运算过程，形成“计算图”，然后用反向传播算梯度。要让张量能被追踪梯度，需要在创建时加requires_grad=True：
x = torch.tensor(2.0, requires_grad=True) # 需要追踪梯度
y = x ** 2 # y = x²
y.backward() # 反向传播，计算梯度
print(x.grad) # 输出tensor(4.)，即dy/dx在x=2处的值是4
requires_grad=True：告诉PyTorch“这个张量的运算需要被记录，后面要求梯度”；backward()：触发反向传播，计算所有requires_grad=True的张量的梯度；grad：存储计算出的梯度（每次反向传播前最好用x.grad.zero_()清零，避免累加）。
2. 用自动求导实现“线性回归参数更新”
还是y = 2*x + 3，但这次我们不知道w和b，让模型自己学出来：
# 1. 准备数据（带噪声的样本）
x = torch.tensor([1.0, 2.0, 3.0, 4.0])
y_true = torch.tensor([5.1, 7.0, 8.9, 11.2]) # 实际值，接近2x+3
# 2. 定义参数（需要求梯度）
w = torch.tensor(1.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)
# 3. 训练（迭代100次）
learning_rate = 0.01 # 学习率
for epoch in range(100):
# 前向传播：计算预测值
y_pred = w * x + b
# 计算损失（均方误差）
loss = torch.mean((y_pred - y_true) **2)
# 反向传播：计算梯度
loss.backward()
# 更新参数（梯度下降）
with torch.no_grad(): # 暂时关闭梯度追踪（更新参数不需要记录）
w -= learning_rate * w.grad
b -= learning_rate * b.grad
# 清零梯度（否则会累加）
w.grad.zero_()
b.grad.zero_()
print(f"学到的w: {w.item()}, b: {b.item()}") # 应该接近2和3
练习任务：手动实现“逻辑回归”的参数更新
用上面的方法，实现二分类问题的逻辑回归（用sigmoid函数输出概率）。
避坑点：
backward()只能调用一次，第二次调用前需要用retain_graph=True（但新手暂时不用管，遇到再查）；更新参数时必须用with torch.no_grad()，否则PyTorch会把参数更新也记录到计算图里，浪费内存；梯度清零！梯度清零！梯度清零！重要的事说三遍，否则每次backward()会累加梯度，导致参数更新错误。
五、第3周：搭神经网络，用nn模块快速实现模型
手动写线性回归、逻辑回归太麻烦，PyTorch的torch.nn模块封装了常用的神经网络层（如线性层、卷积层）、损失函数（如MSE、交叉熵），能帮你快速搭模型。
目标：掌握nn.Module的用法，会用nn.Sequential搭简单网络，能独立完成“用PyTorch实现一个3层神经网络解决分类问题”。
必学知识点（附代码案例）
1. nn.Module：自定义模型的“模板”
所有神经网络模型都要继承nn.Module，在__init__里定义层，在forward里写前向传播逻辑：
import torch.nn as nn
class MyModel(nn.Module):
def __init__(self):
super().__init__() # 必须调用父类初始化
# 定义一个线性层（输入特征数2，输出特征数1）
self.linear = nn.Linear(in_features=2, out_features=1)
# 定义激活函数（可选，增加非线性）
self.sigmoid = nn.Sigmoid()
def forward(self, x):
# 前向传播：输入x → 线性层 → 激活函数
x = self.linear(x)
x = self.sigmoid(x)
return x
# 创建模型实例
model = MyModel()
# 测试输入（3个样本，每个2个特征）
x = torch.tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
print(model(x)) # 输出3个样本的预测值
2. nn.Sequential：快速搭简单网络
如果网络是“层的顺序堆叠”，用nn.Sequential更简洁（不用写forward）：
# 搭一个3层神经网络（适合分类问题）
model = nn.Sequential(
nn.Linear(10, 32), # 输入10维，输出32维
nn.ReLU(), # ReLU激活函数（非线性）
nn.Linear(32, 16), # 32维→16维
nn.ReLU(),
nn.Linear(16, 2) # 输出2维（2分类）
)
# 测试输入（5个样本，每个10维特征）
x = torch.randn(5, 10) # 随机生成输入
print(model(x).shape) # 输出torch.Size([5, 2])，符合预期
3. 损失函数与优化器
损失函数：nn.MSELoss（回归）、nn.CrossEntropyLoss（分类）等；优化器：torch.optim里的SGD、Adam等，负责参数更新。
# 定义损失函数（分类用交叉熵）
criterion = nn.CrossEntropyLoss()
# 定义优化器（Adam，学习率0.001）
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 训练循环（伪代码）
for x, y in dataloader:
# 前向传播
pred = model(x)
# 算损失
loss = criterion(pred, y)
# 清零梯度
optimizer.zero_grad()
# 反向传播
loss.backward()
# 更新参数
optimizer.step()
练习任务：用PyTorch实现“多层感知机”分类MNIST手写数字
MNIST是手写数字数据集（0-9），用上面的方法搭一个3层神经网络，实现分类。
import torch
import torch.nn as nn
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# 1. 加载数据
transform = transforms.ToTensor() # 转成张量并归一化到0-1
train_dataset = datasets.MNIST(root='data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# 2. 定义模型（3层MLP）
model = nn.Sequential(
nn.Flatten(), # 把28x28的图像展平成784维向量
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 128),
nn.ReLU(),
nn.Linear(128, 10) # 10个类别
)
# 3. 定义损失和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 4. 训练（5轮）
for epoch in range(5):
for images, labels in train_loader:
# 前向传播
outputs = model(images)
loss = criterion(outputs, labels)
# 反向传播+更新
optimizer.zero_grad()
loss.backward()
optimizer.step()
print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
避坑点：
nn.CrossEntropyLoss已经包含了Softmax，输入不需要再过Softmax层；数据加载时记得做ToTensor()，把图像从0-255的PIL格式转成0-1的张量；训练前检查模型输入输出形状是否匹配（比如MNIST图像是28x28，展平后是784，要和第一层线性层的in_features=784对应）。
六、第4周：实战项目，用预训练模型改出自己的应用
学框架的最终目的是“解决实际问题”，而直接从头搭复杂模型太费劲。PyTorch的torchvision、Hugging Face等库提供了大量预训练模型（如ResNet、BERT），我们可以“微调”这些模型，快速实现自己的应用。
目标：学会用预训练模型做迁移学习，完成一个实战项目（如图像分类、文本情感分析）。
实战案例1：用ResNet微调实现“猫狗分类”
ResNet是经典的图像分类模型，我们用它的预训练权重，只改最后一层，实现猫狗分类。
import torch
import torch.nn as nn
from torchvision import models, transforms
from torch.utils.data import DataLoader, Dataset
from PIL import Image
import os
# 1. 定义数据集（假设train文件夹下有cat和dog两个子文件夹）
class CatDogDataset(Dataset):
def __init__(self, root, transform=None):
self.root = root
self.transform = transform
self.images = os.listdir(root)
def __getitem__(self, idx):
img_path = os.path.join(self.root, self.images[idx])
image = Image.open(img_path).convert('RGB')
# 标签：cat为0，dog为1
label = 0 if 'cat' in self.images[idx] else 1
if self.transform:
image = self.transform(image)
return image, torch.tensor(label)
def __len__(self):
return len(self.images)
# 2. 数据增强和加载
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # ResNet的标准化参数
])
train_dataset = CatDogDataset(root='train', transform=transform)
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
# 3. 加载预训练ResNet，修改最后一层
model = models.resnet18(pretrained=True) # 加载预训练权重
# 冻结前面的层（只训练最后一层）
for param in model.parameters():
param.requires_grad = False
# 替换最后一层（原来输出1000类，现在输出2类）
model.fc = nn.Linear(model.fc.in_features, 2)
# 4. 训练（和之前类似）
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.fc.parameters(), lr=0.001) # 只优化最后一层
for epoch in range(3):
for images, labels in train_loader:
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
实战案例2：用Hugging Face的预训练模型做“文本情感分析”
Hugging Face提供了大量NLP预训练模型，用transformers库可以直接调用：
# 先安装库
pip install transformers
from transformers import pipeline
# 加载情感分析 pipeline（默认用distilbert-base-uncased-finetuned-sst-2-english）
classifier = pipeline("sentiment-analysis")
# 测试文本
result = classifier("I love PyTorch, it's easy to use!")
print(result) # 输出[{'label': 'POSITIVE', 'score': 0.9998}]
result = classifier("This movie is terrible.")
print(result) # 输出[{'label': 'NEGATIVE', 'score': 0.9997}]
避坑点：
预训练模型的输入格式有要求（比如ResNet需要特定的标准化参数，NLP模型需要tokenizer），照着官方示例改；微调时可以先冻结预训练层，只训练最后一层（节省算力，效果也不错）；数据量少的时候，迁移学习比从头训练效果好10倍以上，优先用预训练模型。
七、加速学习的5个技巧（新手必看）
1.** 别死磕官方文档，先看中文教程入门 **：官方文档太全太细，新手容易迷路。推荐先看《PyTorch深度学习实战》《动手学深度学习（PyTorch版）》的前几章，有中文解释更易懂。
2.** 代码一定要自己敲，别复制粘贴 **：跟着教程敲代码时，刻意放慢速度，思考每一行的作用（比如zero_grad()为什么要写）。敲错了别慌，报错信息是最好的老师（比如shape mismatch就查维度）。
3.** 用“项目驱动”学习，别只练语法 **：学完基础后，立刻找一个小项目（如图像分类、文本生成），带着问题学。比如想做图像分割，再去学nn.Upsample层，效率更高。
4.** 善用可视化工具 **：用print打印张量形状和值，用TensorBoard看损失曲线：
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter('logs')
writer.add_scalar('Loss/train', loss.item(), epoch) # 记录损失
# 运行后在终端输入 tensorboard --logdir=logs 查看
5.** 遇到问题先搜“PyTorch 报错信息”**：90%的问题别人都遇到过，Stack Overflow、CSDN上有大量解决方案。比如“RuntimeError: CUDA out of memory”，搜一下就知道是显存不够，需要减小batch size。
八、30天学习计划时间表（可直接抄作业）
时间学习内容练习任务第1-2天安装PyTorch，熟悉PyCharm成功运行import torch，创建第一个张量第3-5天张量的创建、索引、数学运算用张量实现矩阵乘法、线性回归预测第6-7天张量的形状变换（reshape/squeeze等）把(2,3,4)的张量转成(6,4)、(1,24)等形状第8-10天autograd自动求导，梯度计算用自动求导实现线性回归的参数更新第11-13天nn.Module和常用层（Linear/ReLU）搭一个2层神经网络，实现简单函数拟合第14-16天损失函数和优化器用nn模块重写线性回归、逻辑回归第17-20天数据加载（DataLoader）和MNIST实战用3层MLP分类MNIST，准确率达到95%以上第21-25天预训练模型和迁移学习用ResNet微调实现猫狗分类第26-30天选一个感兴趣的项目深入（NLP/CV）用Hugging Face做文本分类，或用UNet做分割
最后：别追求“完美入门”，先跑起来再说
很多人学PyTorch时陷入“完美主义陷阱”：觉得自己数学不好、代码不熟练，就迟迟不敢动手。但实际上，哪怕你只会调包，能跑通一个预训练模型，也比对着文档发呆强100倍。
我带过的一个学员，零基础学PyTorch，3周就用ResNet在Kaggle的猫狗分类比赛中拿到了85%的准确率——他甚至说不清“卷积层的步长”是什么，但这完全不影响他完成项目。