PyTorch深度学习入门：从环境搭建到第一个神经网络实战

1. 为什么现在学PyTorch正当时

如果你最近在关注机器学习或者深度学习，PyTorch这个名字出现的频率一定高得离谱。无论是高校实验室的研究论文，还是工业界落地项目的技术栈选型，PyTorch几乎成了默认选项。这感觉就像几年前大家还在争论TensorFlow和PyTorch孰优孰劣，转眼间PyTorch已经一骑绝尘。这种转变背后，核心在于PyTorch的“动态图”设计哲学，它让研究和开发过程变得异常直观和灵活。你可以像写Python脚本一样，边写边运行，即时看到每一行代码对数据的影响，这种“所见即所得”的体验，对于需要快速实验和迭代的深度学习工作来说，是决定性的优势。

我刚开始接触深度学习时，也被各种框架搞得眼花缭乱。但上手PyTorch后，最大的感受就是“自然”。它没有那么多需要预先声明的“图”和“会话”，Tensor（张量）的操作和NumPy数组非常相似，自动求导（Autograd）机制也封装得极其优雅，让你可以专注于模型结构和算法逻辑本身，而不是框架的复杂性。无论是想复现一篇顶会论文的最新模型，还是为自己的业务数据搭建一个分类器，PyTorch都能提供一条平滑的路径。这篇内容，就是希望能帮你跨过从“知道PyTorch”到“能用PyTorch干活”这个门槛。我会从最实际的环境搭建讲起，覆盖核心概念、基础操作、一个完整的项目流程，再到你肯定会遇到的坑和解决技巧，目标就是让你看完之后，手里有代码，心里有底气。

2. 从零开始：搭建你的第一个PyTorch环境

万事开头难，而深度学习环境的搭建，往往是劝退新手的第一个“拦路虎”。CUDA版本、PyTorch版本、Python版本之间的兼容性问题，足以让人头疼。别担心，我们一步步来，目标是搭建一个稳定、可用的开发环境。

2.1 环境基石：Anaconda与Python版本选择

强烈建议使用Anaconda来管理你的Python环境。它可以为每个项目创建独立的虚拟环境，避免不同项目间的包版本冲突，这是保持系统清洁的黄金法则。

首先，去Anaconda官网下载并安装适合你操作系统的版本。安装完成后，打开终端（Windows是Anaconda Prompt或PowerShell，macOS/Linux是Terminal）。

接下来，创建一个专用于PyTorch的虚拟环境。这里Python版本的选择很重要。截至我写这篇文章时，PyTorch 2.3.1（一个较新且稳定的版本）官方明确支持Python 3.8到3.11。我个人的建议是选择Python 3.9或3.10，它们在兼容性和新特性之间取得了很好的平衡。避免使用最新的Python 3.12或更早的3.7，可能会遇到一些未预料的兼容性问题。

# 创建一个名为pytorch_env，Python版本为3.9的虚拟环境 conda create -n pytorch_env python=3.9 # 激活这个环境 conda activate pytorch_env

激活后，你的命令行提示符前面应该会出现(pytorch_env)，这表示你已经在这个独立的环境中工作了。

2.2 核心安装：CPU与GPU版本抉择

这是最关键的一步。PyTorch的安装命令会根据你是否有NVIDIA GPU以及CUDA版本而不同。

首先，确认你的GPU和CUDA驱动：

1. 打开终端，输入nvidia-smi。如果这个命令能运行并输出显卡信息，说明你有NVIDIA GPU且驱动已安装。
2. 查看输出表格右上角的“CUDA Version”，例如“12.4”。这个是你的驱动支持的最高CUDA运行时版本，不是你已经安装的CUDA Toolkit版本。

然后，访问PyTorch官网（pytorch.org）。首页会有一个类似“Get Started”的区域，提供一个安装命令生成器。这是最权威的参考。你需要选择：

• PyTorch Build: Stable (稳定版)
• 你的操作系统
• Package: 推荐使用Conda或Pip。Conda有时能更好地处理一些C++依赖。
• Language: Python
• Compute Platform: 这是核心选择。
  • 如果你没有NVIDIA GPU，或者暂时不想用GPU：选择CPU。命令最简单，安装也最快。
  • 如果你有NVIDIA GPU，并希望使用GPU加速：这里的选择必须谨慎。它指的是你要安装的PyTorch预编译包所依赖的CUDA Toolkit 版本。

