Pytorch Lenet Cifar10

pytorch 实现Lenet 在cifar10数据集上的训练和测试

from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
from torch import optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision.transforms import ToPILImage
show=ToPILImage()
import numpy as np
import matplotlib.pyplot as plt

##load data
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=0)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=0)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

def imshow(img):
    img = img / 2 + 0.5
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))

####network
class LeNet(nn.Module):
    def __init__(self):
        super(LeNet,self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=6,kernel_size=5)
        self.pool1 = nn.MaxPool2d(kernel_size=2,stride=2)
        self.conv2 = nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.dense1 = nn.Linear(16*5*5,120)
        self.dense2 = nn.Linear(120,84)
        self.dense3 = nn.Linear(84,10)

    def forward(self,x):
        x=self.pool1(F.relu(self.conv1(x)))
        x=self.pool2(F.relu(self.conv2(x)))
        x=x.view(-1,16*5*5)
        x=self.dense3(F.relu(self.dense2(F.relu(self.dense1(x)))))
        return x

net=LeNet()
print (net)
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

#train
print ("training begin")
for epoch in range(3):
    running_loss=0
    for i,data in enumerate(trainloader,0):
        # print (inputs,labels)
        image,label=data
        image=Variable(image)
        label=Variable(label)

        # imshow(torchvision.utils.make_grid(image))
        # plt.show()
        # print (label)
        optimizer.zero_grad()

        outputs=net(image)
        loss=criterion(outputs,label)

        loss.backward()
        optimizer.step()

        running_loss+=loss.data

        if i%2000==1999:
            print ('[%d,%5d] loss: %.3f'%(epoch+1,i+1,running_loss/2000))
            running_loss=0
print ("finish training")


#test

#some result
# dataiter=iter(testloader)
# images,labels=dataiter.__next__()
# imshow(torchvision.utils.make_grid(images))
# plt.show()
# print('should be: ', ' '.join('%5s'% classes[labels[j]] for j in range(4)))
#
# outputs=net(Variable(images))
#
# _,predicted=torch.max(outputs.data,1)
# print('Predicted: ', ' '.join('%5s'% classes[predicted[j]] for j in range(4)))

net.eval()
correct=0
total=0
for data in testloader:
    images,labels=data
    outputs=net(Variable(images))
    _,predicted=torch.max(outputs,1)
    total+=labels.size(0)
    correct+=(predicted==labels).sum()
print('Accuracy of the network on the %d test images: %d %%' % (total , 100 * correct / total))

运行过程

LeNet(
  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (dense1): Linear(in_features=400, out_features=120, bias=True)
  (dense2): Linear(in_features=120, out_features=84, bias=True)
  (dense3): Linear(in_features=84, out_features=10, bias=True)
)
training begin
[epoch 1,img  8000] loss: 2.234
[epoch 1,img 16000] loss: 1.875
[epoch 1,img 24000] loss: 1.668
[epoch 1,img 32000] loss: 1.596
[epoch 1,img 40000] loss: 1.544
[epoch 1,img 48000] loss: 1.485
[epoch 2,img  8000] loss: 1.401
[epoch 2,img 16000] loss: 1.368
[epoch 2,img 24000] loss: 1.339
[epoch 2,img 32000] loss: 1.342
[epoch 2,img 40000] loss: 1.298
[epoch 2,img 48000] loss: 1.253
[epoch 3,img  8000] loss: 1.180
[epoch 3,img 16000] loss: 1.212
[epoch 3,img 24000] loss: 1.169
[epoch 3,img 32000] loss: 1.167
[epoch 3,img 40000] loss: 1.163
[epoch 3,img 48000] loss: 1.163
finish training
Accuracy of the network on the 10000 test images: 59 %