PytorchMNIST(使用Pytorch进行MNIST字符集识别任务)

　　都说MNIST相当于机器学习界的Hello World。最近加入实验室，导师给我们安排了一个任务，但是我才刚刚入门呐！！没办法，只能从最基本的学起。

　　Pytorch是一套开源的深度学习张量库。或者我倾向于把它当成一个独立的深度学习框架。为了写这么一个"Hello World"。查阅了不少资料，也踩了不少坑。不过同时也学习了不少东西，下面我把我的代码记录下来，希望能够从中受益更多，同时帮助其他对Pytorch感兴趣的人。代码的注释中有不对的地方欢迎批评指正。

　　代码进行了注释，应该很方便阅读。 dependences: numpy torch torchvision python3 使用pip安装即可。

 # encoding: utf-8
 import torch
 import torch.nn as nn
 import torch.nn.functional as F #加载nn中的功能函数
 import torch.optim as optim #加载优化器有关包
 import torch.utils.data as Data
 from torchvision import datasets,transforms #加载计算机视觉有关包
 from torch.autograd import Variable

 BATCH_SIZE = 64

 #加载torchvision包内内置的MNIST数据集 这里涉及到transform:将图片转化成torchtensor
 train_dataset = datasets.MNIST(root='~/data/',train=True,transform=transforms.ToTensor(),download=True)
 test_dataset = datasets.MNIST(root='~/data/',train=False,transform=transforms.ToTensor())

 #加载小批次数据，即将MNIST数据集中的data分成每组batch_size的小块，shuffle指定是否随机读取
 train_loader = Data.DataLoader(dataset=train_dataset,batch_size=BATCH_SIZE,shuffle=True)
 test_loader = Data.DataLoader(dataset=test_dataset,batch_size=BATCH_SIZE,shuffle=False)

 #定义网络模型亦即Net 这里定义一个简单的全连接层784->10
 class Model(nn.Module):
     def __init__(self):
         super(Model,self).__init__()
         self.linear1 = nn.Linear(784,10)

     def forward(self,X):
         return F.relu(self.linear1(X))

 model = Model() #实例化全连接层
 loss = nn.CrossEntropyLoss() #损失函数选择，交叉熵函数
 optimizer = optim.SGD(model.parameters(),lr = 0.1)
 num_epochs = 5

 #以下四个列表是为了可视化（暂未实现）
 losses = []
 acces = []
 eval_losses = []
 eval_acces = []

 for echo in range(num_epochs):
     train_loss = 0   #定义训练损失
     train_acc = 0    #定义训练准确度
     model.train()    #将网络转化为训练模式
     for i,(X,label) in enumerate(train_loader):     #使用枚举函数遍历train_loader
         X = X.view(-1,784)       #X:[64,1,28,28] -> [64,784]将X向量展平
         X = Variable(X)          #包装tensor用于自动求梯度
         label = Variable(label)
         out = model(X)           #正向传播
         lossvalue = loss(out,label)         #求损失值
         optimizer.zero_grad()       #优化器梯度归零
         lossvalue.backward()    #反向转播，刷新梯度值
         optimizer.step()        #优化器运行一步，注意optimizer搜集的是model的参数

         #计算损失
         train_loss += float(lossvalue)
         #计算精确度
         _,pred = out.max(1)
         num_correct = (pred == label).sum()
         acc = int(num_correct) / X.shape[0]
         train_acc += acc

     losses.append(train_loss / len(train_loader))
     acces.append(train_acc / len(train_loader))
     print("echo:"+' ' +str(echo))
     print("lose:" + ' ' + str(train_loss / len(train_loader)))
     print("accuracy:" + ' '+str(train_acc / len(train_loader)))
     eval_loss = 0
     eval_acc = 0
     model.eval() #模型转化为评估模式
     for X,label in test_loader:
         X = X.view(-1,784)
         X = Variable(X)
         label = Variable(label)
         testout = model(X)
         testloss = loss(testout,label)
         eval_loss += float(testloss)

         _,pred = testout.max(1)
         num_correct = (pred == label).sum()
         acc = int(num_correct) / X.shape[0]
         eval_acc += acc

     eval_losses.append(eval_loss / len(test_loader))
     eval_acces.append(eval_acc / len(test_loader))
     print("testlose: " + str(eval_loss/len(test_loader)))
     print("testaccuracy:" + str(eval_acc/len(test_loader)) + '\n')

运行后的结果如下:

　　我们在上面的代码中，将图片对应的Pytorchtensor展平，并通过一个全连接层，仅仅是这样就达到了90%以上的准确率。如果使用卷积层，正确率有望达到更高。

　　代码并不完备，还可以增加visualize和predict功能，等我学到更多知识后，有待后续添加。