Cifar-10训练记录

cifar-10介绍

任务是对10个类别的对象进行分类，使用cifar-10数据集。cifar-10数据集共有60000张彩色图像，大小为32 * 32 * 3，一共有10个类别，每个类别6000张。其中50000张用于训练，10000用于测试。

构建模型

首先导入必要的包

import os
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torch.nn.functional as F
from torchvision import datasets
from torchvision import transforms
from torch.utils.data import DataLoader, Dataset
import collections
# 使用gpu训练和测试
os.environ['CUDA_VISIBLE_DEVICES'] = '0, 1'

数据读入和加载
下载并使用PyTorch提供的内置数据集

transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# 将数据转换为tensor格式并归一化到(-1, 1)区间
train_data = datasets.CIFAR10(root='./', train=True, download=True, transform=transform)
test_data = datasets.CIFAR10(root='./', train=False, download=True, transform=transform)
# 读取数据集
train_loader = DataLoader(train_data, batch_size=4, shuffle=True, num_workers=4)
test_loader = DataLoader(test_data, batch_size=4, shuffle=False, num_workers=4)
# 定义DataLoader加载数据,每批次读入数据为batch_size
classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
# 对应类别labels

可视化操作

def imshow(img):img = img / 2 + 0.5npimg = img.numpy()plt.imshow(np.transpose(npimg, (1, 2, 0)))plt.show()
images, labels = next(iter(train_loader))
print(images.shape, labels.shape)
imshow(torchvision.utils.make_grid(images))
print(' '.join('%5s'%classes[labels[j]] for j in range(4)))

模型设计
由于任务较为简单，我们搭建一个CNN，模型构建完成后，将模型放在GPU上用于训练。

class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(3, 6, 5)self.pool = nn.MaxPool2d(2, 2)self.conv2 = nn.Conv2d(6, 16, 5)self.fc1 = nn.Linear(16*5*5, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, 10)self.relu = nn.ReLU()def forward(self, x):x = self.pool(self.relu(self.conv1(x)))x = self.pool(self.relu((self.conv2(x))))x = x.view(-1, 16*5*5)x = self.relu(self.fc1(x))x = self.relu(self.fc2(x))x = self.fc3(x)return xnet = Net()
net = net.cuda()

设定损失函数和优化器

使用torch.nn模块自带的交叉熵损失函数。
使用Adam优化器，先设置学习率为1e-3，惩罚系数1e-8。

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=1e-3, weight_decay=1e-7)

训练

def train(epoch):# 设置模型状态为trainnet.train()train_loss = 0num_pred = 0for image, label in train_loader:image, label = image.cuda(), label.cuda()optimizer.zero_grad()out_put = net(image)loss = criterion(out_put, label)loss.backward()optimizer.step()train_loss += loss * len(image)preds = torch.argmax(out_put, 1)num_pred += np.sum(preds.cpu().numpy()==label.cpu().numpy())train_loss /= len(train_loader.dataset)accuracy = num_pred / len(train_loader.dataset)print('Epoch:{}\tTraining Loss:{:.6f}\tTraining Accuracy:{:.6f}'.format(epoch, train_loss, accuracy))

测试

def val(epoch):print('crrent learning rate: ', optimizer.state_dict()["param_groups"][0]["lr"])net.eval()class_correct = list(0. for i in range(10))class_total = list(0. for i in range(10))val_loss = 0gt_labels = []pred_labels = []with torch.no_grad():for data, label in test_loader:data, label = data.cuda(), label.cuda()output = net(data)preds = torch.argmax(output, 1)c = (preds == label).squeeze()for i in range(4):label1 = label[i]class_correct[label1] += c[i].item()class_total[label1] += 1gt_labels.append(label.cpu().data.numpy())pred_labels.append(preds.cpu().data.numpy())loss = criterion(output, label)val_loss += loss.item()*data.size(0)val_loss = val_loss / len(test_loader.dataset)gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)acc = np.sum(gt_labels == pred_labels) / len(pred_labels)print(F'Epoch:{epoch} \tValidation Loss: {val_loss:6f} , Accuracy: {acc:6f}')for i in range(10):print("Accuracy of %5s : %2d %%" %(classes[i], 100*class_correct[i] / class_total[i]))

模型搭建完毕，开始训练和测试，先进行10个轮次。

