Pytorch写CNN

用Pytorch写了两个CNN网络，数据集用的是FashionMNIST。其中CNN_1只有一个卷积层、一个全连接层，CNN_2有两个卷积层、一个全连接层，但训练完之后的准确率两者差不多，且CNN_1训练时间短得多，且跟两层的全连接的准确性也差不多，看来深度学习水很深，还需要进一步调参和调整网络结构。

CNN_1：

runnig time:29.795 sec.
accuracy: 0.8688

CNN_2：

runnig time:165.101 sec.
accuracy: 0.8837

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
import matplotlib.pyplot as plt


#import os
#os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
'''数据集为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
    
def cal_accuracy(model,x_test,y_test,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
    return acc

class CNN_1(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1=nn.Sequential(
                nn.Conv2d(1,#in_channels,即图片的通道数量,黑白为1,RGB彩色为3,filter的层数默认与此数字一致
                          32,#out_channels,即filter的数量
                          4,#kernel_size,4代表(4,4)即正方形的filter，若为长方形，则(height,width)
                          stride=2,#filter移动的步长,2代表(2,2)表示右移和下移都是一个像素，否则用(n,m)表示步长
                          padding=2#图片外围每一条边补充0的层数,output_size=1+(input_size+2*padding-filter_size)/stride
                          ),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)
                )
        self.out=nn.Linear(32*7*7,10)
        
    def forward(self,x):
        x=self.conv1(x)
        temp=x.view(x.shape[0],-1)
        out=self.out(temp)
        return out

class CNN_2(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1=nn.Sequential(
                nn.Conv2d(1,#in_channels,即图片的通道数量,黑白为1,RGB彩色为3,filter的层数默认与此数字一致
                          32,#out_channels,即filter的数量
                          5,#kernel_size,3代表(3,3)即正方形的filter，若为长方形，则(height,width)
                          stride=1,#filter移动的步长,1代表(1,1)表示右移和下移都是一个像素，否则用(n,m)表示步长
                          padding=2#图片外围每一条边补充0的层数,此处设置为2是为了保持输出的长宽与图片的长宽一致，因为output_size=1+(input_size+2*padding-filter_size)/stride
                          ),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)
                )
        self.conv2=nn.Sequential(
                nn.Conv2d(32,#in_channels,即图片的通道数量,黑白为1,RGB彩色为3,filter的层数默认与此数字一致
                          16,#out_channels,即filter的数量
                          5,#kernel_size,5代表(5,5)即正方形的filter，若为长方形，则(height,width)
                          stride=1,#filter移动的步长,1代表(1,1)表示右移和下移都是一个像素，否则用(n,m)表示步长
                          padding=2#图片外围每一条边补充0的层数,此处设置为2是为了保持输出的长宽与图片的长宽一致，因为output_size=1+(input_size+2*padding-filter_size)/stride
                          ),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)
                )
        self.out=nn.Linear(16*7*7,10)
        
    def forward(self,x):
        x=self.conv1(x)
        x=self.conv2(x)
        x=x.view(x.size(0),-1)
        out=self.out(x)
        return out
    
def train_3():
    num_epoch=5
    #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=CNN_2()
    '''定义损失函数'''
    loss_func=torch.nn.CrossEntropyLoss()
    '''定义优化器'''
    optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
    start=time.time()

    acc_hist=[] 
    loss_hist=[]
    for i in range(num_epoch):
        for index,(x_data,y_data) in enumerate(dl_train):
            prediction=model(torch.unsqueeze(x_data, dim=1))
            loss=loss_func(prediction,y_data)
            print('No.%s,loss=%.3f'%(index+1,loss.data.numpy()))
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            loss_val=loss.data.numpy()
            if i==0:
                acc=cal_acc(prediction,y_data)
                acc_hist.append(acc)
                loss_hist.append(loss_val)
        print('No.%s,loss=%.3f'%(i+1,loss_val))
        #loss_hist.append(loss_val)
        #acc=cal_accuracy(model,x_test,y_test,samples=10000)
        #acc_hist.append(acc)
        print('acc=',acc)
        
    end=time.time()
    print('runnig time:%.3f sec.'%(end-start))
    acc=cal_accuracy(model,torch.unsqueeze(x_test,dim=1),y_test,samples=10000)
    print('accuracy:',acc)
    
if __name__=='__main__':
    train_3()