关于CUDA版本选择的实战经验：官网可能提供CUDA 12.1, 11.8等选项。一个非常常见且稳定的组合是PyTorch 2.3.1 + CUDA 11.8。这个组合经过了大量项目验证，社区支持度极高。即使你的nvidia-smi显示支持CUDA 12.4，只要你的驱动版本足够高（一般470以上），你依然可以安装并运行基于CUDA 11.8的PyTorch，因为驱动是向下兼容的。选择CUDA 11.8能最大程度避免一些冷门库（如某些版本的apex或mmcv）的兼容性问题。

假设我们选择Conda安装，CUDA 11.8，官网生成的命令可能类似于：

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

对于“一台不能联网的电脑”的离线安装方案：这确实是个麻烦事，但可以解决。核心思路是“离线包下载+本地安装”。

1. 在一台能联网的、操作系统和Python版本相同的电脑上，使用pip download命令下载所有依赖的.whl包。

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

2. 将下载的所有文件拷贝到离线电脑。
3. 在离线电脑的虚拟环境中，使用pip install命令安装本地文件。

   pip install --no-index --find-links=./downloaded_packages_dir torch torchvision torchaudio

   其中./downloaded_packages_dir是你存放所有.whl文件的目录。

安装完成后，在Python中运行以下代码验证：

import torch print(torch.__version__) # 打印PyTorch版本 print(torch.cuda.is_available()) # 打印CUDA是否可用，True则GPU环境正常

如果最后一行输出True，那么恭喜你，一个带GPU加速的PyTorch环境已经就绪。

2.3 镜像加速与依赖管理

如果你在国内，使用PyTorch官方源下载可能会非常慢。为Conda和Pip配置国内镜像源是必备技能。

配置Conda镜像（清华源）：

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

配置Pip镜像（阿里云源）：在用户目录下创建或修改pip.conf文件。

• Linux/macOS:~/.pip/pip.conf
• Windows:%USERPROFILE%\pip\pip.ini文件内容：

[global] index-url = https://mirrors.aliyun.com/pypi/simple/ trusted-host = mirrors.aliyun.com

注意：有时镜像源可能没有最新版本的PyTorch包。如果安装失败，可以尝试临时移除镜像，使用-c pytorch -c nvidia指定从官方频道安装，或者换一个镜像源（如中科大源）。

3. 理解PyTorch的核心：Tensor与Autograd

环境搭好，我们就进入了PyTorch的世界。这个世界里有两个最核心的基石：Tensor（张量）和Autograd（自动求导）。理解了它们，你就理解了PyTorch一半的精髓。

3.1 Tensor：一切数据的容器

Tensor可以简单理解为多维数组。它是PyTorch中存储和变换数据的基本单位，和NumPy的ndarray非常像，但有一个关键增强：Tensor可以运行在GPU上，从而进行高速的数值计算。

创建Tensor的多种方式：

import torch # 1. 从数据直接创建 x = torch.tensor([1, 2, 3, 4]) # 创建一个一维Tensor y = torch.tensor([[1, 2], [3, 4]]) # 创建一个二维矩阵 # 2. 创建特定形状的Tensor zeros = torch.zeros(2, 3) # 2行3列的全0矩阵 ones = torch.ones(2, 3) # 全1矩阵 rand = torch.rand(2, 3) # 元素服从[0,1)均匀分布的随机矩阵 randn = torch.randn(2, 3) # 元素服从标准正态分布N(0,1)的矩阵 # 3. 从NumPy数组创建 (非常常用！) import numpy as np np_array = np.array([1, 2, 3]) torch_tensor = torch.from_numpy(np_array) # NumPy -> Tensor # 注意：通过from_numpy创建的Tensor与原始NumPy数组共享内存，修改一个会影响另一个。 # 4. 指定设备（CPU或GPU） if torch.cuda.is_available(): device = torch.device("cuda:0") # 使用第一块GPU gpu_tensor = torch.ones(2, 3, device=device) # 或者创建后移动 cpu_tensor = torch.ones(2, 3) gpu_tensor = cpu_tensor.to(device) # 移动到GPU

