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型等内容。

  1 import time
  2 import torch.nn as nn
  3 from torchvision.datasets import FashionMNIST
  4 import torch
  5 import numpy as np
  6 from torch.utils.data import DataLoader
  7 import torch.utils.data as Data
  8 
  9 '''数据集为FashionMNIST'''
 10 data=FashionMNIST('../pycharm_workspace/data/')
 11 
 12 def train_test_split(data,test_pct=0.3):
 13     test_len=int(data.data.size(0)*test_pct)
 14     x_test=data.data[0:test_len].type(torch.float)
 15     x_train=data.data[test_len:].type(torch.float)
 16     
 17     y_test=data.targets[0:test_len]
 18     y_train=data.targets[test_len:]
 19   
 20     return x_train,y_train,x_test,y_test
 21 
 22 '''自定义神经网络1'''    
 23 class MLP(nn.Module):
 24     def __init__(self,input_size,hidden_size,output_size):
 25         super().__init__()
 26         self.linear1=nn.Linear(input_size,hidden_size)
 27         self.linear2=nn.Linear(hidden_size,output_size)
 28 
 29     def forward(self,x):
 30         out=self.linear1(x)
 31         out=torch.relu(out)
 32         out=self.linear2(out)
 33         return out
 34         #out=torch.softmax()
 35 
 36 def train_1():
 37     '''创建模型对象'''
 38     input_size=784#训练数据的维度
 39     hidden_size=64#隐藏层的神经元数量，这个数量越大，神经网络越复杂，训练后网络的准确度越高，但训练耗时也越长
 40     ouput_size=10#输出层的神经元数量
 41     mlp=MLP(input_size,hidden_size,ouput_size)
 42     '''定义损失函数'''
 43     loss_func=torch.nn.CrossEntropyLoss()
 44     '''定义优化器'''
 45     #optimizer=torch.optim.RMSprop(mlp.parameters(),lr=0.001,alpha=0.9)
 46     #optimizer=torch.optim.Adam(mlp.parameters(),lr=0.01)
 47     optimizer=torch.optim.Adam(mlp.parameters(),lr=0.001)
 48     x_train,y_train,x_test,y_test=train_test_split(data,0.2)
 49     start=time.time()
 50     for i in range(200):
 51         x=x_train.view(x_train.shape[0],-1)
 52         prediction=mlp(x)
 53         loss=loss_func(prediction,y_train)
 54         print('Batch No.%s,loss:%s'%(i,loss.data.numpy()))
 55         optimizer.zero_grad()
 56         loss.backward()
 57         optimizer.step()
 58     end=time.time()
 59     print('runnig time:%.3f sec.'%(end-start))
 60     
 61     '''评估模型效果'''
 62     samples=10000
 63     '''取一定数量的样本，用于评估'''
 64     x_input=x_test[:samples]
 65     '''模型输入必须为tensor形式，且维度为(784,)'''
 66     x_input=x_input.view(x_input.shape[0],-1)
 67     y_pred=mlp(x_input)
 68     '''把模型输出(向量)转为label形式'''
 69     y_pred_=list(map(lambda x:np.argmax(x),y_pred.data.numpy()))
 70     '''计算准确率'''
 71     acc=sum(y_pred_==y_test.numpy()[:samples])/samples
 72     print('Accuracy:',acc)
　　　　 ###输出：Accuracy:0.8153
 73 
 74 '''自定义神经网络2'''  
 75 class MyNet(nn.Module):
 76     def __init__(self,in_size,hidden_size,out_size):
 77         super().__init__()
 78         self.linear1=nn.Linear(in_size,hidden_size)
 79         self.linear2=nn.Linear(hidden_size,out_size)
 80 
 81     def forward(self,x):
 82         x=x.view(x.size(0),-1)
 83         out=self.linear1(x)
 84         out=torch.relu(out)
 85         out=self.linear2(out)
 86         return out        
 87     
 88 def train_2():
 89     num_epoch=20
 90     #t_data=data.data.type(torch.float)
 91     x_train,y_train,x_test,y_test=train_test_split(data,0.2)
 92     '''使用DataLoader批量输入训练数据'''
 93     dl_train=DataLoader(Data.TensorDataset(x_train,y_train),batch_size=100,shuffle=True)
 94     '''创建模型对象'''
 95     model=MyNet(784,512,10)
 96     '''定义损失函数'''
 97     loss_func=torch.nn.CrossEntropyLoss()
 98     '''定义优化器'''
 99     optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
100     start=time.time()
101     for i in range(num_epoch):
102         for index,(x_data,y_data) in enumerate(dl_train):
103             prediction=model(x_data)
104             loss=loss_func(prediction,y_data)
105             print('No.%s,loss=%.3f'%(index,loss.data.numpy()))
106             optimizer.zero_grad()
107             loss.backward()
108             optimizer.step()
109         print('No.%s,loss=%.3f'%(i,loss.data.numpy()))   
110     end=time.time()
111     print('runnig time:%.3f sec.'%(end-start))
112     
113     '''评估模型的Accuracy'''
114     samples=10000
115     '''取一定数量的样本，用于评估'''
116     y_pred=model(x_test[:samples])
117     '''把模型输出(向量)转为label形式'''
118     y_pred_=list(map(lambda x:np.argmax(x),y_pred.data.numpy()))
119     '''计算准确率'''
120     acc=sum(y_pred_==y_test.numpy()[:samples])/samples
121     print('Accuracy:',acc)
122     ###输出：Accuracy:0.8622

题外话，用相同的数据集、相同的神经网络结构、相同的优化器、相同的参数，把Pytorch跟TensorFlow2.0对比，发现pytorch对cpu的占用更小，TF 2.0跑起来Mac pro呼呼地响，Pytorch跑的时候安静很多。