for epoch in range(10):train(epoch+1)val(epoch+1)

结果
Epoch:10 Training Loss:0.855442 Accuracy:0.694800
crrent learning rate: 0.001
Epoch:10 Validation Loss:1.158405 Accuracy:0.618900
发现训练和测试精确率都不满意。

优化

加深模型
由于测试精确率较低，我们考虑采用加深模型来提高精确率，将原本的三层卷积加深为四层。
加宽模型

class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(3, 16, 3)self.conv2 = nn.Conv2d(16, 80, 4)self.conv3 = nn.Conv2d(80, 400, 3)self.conv4 = nn.Conv2d(400, 800, 2, padding=2)self.fc1 = nn.Linear(3200, 400)self.fc2 = nn.Linear(400, 120)self.fc3 = nn.Linear(120, 84)self.fc4 = nn.Linear(84, 10)self.relu = nn.ReLU()self.pool = nn.MaxPool2d(2)def forward(self, x):x = self.conv1(x)x = self.relu(x)x = self.pool(x)x = self.conv2(x)x = self.relu(x)x = self.pool(x)x = self.conv3(x)x = self.relu(x)x = self.pool(x)x = self.conv4(x)x = self.relu(x)x = self.pool(x)x = x.view(x.size()[0], -1)x = self.fc1(x)x = self.relu(x)x = self.fc2(x)x = self.relu(x)x = self.fc3(x)x = self.relu(x)x = self.fc4(x)return xdef num_flat_features(self, x):size = x.size()[1:]num_features = 1for s in size:num_features *= sreturn num_featuresnet = Net()
net = net.cuda()

经过加深和加宽模型后结果为：
Epoch:10 Training Loss:0.447619 Accuracy:0.849860
crrent learning rate: 0.001
Epoch:10 Validation Loss:1.045875 Accuracy:0.713100
逐层归一化
如果不进行归一化，那么由于特征向量中不同特征的取值相差较大，会导致目标函数变“扁”。这样在进行梯度下降的时候，梯度的方向就会偏离最小值的方向，走很多弯路，即训练时间过长。
过拟合问题
对比训练精确度和测试精确率发现，训练精确率远大于测试精确率，即考虑出现过拟合问题。
增加dropout
为了解决过拟合问题，增加dropout层，但会增加训练时间。
正则化力度
将正则化惩罚系数1e-8改为1e-5。

调整学习率

def adjust_learning_rate(optimizer, epoch):lr = 1e-3 * (0.1) ** (epoch // 4)for param_group in optimizer.param_groups:param_group['lr'] = lr

class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(3, 30, 3)self.conv2 = nn.Conv2d(30, 300, 4)self.conv3 = nn.Conv2d(300, 600, 3)self.conv4 = nn.Conv2d(600, 1200, 2, padding=2)self.fc1 = nn.Linear(4800, 10)self.fc2 = nn.Linear(400, 10)self.relu = nn.ReLU()self.pool = nn.MaxPool2d(2)self.dropout = nn.Dropout(0.1)self.batchnorm1 = nn.BatchNorm2d(30)self.batchnorm2 = nn.BatchNorm2d(300)self.batchnorm3 = nn.BatchNorm2d(600)self.batchnorm4 = nn.BatchNorm2d(1200)def forward(self, x):x = self.conv1(x)x = self.relu(x)x = self.pool(x)x = self.batchnorm1(x)x = self.dropout(x)x = self.conv2(x)x = self.relu(x)x = self.pool(x)x = self.batchnorm2(x)x = self.dropout(x)x = self.conv3(x)x = self.relu(x)x = self.pool(x)x = self.batchnorm3(x)x = self.dropout(x)x = self.conv4(x)x = self.relu(x)x = self.pool(x)x = self.batchnorm4(x)x = self.dropout(x)x = x.view(x.size()[0], -1)x = self.fc1(x)# x = self.relu(x)# x = self.fc2(x)return xdef num_flat_features(self, x):size = x.size()[1:]num_features = 1for s in size:num_features *= sreturn num_featuresnet = Net()
net = net.cuda()

最终结果
经过以上诸多处理手段，得到最终结果为：
Epoch:20 Training Loss:0.172814 Accuracy:0.941460
crrent learning rate: 1.0000000000000002e-07
Epoch:20 Validation Loss: 0.641045 Accuracy: 0.801200