Tensor的基本操作：Tensor支持几乎所有你能想到的数学运算，语法非常直观。

a = torch.tensor([1, 2, 3]) b = torch.tensor([4, 5, 6]) # 算术运算 c = a + b # 逐元素相加: tensor([5, 7, 9]) d = a * b # 逐元素相乘: tensor([4, 10, 18]) e = torch.matmul(a.reshape(1,3), b.reshape(3,1)) # 矩阵乘法: tensor([32]) # 形状变换 (非常重要！) x = torch.randn(4, 3, 28, 28) # 一个4张3通道28x28图片的batch print(x.shape) # torch.Size([4, 3, 28, 28]) y = x.view(4, -1) # view: 改变形状，-1表示自动计算该维度大小 print(y.shape) # torch.Size([4, 2352]) # 3*28*28=2352 z = x.permute(0, 2, 3, 1) # permute: 重排维度顺序 print(z.shape) # torch.Size([4, 28, 28, 3]) # 将通道维移到最后，适合某些可视化或操作 # 索引和切片 (和Python列表/NumPy几乎一样) print(x[0].shape) # 第一张图片: torch.Size([3, 28, 28]) print(x[:, 0, :, :].shape) # 所有图片的第一个通道: torch.Size([4, 28, 28])

3.2 Autograd：让神经网络自己学习

Autograd是PyTorch的自动微分引擎。正是它，使得神经网络的训练变得如此简单。其核心思想是：在Tensor上进行的所有操作，都会被自动记录到一个“计算图”中。当你完成前向传播计算后，可以一键反向传播，自动计算出所有参与运算的Tensor的梯度（导数）。

requires_grad属性：要启用一个Tensor的自动求导功能，你需要在创建时或之后设置requires_grad=True。

x = torch.ones(2, 2, requires_grad=True) # 创建时启用 # 或者 x = torch.ones(2, 2) x.requires_grad_(True) # 就地修改 print(x.requires_grad) # True

一个完整的求导示例：

# 1. 创建需要梯度的Tensor x = torch.tensor([1., 2., 3.], requires_grad=True) w = torch.tensor([0.1, 0.2, 0.3], requires_grad=True) b = torch.tensor(1.0, requires_grad=True) # 2. 前向传播（构建计算图） y = w * x + b # y = 0.1*1 + 0.2*2 + 0.3*3 + 1 = 2.4 # 假设我们的目标是让y接近0，定义一个简单的损失 loss = y.sum() # loss = 2.4 print(loss) # tensor(2.4000, grad_fn=<SumBackward0>) # 注意loss有一个grad_fn属性，它指向创建这个Tensor的操作（SumBackward0）。 # 3. 反向传播（自动求导） loss.backward() # 这是关键！计算所有requires_grad=True的Tensor的梯度 # 4. 查看梯度 print(w.grad) # tensor([1., 2., 3.]) print(x.grad) # tensor([0.1000, 0.2000, 0.3000]) print(b.grad) # tensor(3.)

w.grad是损失函数loss对w的偏导数。因为loss = sum(w*x + b)，所以d(loss)/d(w_i) = x_i。当x=[1,2,3]时，w.grad就是[1,2,3]。这和我们手动求导的结果一致。

梯度累加与清零：backward()计算的梯度会累加到Tensor的.grad属性中。在每次参数更新前，必须手动将梯度清零，否则梯度会越加越大。

# 错误的做法：连续两次backward而不清零 loss.backward() print(w.grad) # 第一次梯度 loss.backward() print(w.grad) # 第二次梯度会累加上去，变成两倍！ # 正确的做法：在优化器步骤中，通常这样操作 optimizer = torch.optim.SGD([w, b], lr=0.01) # 后续会讲优化器 for epoch in range(num_epochs): # ... 前向传播计算loss ... optimizer.zero_grad() # 清零所有优化器管理参数的梯度 loss.backward() # 反向传播，计算当前梯度 optimizer.step() # 根据梯度更新参数

实操心得：在验证或测试模型时，我们不需要计算梯度，因为不涉及参数更新。此时可以使用torch.no_grad()上下文管理器来关闭梯度计算，这能显著减少内存消耗并加速计算。

