详细介绍pytorch重要的API

---

1. Tensor（张量）

Tensor 是 PyTorch 中最基本的数据结构，提供了多种创建和操作张量的函数。

创建 Tensor

import torch

# 创建一个 Tensor
x = torch.tensor([1.0, 2.0, 3.0])

# 从 NumPy 数组创建 Tensor
import numpy as np
np_array = np.array([1.0, 2.0, 3.0])
x = torch.from_numpy(np_array)

# 创建全零或全一 Tensor
x = torch.zeros(3, 4)
x = torch.ones(3, 4)

# 创建随机 Tensor
x = torch.randn(3, 4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

操作 Tensor

# 基本操作
x = torch.tensor([1.0, 2.0, 3.0])
y = x + 2
z = x * y

# 索引和切片
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(x[0, 1])  # 输出 2
print(x[:, 1])  # 输出 tensor([2, 5])
1
2
3
4
5
6
7
8
9

2. Autograd（自动求导）

Autograd 提供了自动求导功能，可以跟踪 Tensor 上的操作并计算梯度。

# 创建一个需要求导的 Tensor
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x * 2
y.backward(torch.tensor([1.0, 1.0, 1.0]))
print(x.grad)  # 输出梯度
1
2
3
4
5

3. nn.Module（神经网络模块）

nn.Module 是构建神经网络的基础类，提供了定义网络层和前向传播的方法。

import torch.nn as nn
import torch.nn.functional as F

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 20)
        self.fc2 = nn.Linear(20, 1)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleNN()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4. Optimizer（优化器）

优化器用于更新神经网络的参数，提供了多种优化算法。

import torch.optim as optim

model = SimpleNN()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 优化步骤
optimizer.zero_grad()  # 清空梯度
loss = compute_loss(model, data)  # 计算损失
loss.backward()  # 反向传播
optimizer.step()  # 更新参数
1
2
3
4
5
6
7
8
9
10

5. Loss Function（损失函数）

损失函数用于衡量模型预测值与真实值之间的差异，提供了多种损失函数。

criterion = nn.MSELoss()

# 计算损失
output = model(data)
loss = criterion(output, target)
1
2
3
4
5

6. DataLoader（数据加载器）

DataLoader 用于加载数据集，并提供批量加载、数据打乱等功能。

from torch.utils.data import DataLoader
from torchvision import datasets, transforms

transform = transforms.Compose([transforms.ToTensor()])
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 迭代数据
for images, labels in train_loader:
    # 训练代码
    pass
1
2
3
4
5
6
7
8
9
10
11

7. torchvision（视觉工具包）

torchvision 提供了常用的数据集、模型架构和图像转换工具。

数据集

from torchvision import datasets

train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
1
2
3

模型

from torchvision import models

# 加载预训练的 ResNet-50 模型
model = models.resnet50(pretrained=True)
1
2
3
4

图像转换

from torchvision import transforms

transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
1
2
3
4
5
6
7
8

8. torch.nn.functional（函数式接口）

torch.nn.functional 提供了一些常用的函数式操作，如激活函数、损失函数等。

import torch.nn.functional as F

x = torch.randn(10)
y = F.relu(x)
1
2
3
4

9. torch.utils.data（数据工具）

torch.utils.data 提供了数据加载和预处理的工具，包括 Dataset 和 DataLoader。

Dataset

from torch.utils.data import Dataset

class CustomDataset(Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets

    def __getitem__(self, index):
        return self.data[index], self.targets[index]

    def __len__(self):
        return len(self.data)
1
2
3
4
5
6
7
8
9
10
11
12

DataLoader

from torch.utils.data import DataLoader

data = torch.randn(100, 10)
targets = torch.randint(0, 2, (100,))
dataset = CustomDataset(data, targets)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)
1
2
3
4
5
6

10. torch.cuda（GPU 支持）

torch.cuda 提供了 GPU 计算的支持，包括设备管理、内存管理等。

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# 将数据移动到 GPU
images, labels = images.to(device), labels.to(device)
1
2
3
4
5