PyTorch基础知识简述

从最核心的基础概念入手，提供可直接运行的代码并详细解释，打好 PyTorch 的基础。

前置准备：安装 PyTorch

首先确保已安装 PyTorch，新手推荐先安装 CPU 版本（无需显卡配置），终端执行以下命令：

# CPU版本（推荐新手）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
# GPU版本（需提前配置CUDA，适合有NVIDIA显卡的场景）
# pip install torch torchvision torchaudio

---

一、核心模块 1：张量（Tensor）基础（PyTorch 的核心数据结构）

张量是 PyTorch 中存储数据的基本单元，类似 NumPy 数组，但支持 GPU 加速和自动求导。

关键代码示例

import torch  # 导入PyTorch核心库

# 1. 创建张量
# 从列表创建
tensor_from_list = torch.tensor([[1, 2, 3], [4, 5, 6]])
# 创建全0张量（指定形状）
tensor_zeros = torch.zeros((2, 3))
# 创建全1张量（指定数据类型）
tensor_ones = torch.ones((2, 3), dtype=torch.float32)
# 创建随机张量（均匀分布0-1）
tensor_rand = torch.rand((2, 3))
# 创建随机张量（正态分布，均值0，方差1）
tensor_randn = torch.randn((2, 3))

# 2. 张量基本属性
print("张量形状:", tensor_from_list.shape)  # 输出: torch.Size([2, 3])
print("数据类型:", tensor_from_list.dtype)    # 输出: torch.int64（默认）
print("存储设备:", tensor_from_list.device)  # 输出: cpu（默认）

# 3. 张量形状操作
# 重塑形状（reshape，不改变数据）
tensor_reshaped = tensor_from_list.reshape(3, 2)
# 展平张量
tensor_flatten = tensor_from_list.flatten()

# 4. 张量运算（逐元素运算）
tensor_a = torch.tensor([1, 2, 3])
tensor_b = torch.tensor([4, 5, 6])
# 加法
tensor_add = tensor_a + tensor_b  # 等价于 torch.add(tensor_a, tensor_b)
# 乘法（逐元素）
tensor_mul = tensor_a * tensor_b  # 等价于 torch.mul(tensor_a, tensor_b)
# 矩阵乘法（注意维度匹配）
tensor_matmul = torch.matmul(tensor_from_list, tensor_reshaped)  # (2,3) × (3,2) = (2,2)

# 5. 设备切换（CPU ↔ GPU）
if torch.cuda.is_available():  # 检查是否有可用GPU
    tensor_gpu = tensor_from_list.to("cuda")  # 移到GPU
    tensor_cpu = tensor_gpu.to("cpu")         # 移回CPU
else:
    print("无可用GPU，使用CPU运行")

# 6. 张量与NumPy互转
import numpy as np
# 张量转NumPy数组
numpy_arr = tensor_from_list.numpy()
# NumPy数组转张量
tensor_from_np = torch.from_numpy(numpy_arr)

关键解释

• torch.tensor()：创建张量的基础方法，参数可以是列表 / 数组，支持指定dtype（数据类型）、device（设备）。
• 形状操作（reshape/flatten）：仅改变张量的 "视图"，不复制数据，效率高。
• 设备切换：只有移到 GPU 的张量才能利用显卡加速，torch.cuda.is_available()是判断 GPU 是否可用的核心代码。

---

二、核心模块 2：自动求导（Autograd）（PyTorch 的核心特性）

Autograd 是 PyTorch 实现反向传播的核心，能自动计算张量的梯度（导数），是构建神经网络的基础。

关键代码示例

import torch

# 1. 创建需要求导的张量（requires_grad=True）
x = torch.tensor([2.0], requires_grad=True)
y = torch.tensor([3.0], requires_grad=True)

# 2. 定义计算图（z = x² + y + 3）
z = x**2 + y + 3

# 3. 反向传播（计算梯度）
z.backward()  # 对z关于所有叶子节点（x、y）求导

# 4. 查看梯度（存储在.grad属性中）
print("x的梯度 (dz/dx = 2x):", x.grad)  # 输出: tensor([4.])
print("y的梯度 (dz/dy = 1):", y.grad)    # 输出: tensor([1.])

# 5. 梯度清零（关键！多次反向传播前必须清零）
x.grad.zero_()
y.grad.zero_()

# 6. 禁用梯度计算（推理阶段常用）
with torch.no_grad():
    z_no_grad = x**2 + y + 3
    print("禁用梯度后，z的requires_grad:", z_no_grad.requires_grad)  # 输出: False

关键解释

• requires_grad=True：标记张量需要计算梯度，只有叶子节点（直接创建的张量）的grad会被保留。
• backward()：触发反向传播，计算所有依赖该张量的叶子节点的梯度。
• grad.zero_()：梯度会累加，因此每次迭代（如训练）前必须清零，否则梯度会错误叠加。
• torch.no_grad()：上下文管理器，禁用梯度计算，减少内存占用，常用于模型推理（预测）阶段。

---

三、核心模块 3：数据加载（Dataset & DataLoader）

PyTorch 提供了标准化的数据加载工具，解决批量加载、打乱、多线程加载等问题，是训练模型的必备代码。

