PyTorch教程

PyTorch是由Facebook开发的、基于Python的开源机器学习框架。它具有易于使用的API、动态计算图、自动区分和GPU加速的特性，在学术界和工业界都受到广泛关注。

安装

安装PyTorch可以通过官网提供的命令行方式进行安装，具体介绍可查看PyTorch官网。

# 安装PyTorch CPU版本
pip3 install torch

# 安装PyTorch GPU版本（需要CUDA支持）
pip3 install torch torchvision torchaudio

第一个PyTorch程序

下面是一个简单的PyTorch程序，它实现了一个两层的全连接神经网络，并应用于分类MNIST手写数字数据集。这个程序演示了PyTorch的基本结构、数据加载、模型定义及训练过程。

import torch
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision.transforms import ToTensor
from torch import nn, optim

# 加载MNIST数据集
train_data = MNIST('data', train=True, download=True, transform=ToTensor())
test_data = MNIST('data', train=False, download=True, transform=ToTensor())
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=64, shuffle=False)

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = torch.flatten(x, start_dim=1)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return nn.functional.log_softmax(x, dim=1)

model = Net()

# 训练模型
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
criterion = nn.CrossEntropyLoss()

for epoch in range(5):
    model.train()
    for data, label in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()

    model.eval()
    correct = 0
    total = 0
    for data, label in test_loader:
        output = model(data)
        _, predict = torch.max(output, 1)
        total += label.size(0)
        correct += (predict == label).sum().item()

    print(f'Epoch {epoch + 1}: accuracy {correct / total:.4f}')

动态计算图

PyTorch通过动态计算图实现了反向传播算法，并能够在运行时自动构建计算图。这种动态性使得PyTorch可以更加灵活地处理控制流等复杂结构。下面是一个简单的例子，演示了如何通过动态计算图实现一个简单的循环神经网络（RNN）。

import torch
from torch import nn

# 定义RNN
class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size
        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(input_size + hidden_size, output_size)
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, input, hidden):
        combined = torch.cat((input, hidden), 1)
        hidden = self.i2h(combined)
        output = self.i2o(combined)
        output = self.softmax(output)
        return output, hidden

# 执行RNN
input_size = 3
hidden_size = 2
output_size = 2

rnn = RNN(input_size, hidden_size, output_size)

hidden = torch.zeros(1, hidden_size)
for i in range(5):
    input = torch.randn(1, input_size)
    output, hidden = rnn(input, hidden)
    print(output)

自动求导

自动求导是PyTorch的一个核心功能。它可以帮助开发者快速地计算梯度，并且支持高阶求导。下面是一个简单的例子，演示了如何使用自动求导。

import torch

# 定义函数
def function(x):
    y = x ** 2
    return y

# 计算函数导数
x = torch.tensor(2.0, requires_grad=True)
y = function(x)
y.backward()
print(x.grad)

GPU加速

PyTorch支持在GPU上运行，并能够自动将张量转移到GPU上进行计算。下面是一个简单的例子，演示了如何使用GPU加速计算。

import torch

# 通过GPU加速计算
x = torch.tensor([1, 2, 3])
y = torch.tensor([4, 5, 6])
if torch.cuda.is_available():
    x = x.cuda()
    y = y.cuda()
z = x + y
if torch.cuda.is_available():
    z = z.cpu()
print(z)

结论

PyTorch是一个简单易用、功能强大的机器学习框架。它的动态计算图、自动求导和GPU加速等特性大大提高了开发效率。如果你对机器学习和深度学习感兴趣，那么PyTorch是一个不错的选择。