目标检测实战(一)：CIFAR10结合神经网络加载、训练、测试完整步骤

导入模块

#  首先当然肯定要导入torch和torchvision，至于第三个是用于进行数据预处理的模块
import torch
import argparse
import torchvision
import torch.nn as nn
import torch.optim as optim  # 导入torch.potim模块
import matplotlib.pyplot as plt
from torch.autograd import Variable
import torchvision.transforms as transforms
from Model.csp_shufflenetv2 import csp_shufflenet_v2_x1_0


def image_show(images):
    images = images.numpy()
    images = images.transpose((1, 2, 0))
    print(images.shape)
    plt.imshow(images)
    plt.show()

image_show用于后面显示图片

加载CIFAR10

"""""""""""""""数据集加载"""""""""""""""""""""""""""""""""""""""""""""""""""""
#  由于torchvision的datasets的输出是[0,1]的PILImage，所以我们先先归一化为[-1,1]的Tensor
#  首先定义了一个变换transform，利用的是上面提到的transforms模块中的Compose( )
#  把多个变换组合在一起，可以看到这里面组合了ToTensor和Normalize这两个变换
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

# 定义了我们的训练集，名字就叫trainset，至于后面这一堆，其实就是一个类：
# torchvision.datasets.CIFAR10( )也是封装好了的
# 如果download为True，就可以直接下载数据集，如果你数据集在root下，那么就设置download为False
# （不翻墙可能会慢一点吧）然后进行变换，可以看到transform就是我们上面定义的transform，数据增强
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=False, transform=transform)
# trainloader其实是一个比较重要的东西，我们后面就是通过trainloader把数据传入网
# 络，当然这里的trainloader其实是个变量名，可以随便取，重点是他是由后面的
# torch.utils.data.DataLoader()定义的，这个东西来源于torch.utils.data模块，
#  网页链接http://pytorch.org/docs/0.3.0/data.html
trainloader = torch.utils.data.DataLoader(trainset, batch_size=16,
                                          shuffle=True, num_workers=2)
# 对于测试集的操作和训练集一样
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=16,
                                         shuffle=False, num_workers=2)

# 类别信息也是需要我们给定的
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
"""""""""""""""数据集加载完毕"""""""""""""""""""""""""""""""""""""""""""""""""""""

载入神经网络

这里的类别数要设置的和你载入的数据集类别数一样

"""""""""""""""定义神经网络"""""""""""""""""""""""""""""""""""""""""""""""""""""
model = csp_shufflenet_v2_x1_0(num_classes=10).to(device)
"""""""""""""""神经网络加载完毕"""""""""""""""""""""""""""""""""""""""""""""""""""""

定义损失函数和优化器

"""""""""""""""定义损失函数和优化器"""""""""""""""""""""""""""""""""""""""""""""""""""""
criterion = nn.CrossEntropyLoss()  # 同样是用到了神经网络工具箱 nn 中的交叉熵损失函数
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)  # optim模块中的SGD梯度优化方式---随机梯度下降
"""""""""""""""损失函数和优化器加载完毕"""""""""""""""""""""""""""""""""""""""""""""""""""""

开始训练网络

经过前面的数据加载和网络定义后，就可以开始训练了
Pytorch其实利用的是Autograd模块来进行自动求导，反向传播。
Autograd中最核心的类就是Variable了，它封装了Tensor，并几乎支持所有Tensor的操作

"""""""""""""""训练开始"""""""""""""""""""""""""""""""""""""""""""""""""""""
if args.train:
    for epoch in range(2):  # loop over the dataset multiple times 指定训练一共要循环几个epoch

        running_loss = 0.0  # 定义一个变量方便我们对loss进行输出
        for i, data in enumerate(trainloader, 0):  # 这里我们遇到了第一步中出现的trailoader，代码传入数据
            # enumerate是python的内置函数，既获得索引也获得数据，详见下文
            # get the inputs
            inputs, labels = data  # data是从enumerate返回的data，包含数据和标签信息，分别赋值给inputs和labels

            # wrap them in Variable
            inputs, labels = Variable(inputs), Variable(labels)  # 将数据转换成Variable，第二步里面我们已经引入这个模块
            # 所以这段程序里面就直接使用了，下文会分析
            # zero the parameter gradients
            optimizer.zero_grad()  # 要把梯度重新归零，因为反向传播过程中梯度会累加上一次循环的梯度

            # forward + backward + optimize
            outputs = model(inputs.to(device))  # 把数据输进网络net，这个net()在第二步的代码最后一行我们已经定义了
            loss = criterion(outputs, labels.to(device))  # 计算损失值,criterion我们在第三步里面定义了
            loss.backward()  # loss进行反向传播，下文详解
            optimizer.step()  # 当执行反向传播之后，把优化器的参数进行更新，以便进行下一轮
            # print statistics                   # 这几行代码不是必须的，为了打印出loss方便我们看而已，不影响训练过程
            running_loss += loss.item()  # 从下面一行代码可以看出它是每循环0-1999共两千次才打印一次
            if i % 2000 == 1999:  # print every 2000 mini-batches   所以每个2000次之类先用running_loss进行累加
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))  # 然后再除以2000，就得到这两千次的平均损失值
                running_loss = 0.0  # 这一个2000次结束后，就把running_loss归零，下一个2000次继续使用

    print('Finished Training')
