PyTorch-神经网络基础

PyTorch是基于Python的科学计算库，它主要用于两个方面：第一，作为NumPy的替代品，可以利用GPU的性能加快数值计算的速度；第二，作为一种灵活、高效的深度学习平台，可以搭建神经网络。

安装

可以通过以下命令安装PyTorch：

pip install torch

张量（Tensor）

PyTorch中最重要的数据结构是张量（tensor）。和NumPy的数组一样，PyTorch的张量可以有不同的维度，同时支持运行在CPU或GPU上，可以通过以下方式创建一个矩阵：

import torch

# 创建一个5x3的矩阵，未初始化
x = torch.empty(5, 3)
print(x)

# 创建一个5x3的矩阵，随机初始化
x = torch.rand(5, 3)
print(x)

# 创建一个5x3的矩阵，全为0
x = torch.zeros(5, 3, dtype=torch.long)
print(x)

# 从数据直接创建张量
x = torch.tensor([5.5, 3])
print(x)

# 通过已有张量创建新张量，会保留之前张量的属性
y = x.new_ones(5, 3, dtype=torch.double)
print(y)

# 改变形状，返回新张量
z = x.view(1, 2)
print(z)

自动求导（Autograd）

PyTorch中的自动求导功能（Autograd）允许我们对神经网络中的参数进行优化，我们只需要定义好前向传播（计算输出）的函数，PyTorch会自动计算它的梯度。

import torch

# 创建一个需要求导的Tensor
x = torch.ones(2, 2, requires_grad=True)
print(x)

# 定义一个计算输出的函数
y = x + 2
print(y)

# 计算y的梯度
z = y * y * 3
out = z.mean()
out.backward()

# 查看梯度
print(x.grad)

神经网络

PyTorch中的神经网络模块nn可以用于构建各种神经网络。

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

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()

        # 卷积层
        # 输入通道数为1，输出通道数为6，卷积核为5x5
        self.conv1 = nn.Conv2d(1, 6, 5)
        # 卷积层
        # 输入通道数为6，输出通道数为16，卷积核为5x5
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 全连接层
        # 输入大小为16*5*5，输出大小为120
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        # 全连接层
        # 输入大小为120，输出大小为84
        self.fc2 = nn.Linear(120, 84)
        # 全连接层
        # 输入大小为84，输出大小为10
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # 2x2的池化层，步长为2
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        # 计算特征数量
        size = x.size()[1:]
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

训练神经网络

import torch.optim as optim

net = Net()

# 定义损失函数
criterion = nn.CrossEntropyLoss()
# 定义优化器
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 训练网络
for epoch in range(2):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # 获取输入数据和标签
        inputs, labels = data

        # 梯度清零
        optimizer.zero_grad()

        # 前向传播
        outputs = net(inputs)
        loss = criterion(outputs, labels)

        # 反向传播+优化
        loss.backward()
        optimizer.step()

        # 打印统计信息
        running_loss += loss.item()
        if i % 2000 == 1999:  # 每2000批次打印一次
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

测试神经网络

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))