基于Pytorch完成CNN实现Minist（CPU和GPU版)

在进行机器学习和深度学习的过程中，python语言有很多优秀的开源库和深度学习开源框架。例如tensorflow，caffe，keras，pytorch。我选择了pytorch进行学习。因为pytorch的语法规则更几近于python语法，这样使得代码的可读性很强，且编程接口都比较友好（tensorflow直接语法劝退。后续也会学习，但是不是现在。）。

当然啦，就像学各种语言的Helloworld一样，Minist数据分类，其实就是深度学习和机器学习的一个Hello World。毕竟实践出真知。

我就不赘述pytorch的安装和API了  百度很强大，还是跑出来一个可见的结果更令人欣慰。

直接一部分一部分的上代码。

先导入各种包，这里说一下torchvision的包的主要功能是实现数据的处理，导入和预览呢，所以如果需要对计算机视觉的相关问题 进行处理，就可以利用 torchvision包中提供的大量的类来完成相应的工作。

import torch
from torchvision import datasets,transforms
import torchvision
from torch.autograd import  Variable
import numpy as np
import matplotlib.pyplot as plt

这样我们就可以通过torchvision.datasets加需要下载的数据集名称就可以了，而且torchvision还包含了COCO、imageNet、CIFCAR等数据集。

transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize(mean=[0.5,0.5,0.5],std=[0.5,0.5,0.5])])

上述代码用到了transforms。这个类库可以对载入的数据进行变换。建议去看中文文档 ，在这里我们只是用了一个类型转换，和数据标准化转换。

data_train=datasets.MNIST(root="./data",  transform=transform, train=True,
                          download=True
                          )
data_test=datasets.MNIST(root="./data", transform=transform, train=False)

这样数据集就会被下载下来。train=True即赋值为训练集，False就是测试集。

数据集下载完成后。就要对数据进行装载，利用batch _size来确认每个包的大小，用Shuffle来确认打乱数据集的顺序。

data_loader_train=torch.utils.data.DataLoader(dataset=data_train,
                                              batch_size=64,
                                              shuffle=True)
data_loader_test=torch.utils.data.DataLoader(dataset=data_test,
                                             batch_size=64,
                                             shuffle=True)

装载完成后，我们可以选取其中某个批次的数据进行预览

images,labels=next(iter(data_loader_train))
img=torchvision.utils.make_grid(images)

img=img.numpy().transpose(1,2,0)

std=[0.5,0.5,0.5]
mean=[0.5,0.5,0.5]

img=img*std+mean

print([labels[i] for i in range(4)])

plt.show()

 

 当数据装载完成后，我们就可以开始编写卷积神经网络和参数优化了在pytorch中为我们提供了torch.nn这个类，包含了

卷积层torch.nn.Conv2d(),线性整流单元也就是激活函数torch.nn.ReLU(),池化层torch.nn.MaxPool2d(),全连接层torch.nn.Linear()等

class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.conv1 = torch.nn.Sequential(torch.nn.Conv2d(1,64,kernel_size=3,stride=1,padding=1),
                                        torch.nn.ReLU(),
                                        torch.nn.Conv2d(64,128,kernel_size=3,stride=1,padding=1),
                                        torch.nn.ReLU(),
                                        torch.nn.MaxPool2d(stride=2,kernel_size=2))
        self.dense = torch.nn.Sequential(torch.nn.Linear(14*14*128,1024),
                                        torch.nn.ReLU(),
                                        torch.nn.Dropout(p=0.5),
                                        torch.nn.Linear(1024,10))
    def forward(self,x):
        x = self.conv1(x)
        x = x.view(-1,14*14*128)
        x = self.dense(x)
        return x

我们通过继承torch.nn.Modeule来构造网络，因为手写数字 识别比较简单，我们只是用了两个卷积层，一个最大池化层，两个全连接层。在向前传播过程中进行x.view(-1,14*14*128)对参数实现扁平化。最后通过自己self.dense定义的全连接层进行最后的分类

model = Model()
if torch.cuda.is_available():
    model.cuda()#将所有的模型参数移动到GPU上
cost = torch.nn.CrossEntropyLoss()
optimzer = torch.optim.Adam(model.parameters())

我们构造出一个模型对象，如果支持GPU的，可以将模型的参数装载到GPU上，在这里我们使用交叉熵损作为损失函数，利用pytorch中自带的optim.Adam对参数进行调优，当然optim中包含了许多调优方法，SGD,AdaGrad,RMSProp,Adam等。

这时我们打印一下model就可以看到 模型结构了

最后卷积神经网络模型进行训练和参数优化

n_epochs = 5

for epoch in range(n_epochs):
    running_loss = 0.0
    running_correct = 0
    print("Epoch{}/{}".format(epoch,n_epochs))
    print("-"*10)
    for data in data_loader_train:
        #print("train ing")
        X_train,y_train = data
        #有GPU加下面这行，没有不用加
        X_train,y_train = X_train.cuda(),y_train.cuda()
        X_train,y_train = Variable(X_train),Variable(y_train)
        outputs = model(X_train)
        _,pred = torch.max(outputs.data,1)
        optimzer.zero_grad()
        loss = cost(outputs,y_train)
        
        loss.backward()
        optimzer.step()
        running_loss += loss.data[0]
        running_correct += torch.sum(pred == y_train.data)
    testing_correct = 0
    for data in data_loader_test:
        X_test,y_test = data
        #有GPU加下面这行，没有不用加
        X_test,y_test = X_test.cuda(),y_test.cuda()
        X_test,y_test = Variable(X_test),Variable(y_test)
        outputs = model(X_test)
        _,pred = torch.max(outputs,1)
        testing_correct += torch.sum(pred == y_test.data)
    print("Loss is :{:.4f},Train Accuracy is:{:.4f}%,Test Accuracy is:{:.4f}".format(running_loss/len(data_train),100*running_correct/len(data_train),100*testing_correct/len(data_test)))
        

经过5轮迭代。以后得到如下结果

CPU版本跑的话。。可以吧 batch_size设置到256，不过。。如果跑图像，建议直接上GPU。这样，我们就通过Minist数据集完成了对pytorch的基础用法的熟悉。以后的路还长！！