- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者:K同学啊 | 接辅导、项目定制
- 🚀 文章来源:K同学的学习圈子
CIFAR10是CIFAR-10是一个更接近普适物体的彩色图像数据集。CIFAR-10 是由Hinton 的学生Alex Krizhevsky 和Ilya Sutskever 整理的一个用于识别普适物体的小型数据集。一共包含10 个类别的RGB 彩色图片:飞机( airplane )、汽车( automobile )、鸟类( bird )、猫( cat )、鹿( deer )、狗( dog )、蛙类( frog )、马( horse )、船( ship )和卡车( truck )。每个图片的尺寸为32 × 32 ,每个类别有6000个图像,数据集中一共有50000 张训练图片和10000 张测试图片。
与MNIST 数据集中目比, CIFAR-10 真高以下不同点
(1)、CIFAR-10 是3 通道的彩色RGB 图像,而MNIST 是灰度图像。
(2)、CIFAR-10 的图片尺寸为32 × 32 , 而MNIST 的图片尺寸为28 × 28 ,比MNIST 稍大。
(3)、相比于手写字符, CIFAR-10 含有的是现实世界中真实的物体,不仅噪声很大,而且物体的比例、特征都不尽相同,这为识别带来很大困难。
下面本文以CIFAR10数据集为例实现一个两层卷积神经网络的简单模型。
本人电脑配置
Python 3.8.0
Pytorch 1.8.1
torchvision 0.9.1 + cu10.2
前期准备
1. 设置GPU
在这里想要说明一点是,如果电脑有显卡,在装pytorch时需要安装gpu版本的,可参考网上其他博主,不能直接“pip install torch”,否则会默认安装CPU版本。
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
from torch.optim.lr_scheduler import ReduceLROnPlateau
# device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
2. 导入数据
使用dataset下载CIFAR数据集,并划分好训练集与测试集;使用dataloader加载数据,并设置好基本的batch_size。
下载数据到主目录的文件夹的data文件夹里
# import data, the dataset is cifar10
train_ds = torchvision.datasets.CIFAR10('data',
train=True,
transform=torchvision.transforms.ToTensor(),
download=True)
test_ds = torchvision.datasets.CIFAR10('data',
train=False,
transform=torchvision.transforms.ToTensor(),
download=True)
batch_size = 32
train_dl = torch.utils.data.DataLoader(train_ds,
batch_size=batch_size,
shuffle=True)
test_dl = torch.utils.data.DataLoader(test_ds,
batch_size=batch_size)
构建网络模型
1. 搭建模型
构建两层卷积、两层全连接的神经网络。在倒数第二层后面添加了Droupout操作,以防止过拟合
# construct the CNN network
import torch.nn.functional as F
number_classes = 10
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=3)
self.pool1 = nn.MaxPool2d(kernel_size=2)
self.conv2 = nn.Conv2d(64, 64,kernel_size=3)
self.pool2 = nn.MaxPool2d(kernel_size=2)
self.conv3 = nn.Conv2d(64, 128, kernel_size=3)
self.pool3 = nn.MaxPool2d(kernel_size=2)
# classifier
self.fc1 = nn.Linear(512, 256)
self.dropout = nn.Dropout(p=0.5)
self.fc2 = nn.Linear(256, number_classes)
def forward(self, x):
x = self.pool1(F.relu(self.conv1(x)))
x = self.pool2(F.relu(self.conv2(x)))
x = self.pool3(F.relu(self.conv3(x)))
x = torch.flatten(x, start_dim=1)
x = F.relu(self.fc1(x))
x = self.dropout(x)
x = self.fc2(x)
return x
2. 可视化模型
利用torchinfo包查看模型的结构并计算模型每一层的参数量,显示出来的结果如下。
from torchinfo import summary
model = Model().to(device)
summary(model)
==============================================
Layer (type:depth-idx) Param
==============================================
Model --
├─Conv2d: 1-1 1,792
├─MaxPool2d: 1-2 --
├─Conv2d: 1-3 36,92
├─MaxPool2d: 1-4 --
├─Conv2d: 1-5 73,85
├─MaxPool2d: 1-6 --
├─Linear: 1-7 131,3
├─Dropout: 1-8 --
├─Linear: 1-9 2,570
==============================================
Total params: 246,474
Trainable params: 246,474
Non-trainable params: 0
==============================================
3. 编写训练函数
设置损失函数,这里采用的交叉熵损失函数,设置优化器为SGD优化,同时在其中加入了动量,也是为了防止过拟合。
# train model
# parameters
loss_fn = nn.CrossEntropyLoss()
learning_rate = 1e-2
# opt = torch.optim.SGD(model.parameters(), lr=learning_rate)
opt = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.78)#add mommentum
scheduler=torch.optim.lr_scheduler.ExponentialLR(opt, gamma=0.8)
# train
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
num_batches = len(dataloader)
train_loss, train_acc = 0, 0
for X, y in dataloader:
X, y = X.to(device), y.to(device)
# calculate the error
pred = model(X)
loss = loss_fn(pred, y)
# backward
optimizer.zero_grad()
loss.backward()
optimizer.step()
# recording accuracy and loss value
train_acc += (pred.argmax(1)==y).type(torch.float).sum().item()
train_loss += loss.item()
scheduler.step()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
4. 编写测试函数
当不进行训练时,停止梯度更新,节省计算内存消耗。
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset)
num_batches = len(dataloader)
test_loss, test_acc = 0, 0
with torch.no_grad():
for imgs, target in dataloader:
imgs, target = imgs.to(device), target.to(device)
# calculate loss
target_pred = model(imgs)
loss = loss_fn(target_pred, target)
test_loss += loss.item()
test_acc += (target_pred.argmax(1)==target).type(torch.float).sum().item()
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
5. 主函数
设置迭代epoch次数,这里设定为100,并记录训练误差、精度,测试误差、精度。同时为了保存模型,选取训练过程中测试集上精度最大的模型进行保存。
# start to train
epochs = 100
best_acc = 0.0
train_loss = []
train_acc = []
test_loss = []
test_acc = []
for epoch in range(epochs):
model.train()
epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
train_acc.append(epoch_train_acc)
train_loss.append(epoch_train_loss)
test_acc.append(epoch_test_acc)
test_loss.append(epoch_test_loss)
if epoch_test_acc >= best_acc:
best_acc = epoch_test_acc
print('save model')
torch.save(model.state_dict(), 'model.pth')
template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}')
print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')
结果总结
1、由于CIFAR10数据比较复杂,当采用原文中的设置进行100次迭代时,发生了过拟合现象,即训练精度达到1,测试误差先减小后不断增大,效果如下
2、改进措施:在优化器中添加了动量,添加了学习率逐渐下降的机制,以及在网络模型的第一个全连接层后面添加Droupout机制,在改进之后,发现训练过程稳定下来了
3、对过拟合问题进行改进后,发现测试集的精度稳定在70%左右,这应该是两层神经网络达到的上限了,想要提高精度,可增加卷积神经网络的宽度和深度。