注:仅供个人学习使用。
本节介绍机器学习中常见任务的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()