PyTorch框架实战系列（2）——图像分类器优化

接上篇：PyTorch框架实战系列（1）——CNN图像分类器

对PyTorch教程图像分类器进行优化：（不涉及GPU训练，所以没写可GPU训练的代码）

1、CNN（卷积神经网络）增加了网络深度，卷积层逐层对特征进行提取，从微小特征总结为较大特征，最后由全连接层进行仿射变换。以下是模型架构：

Model(
  (block): Sequential(
    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (4): ReLU()
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU()
    (8): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (9): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (10): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (11): ReLU()
    (12): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (classer): Sequential(
    (0): Dropout(p=0.5, inplace=False)
    (1): Linear(in_features=512, out_features=10, bias=True)
  )
)

2、对训练过程进行优化，增加训练次数，并且每在一定数量样本训练后，将模型在测试集上进行验证，当测试集损失值不再收敛时自动停止训练。

3、增加模型测试评估报告，包括准确率、混淆矩阵和各类别的精确度、召回率及F1评分。

CNN.py

import torch.nn as nn


class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.block = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),

            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),

            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),

            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128, affine=True),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )

        self.classer = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(in_features=512, out_features=10),
        )

    def forward(self, x):
        x = self.block(x)   # [1, 128, 2, 2]
        x = x.view(x.size()[0], -1) # [1, 512]
        x = self.classer(x) # [1, 10]
        # print(x.size())
        return x


if __name__ == '__main__':
    import torch
    from torch.autograd import Variable

    x = Variable(torch.rand(1, 3, 32, 32))
    model = Model()
    print(model)
    y = model(x)
    print(y)

train.py

# -*- coding: utf-8 -*-
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import torch.optim as optim
import torch.nn as nn
from CNN import Model
import torch
import numpy as np
from sklearn import metrics


def train(save_path, model, trainloader, testloader):
    # 训练模式
    model.train()
    # 指定损失函数和优化器，学习率0.001
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    total_batch = 0  # 记录进行到多少batch
    dev_best_loss = float('inf')  # 记录验证集最佳损失率
    last_improve = 0  # 记录上次验证集loss下降的batch数
    flag = False  # 记录是否很久没有效果提升
    # 批次训练
    for epoch in range(20):
        print('Epoch [{}/{}]'.format(epoch + 1, 20))
        # 从迭代器中按mini-batch训练
        for trains, labels in trainloader:
            outputs = model(trains)
            # 模型梯度归零
            model.zero_grad()
            # 损失函数反馈传递
            loss = criterion(outputs, labels)
            loss.backward()
            # 执行优化
            optimizer.step()
            # 每多少轮在测试集上查看训练的效果
            if total_batch % 100 == 0:
                # 获得训练集准确率
                true = labels.data
                predic = torch.max(outputs.data, 1)[1]
                train_acc = metrics.accuracy_score(true, predic)
                # 如果验证集上继续收敛则保存模型参数
                dev_acc, dev_loss = evaluate(model, testloader)
                if dev_loss < dev_best_loss:
                    dev_best_loss = dev_loss
                    torch.save(model.state_dict(), save_path)
                    improve = '*'
                    last_improve = total_batch
                else:
                    improve = ''
                # 训练成果
                msg = 'Iter: {0:>6},  Train Loss: {1:>5.2},  Train Acc: {2:>6.2%},  Val Loss: {3:>5.2},  Val Acc: {4:>6.2%}  {5}'
                print(msg.format(total_batch, loss.item(), train_acc, dev_loss, dev_acc, improve))
                # 恢复训练
                model.train()
            total_batch += 1
            # 验证集loss超过多少batch没下降，结束训练
            if total_batch - last_improve > 500:
                print("Finished Training...")
                # torch.save(model.state_dict(), save_path)
                flag = True
                break
        if flag:
            break
    # 使用测试集测试评估模型
    model_test(save_path, model, testloader)

# 验证模型
def evaluate(model, dataloader, test=False):
    class_list = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
    # 模型预测模式
    model.eval()
    loss_total = 0
    predict_all = np.array([], dtype=int)
    labels_all = np.array([], dtype=int)
    loss_func = nn.CrossEntropyLoss()
    # 不记录模型梯度
    with torch.no_grad():
        for texts, labels in dataloader:
            outputs = model(texts)
            loss = loss_func(outputs, labels)
            loss_total += loss
            labels = labels.data.numpy()
            predic = torch.max(outputs.data, 1)[1].numpy()
            labels_all = np.append(labels_all, labels)
            predict_all = np.append(predict_all, predic)
    # 验证集准确度
    acc = metrics.accuracy_score(labels_all, predict_all)
    # 给出模型测试结果，评估报告和混淆矩阵
    if test:
        report = metrics.classification_report(labels_all, predict_all, target_names=class_list, digits=4)
        confusion = metrics.confusion_matrix(labels_all, predict_all)
        return acc, loss_total / len(dataloader), report, confusion
    else:
        return acc, loss_total / len(dataloader)