with torch.no_grad(): # 在这个块内的所有计算都不会被记录到计算图中 output = model(test_data) # 即使model的参数requires_grad=True，这里的output也不会保留梯度信息

4. 构建你的第一个神经网络：以全连接网络为例

理解了Tensor和Autograd，我们就可以用PyTorch提供的更高层抽象——torch.nn模块来搭建神经网络了。nn.Module是所有神经网络模块的基类，你的模型应该继承这个类。

4.1 定义网络模型

我们来构建一个用于手写数字识别（MNIST数据集）的简单全连接神经网络。MNIST图像是28x28的灰度图，我们将其展平为784维的向量作为输入，输出是10个数字类别的概率。

import torch.nn as nn import torch.nn.functional as F class SimpleNN(nn.Module): def __init__(self, input_size=784, hidden_size=128, num_classes=10): super(SimpleNN, self).__init__() # 必须调用父类初始化 # 定义网络层 self.fc1 = nn.Linear(input_size, hidden_size) # 全连接层1: 784 -> 128 self.fc2 = nn.Linear(hidden_size, hidden_size) # 全连接层2: 128 -> 128 self.fc3 = nn.Linear(hidden_size, num_classes) # 输出层: 128 -> 10 # 注意：我们并没有在这里定义激活函数。通常激活函数不包含可学习参数，可以在forward中直接使用。 def forward(self, x): # 定义数据的前向传播流程 # x的形状: [batch_size, 1, 28, 28] 或 [batch_size, 784] x = x.view(-1, 784) # 将图像展平，-1表示自动推断batch_size out = self.fc1(x) # 线性变换 out = F.relu(out) # 非线性激活函数 out = self.fc2(out) out = F.relu(out) out = self.fc3(out) # 最后一层通常不加激活函数（对于分类问题，配合CrossEntropyLoss会内部做Softmax） return out # 实例化模型 model = SimpleNN() print(model)

nn.Linear是线性层（全连接层），其参数weight和bias会在创建时自动初始化（通常是均匀分布或正态分布），并且默认requires_grad=True。forward方法定义了数据如何流过这些层。你只需要定义forward，backward方法会由Autograd通过你定义的forward自动生成。

4.2 准备数据：DataLoader的使用

在深度学习中，数据准备和管理至关重要。PyTorch提供了torch.utils.data.DataLoader和Dataset类来高效地加载和批处理数据。

使用内置数据集（以MNIST为例）：

import torchvision import torchvision.transforms as transforms # 定义数据预处理转换 # ToTensor()将PIL图像或NumPy数组转换为[C, H, W]范围的Tensor，并归一化到[0,1] # Normalize进行标准化，给定均值和标准差，这里是对单通道灰度图操作 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) # MNIST的全局均值和标准差 ]) # 下载并加载训练集和测试集 train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True) test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True) # 创建数据加载器DataLoader # DataLoader负责从Dataset中按批次采样，并提供了多线程加速、数据打乱等功能 train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, # 每批64张图片 shuffle=True) # 训练集需要打乱 test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False) # 测试集不需要打乱

自定义Dataset：当你的数据不在标准格式中时，你需要自定义Dataset。关键是实现__len__和__getitem__两个方法。

from torch.utils.data import Dataset import pandas as pd from PIL import Image class CustomImageDataset(Dataset): def __init__(self, csv_file, img_dir, transform=None): self.annotations = pd.read_csv(csv_file) # 假设CSV有'image_name'和'label'列 self.img_dir = img_dir self.transform = transform def __len__(self): return len(self.annotations) def __getitem__(self, idx): img_path = os.path.join(self.img_dir, self.annotations.iloc[idx, 0]) image = Image.open(img_path).convert('RGB') # 打开图片并确保是RGB label = self.annotations.iloc[idx, 1] if self.transform: image = self.transform(image) # 应用预处理 return image, label

4.3 训练循环的完整拼图

有了模型和数据，我们还需要损失函数和优化器，才能构成一个完整的训练循环。

