Step 1：数据加载和处理

一般使用深度学习框架会经过下面几个流程：

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

所以自己写代码的时候基本上按照这四大模块四步走就ok了。

本例步骤：

A、Load and normalizing the CIFAR10 training and test datasets using torchvision
B、Define a Convolution Neural Network
C、Define a loss function
D、Train the network on the training data
E、Test the network on the test data

首先使用torchvision加载和归一化训练数据与测试数据。

torchvision实现了常用的一些深度学习的相关图像数据的加载功能，比如cifar10、Imagenet、Mnist等。保存在torchvision.datasets模块中；

torchvision也封装了一些处理数据的方法。保存在torchvision.transforms模块中。

torchvision还封装了一些模型和工具封装在相应模型中。

#  首先当然肯定要导入torch和torchvision，至于第三个是用于进行数据预处理的模块
import torch
import torchvision
import torchvision.transforms as transforms
 
　　 #  由于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( )也是封装好了的，就在我前面提到的torchvision.datasets
    # 模块中,不必深究，如果想深究就看我这段代码后面贴的图1，其实就是在下载数据
    #（不FQ可能会慢一点吧）然后进行变换，可以看到transform就是我们上面定义的transform
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
    # trainloader其实是一个比较重要的东西，我们后面就是通过trainloader把数据传入网
    # 络，当然这里的trainloader其实是个变量名，可以随便取，重点是它是由后面的
    # torch.utils.data.DataLoader()定义的，这个东西来源于torch.utils.data模块，
    #  网页链接http://pytorch.org/docs/0.3.0/data.html，这个类可见我后面图2
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)
    # 对于测试集的操作和训练集一样
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')

Step 2：定义卷积神经网络

这一步虽然代码量很少，但是却包含很多难点和重点，执行这一步的代码需要包含神经网络工具箱torch.nn、神经网络函数torch.nn.functional。

注意：虽然官网给的程序有这么一句 from torch.autograd import Variable，但是此步中确实没有显式地用到variable，只能说网络里运行的数据确实要以variable的形式存在，在后面我们会讲解这个内容。

# 首先是调用Variable、 torch.nn、torch.nn.functional
from torch.autograd import Variable   # 这一步还没有显式用到variable，但是现在写在这里也没问题，后面会用到
import torch.nn as nn
import torch.nn.functional as F
 
 
class Net(nn.Module):                 # 我们定义网络时一般是继承的torch.nn.Module创建新的子类
    def __init__(self):    
        super(Net, self).__init__()   # 第二、三行都是python类继承的基本操作,此写法应该是python2.7的继承格式,但python3里写这个好像也可以
        self.conv1 = nn.Conv2d(3, 6, 5)       # 添加第一个卷积层,调用了nn里面的Conv2d（）
        self.pool = nn.MaxPool2d(2, 2)        # 最大池化层
        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)
 
    def forward(self, x):                  # 这里定义前向传播的方法，为什么没有定义反向传播的方法呢？这其实就涉及到torch.autograd模块了，
                                           # 但说实话这部分网络定义的部分还没有用到autograd的知识，所以后面遇到了再讲
        x = self.pool(F.relu(self.conv1(x)))  # F是torch.nn.functional的别名，这里调用了relu函数 F.relu()
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)  # .view( )是一个tensor的方法，使得tensor改变size但是元素的总数是不变的。
                                    #  第一个参数-1是说这个参数由另一个参数确定， 比如矩阵在元素总数一定的情况下，确定列数就能确定行数。
                                    #  那么为什么这里只关心列数不关心行数呢，因为马上就要进入全连接层了，而全连接层说白了就是矩阵乘法，
                                    #  你会发现第一个全连接层的首参数是16*5*5，所以要保证能够相乘，在矩阵乘法之前就要把x调到正确的size
                                    # 更多的Tensor方法参考Tensor: http://pytorch.org/docs/0.3.0/tensors.html
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
 
 # 和python中一样，类定义完之后实例化就很简单了，我们这里就实例化了一个net
net = Net()

知识点：

1、神经网络工具箱torch.nn

：这是一个专为深度学习设计的模块，我们来看一下官方文档中它的目录。

a.  Container中的Module，也即nn.Module

 看一下nn.Module的详细介绍：

　　可知，nn.Module是所有神经网络的基类，我们自己定义任何神经网络，都要继承nn.Module!class Net(nn.Module)。

b.  convolution layers

 我们在上面的代码块中用到了Conv2d： self.conv1 = nn.Conv2d(3, 6, 5)    self.conv2 = nn.Conv2d(6, 16, 5)

 例如Conv2d(1,20,5)的意思就是说，输入是1通道的图像，输出是20通道，也就是20个卷积核，卷积核是5*5，其余参数都是用的默认值。

c.  pooling layers

 可以看到有很多的池化方式，我们上面的代码采用的是Maxpool2d： self.pool = nn.MaxPool2d(2, 2)

d.  Linear layer

e.   Non-linear Activations

要注意，其实这个例子中的非线性激活函数用的并不是torch.nn模块中的这个部分，但是torch.nn模块中有这个部分，所以还是提一下。
此例中的激活函数用的其实是torch.nn.functional 模块中的函数。它们是有区别的，区别下文继续讲。现在先浏览一下这个部分的内容即可：

2、torch.nn.functional

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