# 测试模型
def model_test(save_path, model, testloader):
    # 加载模型参数
    model.load_state_dict(torch.load(save_path))
    # 预测模式
    model.eval()
    # 模型测试评估
    test_acc, test_loss, test_report, test_confusion = evaluate(model, testloader, test=True)
    msg = 'Test Loss: {0:>5.2},  Test Acc: {1:>6.2%}'
    print(msg.format(test_loss, test_acc))
    print("混淆矩阵...")
    print(test_confusion)
    print("评估报告...")
    print(test_report)


if __name__ == '__main__':
    data_path = './data'    # 数据集
    save_path = './cnn_model.pth'   # 模型保存路径

    # 数据集转化为张量，并标准化
    # input[channel] = (input[channel] - mean[channel]) / std[channel]
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])
    # transform = None
    # 下载数据集
    trainset = datasets.CIFAR10(root=data_path, train=True, download=True, transform=transform)
    testset = datasets.CIFAR10(root=data_path, train=False, download=True, transform=transform)

    # 查看数据集大小
    print('trainset', len(trainset))
    print('testset', len(testset))

    batch_size = 100    # mini-batch
    # 构造迭代器
    trainloader = DataLoader(dataset=trainset, batch_size=batch_size, shuffle=True)
    testloader = DataLoader(dataset=testset, batch_size=batch_size, shuffle=True)

    # 迭代器输出的张量
    for sample, label in trainloader:
        print(sample.size(), label.size())
        break

    # 模型实例化
    model = Model()
    train(save_path, model, trainloader, testloader)

输出结果如下：

