import torch
import torchvision
import torchvision.transforms as transforms
## 数据预处理
# torchvision 数据集加载完后的输出是范围在 [ 0, 1 ] 之间的 PILImage，使用transform将其标准化为范围在 [ -1, 1 ] 之间的张量。
# Compose 类的自调用方法(__call__)将几个 transforms 方法集合在一起，本例中将 ToTensor() 和 Normalize() 结合在一起
# ToTensor() 方法将一个 PIL Image 或 numpy.ndarray 转换为 tensor 张量
# Normalize() 方法将数据进行标准化，第一个元组为标准化后数据的 mean (平均值)，第二个元组为标准化后数据的 std (方差)
# output[channel] = (input[channel] - mean[channel]) / std[channel]
# 元组中元素的个数即为输入数据的 channel，如本实验的 CIFAR10，一个数据的结构为 3x32x32 即 3 个 channel。
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# 训练数据加载器
# datasets 为原始数据（已经经过数据预处理），dataloaer 则将 datasets 分 batch 以便在后续的训练中一次训练多个数据。
trainset = torchvision.datasets.CIFAR10(
root='./data', train=True, download=True, transform=transform)
# shuffle 为 true，每次 epoch 数据集会重新分组
# dataloader 对 dataset 的要求是其要有 __getitem__() 和 __len__() 方法
# torchvision 中的 dataset 默认都有上述两个方法
# __getitem__() 方法使得对象可以通过下标的方式 dataset[i] 的方式来取得第 i 个数据
# DataLoader 本质上就是一个 iterable（内部定义了 __iter__ 方法）
# __iter__ 被定义成生成器，使用 yield 来返回数据，并利用多进程来加速 batch data 的处理
# DataLoader 组装好数据后返回的是 Tensor 类型的数据
batchsize = 8
trainloader = torch.utils.data.DataLoader(
trainset, batch_size=batchsize, shuffle=True, num_workers=2)
# 测试数据加载器
testset = torchvision.datasets.CIFAR10(
root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(
testset, batch_size=batchsize, shuffle=False, num_workers=2)
# 图像类别
classes = ('plane', 'car', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck')
trainloader, testloader
## 预览训练集中的图像和标签
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
# imshow 函数用于打印出数据集中的图片
def imshow(img):
img = img / 2 + 0.5 # 反向归一化
npimg = img.numpy() # 将 tensor 类型转化为 numpy 数据类型
plt.imshow(np.transpose(npimg, (1, 2, 0))) # np.transpose() 方法用于重新排列数组的轴，imshow() 要求 channel 轴在第三维。
# iter() 传入可遍历数据对象用于生成迭代器
# .next() 方法用于取出迭代器一次迭代的返回值，为元组 (images, labels)
dataiter = iter(trainloader)
images, labels = dataiter.next()
# 展示图像，使用 imshow() 函数打印 images
# torchvision.utils.make_grid() 方法用于将多张图片拼接成一张图片
imshow(torchvision.utils.make_grid(images))
# 显示图像标签
print(' '.join('%5s' % classes[labels[j]] for j in range(batchsize)))
## 定义神经网络的网络结构
import torch.nn as nn
import torch.nn.functional as F
# 简单的前馈神经网络
# 使用 pytorch 定义的神经网络，不需要在模型中指定传入的 batch 数
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
net
# 构造损失函数对象，计算模型损失
criterion = nn.CrossEntropyLoss()
## 构造优化器，用于参数更新
import torch.optim as optim
# SGD --> stochastic gradient descent 随机梯度下降算法
# 传入可更新参数、lr --> learningrate、momentum --> 动量
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
## 开始训练模型
for epoch in range(2): # 迭代两次，range(0,2)，是一个前闭后开区间
running_loss = 0.0
for i, (inputs, labels) in enumerate(trainloader, 0): # enumerate() 分别传入可遍历数据对象和对象第一组数据的编号(默认为 0 )
# 清空梯度缓存
optimizer.zero_grad()
# 正向传播
outputs = net(inputs)
loss = criterion(outputs, labels)
# 反向传播
loss.backward()
# 优化
optimizer.step()
# loss.item() 方法取出当前的 loss 值
# running_loss 累计 200 批次 loss 的值
running_loss += loss.item()
if i % 200 == 199: # 每 200 批次打印一次平均损失值
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 200))
running_loss = 0.0
print('Finished Training.')
# iter() 传入可遍历数据对象创建一个迭代器
dataiter = iter(testloader)
images, labels = dataiter.next()
# 显示图片
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(batchsize)))
## 进行模型验证
outputs = net(images)
# predicted 存储最大值的索引
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(batchsize)))
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() # tensor 张量的数据通过方法 item() 获取
print('Accuracy of the network on the 10000 test images: %d%%' %
(100 * correct / total))
## 验证模型对不同类型的图片的准确度
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d%%' %
(classes[i], 100 * class_correct[i] / class_total[i]))
