pytorch手写字母用自己的网络进行训练对比lenet

导入必要的模块

import torch
from torch.autograd import Variable
import numpy as np
import matplotlib.pyplot as plt
from torch import nn,optim
from torch.utils.data import DataLoader
from torchvision import datasets,transforms

定义自己的网络结构

包括卷积，bacth norm，relu，maxpooling层

定义网络结构
class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.layer1=nn.Sequential(
            nn.Conv2d(1,16,kernel_size=3),#b,16,26,26)
            nn.BatchNorm2d(16),
            nn.ReLU(inplace=True))
        self.layer2=nn.Sequential(
            nn.Conv2d(16,32,kernel_size=3),#b,32,24.24
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2))
        self.layer3=nn.Sequential(
            nn.Conv2d(32,64,kernel_size=3),#b,64,10,10)
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True))
        self.layer4=nn.Sequential(
            nn.Conv2d(64,128,kernel_size=3),#b,128,8.8
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2))#b,128,4,4
        self.fc=nn.Sequential(
            nn.Linear(128*4*4,1024),
            nn.ReLU(inplace=True),
            nn.Linear(1024,128),
            nn.ReLU(inplace=True),
            nn.Linear(128,10)
        )
    def forward(self,x):
        x=self.layer1(x)
        x=self.layer2(x)
        x=self.layer3(x)
        x=self.layer4(x)
        x=x.view(x.size(0),-1)
        x=self.fc(x)
        return x

定义Lenet网路结构

#定义一个lenet5网络结构
class Lenet(nn.Module):
    def __init__(self):
        super(Lenet,self).__init__()
        layer1=nn.Sequential()
        layer1.add_module('conv1',nn.Conv2d(1,6,3,padding=1))
        layer1.add_module('pool1',nn.MaxPool2d(2,2))
        self.layer1=layer1
        
        layer2=nn.Sequential()
        layer2.add_module('conv2',nn.Conv2d(6,16,5))
        layer2.add_module('pool2',nn.MaxPool2d(2,2))
        self.layer2=layer2
        
        layer3=nn.Sequential()
        layer3.add_module('fc1',nn.Linear(400,120))
        layer3.add_module('fc2',nn.Linear(120,84))
        layer3.add_module('fc3',nn.Linear(84,10))
        self.layer3=layer3
    def forward(self,x):
        x=self.layer1(x)
        x=self.layer2(x)
        x=x.view(x.size(0),-1)
        x=self.layer3(x)
        return x

开始训练

import torch
from torch.autograd import Variable
import numpy as np
import matplotlib.pyplot as plt

from torch import nn,optim
from torch.utils.data import DataLoader
from torchvision import datasets,transforms
#定义一些超参数
batch_size=64
learning_rate=1e-2
num_epoches=20
#预处理
data_tf=transforms.Compose(
[transforms.ToTensor(),transforms.Normalize([0.5],[0.5])])#将图像转化成tensor，然后继续标准化，就是减均值，除以方差

#读取数据集
train_dataset=datasets.MNIST(root='./data',train=True,transform=data_tf,download=True)
test_dataset=datasets.MNIST(root='./data',train=False,transform=data_tf)
#使用内置的函数导入数据集
train_loader=DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader=DataLoader(test_dataset,batch_size=batch_size,shuffle=False)

#导入网络，定义损失函数和优化方法
model=Lenet()#如果使用Lenet就用这个网路
#model=CNN()#使用CNN进行训练
if torch.cuda.is_available():#是否使用cuda加速
    model=model.cuda()
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=learning_rate)
n_epochs=1
for epoch in range(n_epochs):
    total=0
    running_loss=0.0
    running_correct=0
    print("epoch {}/{}".format(epoch,n_epochs))
    print("-"*10)
    for data in train_loader:
        img,label=data
        #img=img.view(img.size(0),-1)
        img = Variable(img)
        if torch.cuda.is_available():
            img=img.cuda()
            label=label.cuda()
        else:
            img=Variable(img)
            label=Variable(label)
        out=model(img)#得到前向传播的结果
        loss=criterion(out,label)#得到损失函数
        print_loss=loss.data.item()
        optimizer.zero_grad()#归0梯度
        loss.backward()#反向传播
        optimizer.step()#优化
        running_loss+=loss.item()
        epoch+=1
        if epoch%50==0:
            print('epoch:{},loss:{:.4f}'.format(epoch,loss.data.item()))
    _, predicted = torch.max(out.data, 1)
    total += label.size(0)#得到总图片数目
    running_correct += (predicted == label).sum()#分类正确的
    print('第%d个epoch的识别准确率为：%d%%' % (epoch + 1, (100 * running_correct / total))

运行结果

lenet的结果 左 和 CNN的结果（右）