LeNet图像分类网络二（Pytorch)

同样地，官方地址在这里https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py
在正式训练网络之前，我们要下载数据集，用pythorch自带的库可以很方便的实现下载。下面是下载CIFAR10，并且展示图片的代码：

import torch
import torchvision      #torchvision是pytorch的一个图形库，主要用来构建计算机视觉模型，
                        # 可以用来下载数据
import torchvision.transforms as transforms #用于图形变换
import matplotlib.pyplot as plt
import numpy as np
if __name__ == '__main__':
        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)
        #组合数据集和样本。数据集是trainset，每批次加载4张图，true表示重新混合，有2个子流程用于数据加载
        trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                                  shuffle=True, num_workers=2)
        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=2)
        classes = ('plane', 'car', 'bird', 'cat',
                   'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
        def imshow(img):       #用以展示图片的函数
            img = img / 2 + 0.5     # unnormalize，非规范化
            npimg = img.numpy()     #image转为numpy类
            plt.imshow(np.transpose(npimg, (1, 2, 0)))  #改变数组的排列顺序，这样才可以展示
            plt.show()   #显示图片，只用上面那一行是使用不了的
        # get some random training images
        dataiter = iter(trainloader)        #获取训练集的图像和标签
        images, labels = dataiter.next()
        # show images
        imshow(torchvision.utils.make_grid(images))   #输出图象
        # print labels
        print(' '.join('%5s' % classes[labels[j]] for j in range(4)))  #输出标签

如果下载失败，可以根据提示去网站上下载，放到程序中指定的位置就可以了。

结果：


训练网络的代码如下，是可以直接运行的。

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms #用于图形变换
import torch.optim as optim
if __name__ == '__main__':
    #################前面是建立网络部分###################
    class Net(nn.Module):
        def __init__(self):
            super(Net,self).__init__()
            self.conv1 = nn.Conv2d(3,6,5)
            self.conv2 = nn.Conv2d(6,16,5)
            self.fc1 = nn.Linear(400,120)
            self.fc2 = nn.Linear(120,84)
            self.fc3 = nn.Linear(84,10)
        def forward(self,x):
            x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))
            x = F.max_pool2d(F.relu(self.conv2(x)),(2,2))
            x = x.view(-1, self.num_flat_features(x))
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
        def num_flat_features(self,x):
            size = x.size()[1:]
            num_features = 1
            for s in size:
                num_features *= s
            return num_features
    net = Net()
    #定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()    #定义损失函数的类型为cross-entorpy
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)  #优化器为SGD类型
    ###########################网络搭建成功##########################
    #加载数据集
    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)
    # 组合数据集和样本。数据集是trainset，每批次加载4张图，true表示重新混合，有2个子流程用于数据加载
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                              shuffle=True, num_workers=2)
    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=2)
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    #开始训练网络
    for epoch in range(2):  # 多次遍历数据集
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data
            # zero the parameter gradients
            optimizer.zero_grad()      #将梯度参数清零
            # forward + backward + optimize
            outputs = net(inputs)   #网络的输出
            loss = criterion(outputs, labels)   #计算误差
            loss.backward()            #反向传播
            optimizer.step()      #权重更新
            # print statistics
            running_loss += loss.item()
            if i % 2000 == 1999:    # print every 2000 mini-batches
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    print('Finished Training')
    #将训练好的网络参数保存起来
    PATH = './cifar_net.pth'
    torch.save(net.state_dict(), PATH)

程序会输出训练过程中网络的误差，可以看到它是在逐渐减小的。