Files already downloaded and verified
Files already downloaded and verified
trainset 50000
testset 10000
torch.Size([100, 3, 32, 32]) torch.Size([100])
Epoch [1/20]
Iter:      0,  Train Loss:   2.5,  Train Acc: 14.00%,  Val Loss:   2.3,  Val Acc: 13.20%  *
Iter:    100,  Train Loss:   1.5,  Train Acc: 42.00%,  Val Loss:   1.5,  Val Acc: 44.82%  *
Iter:    200,  Train Loss:   1.4,  Train Acc: 47.00%,  Val Loss:   1.3,  Val Acc: 52.96%  *
Iter:    300,  Train Loss:   1.2,  Train Acc: 57.00%,  Val Loss:   1.3,  Val Acc: 53.33%  
Iter:    400,  Train Loss:   1.1,  Train Acc: 61.00%,  Val Loss:   1.1,  Val Acc: 60.16%  *
Epoch [2/20]
Iter:    500,  Train Loss:  0.95,  Train Acc: 60.00%,  Val Loss:   1.0,  Val Acc: 63.07%  *
Iter:    600,  Train Loss:   1.0,  Train Acc: 63.00%,  Val Loss:   1.0,  Val Acc: 62.91%  
Iter:    700,  Train Loss:  0.77,  Train Acc: 69.00%,  Val Loss:   1.0,  Val Acc: 64.62%  *
Iter:    800,  Train Loss:  0.94,  Train Acc: 63.00%,  Val Loss:   1.1,  Val Acc: 62.55%  
Iter:    900,  Train Loss:  0.93,  Train Acc: 63.00%,  Val Loss:  0.96,  Val Acc: 65.69%  *
Epoch [3/20]
Iter:   1000,  Train Loss:  0.83,  Train Acc: 68.00%,  Val Loss:  0.97,  Val Acc: 65.84%  
Iter:   1100,  Train Loss:  0.77,  Train Acc: 71.00%,  Val Loss:  0.94,  Val Acc: 67.48%  *
Iter:   1200,  Train Loss:   1.0,  Train Acc: 65.00%,  Val Loss:  0.86,  Val Acc: 69.97%  *
Iter:   1300,  Train Loss:  0.77,  Train Acc: 74.00%,  Val Loss:  0.86,  Val Acc: 70.56%  
Iter:   1400,  Train Loss:  0.91,  Train Acc: 69.00%,  Val Loss:  0.87,  Val Acc: 69.61%  
Epoch [4/20]
Iter:   1500,  Train Loss:  0.56,  Train Acc: 79.00%,  Val Loss:  0.85,  Val Acc: 70.40%  *
Iter:   1600,  Train Loss:  0.62,  Train Acc: 74.00%,  Val Loss:  0.76,  Val Acc: 73.41%  *
Iter:   1700,  Train Loss:   0.7,  Train Acc: 78.00%,  Val Loss:  0.78,  Val Acc: 73.04%  
Iter:   1800,  Train Loss:  0.75,  Train Acc: 80.00%,  Val Loss:  0.78,  Val Acc: 72.59%  
Iter:   1900,  Train Loss:  0.89,  Train Acc: 63.00%,  Val Loss:  0.77,  Val Acc: 72.92%  
Epoch [5/20]
Iter:   2000,  Train Loss:  0.58,  Train Acc: 81.00%,  Val Loss:  0.75,  Val Acc: 73.93%  *
Iter:   2100,  Train Loss:   0.7,  Train Acc: 75.00%,  Val Loss:  0.77,  Val Acc: 73.61%  
Iter:   2200,  Train Loss:  0.85,  Train Acc: 66.00%,  Val Loss:   0.8,  Val Acc: 72.10%  
Iter:   2300,  Train Loss:  0.67,  Train Acc: 78.00%,  Val Loss:  0.74,  Val Acc: 74.53%  *
Iter:   2400,  Train Loss:  0.86,  Train Acc: 76.00%,  Val Loss:  0.75,  Val Acc: 73.82%  
Epoch [6/20]
Iter:   2500,  Train Loss:  0.78,  Train Acc: 72.00%,  Val Loss:   0.8,  Val Acc: 72.36%  
Iter:   2600,  Train Loss:  0.65,  Train Acc: 76.00%,  Val Loss:  0.75,  Val Acc: 74.33%  
Iter:   2700,  Train Loss:  0.66,  Train Acc: 81.00%,  Val Loss:  0.74,  Val Acc: 74.53%  
Iter:   2800,  Train Loss:  0.66,  Train Acc: 75.00%,  Val Loss:  0.72,  Val Acc: 75.29%  *
Iter:   2900,  Train Loss:  0.75,  Train Acc: 74.00%,  Val Loss:  0.87,  Val Acc: 70.47%  
Epoch [7/20]
Iter:   3000,  Train Loss:   0.6,  Train Acc: 77.00%,  Val Loss:  0.69,  Val Acc: 75.98%  *
Iter:   3100,  Train Loss:  0.57,  Train Acc: 83.00%,  Val Loss:   0.7,  Val Acc: 76.36%  
Iter:   3200,  Train Loss:  0.54,  Train Acc: 78.00%,  Val Loss:  0.72,  Val Acc: 75.94%  
Iter:   3300,  Train Loss:  0.55,  Train Acc: 81.00%,  Val Loss:  0.67,  Val Acc: 77.06%  *
Iter:   3400,  Train Loss:  0.58,  Train Acc: 76.00%,  Val Loss:   0.7,  Val Acc: 75.97%  
Epoch [8/20]
Iter:   3500,  Train Loss:  0.47,  Train Acc: 85.00%,  Val Loss:  0.69,  Val Acc: 76.08%  
Iter:   3600,  Train Loss:  0.69,  Train Acc: 78.00%,  Val Loss:  0.74,  Val Acc: 74.58%  
Iter:   3700,  Train Loss:  0.68,  Train Acc: 83.00%,  Val Loss:  0.73,  Val Acc: 75.18%  
Iter:   3800,  Train Loss:  0.88,  Train Acc: 70.00%,  Val Loss:  0.69,  Val Acc: 76.80%  
Finished Training...
Test Loss:  0.67,  Test Acc: 77.06%
混淆矩阵...
[[794  31  43  10   9   5   8  15  49  36]
 [ 11 918   2   4   3   3   1   0  10  48]
 [ 65   6 706  39  71  46  35  18   5   9]
 [ 21  10  83 533  60 175  60  32  11  15]
 [ 21   2  81  38 747  34  19  51   6   1]
 [ 13   4  54 103  43 717  18  38   2   8]
 [  5   5  77  47  38  24 790   6   6   2]
 [  7   3  41  22  50  54   2 809   2  10]
 [ 56  41  14  12   5   1   2   2 837  30]
 [ 18  85   6   6   4   3   2   8  13 855]]
评估报告...
              precision    recall  f1-score   support

       plane     0.7854    0.7940    0.7897      1000
         car     0.8308    0.9180    0.8722      1000
        bird     0.6378    0.7060    0.6701      1000
         cat     0.6548    0.5330    0.5877      1000
        deer     0.7252    0.7470    0.7360      1000
         dog     0.6751    0.7170    0.6954      1000
        frog     0.8431    0.7900    0.8157      1000
       horse     0.8264    0.8090    0.8176      1000
        ship     0.8895    0.8370    0.8624      1000
       truck     0.8432    0.8550    0.8491      1000

   micro avg     0.7706    0.7706    0.7706     10000
   macro avg     0.7711    0.7706    0.7696     10000
weighted avg     0.7711    0.7706    0.7696     10000

可以看到，准确率从55%提升到了77%，优化效果明显。

 

还可以使用学习率衰减的方法，应该能够让模型更快收敛。

对比项目实践中图像分类的准确率，本例的准确率还是比较低的。主要因为这个数据集32*32的分辨率还是太小了，很多细微特征无法提取。