调参侠带你入门深度学习：Lenet分类实战：训练与推理

Posted 2021-12-13 神佑我调参侠

前言

上篇文章中我们已经介绍了LeNet模型的搭建，这篇文章我们以CIFAR10这个数据集为例，来带大家体验一波深度学习的魅力！

CIFAR10 dataset介绍

它有以下类别： ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’. 并且是3X32X32的3通道图像。

加载数据

import torch
import torch.nn as nn
import torchvision
import numpy as np
import matplotlib.pyplot as plt
import torchvision.transforms as transforms
from model import Lenet
import torch.optim as optim #优化

#1.数据集处理
#预处理，to_tensor(whc->cwh,0~255->0~1)，正则化处理
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])
#训练数据集
trainset = torchvision.datasets.CIFAR10(root='./root',train=True,transform=transform,download=False)
#读取训练数据集
trainloader = torch.utils.data.DataLoader(trainset,batch_size=36,shuffle=True,num_workers=0)

#验证数据集
val_set = torchvision.datasets.CIFAR10(root='./root',train=False,download=False,transform=transform)
#读取验证数据集,5000?
val_dataloader = torch.utils.data.DataLoader(val_set,batch_size=4,shuffle=False,num_workers=0)

#生成迭代器
val_data_iter = iter(val_dataloader)
val_image,val_label = val_data_iter.next()

classes = ('plane','car','bird','cat','deer','dog','frog','horse','ship','truck')

def show(img):
	#标准化公式为 y=(x-0.5)/0.5 ,而这里的是反标准化:x=2y+0.5
	img = img / 2 + 0.5
	#转换为numpy格式
	nping = img.numpy()
	#在tensor中为chw，这里要变成hwc 所以为1，2，0
	plt.imshow(np.transpose(nping,(1,2,0)))
	plt.show()

print(''.join('%5s' % classes[val_label[j]] for j in range(4)))
show(torchvision.utils.make_grid(val_image))

训练

#2.加载模型
net = Lenet()

#3.定义损失函数(内置了softmax)和优化器
loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(),lr=0.001)

#4.训练
#迭代轮数
for epoch in range(5):
	running_loss = 0.0
	#对训练数据集进行遍历，加上索引
	for step,data in enumerate(trainloader,start=0):
		#读入数据
		input,labels = data
		#梯度清零
		optimizer.zero_grad()
		#前向传播
		output = net(input)
		#计算损失
		loss = loss_func(output,labels)
		#反向传播
		loss.backward()
		#优化器优化，参数更新
		optimizer.step()

		running_loss = running_loss + loss.item()
		#每500次评估一下结果
		if step % 500 == 499:
			outputs = net(val_image)
			#获取最大的预测的位置，【1】表示位置，dim=1表示维度为1
			predict_y = torch.max(outputs,dim=1)[1]
			#.item()指从tensor中获取数据
			accuracy = torch.eq(predict_y,val_label).sum().item()/val_label.size(0)
			print('[%d,%5d] train_loss: %.3f test_accuracy: %.3f'%
					(epoch + 1,step + 1, running_loss / 500,accuracy))
			running_loss = 0.0

print('Finished Training!')
save_path='./Lenet.pth'
torch.save(net.state_dict(),save_path)

预测

import torch
import torchvision.transforms as transforms
from PIL import Image
from model import Lenet

#预处理
transform = transforms.Compose(
	[transforms.Resize((32,32)),
	transforms.ToTensor(),
	transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))]
	)

classes = ('plane','car','bird','cat','deer','dog','frog','horse','ship','truck')

#加载网络
net = Lenet()
net.load_state_dict(torch.load('./Lenet.pth'))

#读取图片
im = Image.open('./1.jpg')
#预处理图像，（CHW）
im = transform(im)
#增加一个维度，而训练的时候没有是因为用的迭代器自动给N加上去了
im = torch.unsqueeze(im,dim=0)

with torch.no_grad():
	output = net(im)
	predict = torch.max(output,dim=1)[1].data.numpy()
print(classes[int(predict)])

总结

这次的项目拖了好久，然后是在宿舍熬夜完成了，这个项目从0开始编写代码，对其有了新的认识，但还是不太熟练，然后Lenet网络就这样了，下一个我们会开始AlexNet的学习。