import torch.optim as optim # 1. 实例化模型、损失函数、优化器 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = SimpleNN().to(device) # 将模型移动到设备（GPU/CPU） criterion = nn.CrossEntropyLoss() # 交叉熵损失，适用于多分类 optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9) # 随机梯度下降优化器 # 也可以使用Adam优化器，它通常需要更少的超参数调优 # optimizer = optim.Adam(model.parameters(), lr=0.001) # 2. 训练循环 num_epochs = 5 for epoch in range(num_epochs): model.train() # 将模型设置为训练模式（影响Dropout、BatchNorm等层的行为） running_loss = 0.0 for i, (images, labels) in enumerate(train_loader): # 将数据移动到设备 images = images.to(device) labels = labels.to(device) # 前向传播 outputs = model(images) loss = criterion(outputs, labels) # 反向传播与优化 optimizer.zero_grad() # 清零梯度缓存 loss.backward() # 反向传播，计算梯度 optimizer.step() # 根据梯度更新参数 # 打印统计信息 running_loss += loss.item() if (i+1) % 100 == 0: # 每100个batch打印一次 print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], Loss: {running_loss/100:.4f}') running_loss = 0.0 # 3. 每个epoch后在测试集上评估 model.eval() # 将模型设置为评估模式 with torch.no_grad(): # 评估时不计算梯度，节省内存和计算 correct = 0 total = 0 for images, labels in test_loader: images = images.to(device) labels = labels.to(device) outputs = model(images) _, predicted = torch.max(outputs.data, 1) # 获取预测类别 total += labels.size(0) correct += (predicted == labels).sum().item() print(f'Epoch [{epoch+1}/{num_epochs}] 测试集准确率: {100 * correct / total:.2f} %')

这个训练循环是PyTorch深度学习项目的核心模板。model.train()和model.eval()的切换至关重要，它控制了如Dropout和BatchNorm这类在训练和评估时行为不同的层。

5. 避坑指南与性能优化实战

纸上得来终觉浅，绝知此事要躬行。在实际使用PyTorch的过程中，你会遇到各种各样的问题。下面是我总结的一些常见“坑”和优化技巧。

5.1 内存管理与调试技巧

1. “CUDA out of memory”错误：这是GPU开发者最常见的错误。根本原因是GPU显存被耗尽。

• 检查点：
  • 减小Batch Size：这是最直接有效的方法。将DataLoader的batch_size减半试试。
  • 使用梯度累积：如果因为模型太大导致batch size只能设为1，但小batch可能不稳定，可以使用梯度累积。原理是多次前向传播的梯度累加后再更新一次参数，模拟大batch的效果。

    accumulation_steps = 4 optimizer.zero_grad() for i, (data, label) in enumerate(train_loader): output = model(data) loss = criterion(output, label) / accumulation_steps # 损失按累积步数平均 loss.backward() # 梯度累积，不立即清零 if (i+1) % accumulation_steps == 0: optimizer.step() # 累积了accumulation_steps个batch的梯度后，更新一次参数 optimizer.zero_grad() # 清零梯度，准备下一次累积

  • 使用更小的模型或混合精度训练：考虑简化模型结构。PyTorch也支持自动混合精度训练（AMP），使用torch.cuda.amp，它能让部分计算使用float16，节省显存并加速。
  • 及时释放不用的变量：在循环中，将不再需要的大Tensor设置为None，并手动调用torch.cuda.empty_cache()（效果有限，但有时有用）。

2. 调试神器：torch.autograd.detect_anomaly当你的损失函数出现NaN或者训练不收敛时，可能是梯度爆炸或出现了非法运算。启用异常检测可以在反向传播时定位问题源头。

torch.autograd.set_detect_anomaly(True) with torch.autograd.detect_anomaly(): # 在这里运行你的前向和反向传播 loss = model(data) loss.backward() # 如果发生NaN或inf，会打印出导致该问题的具体操作栈。

5.2 模型保存、加载与部署

保存和加载模型：PyTorch通常保存模型的state_dict（一个字典，将每一层映射到其参数Tensor），而不是整个模型。

# 保存 torch.save(model.state_dict(), 'model_weights.pth') # 加载（需要先实例化一个相同结构的模型） model = SimpleNN() model.load_state_dict(torch.load('model_weights.pth')) model.eval() # 别忘了切换到评估模式 # 保存整个模型（不推荐，因为和代码绑定过紧） # torch.save(model, 'entire_model.pth') # loaded_model = torch.load('entire_model.pth')

模型部署：要将PyTorch模型部署到生产环境（如Web服务），通常需要将其转换为更高效的格式。

