- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊
目标
- 实现CIFAR-10的彩色图片识别
- 实现比P1周更复杂一点的CNN网络
具体实现
（一）环境
语言环境：Python 3.10
编 译 器: PyCharm
框 架: Pytorch 2.5.1
（二）具体步骤
1.
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
# 第一步：设置GPU
def USE_GPU():
if torch.cuda.is_available():
print('CUDA is available, will use GPU')
device = torch.device("cuda")
else:
print('CUDA is not available. Will use CPU')
device = torch.device("cpu")
return device
device = USE_GPU()
输出：CUDA is available, will use GPU
# 第二步：导入数据。同样的CIFAR-10也是torch内置了，可以自动下载
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True,
transform=torchvision.transforms.ToTensor())
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True,
transform=torchvision.transforms.ToTensor())
batch_size = 32
train_dataload = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dataload = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size)
# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dataload))
print(imgs.shape)
# 查看一下图片
import numpy as np
plt.figure(figsize=(20, 5))
for i, images in enumerate(imgs[:20]):
# 使用numpy的transpose将张量（C,H, W)转换成（H, W, C)，便于可视化处理
npimg = imgs.numpy().transpose((1, 2, 0))
# 将整个figure分成2行10列，并绘制第i+1个子图
plt.subplot(2, 10, i+1)
plt.imshow(npimg, cmap=plt.cm.binary)
plt.axis('off')
plt.show()
输出：
Files already downloaded and verified
Files already downloaded and verified
torch.Size([32, 3, 32, 32])
# 第三步，构建CNN网络
import torch.nn.functional as F
num_classes = 10 # 因为CIFAR-10是10种类型
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
# 提取特征网络
self.conv1 = nn.Conv2d(3, 64, 3)
self.pool1 = nn.MaxPool2d(kernel_size=2)
self.conv2 = nn.Conv2d(64, 64, 3)
self.pool2 = nn.MaxPool2d(kernel_size=2)
self.conv3 = nn.Conv2d(64, 128, 3)
self.pool3 = nn.MaxPool2d(kernel_size=2)
# 分类网络
self.fc1 = nn.Linear(512, 256)
self.fc2 = nn.Linear(256, num_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, 1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
from torchinfo import summary
# 将模型转移到GPU中
model = Model().to(device)
summary(model)
# 训练模型
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 设置学习率
opt = torch.optim.SGD(model.parameters(), lr=learn_rate) # 设置优化器
# 编写训练函数
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) # 训练集的大小 ，这里一共是60000张图片
num_batches = len(dataloader) # 批次大小，这里是1875（60000/32=1875)
train_acc, train_loss = 0, 0 # 初始化训练正确率和损失率都为0
for X, y in dataloader: # 获取图片及标签，X-图片，y-标签（也是实际值）
X, y = X.to(device), y.to(device)
# 计算预测误差
pred = model(X) # 网络输出预测值
loss = loss_fn(pred, y) # 计算网络输出的预测值和实际值之间的差距
# 反向传播
optimizer.zero_grad() # grad属性归零
loss.backward() # 反向传播
optimizer.step() # 第一步自动更新
# 记录正确率和损失率
train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
# 测试函数
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集大小，这里一共是10000张图片
num_batches = len(dataloader) # 批次大小 ，这里312，即10000/32=312.5,向上取整
test_acc, test_loss = 0, 0
# 因为是测试，因此不用训练，梯度也不用计算不用更新
with torch.no_grad():
for imgs, target in dataloader:
imgs, target = imgs.to(device), target.to(device)
# 计算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
# 正式训练
epochs = 10
train_acc, train_loss, test_acc, test_loss = [], [], [], []
for epoch in range(epochs):
model.train()
epoch_train_acc, epoch_train_loss = train(train_dataload, model, loss_fn, opt)
model.eval()
epoch_test_acc, epoch_test_loss = test(test_dataload, 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)
template = 'Epoch:{:2d}, 训练正确率:{:.1f}%, 训练损失率:{:.3f}, 测试正确率：{:.1f}%, 测试损失率：{:.3f}'
print(template.format(epoch+1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')
# 结果可视化
# 隐藏警告
import warnings
warnings.filterwarnings('ignore') # 忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei'] # 正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 正常显示+/-号
plt.rcParams['figure.dpi'] = 100 # 分辨率
epochs_range = range(epochs)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1) # 第一张子图
plt.plot(epochs_range, train_acc, label='训练正确率')
plt.plot(epochs_range, test_acc, label='测试正确率')
plt.legend(loc='lower right')
plt.title('训练和测试正确率比较')
plt.subplot(1, 2, 2) # 第二张子图
plt.plot(epochs_range, train_loss, label='训练损失率')
plt.plot(epochs_range, test_loss, label='测试损失率')
plt.legend(loc='upper right')
plt.title('训练和测试损失率比较')
plt.show()
# 保存模型
torch.save(model, './models/cnn-cifar10.pth')
再次设置epochs为50训练结果：
epochs增加到100，训练结果：
可以看到训练集和测试集的差距有点大，不太理想。做一下数据增加试试：
data_transforms= {
'train': transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
]),
'test': transforms.Compose([
transforms.ToTensor(),
])
}
在dataset中：
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=data_transforms['train'])
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=data_transforms['test'])
运行结果：
比较漂亮了，再调整batch_size=16和epochs=20,提高了近6个百分点。
batch_size=16,epochs=50:有第20轮左右的时候，验证集的确认性基本就没有再提高了。和上面基本一样。
（三）总结
- epochs并不是越多越好。batch_size同样的道理
- 数据增强确实可以提高模型训练的准确性。