定义网络模型，主要会用到的就是torch.nn 和torch.nn.funtional这两个模块，这两个模块值得去细细品味一番，希望大家可以去读一下官方文档！

Step 3：定义损失函数和优化器

import torch.optim as optim          #导入torch.potim模块
 
criterion = nn.CrossEntropyLoss()    #同样是用到了神经网络工具箱 nn 中的交叉熵损失函数
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)   #optim模块中的SGD梯度优化方式---随机梯度下降

涉及知识点

1、优化器

pytorch将深度学习中常用的优化方法全部封装在torch.optim之中，所有的优化方法都是继承基类optim.Optimizier

图中提到了如果想要把模型搬到GPU上跑，就要在定义优化器之前就完成.cuda( )这一步。

2、损失函数

损失函数是封装在神经网络工具箱nn中的,包含很多损失函数，如图所示：

此例中用到的是交叉熵损失，criterion = nn.CrossEntropyLoss() 详情如下：

 基本上这一步没什么好说的，就是在众多的优化器方法和损失函数中选择就ok，具体选什么就由自己情况定。

 Step 4：训练

经过前面的数据加载和网络定义后，就可以开始训练了，这里会看到前面遇到的一些东西究竟在后面会有什么用，所以这一步应该仔细研究一下。

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 = net(inputs)                # 把数据输进网络net，这个net()在第二步的代码最后一行我们已经定义了
        loss = criterion(outputs, labels)    # 计算损失值,criterion我们在第三步里面定义了
        loss.backward()                      # loss进行反向传播，下文详解
        optimizer.step()                     # 当执行反向传播之后，把优化器的参数进行更新，以便进行下一轮
 
        # print statistics                   # 这几行代码不是必须的，为了打印出loss方便我们看而已，不影响训练过程
        running_loss += loss.data[0]         # 从下面一行代码可以看出它是每循环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')

分析：

1、autograd

在第二步中我们定义网络时定义了前向传播函数，但是并没有定义反向传播函数，可是深度学习是需要反向传播求导的，
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()代码就是在实现反向传播，自动计算所有的梯度。

所以训练部分的代码其实比较简单：
running_loss和后面负责打印损失值的那部分并不是必须的，所以关键行不多，总得来说分成三小节
第一节：把最开始放在trainloader里面的数据给转换成variable，然后指定为网络的输入；
第二节：每次循环新开始的时候，要确保梯度归零
第三节：forward+backward，就是调用我们在第三步里面实例化的net()实现前传，loss.backward()实现后传
每结束一次循环，要确保梯度更新。

 Step 5：测试

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

这一部分代码就是先随机读取4张图片，让我们看看这四张图片是什么并打印出相应的label信息，

因为第一步里面设置了是shuffle了数据的，也就是顺序是打乱的，所以各自出现的图像不一定相同。

outputs = net(Variable(images))      # 注意这里的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(4)))  # python的字符串格式化

这里用到了torch.max(  ), 它是属于Tensor的一个方法：

 注意到注释中第一句话，是说返回输入Tensor中每行的最大值，并转换成指定的dim（维度）.

所以我们程序中的 torch.max(outputs.data, 1) ，返回一个tuple (元组)

而这里很明显，这个返回的元组的第一个元素是image data，即是最大的 值，第二个元素是label， 即是最大的值 的 索引！

我们只需要label（最大值的索引），所以就会有 _ , predicted这样的赋值语句，表示忽略第一个返回值，把它赋值给 _， 就是舍弃它的意思；

我在注释中也说明了这是什么意思

这里说一下，这第二个参数1，看清楚上面的说明是 the dimension to reduce！ 而不是去这个dimension上面找最大

所以这里dim=1，基于我们的a是 4行 x 4列 这么一个维度，所以指的是 消除列这个维度，这是个什么意思呢？

如果我们把上面的示例代码中，的参数 keepdim=True写上，torch.max(a,1,keepdim=True), 会发现，返回的结果的第一个元素，即表示最大的值的那部分，其实是一个 size为 【4，1】的Tensor，也就是其实它是在 按照每行 来找最大，所以结果是4行，然后因为只找一个最大值，所以是1列，整个size就是 4行 1 列， 然后参数dim=1，相当于调用了 squeeze(1),这个操作，上面的说明也是这么写的，所以最后就得到结果是一个size为4的vector。

你可以自己下去在ipython里面做实验，发现如果dim=0，它其实是在返回每列的最大值，

所以一定不要搞混！这里的dim是指的 the dimension to reduce！并不是在the dimension上去返回最大值。

所以其实我自己写的时候一般更喜欢用 torch.argmax（）这个函数更直观更好理解一些

总之在这里你只需要理解这行操作的功能是：返回了最大的索引，即预测出来的类别。 想深入研究可以自己去ipython里面试一下

correct = 0   # 定义预测正确的图片数，初始化为0
total = 0     # 总共参与测试的图片数，也初始化为0
for data in testloader:  # 循环每一个batch
    images, labels = data
    outputs = net(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))          # 最后打印结果

tutorial给的结果是53%.

来测试一下每一类的分类正确率:

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
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    c = (predicted == labels).squeeze()
    for i in range(4):      # 因为每个batch都有4张图片，所以还需要一个4的小循环
        label = labels[i]   # 对各个类的进行各自累加
        class_correct[label] += c[i]
        class_total[label] += 1
 
 
for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))