数据集介绍
CIFAR-10是一个常用的彩色图片数据集,它有10个类别: ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。每张图片都是 3 × 32 × 32 3\times32\times32 3×32×32,也即3-通道彩色图片,分辨率为 32 × 32 32\times32 32×32。此外,还有一个CIFAR-100的数据集,由于CIFAR-10和CIFAR-100除了分类类别数不一样外,其他差别不大,此处仅拿CIFAR-10这个相对小点的数据集来进行介绍,介绍用pytorch来进行图像分类的一般思路和方法。
该数据集共有60000张彩色图像,这些图像是32*32,分为10个类,每类6000张图。这里面有50000张用于训练,构成了5个训练批,每一批10000张图;另外10000用于测试,单独构成一批。测试批的数据里,取自10类中的每一类,每一类随机取1000张。抽剩下的就随机排列组成了训练批。注意一个训练批中的各类图像并不一定数量相同,总的来看训练批,每一类都有5000张图。
下图是下载CIFAR-10数据集并解压后得到的文件
下图是CIFAR-10数据集的各个文件的介绍
关于数据集的介绍部分,网上有很多的资料,在此不再多说,直接上重点~~
图像分类步骤
下面我们来尝试实现对CIFAR-10数据集的分类,步骤如下:
- 使用torchvision加载并预处理CIFAR-10数据集
- 定义网络
- 定义损失函数和优化器
- 训练网络并更新网络参数
- 测试网络
数据加载及预处理
注:基本环境要求:python 3.6, pytorch 0.4.1(更新的版本应该也可以),完整代码已给出。
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
show = ToPILImage() # 可以把Tensor转成Image,方便可视化
# 第一次运行程序torchvision会自动下载CIFAR-10数据集,
# 大约160M,需花费一定的时间,
# 如果已经下载有CIFAR-10,可通过root参数指定
# 定义对数据的预处理
transform = transforms.Compose([
transforms.ToTensor(), # 转为Tensor
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), # 归一化 先将输入归一化到(0,1),再使用公式”(x-mean)/std”,将每个元素分布到(-1,1)
])
# 训练集(因为torchvision中已经封装好了一些常用的数据集,包括CIFAR10、MNIST等,所以此处可以这么写 tv.datasets.CIFAR10())
trainset = tv.datasets.CIFAR10(
root='DataSet/', # 将下载的数据集压缩包解压到当前目录的DataSet目录下
train=True,
download=False, # 如果之前没手动下载数据集,这里要改为True
transform=transform)
trainloader = t.utils.data.DataLoader(
trainset,
batch_size=4,
shuffle=True,
num_workers=2)
# 测试集
testset = tv.datasets.CIFAR10(
'DataSet/',
train=False,
download=False, # 如果之前没手动下载数据集,这里要改为True
transform=transform)
testloader = t.utils.data.DataLoader(
testset,
batch_size=4,
shuffle=False,
num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
其中,Dataset对象是一个数据集,可以按下标访问,返回形如(data, label)的元组数据,如下:
(data, label) = trainset[66]
data.size() # 验证某一张图片的维度 —— 3*32*32
print(classes[label]) # label是一个0-9的数字
# (data + 1) / 2是为了还原被归一化的数据 (这部分计算是可以推算出来的)
show((data + 1) / 2).resize((100, 100))
上面测试代码的输出为:
定义好Dataset后,我们还要为每个Dataset定义一个Dataloader,Dataloader是一个可迭代的对象,它将dataset返回的每一条数据拼接成一个batch,并提供多线程加速优化和数据打乱等操作。当程序对dataset的所有数据遍历完一遍之后,相应的对Dataloader也完成了一次迭代,如下:
dataiter = iter(trainloader) # trainloader is a DataLoader Object
images, labels = dataiter.next() # 返回4张图片及标签 images,labels都是Tensor images.size()= torch.Size([4, 3, 32, 32]) lables = tensor([5, 6, 3, 8])
print(' '.join('%11s'%classes[labels[j]] for j in range(4)))
show(tv.utils.make_grid((images+1)/2)).resize((400,100))
上面测试代码的输出为:
上面的两段测试代码(关于Dataset和Dataloader)只是为了让我们对pytorch的数据加载及预处理部分先有一个基本的熟悉。
定义网络
这是一个比较简单的图像分类任务,直接用比较简单的网络即可得到较好的结果,此处用LeNet网络来进行图像分类,LeNet网络的定义如下:
注:对这部分不太懂的可先参考这篇博客
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
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) # 最后是一个十分类,所以最后的一个全连接层的神经元个数为10
def forward(self, x):
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(x.size()[0], -1) # 展平 x.size()[0]是batch size
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
print(net)
"print(net)"的输出为:(这就是整个网路的结构)
定义损失函数和优化器
from torch import optim
criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
训练网络
所有网络的训练流程都是类似的,不断地执行如下流程:
- 输入数据
- 前向传播+反向传播
- 更新参数
在CPU训练
t.set_num_threads(4)
for epoch in range(2):
running_loss = 0.0
for i, data in enumerate(trainloader, 0): # i 第几个batch data:一个batch中的数据
# 输入数据
inputs, labels = data # images:batch大小为4 labels:batch大小为4
# 梯度清零
optimizer.zero_grad()
# forward + backward
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
# 更新参数
optimizer.step()
# 打印log信息
# loss 是一个scalar,需要使用loss.item()来获取数值,不能使用loss[0]
running_loss += loss.item()
if i % 2000 == 1999: # 每2000个batch打印一下训练状态
print('[%d, %5d] loss: %.3f' \
% (epoch+1, i+1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
输出如下:
此处仅训练了2个epoch(遍历完一遍数据集称为一个epoch),来看看网络有没有效果。将测试图片输入到网络中,计算它的label,然后与实际的label进行比较。
dataiter = iter(testloader)
images, labels = dataiter.next() # 一个batch返回4张图片
print('实际的label: ', ' '.join(\
'%08s'%classes[labels[j]] for j in range(4)))
# show(tv.utils.make_grid(images / 2 - 0.5)).resize((400,100))
show(tv.utils.make_grid((images+1) / 2 )).resize((400,100))
输出如下:
接着计算网络预测的label:
images.shape
# 计算图片在每个类别上的分数
outputs = net(images) # images 4张图片的数据
# 得分最高的那个类
_, predicted = t.max(outputs.data, 1) # 1是维度参数,返回值为两个,一个为最大值,另一个为最大值的索引
print('预测结果: ', ' '.join('%5s'\
% classes[predicted[j]] for j in range(4)))
输出如下:
已经可以看出效果,准确率50%,但这只是一部分的图片,再来看看在整个测试集上的效果。
correct = 0 # 预测正确的图片数
total = 0 # 总共的图片数
# 由于测试的时候不需要求导,可以暂时关闭autograd,提高速度,节约内存
with t.no_grad():
for data in testloader: # data是个tuple
images, labels = data # image和label 都是tensor
outputs = net(images)
_, predicted = t.max(outputs, 1)
total += labels.size(0) # labels tensor([3, 8, 8, 0]) labels.size: torch.Size([4])
correct += (predicted == labels).sum()
print('10000张测试集中的准确率为: %d %%' % (100 * correct / total))
输出如下:
训练的准确率远比随机猜测(准确率10%)好,证明网络确实学到了东西。
在GPU训练
就像把Tensor从CPU转到GPU一样,模型也可以类似地从CPU转到GPU。
dataiter = iter(testloader)
images, labels = dataiter.next() # 一个batch返回4张图片
net_gpu = Net()
net_gpu.cuda()
device = t.device("cuda:0" if t.cuda.is_available() else "cpu")
device
images = images.to(device)
labels = labels.to(device)
output = net_gpu(images)
output = output.to(device)
loss= criterion(output,labels)
loss
for epoch in range(2):
running_loss = 0.0
for i, data in enumerate(trainloader, 0): # i 第几个batch data:一个batch中的数据
# 输入数据
inputs, labels = data # images:大小为4 labels:大小为4
inputs = inputs.to(device)
labels = labels.to(device)
# 梯度清零
optimizer.zero_grad()
# forward + backward
outputs = net_gpu(inputs)
outputs = outputs.to(device)
loss = criterion(outputs, labels)
loss.backward()
# 更新参数
optimizer.step()
# 打印log信息
# loss 是一个scalar,需要使用loss.item()来获取数值,不能使用loss[0]
running_loss += loss.item()
if i % 2000 == 1999: # 每2000个batch打印一下训练状态
print('[%d, %5d] loss: %.3f' \
% (epoch+1, i+1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
如果发现在GPU上并没有比CPU提速很多,实际上是因为网络比较小,GPU没有完全发挥自己的真正实力。
对PyTorch的基础介绍至此结束。总结一下,本节主要包含以下内容。
- Tensor: 类似Numpy数组的数据结构,与Numpy接口类似,可方便地互相转换。
- autograd/: 为tensor提供自动求导功能。
- nn: 专门为神经网络设计的接口,提供了很多有用的功能(神经网络层,损失函数,优化器等)。
- 神经网络训练: 以CIFAR-10分类为例演示了神经网络的训练流程,包括数据加载、网络搭建、训练及测试。
通过本文的学习,相信读者可以体会出PyTorch具有接口简单、使用灵活等特点。