Pytorch教程（2）--0. 快速入门

网站链接：https://pytorch.org/tutorials/
本节链接：https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html
注：仅供个人学习使用。

本节介绍机器学习中常见任务的API。请参阅每一节中的链接以深入了解。

本节我们使用的训练集为60000张手写数字图片及对应的标签，测试集为10000张同类型的图片及标签。我们设计一个人工神经网络，输入训练集进行训练，得到该网络模型及其参数。然后，用这个训练好的网络模型进行图片识别，再跟该图片的标签进行比对。具体过程包括以下几步：读取数据集、创建模型、训练模型、使用模型进行预测。

一、读取数据集

PyTorch有两个原生类型来处理数据：
torch.utils.data.Dataset：存储样本及其相应的标签；
torch.utils.data.DataLoader：给Dataset包装了一个iterable。

PyTorch提供特定领域的库，如TorchText、TorchVision和TorchAudio，所有这些库都包含数据集。本节我们将使用TorchVision数据集。torchvision.datasets模块包含许多实际视觉数据的数据集对象，如CIFAR、COCO（完整列表）。

在本节我们使用TorchVision中的FashionMNIST数据集，该数据集来自美国国家标准与技术研究所，由 250 个不同人手写的数字构成，数字以二进制图片的形式存储，每个图片28x28像素。
数据集包括四个包，内容如下表所示：

训练用图像集 train-images-idx3-ubyte.gz 包含60,000 个样本
训练用标签集 train-labels-idx1-ubyte.gz 包含60,000 个标签
测试用图像集 t10k-images-idx3-ubyte.gz 包含 10,000 个样本
测试用标签集 t10k-labels-idx1-ubyte.gz 包含 10,000 个标签

每个TorchVision数据集包含两个参数：transform和target_transform，分别修改样本和标签。我们将数据集作为参数传递给DataLoader。这在我们的数据集上包装了一个iterable，并支持自动批处理、采样、洗牌(数据打乱)和多进程数据加载。这里我们将批数量定义为64，即dataloader iterable中的每个元素将返回一批64个特性(64张图片)和标签。

注意：第一次运行时download=True，数据集下载完成后就可以设置为False了。

代码：

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda, Compose
import matplotlib.pyplot as plt


# Download training data from open datasets.
training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=False,          #第一次运行时download=True，数据集下载完成后设置为False
    transform=ToTensor(),
)

# Download test data from open datasets.
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=False,          #第一次运行时download=True，数据集下载完成后设置为False
    transform=ToTensor(),
)

batch_size = 64

# Create data loaders.
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

for x, y in test_dataloader:
    print("Shape of x [N, C, H, W]: ", x.shape)     
    print("Shape of y: ", y.shape, y.dtype)        
    break

输出：
torch.Size([64, 1, 28, 28])：64张每张1通道尺寸为28*28的图片
torch.Size([64]) torch.int64：64个整数标签

Shape of x [N, C, H, W]:  torch.Size([64, 1, 28, 28])
Shape of y:  torch.Size([64]) torch.int64

二、创建模型

为了在PyTorch中定义神经网络，我们创建了一个从nn.Module继承的类。我们在init函数中定义网络的各层，并在forward函数中指定数据如何前向传递。为了加速，我们将其移动到GPU（如果可用）。

为什么这么创建网络先暂且不谈。

代码：

# Get cpu or gpu device for training.
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

# Define model
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork().to(device)
print(model)

输出：

Using cpu device
NeuralNetwork(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
    (5): ReLU()
  )
)

三、训练模型

为了训练模型，我们需要定义损失函数和优化器。

代码：

loss_fn = nn.CrossEntropyLoss()       #交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)       #随机梯度下降算法

定义训练函数：
在单个训练循环中，模型对训练数据集进行预测（分批输入），并将预测误差反向传播以调整模型参数。
训练函数传入四个参数：数据、网络模型、损失函数、优化函数。
步骤:
输入64张每张1通道尺寸为28*28的图片；
计算网络模型输出误差；
梯度清零；
误差反向传播；
调整网络模型参数；

代码：

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):
        X, y = X.to(device), y.to(device)

        # Compute prediction error
        pred = model(X)                 #输入64张每张1通道尺寸为28 * 28的图片
        loss = loss_fn(pred, y)         #计算网络模型输出误差；

        # Backpropagation
        optimizer.zero_grad()           #梯度清零；
        loss.backward()                 #误差反向传播；
        optimizer.step()                #调整网络模型参数；

        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

定义测试函数：
根据测试数据集检查模型的性能，以确保它是学习的。

代码：

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

训练过程通过迭代 (epoch)完成。在每个迭代中，网络模型学习调整参数更接近样本标签结果。我们在每个迭代中打印模型的准确度和损失，希望看到随着迭代次数增加，准确度随上升，损失下降。

代码:

epochs = 100
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model, loss_fn)
print("Done!")

输出：

Epoch 1
-------------------------------
loss: 2.307929  [    0/60000]
loss: 2.302274  [ 6400/60000]
loss: 2.301367  [12800/60000]
loss: 2.299623  [19200/60000]
loss: 2.295366  [25600/60000]
loss: 2.288283  [32000/60000]
loss: 2.292056  [38400/60000]
loss: 2.292953  [44800/60000]
loss: 2.284753  [51200/60000]
loss: 2.287445  [57600/60000]
Test Error: 
 Accuracy: 32.3%, Avg loss: 2.283921 
...
Epoch 100
-------------------------------
loss: 0.321112  [    0/60000]
loss: 0.332128  [ 6400/60000]
loss: 0.405130  [12800/60000]
loss: 0.557791  [19200/60000]
loss: 0.323931  [25600/60000]
loss: 0.359702  [32000/60000]
loss: 0.274745  [38400/60000]
loss: 0.642096  [44800/60000]
loss: 0.344451  [51200/60000]
loss: 0.590417  [57600/60000]
Test Error: 
 Accuracy: 85.0%, Avg loss: 0.429400 

可以看到，随着迭代次数增加，准确度从32.3%提升至85.0%，平均误差从2.283921降至0.429400

训练完网络模型后，我们将其保存成文件，常用方法是序列化内部状态字典（包含模型参数）。

torch.save(model.state_dict(), "./model/model_QuickStart.pth")
print("Saved PyTorch Model State to model_QuickStart.pth")

四、使用模型进行预测

首先需要加载训练好的网络模型，这个过程包括重新创建网络模型结构并加载模型参数。

代码：

model = NeuralNetwork()
model.load_state_dict(torch.load("./model/model_QuickStart.pth"))

然后我们就可以使用模型进行预测了。这里稍微修改一点代码，选择测试集第一张图片作为输入，用刚才训练好的网络模型进行识别，然后，显示该图片，图片的标题为该图片的识别值，以及标签值。

代码：

model.eval()
index = 0
img, label = test_data[index][0], test_data[index][1]

with torch.no_grad():
    pred = model(img)
    predicted, actual = pred[0].argmax(0), label

    # show one picture
    plt.imshow(img.reshape(28, 28), cmap='gray')
    plt.title(f'Predicted: "{predicted}", Actual: "{actual}"')
    plt.show()