文章目录
(一)概述
(二)数据预处理
(三)构建网络
(四)选择优化器
(五)训练测试加保存模型
正文
(一)概述
1、CIFAR-10数据集包含10个类别的60000个32x32彩色图像,每个类别有6000张图像。有50000张训练图像和10000张测试图像。
2、数据集分为五个训练批次和一个测试批次,每个批次具有10000张图像。测试集包含从每个类别中1000张随机选择的图像。剩余的图像按照随机顺序构成5个批次的训练集,每个批次中各类图像的数量不相同,但总训练集中每一类都正好有5000张图片
3、数据集中的class(类),以及每个class的10个随机图像:
(二)数据预处理
1、引入包库
import torch
import numpy as np
from torch.utils.data import DataLoader
from torchvision import datasets,transforms
import torch.nn as nn
import torch.nn.functional as F
import os
import time
2、定义超参数
#定义超参数
batch_size=100
learning_rate=1e-2
epochs=200
3、标准化
data_tf=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
4、读取数据
train_data = datasets.CIFAR10(root='./data',train=True,transform=data_tf,download=False)
test_data = datasets.CIFAR10(root='./data',train=False,transform=data_tf)
5、装载数据
train_loader=DataLoader(train_data,batch_size=batch_size,shuffle=True)
test_loader=DataLoader(test_data,batch_size=batch_size,shuffle=True)
(三)构建网络
代码
class Alexnet(nn.Module):
def __init__(self):
super(Alexnet, self).__init__()
self.conv1 = nn.Conv2d(3,64,3,2,1)
self.pool = nn.MaxPool2d(3, 2)
self.conv2 = nn.Conv2d(64,192, 5, 1, 2)
self.conv3 = nn.Conv2d(192, 384, 3, 1, 1)
self.conv4 = nn.Conv2d(384,256, 3, 1, 1)
self.conv5 = nn.Conv2d(256,256, 3, 1, 1)
self.drop = nn.Dropout(0.5)
self.fc1 = nn.Linear(256*6*6, 4096)
self.fc2 = nn.Linear(4096, 4096)
self.fc3 = nn.Linear(4096, 1000)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = F.relu(self.conv3(x))
x = F.relu(self.conv4(x))
x = self.pool(F.relu(self.conv5(x)))
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = self.drop(F.relu(self.fc1(x)))
x = self.drop(F.relu(self.fc2(x)))
x = self.fc3(x)
return x
网络结构
(四)选择模型、优化器,定义loss
model=AlexNet()
#定义loss与参数更新
criterion=nn.CrossEntropyLoss()
optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate)
(五)训练测试
#训练
for epoch in range(epochs):
total = 0
running_loss = 0.0
running_correct = 0
print("epoch {}/{}".format(epoch, epochs))
print("-" * 10)
for data in train_loader:
img, label = data
img = Variable(img)
if torch.cuda.is_available():
img = img.cuda()
label = label.cuda()
else:
img = Variable(img)
label = Variable(label)
out = model(img) # 得到前向传播的结果
loss = criterion(out, label) # 得到损失函数
print_loss = loss.data.item()
optimizer.zero_grad() # 归0梯度
loss.backward() # 反向传播
optimizer.step() # 优化
running_loss += loss.item()
epoch += 1
if epoch % 50 == 0:
print('epoch:{},loss:{:.4f}'.format(epoch, loss.data.item()))
_, predicted = torch.max(out.data, 1)
total += label.size(0)
running_correct += (predicted == label).sum()
print('第%d个epoch的识别准确率为:%d%%' % (epoch + 1, (100 * running_correct / total)))