Pytorch

Tensor

Tensor（张量） 就是一个多维数组。

它的概念类似于：

0 维 → 标量（scalar），比如 3.14
1 维 → 向量（vector），比如 [1, 2, 3]
2 维 → 矩阵（matrix），比如： $$ \begin{bmatrix} 1 & 2 \ 3 & 4 \end{bmatrix} $$
3 维及以上 → 高维张量，比如图像（batch_size × height × width × channel）

可以理解为：Tensor = 带维度的数字容器。

PyTorch 的 Tensor 类似于 NumPy 的 ndarray，但它还有两个关键优势：

可以放到 GPU 上，加速计算（非常适合深度学习）。
支持自动求导（autograd），用于反向传播。

t0 = torch.tensor(5)
print(t0, t0.shape)   # tensor(5)  torch.Size([])

# 向量 (1维 Tensor)
t1 = torch.tensor([1, 2, 3])
print(t1, t1.shape)   # tensor([1, 2, 3]) torch.Size([3])

# 矩阵 (2维 Tensor)
t2 = torch.tensor([[1, 2], [3, 4]])
print(t2, t2.shape)   # tensor([[1, 2],[3, 4]]) torch.Size([2, 2])

# 随机 Tensor
t3 = torch.randn(2, 3)  # 2行3列，服从标准正态分布
print(t3)

# 全零 / 全一 Tensor
t4 = torch.zeros(3, 3)
t5 = torch.ones(2, 4)

如何用 PyTorch 写一个神经网络

我会分步骤说明，并给出示例代码。

基本流程

在 PyTorch 中，训练一个神经网络通常分为以下几个步骤：

准备数据
使用 torch.tensor、Dataset 和 DataLoader 来加载数据。
定义模型
继承 nn.Module，在 __init__ 里定义层，在 forward 里写前向传播。
定义损失函数和优化器
损失函数：如 nn.CrossEntropyLoss
优化器：如 torch.optim.SGD、Adam
训练循环
前向传播 → 计算损失 → 反向传播 (loss.backward()) → 更新参数 (optimizer.step())
测试/验证模型
不需要梯度计算 (torch.no_grad())，评估准确率。

示例：简单的全连接分类网络

假设我们要用一个小型网络对输入数据进行分类。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# ======================
# 1. 准备数据
# ======================
# 随机生成一些数据: 1000 个样本，每个样本 20 维特征
X = torch.randn(1000, 20)
y = torch.randint(0, 2, (1000,))  # 二分类 (0 或 1)

dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# ======================
# 2. 定义神经网络
# ======================
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(20, 64)   # 输入20维，输出64维
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(64, 2)    # 输出类别数=2

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x  # CrossEntropyLoss 会自动做 softmax

model = SimpleNet()

# ======================
# 3. 定义损失函数 & 优化器
# ======================
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# ======================
# 4. 训练循环
# ======================
for epoch in range(5):  # 训练 5 个 epoch
    for batch_X, batch_y in dataloader:
        optimizer.zero_grad()            # 清空梯度
        outputs = model(batch_X)         # 前向传播
        loss = criterion(outputs, batch_y) # 计算损失
        loss.backward()                  # 反向传播
        optimizer.step()                 # 更新参数
    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

# ======================
# 5. 测试模型
# ======================
with torch.no_grad():  # 测试时不需要计算梯度
    test_X = torch.randn(5, 20)
    preds = model(test_X)
    predicted_classes = torch.argmax(preds, dim=1)
    print("预测类别:", predicted_classes)

3. 关键点解释

nn.Module：PyTorch 网络的基类，必须实现 __init__ 和 forward。
CrossEntropyLoss：适合分类任务，内部会做 log_softmax。
优化器：常用 SGD、Adam，调用顺序是：

optimizer.zero_grad()
loss.backward()
optimizer.step()

torch.no_grad()：在验证/推理时使用，避免计算梯度，提高效率。