• TorchScript：通过torch.jit.trace或torch.jit.script将模型转换为一个可以脱离Python运行的序列化模型。

  # 示例：通过追踪（trace）生成TorchScript example_input = torch.rand(1, 1, 28, 28) traced_script_module = torch.jit.trace(model, example_input) traced_script_module.save("traced_model.pt")

• ONNX：一种开放的模型交换格式，可以将PyTorch模型导出，然后用其他推理引擎（如TensorRT, OpenVINO）运行。

  torch.onnx.export(model, example_input, "model.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch_size"}}) # 支持动态batch

5.3 监控与可视化

了解模型在训练时内部发生了什么非常重要。torch.utils.tensorboard是官方推荐的利器。

from torch.utils.tensorboard import SummaryWriter # 初始化 writer = SummaryWriter('runs/experiment_1') # 在训练循环中记录 for epoch in range(num_epochs): # ... 训练 ... writer.add_scalar('Loss/train', running_loss / 100, epoch * len(train_loader) + i) writer.add_scalar('Accuracy/test', accuracy, epoch) # 还可以记录模型图、直方图、图像等 # writer.add_graph(model, images) # writer.add_histogram('fc1.weight', model.fc1.weight, epoch) # 训练完成后，在命令行启动TensorBoard # tensorboard --logdir=runs

5.4 版本兼容性与环境复现

“在我电脑上好好的，怎么到你那就错了？”——版本问题是万恶之源。

• 使用requirements.txt或environment.yml：

  # 导出环境 (pip) pip freeze > requirements.txt # 导出环境 (conda) conda env export > environment.yml --no-builds # --no-builds可以避免记录具体的构建号，提高可移植性 # 根据environment.yml创建环境 conda env create -f environment.yml

• 注意PyTorch与CUDA的对应关系：这是最易出错的地方。务必查阅PyTorch官网的安装页面，确认你安装的PyTorch版本支持你系统上的CUDA版本（或CPU）。例如，cuda 12.8可能需要寻找特定版本的PyTorch预览版，而cuda 11.8则有广泛的稳定版支持。

6. 从入门到进阶：下一步学习路径

掌握了以上内容，你已经能够用PyTorch完成很多基础任务了。但深度学习领域浩瀚无垠，以下是一些建议的进阶方向：

1. 深入核心模块：

• torch.nn：深入学习其他层，如卷积层nn.Conv2d、循环神经网络层nn.LSTM、nn.GRU，以及Dropout、BatchNorm等。
• torch.optim：尝试不同的优化器，如AdamW、RMSprop，并学习如何使用学习率调度器lr_scheduler。
• torchvision：如果你做计算机视觉，这个库是宝藏，包含数据集、模型架构（如ResNet）、图像变换和增强方法。

2. 项目实践：

• 复现经典论文：尝试复现LeNet, AlexNet, VGG，甚至更现代的ResNet在CIFAR-10上的效果。
• 参与Kaggle竞赛：这是一个绝佳的实战平台，从数据预处理、特征工程、模型搭建、集成学习到调参，全流程锻炼。
• 个人兴趣项目：用深度学习解决一个你感兴趣的实际问题，比如用LSTM写诗、用CNN识别你的猫狗照片。

3. 学习优秀资源：

• 官方教程：PyTorch官网的Tutorials质量极高，涵盖从基础到前沿的各个方面。
• “动手学深度学习”（李沐）：有PyTorch版，是系统学习深度学习和PyTorch的经典教材。
• “小土堆”PyTorch视频教程：在B站上非常受欢迎的入门实战视频，手把手敲代码。
• “刘二大人”PyTorch课程：同样在B站，讲解深入浅出，作业设计得很好。

最后，我想说的是，框架只是工具，PyTorch让这个工具变得非常顺手。但真正的核心在于你对机器学习、深度学习理论的理解，以及你利用工具解决实际问题的能力。多读代码、多写代码、多调试、多思考，遇到问题善用Google、Stack Overflow和PyTorch论坛，你很快就能从“入门”走向“熟练”，甚至“精通”。这个过程就像搭积木，最初你看着说明书（教程）一步步来，熟练之后，你就能自由地创造属于自己的模型大厦了。