"""""""""""""""训练结束"""""""""""""""""""""""""""""""""""""""""""""""""""""

想要计算各个variable的梯度，只需调用根节点的backward方法，Autograd就会自动沿着整个计算图进行反向计算
而在此例子中，根节点就是我们的loss，所以：

程序中的loss.backward()代码就是在实现反向传播，自动计算所有的梯度。

所以训练部分的代码其实比较简单：
running_loss和后面负责打印损失值的那部分并不是必须的，所以关键行不多，总得来说分成三小节

• 第一节：把最开始放在trainloader里面的数据给转换成variable，然后指定为网络的输入；
• 第二节：每次循环新开始的时候，要确保梯度归零
• 第三节：forward+backward，就是调用我们在第三步里面实例化的net()实现前传，loss.backward()实现后传，每结束一次循环，要确保梯度更新

开始测试

第一部分
这一部分代码就是先随机读取16张图片，让我们看看这四张图片是什么并打印出相应的label信息，
因为第一步里面设置了是shuffle了数据的，也就是顺序是打乱的，所以各自出现的图像不一定相同，

dataiter = iter(testloader)  # 创建一个python迭代器，读入的是我们第一步里面就已经加载好的testloader
images, labels = dataiter.next()  # 返回一个batch_size的图片，根据第一步的设置，应该是16张
# print images
image_show(torchvision.utils.make_grid(images))  # 展示这四张图片
print('GroundTruth: ', ' '.join(
    '%5s' % classes[labels[j]] for j in range(16)))  # python字符串格式化 ' '.join表示用空格来连接后面的字符串，参考python的join（）方法

第二部分
返回了最大的索引，即预测出来的类别。

outputs = model(Variable(images.to(device)))  # 注意这里的images是我们从上面获得的那四张图片，所以首先要转化成variable
_, predicted = torch.max(outputs.data, 1)
# 这个 _ , predicted是python的一种常用的写法，表示后面的函数其实会返回两个值
# 但是我们对第一个值不感兴趣，就写个_在那里，把它赋值给_就好，我们只关心第二个值predicted
# 比如 _ ,a = 1,2 这中赋值语句在python中是可以通过的，你只关心后面的等式中的第二个位置的值是多少
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(16)))  # python的字符串格式化

第三部分

correct = 0  # 定义预测正确的图片数，初始化为0
total = 0  # 总共参与测试的图片数，也初始化为0
for data in testloader:  # 循环每一个batch
    images, labels = data
    images,labels=images.to(device),labels.to(device)
    outputs = model(Variable(images))  # 输入网络进行测试
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)  # 更新测试图片的数量
    correct += (predicted == labels).sum()  # 更新正确分类的图片的数量
print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))  # 最后打印结果

第四部分
来测试一下每一类的分类正确率，也可以在这基础上求map

class_correct = list(0. for i in range(10))  # 定义一个存储每类中测试正确的个数的 列表，初始化为0
class_total = list(0. for i in range(10))  # 定义一个存储每类中测试总数的个数的 列表，初始化为0
for data in testloader:  # 以一个batch为单位进行循环
    images, labels = data
    images,labels=images.to(device),labels.to(device)
    outputs = model(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    c = (predicted == labels).squeeze()
    for i in range(16):  # 因为每个batch都有4张图片，所以还需要一个16的小循环
        label = labels[i]  # 对各个类的进行各自累加
        class_correct[label] += c[i]
        class_total[label] += 1

totle=[]
for i in range(10):
    # print(int(100 * class_correct[i] / class_total[i]))
    totle.append(int(100 * class_correct[i] / class_total[i]))
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))
print('map:',sum(totle)/len(totle))
"""""""""""""""测试结束"""""""""""""""""""""""""""""""""""""""""""""""""""""

这里直接测试的网络架构，并没有训练所以map和各类ap都很低。