pytorch1.2做CIFAR-10数据集分类详解，pytorch入门程序

问题：刚刚上手pytorch，不熟悉pytorch库也不精通python。
解决办法：通过经典框架快速上手。啊啊啊，好好学习，早日发顶刊顶会啊。
说明：

	经过修改，可以直接在VS中复制粘贴运行，非常简洁，哈哈哈，保证给你自信心。	
	
	原型代码是从Pytorch的官网下载的，官网可以在jupyter notebook下直接运行，但是在VS下会报[Error 32] Broken pipe错误。
	这可能是因为VS不允许多线程。所以我对代码进行了稍微的修改。			
	
	当然，最重要的是注释非常非常多。
	
	官网的博主也是刚入门，所以写得注释非常非常多，这篇就是分享给刚入门的同学看的，已经非常熟悉AI的大佬肯定不会来看这一篇了。
	当然，如果万一万一有大佬看，欢迎指教！

'''
CIFAR-10数据集分类

数据集说明：该数据集共有60000张彩色图像，大小为32*32，分为10个类，每类6000张图。
其中50000张用于训练，分为5个训练批，每一批10000张图；
另外10000用于测试，单独构成一批。
测试批的数据里，取自10类中的每一类，每一类随机取1000张。抽剩下的就随机排列组成了训练批。

运行说明：运行过程中显示图像时程序会暂停，图像关闭后会继续运行。

运行环境：python3.6, pytorch1.2, VS2017

源码：pytorch官网的tutorials

修改+注释：AI414010

时间：2019.9.5

说明：第一个注释+修改的深度学习代码，因为很多东西不懂，所以注释非常多。
希望自己以后写得注释会越来越简洁吧。
'''
import torch
import torchvision
import torchvision.transforms as transforms
#数据加载中引用的库

import matplotlib.pyplot as plt
import numpy as np
#显示图像引用的库

import torch.nn as nn
import torch.nn.functional as F
#搭建神经网络引用的库

import torch.optim as optim
#优化函数的库

#图像的显示函数
def imshow(img):
    img = img / 2 + 0.5     # unnormalize，反归一化，以重新显示图像
    npimg = img.numpy()#把图像转换威numpy数组
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    #三维数组的转换，原本是第三维上是RGB，现在是第二维，打印出相互据来看看就理解了
    plt.show()


#神经网络的搭建
class Net(nn.Module):
    def __init__(self):#具有可学习参数的层放在这里
        super(Net, self).__init__()#继承父类的构造函数
        self.conv1 = nn.Conv2d(3, 6, 5)#第一个卷积层，3通道输入，6通道输出，卷积核为5*5
        self.pool = nn.MaxPool2d(2, 2)#池化层，核为2*2
        self.conv2 = nn.Conv2d(6, 16, 5)#第二个卷积层，6通道输入，16通道输出，卷积核为5*5
        self.fc1 = nn.Linear(16 * 5 * 5, 120)#全连接层，16个通道，特征图的大小是5*5，120通道输出。
        #全连接层的计算其实相当于输入的特征图数据矩阵和全连接层权值矩阵进行内积，
        #就是把特征图压扁成一维再进行运算，所以要指定特征图大小
        self.fc2 = nn.Linear(120, 84)#全连接层，特征图大小1*1
        self.fc3 = nn.Linear(84, 10)#全连接层，特征图大小1*1

    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)#-1-reshape，表示自适应，16*5*5-与全连接层参数匹配
        x = F.relu(self.fc1(x))#激活函数，接在第一个全连接层后
        x = F.relu(self.fc2(x))#激活函数，接在第二个全连接层后
        x = self.fc3(x)#最后一个全连接层，输出
        return x


def main():

    #图像预处理
    transform = transforms.Compose(
        [transforms.ToTensor(),#Convert a PIL Image or numpy.ndarray to tensor.
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])#数据标准化
    #Compose将transforms中几个对图像的操作结合到一起赋值给transform，
    #方便后续调用时调用一个transform即可调用数个操作。


    #加载训练集
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                            download=True, transform=transform)
    #torchvision中自带了常用数据集
    #root-数据库存放的位置，train-作为训练集，transform-对图像进行的变换操作
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                              shuffle=True, num_workers=2)
    #trainloader-决定数据的加载方式
    #trainset-数据从哪儿加载，batchsize-批处理的大小，shuffle-是否每次重新打乱数据
    #num_workers-子进程数


    #加载测试集
    testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                             shuffle=False, num_workers=2)
    #数据集标签
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')



    #取一组训练集并显示
    dataiter = iter(trainloader)#iter函数构造一个迭代对象
    images, labels = dataiter.next()#从数据集中取一个batch，赋值给图像和标签

    # show images
    imshow(torchvision.utils.make_grid(images))#设定显示模式
    # print labels
    print(' '.join('%5s' % classes[labels[j]] for j in range(4)))#打印四张图像的标签


    #调用模型结构
    net = Net()

    #损失函数的设定及训练
    criterion = nn.CrossEntropyLoss()#交叉熵
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)#指定每层的学习率为0.001.动量为0.9

    for epoch in range(2):  # loop over the dataset multiple times，0，1，2三次循环
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):#索引从0开始
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad()#先梯度清零

            # forward + backward + optimize
            outputs = net(inputs)#数据训练一遍
            loss = criterion(outputs, labels)#计算损失
            loss.backward()#反向传播
            optimizer.step()#更新参数

            # print statistics
            running_loss += loss.item()
            if i % 2000 == 1999:    # print every 2000 mini-batches，每训练2000个batch就打印一次loss
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0#每个批次训练完成后loss清零

    print('Finished Training')


    # 取一组测试集并显示
    dataiter = iter(testloader)#iter函数构造一个迭代对象
    images, labels = dataiter.next()#从数据集中取一个batch，赋值给图像和标签
    # print images
    imshow(torchvision.utils.make_grid(images))
    print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))#打印四张测试图像


    #将测试图像送入网络进行训练，获得预测值
    outputs = net(images)
    _, predicted = torch.max(outputs, 1)#按维度返回最大值，返回每一列中的最大值
    print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                                  for j in range(4)))#打印预测结果


    #计算准确率
    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)#取第0维的元素个数，即列数，即样本个数
            correct += (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))#列表解析，创建包含10个0的列表
    class_total = list(0. for i in range(10))#列表解析，创建包含10个0的列表
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, predicted = torch.max(outputs, 1)
            c = (predicted == labels).squeeze()#去掉维度为1的
            for i in range(4):#一个batch为4组数据，一个data为四个图像和标签
                label = labels[i]
                class_correct[label] += c[i].item()#分类正确的样本数
                class_total[label] += 1#全部样本数，即为4


    #所有十个类别的分类准确率
    for i in range(10):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))

if __name__ == '__main__':#防止在被其他文件导入时显示多余的程序主体部分
    main()