简单训练一个分类器——CIFAR10

简单训练一个分类器

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True,
                                        transform=transform)
# root - 数据集的根目录
# train - 如果为True，则创建数据集training.pt，否则创建数据集test.pt。
# download - 如果为true，则从Internet下载数据集并将其放在根目录中。
# transform（callable ，optional） - 一个函数/转换，它接收PIL图像并返回转换后的版本。例如，transforms.RandomCrop
trainloader = torch.utils.data.DataLoader(trainset, batch_size=10,
                                          shuffle=True, num_workers=0)  # 数据集，批次样本数，遍历后是否随机排序， 数据加载的子进程数

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True,
                                       transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=10,
                                         shuffle=False, num_workers=0)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')


def imshow(img):
    img = img / 2 + 0.5  # denormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))


# 获取随机数据
data_iter = iter(trainloader)
images, labels = data_iter.next()

# 展示图像
imshow(torchvision.utils.make_grid(images))
# 显示图像标签
print(' '.join('%5s' % classes[labels[j]] for j in range(10)))


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()  # 定义Net的初始化函数，这个函数定义了该神经网络的基本结构
        # Conv2d 输入通道, 输出通道, 内核大小
        self.conv1 = nn.Conv2d(3, 10, 5)  # 图像卷积，3通道输入，10通道输出
        self.pool = nn.MaxPool2d(2, 2)  # 池化层，可以降低数据体的空间尺寸 kernel_size：窗口大小, stride=None 窗口移动的步长、默认值是kernel_size
        self.conv2 = nn.Conv2d(10, 16, 5)  # 图像卷积，10通道输入，16通道输出
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 全连接层  线性函数为：y = Wx + b,将conv2输出的16通道5*5个节点链接到120个节点
        self.fc2 = nn.Linear(120, 84)  # 图像卷积  线性函数为：y = Wx + b,将fc1输出120个节点连接至84个节点
        self.fc3 = nn.Linear(84, 10)  # 图像卷积  线性函数为：y = Wx + b,将fc2输出84个节点连接至10个节点

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 输入x，conv1卷积，relu函数激活，pool池化
        x = self.pool(F.relu(self.conv2(x)))  # 输入x，conv2卷积，relu函数激活，pool池化
        x = x.view(-1, 16 * 5 * 5)  # 将x转换为fc1输入的位数
        x = F.relu(self.fc1(x))  # 输入x，进入第一层网络，relu函数激活
        x = F.relu(self.fc2(x))  # 输入x，进入第二层网络，relu函数激活
        x = self.fc3(x)  # 输入x，进入第二层网络
        return x


net = Net()

criterion = nn.CrossEntropyLoss()  # 损失函数,输入模型、学习样本，计算误差
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)  # 优化函数
# momentum动量 若当前的梯度方向与累积的历史梯度方向一致，则当前的梯度会被加强，从而这一步下降的幅度更大。若当前的梯度方向与累积的梯度方向不一致，则会减弱当前下降的梯度幅度。

for epoch in range(2):  # 多批次循环

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # 获取输入
        inputs, labels = data  # labels为学习样本

        # 梯度置0
        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

print('Finished Training')

data_iter = iter(testloader)  # 读取批测试集
images, labels = data_iter.next()  # 提取一批测试集

imshow(torchvision.utils.make_grid(images))  # 显示图片
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(10)))

outputs = net(images)  # 将测试集通过训练好的网络
_, predicted = torch.max(outputs, 1)  # 获得输出的判断中最大的
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(10)))

correct, total = 0, 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()   # predicted == labels比较每个元素是否相等，sum()求和，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(10):
            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]))
    plt.show()



for i in range(10):
    print('Accuracy of %5s : %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))
    plt.show()