关键代码示例

import torch
from torch.utils.data import Dataset, DataLoader
import numpy as np

# 1. 自定义数据集类（继承Dataset）
class MyDataset(Dataset):
    def __init__(self, data, labels):
        self.data = torch.from_numpy(data).float()  # 转张量
        self.labels = torch.from_numpy(labels).long()

    # 必须实现：获取单个样本
    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

    # 必须实现：返回数据集长度
    def __len__(self):
        return len(self.data)

# 2. 构造模拟数据
data = np.random.rand(100, 10)  # 100个样本，每个样本10个特征
labels = np.random.randint(0, 2, size=100)  # 二分类标签

# 3. 创建数据集实例
dataset = MyDataset(data, labels)

# 4. 创建DataLoader（批量加载核心）
dataloader = DataLoader(
    dataset,
    batch_size=32,  # 每次加载32个样本
    shuffle=True,   # 每个epoch打乱数据
    num_workers=0   # 加载数据的线程数，新手设为0避免报错
)

# 5. 遍历DataLoader（训练循环中常用）
for epoch in range(2):  # 模拟2个训练轮次
    print(f"\nEpoch {epoch+1}")
    for batch_idx, (batch_data, batch_labels) in enumerate(dataloader):
        print(f"  Batch {batch_idx+1}: 数据形状 {batch_data.shape}, 标签形状 {batch_labels.shape}")
        # 这里可加入模型训练逻辑

关键解释

• Dataset：自定义数据集必须继承该类，并实现__getitem__（获取单样本）和__len__（样本数）。
• DataLoader：核心是批量加载数据，batch_size控制每次加载的样本数，shuffle=True保证训练时数据顺序随机，避免过拟合。
• 遍历DataLoader时，每次返回一个批次的（数据，标签），是训练循环的核心写法。

---

四、核心模块 4：简单神经网络构建（nn.Module）

nn.Module是 PyTorch 中所有模型的基类，封装了参数管理、前向传播、设备切换等功能，是构建模型的核心。

关键代码示例

import torch
import torch.nn as nn
import torch.optim as optim

# 1. 定义简单神经网络（继承nn.Module）
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNet, self).__init__()  # 必须调用父类构造函数
        # 定义网络层
        self.fc1 = nn.Linear(input_size, hidden_size)  # 全连接层1
        self.relu = nn.ReLU()                          # 激活函数
        self.fc2 = nn.Linear(hidden_size, output_size) # 全连接层2

    # 必须实现：前向传播逻辑
    def forward(self, x):
        x = self.fc1(x)   # 第一层输出
        x = self.relu(x)  # 激活
        x = self.fc2(x)   # 输出层
        return x

# 2. 创建模型实例
input_size = 10    # 输入特征数
hidden_size = 20   # 隐藏层神经元数
output_size = 2    # 输出类别数（二分类）
model = SimpleNet(input_size, hidden_size, output_size)

# 3. 查看模型结构
print("模型结构:\n", model)

# 4. 定义损失函数和优化器（训练核心）
criterion = nn.CrossEntropyLoss()  # 交叉熵损失（分类任务）
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降优化器

# 5. 模拟训练步骤
# 模拟一批输入数据（batch_size=32, input_size=10）
inputs = torch.randn(32, input_size)
# 模拟标签（32个样本，标签0/1）
labels = torch.randint(0, 2, (32,))

# 训练单步
optimizer.zero_grad()  # 梯度清零（必须！）
outputs = model(inputs)  # 前向传播
loss = criterion(outputs, labels)  # 计算损失
loss.backward()  # 反向传播（计算梯度）
optimizer.step()  # 更新参数（梯度下降）

print("单步训练后的损失值:", loss.item())

关键解释

• nn.Module：自定义模型必须继承该类，__init__中定义网络层，forward中实现前向传播逻辑（无需手动写反向传播）。
• nn.Linear：全连接层（线性层），参数为(输入维度, 输出维度)，是最基础的网络层。
• 损失函数（criterion）：衡量模型预测值与真实标签的差距，分类任务常用CrossEntropyLoss，回归任务常用MSELoss。
• 优化器（optimizer）：用于更新模型参数，model.parameters()获取模型所有可训练参数，lr是学习率（核心超参数）。
• 训练单步流程：梯度清零 → 前向传播 → 计算损失 → 反向传播 → 更新参数，这是 PyTorch 训练模型的固定流程。

---

总结

1. 张量（Tensor） 是 PyTorch 的核心数据结构，掌握创建、形状操作、运算、设备切换是基础，其requires_grad=True是自动求导的前提。
2. Autograd 自动计算梯度，backward()触发反向传播，grad.zero_()必须在每次训练前执行，避免梯度累加。
3. Dataset/DataLoader 是标准化的数据加载方式，解决批量、打乱、多线程加载问题，是训练模型的必备工具；nn.Module是构建神经网络的核心类，训练流程固定为 "梯度清零→前向传播→计算损失→反向传播→更新参数"。

这些代码覆盖了 PyTorch 最核心的基础用法，建议逐段运行、修改参数（如batch_size、lr），理解每一步的作用，在此基础上再深入学习进阶内容（如卷积层、循环层、模型保存加载等）。