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功能，等我學到更多知識后，有待后續添加。