Press "Enter" to skip to content

DL Practice:Cifar 10分类

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

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

 

 

我们代码中用的是线性层Linear: self.fc1 = nn.Linear(16 * 5 * 5, 120)      self.fc2 = nn.Linear(120, 84)        self.fc3 = nn.Linear(84, 10)

 

 

e.   Non-linear Activations

 

要注意,其实这个例子中的非线性激活函数用的并不是torch.nn模块中的这个部分,但是torch.nn模块中有这个部分,所以还是提一下。

 

此例中的激活函数用的其实是torch.nn.functional 模块中的函数。它们是有区别的,区别下文继续讲。现在先浏览一下这个部分的内容即可:

可以看出,torch.nn 模块中其实也有很多激活函数的,只不过我们此例用的不是这里的激活函数!!!

 

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]))

Be First to Comment

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注