pytorch（9）-- 利用resnet18使cifa10数据集达到95%准确率
一、前言
本文尝试使用resnet18训练测试cifa10数据集，尽可能取得较高的准确率，直接使用只能达到83%左右的准确率，关键在于使用预训练模型，在trainsform中 ，将数据resize 到 224,224 ， 加入随机上下左右翻转数据增强，再使用imagnet的均值方差做归一化。
二、代码
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 8 09:53:54 2022
trainval.py
"""
import torch
import torchvision
import torchvision.transforms as transforms
import argparse,os
from torch import optim
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models.resnet import resnet18
#关键就在这里
transform_train = transforms.Compose(
[
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.ToTensor(),
transforms.Normalize( (0.485, 0.456, 0.406), (0.229, 0.224, 0.225) )])
transform = transforms.Compose(
[ transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize( (0.485, 0.456, 0.406), (0.229, 0.224, 0.225) )])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform_train)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
def train(args, net, device, train_loader, optimizer, epoch ,scheduler):
running_loss = 0.0 # 初始化loss
correct = 0.
batch_num = 0
#重点注意，训练时如果用到Batch Normalization 和 Dropout，就要在训练时使用net.train(),测试时用net.eval(),否则则不用
net.train()
criterion = nn.CrossEntropyLoss() #nn的函数是要先创建，后初始化
#开始数据机加载batch
for batch_idx, (inputs, labels) in enumerate(train_loader, 0):
# 输入数据上传
inputs = inputs.to(device)
labels = labels.to(device)
# 梯度清零
optimizer.zero_grad()
# forward + backward
outputs = net(inputs)
loss = criterion( outputs, labels )
loss.backward()
running_loss += loss.item()
batch_num +=1
pred = outputs.argmax(dim=1, keepdim=True) # get the index of the max log-probability
correct += pred.eq(labels.view_as(pred)).sum().item()
# 更新参数
optimizer.step()
if batch_idx % args.log_interval == 0: #每args.log_interval个批次输出一次loss
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, (batch_idx+1)*len(inputs), len(train_loader.dataset),
100*(batch_idx+1)*len(inputs)/ len(train_loader.dataset), running_loss/( batch_idx+1) ) )
scheduler.step()
def test(args, net, device, test_loader,train_loader, epoch ):
net.eval() #用到Batch Normalization 和 Dropout 就要加上
test_loss = 0
correct = 0
criterion = nn.CrossEntropyLoss() # nn的函数是要先创建，后初始化
with torch.no_grad():
for data, label in test_loader: #不会做反向求导
data, label = data.to(device), label.to(device)
output = net(data)
test_loss += F.cross_entropy(output, label, reduction='sum').item() # sum up batch loss
pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability
correct += pred.eq(label.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
test_loss, correct, len(test_loader.dataset),
100. * correct / len(test_loader.dataset)))
def main():
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=64, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=6, metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.001, metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.9, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=1000, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model', action='store_true', default=True,
help='For Saving the current Model')
#获取参数
args = parser.parse_args()
# 先来判断是否要用cuda,默认是有的话就用
torch.manual_seed(args.seed) #阈值随机设置
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
#准备数据加载器
kwargs = {'num_workers': 0, 'pin_memory': True} if use_cuda else {}
train_loader = torch.utils.data.DataLoader(trainset, batch_size= args.batch_size , shuffle=True, **kwargs )
test_loader = torch.utils.data.DataLoader(testset, batch_size= args.test_batch_size , shuffle=False, **kwargs )
#初始化net,训练和验证都需要net
net = resnet18(pretrained=False)
net.load_state_dict( torch.load( "resnet18-5c106cde.pth" ) ) # 加载官方预训练模型，6个epoch 95.26%
inchannel = net.fc.in_features
net.fc = nn.Linear(inchannel, 10)
net = net.to(device)
print( "Create Net:",net )
#初始化optimizer，只有train时使用
optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 30 , gamma=0.5)
#开始迭代训练
for epoch in range(args.epochs):
train(args, net, device, train_loader, optimizer, epoch , scheduler )
test(args, net, device, test_loader,train_loader, epoch ) #不需要optimizer
if (args.save_model):
torch.save(net.state_dict(), "./cnn_resnet18.pth") # 不使用state_dict()，则将模型结构和权重一起保存
if __name__ =="__main__":
main()
运行该训练代码，在6个epoch可得到10000张测试集95%+准确率
如果加上注意力机制（通道注意力+空间注意力），不知效果如何，有空再实验