Pytorch分類和准確性評估--基於FashionMNIST數據集

最近在學習Pytorch v1.3最新版和Tensorflow2.0。

我學習Pytorch的主要途徑：莫煩Python和Pytorch 1.3官方文檔 ，Pytorch v1.3跟之前的Pytorch不太一樣，比如1.3中，Variable類已經被棄用了（目前還可以用，但不推薦），tensor可以直接調用backward方法進行反向求導，不需要再像之前的版本一樣必須包裝成Variable對象之后再backward。

Tensorflow2.0的學習可以參考北大學生寫的教程：https://tf.wiki/zh/basic/basic.html ，TensorFlow2.0與之前的版本也有很大不同，TF 1.x的很多寫法已經不適用了，2.0把大量keras的內容包括了進去，使用之前的TF方便，但我總感覺混在一起，那還不如直接學Keras，另外跟Pytorch相比，為了實現相同的功能，TF2.0的代碼還是太多了，不夠簡潔。

為了對比兩者的速度，今天自己第一次嘗試用Pytorch實現了用於圖片分類的最簡單的全連接神經網絡。代碼包括了神經網絡的定義、使用DataLoader批訓練、效果的准確性評估，模型使用方法、輸出轉換為label型等內容。

import time
import torch.nn as nn
from torchvision.datasets import FashionMNIST
import torch
import numpy as np
from torch.utils.data import DataLoader
import torch.utils.data as Data

'''數據集為FashionMNIST'''
data=FashionMNIST('../pycharm_workspace/data/')

def train_test_split(data,test_pct=0.3):
    test_len=int(data.data.size(0)*test_pct)
    x_test=data.data[0:test_len].type(torch.float)
    x_train=data.data[test_len:].type(torch.float)
    
    y_test=data.targets[0:test_len]
    y_train=data.targets[test_len:]
  
    return x_train,y_train,x_test,y_test

'''自定義神經網絡1'''    
class MLP(nn.Module):
    def __init__(self,input_size,hidden_size,output_size):
        super().__init__()
        self.linear1=nn.Linear(input_size,hidden_size)
        self.linear2=nn.Linear(hidden_size,output_size)

    def forward(self,x):
        out=self.linear1(x)
        out=torch.relu(out)
        out=self.linear2(out)
        return out
        #out=torch.softmax()

def train_1():
    '''創建模型對象'''
    input_size=784#訓練數據的維度
    hidden_size=64#隱藏層的神經元數量，這個數量越大，神經網絡越復雜，訓練后網絡的准確度越高，但訓練耗時也越長
    ouput_size=10#輸出層的神經元數量
    mlp=MLP(input_size,hidden_size,ouput_size)
    '''定義損失函數'''
    loss_func=torch.nn.CrossEntropyLoss()
    '''定義優化器'''
    #optimizer=torch.optim.RMSprop(mlp.parameters(),lr=0.001,alpha=0.9)
    #optimizer=torch.optim.Adam(mlp.parameters(),lr=0.01)
    optimizer=torch.optim.Adam(mlp.parameters(),lr=0.001)
    x_train,y_train,x_test,y_test=train_test_split(data,0.2)
    start=time.time()
    for i in range(200):
        x=x_train.view(x_train.shape[0],-1)
        prediction=mlp(x)
        loss=loss_func(prediction,y_train)
        print('Batch No.%s,loss:%s'%(i,loss.data.numpy()))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    end=time.time()
    print('runnig time:%.3f sec.'%(end-start))
    
    '''評估模型效果'''
    samples=10000
    '''取一定數量的樣本，用於評估'''
    x_input=x_test[:samples]
    '''模型輸入必須為tensor形式，且維度為(784,)'''
    x_input=x_input.view(x_input.shape[0],-1)
    y_pred=mlp(x_input)
    '''把模型輸出(向量)轉為label形式'''
    y_pred_=list(map(lambda x:np.argmax(x),y_pred.data.numpy()))
    '''計算准確率'''
    acc=sum(y_pred_==y_test.numpy()[:samples])/samples
    print('Accuracy:',acc)
　　　　 ###輸出：Accuracy:0.8153  73 
'''自定義神經網絡2'''  
class MyNet(nn.Module):
    def __init__(self,in_size,hidden_size,out_size):
        super().__init__()
        self.linear1=nn.Linear(in_size,hidden_size)
        self.linear2=nn.Linear(hidden_size,out_size)

    def forward(self,x):
        x=x.view(x.size(0),-1)
        out=self.linear1(x)
        out=torch.relu(out)
        out=self.linear2(out)
        return out        
    
def train_2():
    num_epoch=20
    #t_data=data.data.type(torch.float)
    x_train,y_train,x_test,y_test=train_test_split(data,0.2)
    '''使用DataLoader批量輸入訓練數據'''
    dl_train=DataLoader(Data.TensorDataset(x_train,y_train),batch_size=100,shuffle=True)
    '''創建模型對象'''
    model=MyNet(784,512,10)
    '''定義損失函數'''
    loss_func=torch.nn.CrossEntropyLoss()
    '''定義優化器'''
    optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
    start=time.time()
    for i in range(num_epoch):
        for index,(x_data,y_data) in enumerate(dl_train):
            prediction=model(x_data)
            loss=loss_func(prediction,y_data)
            print('No.%s,loss=%.3f'%(index,loss.data.numpy()))
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        print('No.%s,loss=%.3f'%(i,loss.data.numpy()))   
    end=time.time()
    print('runnig time:%.3f sec.'%(end-start))
    
    '''評估模型的Accuracy'''
    samples=10000
    '''取一定數量的樣本，用於評估'''
    y_pred=model(x_test[:samples])
    '''把模型輸出(向量)轉為label形式'''
    y_pred_=list(map(lambda x:np.argmax(x),y_pred.data.numpy()))
    '''計算准確率'''
    acc=sum(y_pred_==y_test.numpy()[:samples])/samples
    print('Accuracy:',acc)
    ###輸出：Accuracy:0.8622

 

題外話，用相同的數據集、相同的神經網絡結構、相同的優化器、相同的參數，把Pytorch跟TensorFlow2.0對比，發現pytorch對cpu的占用更小，TF 2.0跑起來Mac pro呼呼地響，Pytorch跑的時候安靜很多。