PyTorch-->image classification（图像分类）

使用深度学习框架的流程：

模型定义（包括损失函数的选择）-> 数据处理和加载 -> 训练（可能包含训练过程可视化）-> 测试

以下是根据官方教程的练手，其中卷积神经网络的部分会单独开一篇去写原理，目前俺还不太懂，哈哈哈哈！冲鸭！！！

# 使用torchvision来加载并归一化CIFAR10数据集

import torch
import torchvision  # 保存了一些数据集
import torchvision.transforms as transforms  # 进行数据预处理
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

from torch.autograd import Variable


# 定义网络一般继承torch.nn.Module创建新子类
class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5*5 square conwolution
        # kernel
        # 添加卷积层
        self.conv1 = nn.Conv2d(3, 6, 5)  # 定义一个输入深度为3，输出为6，卷积核大小为 5*5 的 conv1 变量
        self.pool = nn.MaxPool2d(2, 2)  # 最大池化层
        self.conv2 = nn.Conv2d(6, 16, 5)  # 输入通道数为6 输出通道数为16
        # an affine operation: y = Wx + b
        # 3个全连接层
        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):
        # 定义forward()函数：可以在此函数中使用任何Tensor操作
        # backward()函数被autograd自动定义
        # Max pooling over a (2,2) window
        # 输入x -> conv1 -> relu -> 2*2窗口的最大池化
        # x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        # x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        # view 函数将张量x变形成一维向量形式，总特征数不变，为全连接层做准备
        # 为什么这里只关心列数不关心行数呢，因为马上就要进入全连接层了，而全连接层说白了就是矩阵乘法！
        #  第一个全连接层的首参数是16*5*5，所以要保证能够相乘，在矩阵乘法之前就要把x调到正确的size
        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


# torch.nn中大多数layer在torch.nn.funtional中都有一个与之对应的函数。
# 二者的区别在于：
# torch.nn.Module中实现layer的都是一个特殊的类，都是以class xx来定义的， 会自动提取可学习的参数
# 而 nn.functional中的函数，更像是纯函数，由def function( )定义，只进行简单的数学运算。
# 即二者的区别是functional中的函数是一个确定的不变的运算公式，输入数据产生输出就ok，
# 而深度学习中会有很多权重是在不断更新的，不可能每进行一次forward就用新的权重重新来定义一遍函数来进行计算，所以说就会采用类的方式，以确保能在参数发生变化时仍能使用我们之前定好的运算步骤。
# 从这个分析就可以看出什么时候应该用nn.Module中的layer了：
#   如果模型有可学习的参数，最好使用nn.Module对应的相关layer，否则二者都可以使用，没有什么区别。
# 比如此例中的Relu其实没有可学习的参数，只是进行一个运算而已，所以使用的就是functional中的relu函数，
# 而卷积层和全连接层都有可学习的参数，所以用的是nn.Module中的类。
# 不具备可学习参数的层，将它们用函数代替，这样可以不用放在构造函数中进行初始化。


# torchvision dataset 输出范围：[0,1]的PILImage，首先需要归一化为[-1,1]的Tensors
# define a transform :可以将多个变换组合在一起，此处为组合了totensor & normalize
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])  # first RGB三个通道上的均值 second RGB三个通道上的标准差 用于对RGB图像归一化
# define a trainset,加载后使用上面定义的transform进行变换 （存放位置 为True代表创建的是训练集 为True代表需要从网上下载 使用的变换）
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
# 后面会通过loader将数据传入网络
# 组合数据集和采样器 在数据集上提供单进程或多进程的迭代器（数据的来源 每批次进入的数据数量 为True代表打乱数据顺序 默认为0代表在主进程中加载，此处为2代表选用用来加载数据的子进程个数）
#                                                              有些时候使用固定RAM（通过pin_memory）加速RAM到GPU的传输
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)
# define a testset
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')

# show some examples
import matplotlib.pyplot as plt
import numpy as np


# functions to show an image

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


if __name__ == '__main__':
    # get some random training images
    dataiter = iter(trainloader)
    images, labels = dataiter.next()

    # # show
    # imshow(torchvision.utils.make_grid(images))
    # # print labes
    # print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

    net = Net()

    # use a Classification Cross-Entropy 分类交叉熵 loss（损失函数） and SGD 动量 with momentum（优化器）
    # 想把模型搬到GPU上跑，要在定义优化器之前完成.cuda()这一步 因为在将网络参数传递给优化器之前，将它们传输到适当的设备是很重要的，否则优化器将无法以正确的方式跟踪它们
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

    # loop over the dataset multiple times 将数据集循环传给net & momentum
    # 下面进行两次训练
    for epoch in range(2):

        running_loss = 0.0  # 方便对损失函数的值进行输出
        # enumerate() 既获得索引也获得数据
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data  # 从enumerate返回的data 包含数据和标签信息
            # inputs, labels = Variable(inputs),Variable(labels) 将数据转换成Variable
            # don't forget!!!
            optimizer.zero_grad()

            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            # 在定义网络时定义了前向传播函数，但是并没有定义反向传播函数，深度学习是需要反向传播求导的，
            # Pytorch其实利用的是Autograd模块来进行自动求导，反向传播。
            # Autograd中最核心的类就是Variable了，它封装了Tensor，并几乎支持所有Tensor的操作，这里可以参考官方给的详细解释：
            # http: // pytorch.org / tutorials / beginner / blitz / autograd_tutorial.html  # sphx-glr-beginner-blitz-autograd-tutorial-py
            # 以上链接详细讲述了variable究竟是怎么能够实现自动求导的，怎么用它来实现反向传播的。
            # 这里涉及到计算图的相关概念
            # 总结：要计算各个variable的梯度，只需调用根节点的backward方法，Autograd就会自动沿着整个计算图进行反向计算
            # 而在此例子中，根节点就是loss，所以程序中的loss.backward()
            # 代码就是在实现反向传播，自动计算所有的梯度。
            optimizer.step()  # 执行完反向传播之后，更新优化器参数，以便进行下一轮训练

            # print statistics
            running_loss += loss.item()
            # print every 2000 mini-batches
            if i % 2000 == 1999:
                print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0

    print('Finished!!!')

    # save the model
    PATH = './cifar_net.pth'
    torch.save(net.state_dict(), PATH)

    # test the network on the test data

    dataiter = iter(testloader)
    images, labels = dataiter.next()  # 根据设置应该是四张图片

    # print images
    imshow(torchvision.utils.make_grid(images))
    print('Ground_Truth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

    net_1 = Net()

    net_1.load_state_dict(torch.load(PATH))
    outputs = net_1(images)
    _, predited = torch.max(outputs, 1)  # 会返回两个值，但是对第一个不感兴趣
    # .max() 返回输入Tensor中每行的最大值，并转换成指定的dim（维度）
    # 指的 the dimension to reduce！并不是在the dimension上去返回最大值。
    # 理解为：返回最大的索引，即预测出的类别
    print('Predicted: ', ' '.join('%5s' % classes[predited[j]] for j in range(4)))

    # performs on the whole dataset

    correct = 0
    total = 0

    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net_1(images)
            _, predited = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predited == labels).sum().item()

    print('Accuracy of the network on the 10000 test images: %d %%' % (
            100 * (correct / total)))

    # performs on different classes
    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_1(images)
            _, predited = torch.max(outputs, 1)
            c = (predited == labels).squeeze()
            for i in range(4):  # 每个batch有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])))

    # run the neural network on the GPU
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(device)

    net.to(device)
    inputs, labels = data[0].to(device), data[0].to(device)