目录
模型训练
本笔记包含对现有网络模型的使用和修改、保存与读取、完整的模型训练套路、利用GPU训练的两种方法以及完整的模型验证套路。
model_pretrained.py:现有网络模型的使用和修改，以pytorch官网中用于分类的vgg16模型为例，其是在ImageNet数据集（1000个class）上进行预训练。但实操中由于ImageNet数据集过大，有100G，故而未下载到本地。只是利用加载模型参数的不同在debug中观察vgg16在数据集上训练前后参数的不同。同时以将vgg16模型应用到CIFAR-10数据集（10个class）上为例实现模型修改。
model_save.py model_load.py：包含两种模型保存方法以及两种相应的模型加载方法。模型保存包括保存模型结构和模型训练数据及参数。model.py:为了规范化网络训练步骤，将搭建模型部分单独存放在文件中，在训练模型时将其引入即可。train_cpu.py：在cpu上实现完整的模型训练
train_gpu1.py：利用.cuda（）方法在gpu上实现完整的模型训练train_gpu2.py：利用.to(device)在gpu上实现完整的模型训练
test.py：在文件中load已训练且保存好的模型，在imgs中随意添加CIFAR-10数据集中所包含的图像类别相关图片，进行测试验证。如：dog.pn/airplane.png
实验证明利用model_0.pth（即训练一轮保存的模型）会将图片分类错误，使用model_10.pth（即训练十轮保存的模型）会将图片正确分类。
CIFAR-10 数字对应类别
#‘airplane’=0 'automobile'=1 'bird'=2 'cat'=3 'deer'=4
# 'dog'=5 'frog'=6 'horse'=7 'ship'=8 'truck'=9 _len_=10
model_pretrained.py
import torchvision
from torch import nn
# train_data=torchvision.datasets.ImageNet("../dataset",split='train',download=True,
# transform=torchvision.transforms.ToTensor())
# #RuntimeError: The archive ILSVRC2012_devkit_t12.tar.gz is not present in the root directory or is corrupted.
# # You need to download it externally and place it in ../dataset. 只能手动下载 但文件但大了100G
#由于数据集太大 接下来只能debug观察一下模型pretrained=false和true时的区别
#false时 是初始的weight true时，是在ImageNet数据集上训练好的参数
vgg16_false=torchvision.models.vgg16(pretrained=False)#flase时只是加载网络模型，不需要下载
vgg16_true=torchvision.models.vgg16(pretrained=True)#true时需要下载网络模型
# print("ok") #打断点 debug
print(vgg16_true) #输出网络模型 可以知道vgg16可以识别1000个类别（ImageNet数据集含1000个class）
#之前用的CIFAR10数据集包含10个class
train_data=torchvision.datasets.CIFAR10("../dataset",train=True,download=True,
transform=torchvision.transforms.ToTensor())
# 如何在CIFAR10上应用这样一个输出类别为1000个的模型呢？
# 方式①将最后一层线性层中的out_feature的1000 改为10
# 方式②在分类器中再加一层线性层 in_features=1000,out_features=10
#在vgg16_true模型结构中添加层
vgg16_true.classifier.add_module('add_linear',nn.Linear(1000,10))
print(vgg16_true)
print(vgg16_false)
#修改vgg16_false模型结构
vgg16_false.classifier[6]=nn.Linear(4096,10)
print(vgg16_false)vgg16model 结构：（未截图完整）
原vgg16model中的classifier：（最后一个线性层可以看出class为1000个）
add_module后的classifier：
修改最后classifier中最后一个线性层后：
model_save.py
#模型的保存
import torch
import torchvision
from torch import nn
vgg16=torchvision.models.vgg16(pretrained=False)#false时参数是初始参数，即为训练过的参数
#保存方式1
torch.save(vgg16,"vgg16_method1.pth") #会产生.pth文件 不仅保存了模型结构 还保存了模型参数
#保存方式2(官方推荐) 占用空间小
torch.save(vgg16.state_dict(),"vgg16_method2.pth") # 把vgg16中网络模型参数保存为python中的字典形式 只保存参数 不保存结构
#陷阱
class myModel(nn.Module):
def __init__(self):
super(myModel, self).__init__()
self.conv1=nn.Conv2d(3,64,kernel_size=3)
def forward(self,x):
x=self.conv1(x)
return x
model=myModel()
torch.save(model,"model_method1.pth")
model_load.py
#加载模型
import torch
import torchvision
from torch import nn
#方式1-对应model_save.py 中的保存方式1
model = torch.load("vgg16_method1.pth")
# print(model)#debug可以看到保存的该模型参数 输出的是模型的结构
#方式2 加载模型
vgg16 = torchvision.models.vgg16(pretrained=False)#加载模型结构
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))#加载模型参数
# model = torch.load("vgg16_method2.pth")#字典形式存储的模型参数
# print(model)
# print(vgg16)
# 陷阱1 使用方式1保存模型
# 如果是自己定义的模型 加载已经保存的可能它会不认识这个模型
# 需要将原模型class导入 或者 将文件import
model=torch.load('model_method1.pth')
print(model)#AttributeError: Can't get attribute 'myModel' 使用方法1陷阱（未加载保存的自定义model class或者引入其所在文件）
model.py
#为了规范，一般会把该部分单独放在一个文件中，然后引入
import torch
from torch import nn
#搭建神经网络
class myModel(nn.Module):
def __init__(self):
super(myModel, self).__init__()
self.model=nn.Sequential(
nn.Conv2d(3,32,5,1,2),#in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self,x):
x=self.model(x)
return x
#测试网络模型
if __name__ == '__main__': #main
model=myModel()
input=torch.ones((64,3,32,32))
output=model(input)
print(output.shape)train_cpu.py
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time
from model import * #从model.py文件引入搭建的神经网络
#准备数据集
train_data=torchvision.datasets.CIFAR10(root="../dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test_data=torchvision.datasets.CIFAR10(root="../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
#length 数据集长度
train_data_size=len(train_data)
test_data_size=len(test_data)
print("训练数据集的长度为:{}".format(train_data_size))
print("测试数据集的长度为:{}".format(test_data_size))
# print(f"训练数据集的长度为:{train_data_size}")
#利用DataLoader加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
# # 搭建神经网络
# # 为了规范，一般会把该部分单独放在一个文件中，然后引入 （from model import *）
# class myModel(nn.module):
# def __init__(self):
# super(myModel, self).__init__()
# self.model=nn.Sequential(
# nn.Conv2d(3,32,5,1,2),#in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2
# nn.MaxPool2d(2),
# nn.Conv2d(32,32,5,1,2),
# nn.MaxPool2d(2),
# nn.Conv2d(32, 64, 5, 1, 2),
# nn.MaxPool2d(2),
# nn.Flatten(),
# nn.Linear(64*4*4,64),
# nn.Linear(64,10)
# )
#
# def forward(self,x):
# x=self.model(x)
# return x
#创建网络模型
model = myModel()
#创建损失函数
loss_fn = nn.CrossEntropyLoss()
#优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(),learning_rate)
#设置训练网络的一些参数
total_train_step = 0 #记录训练的次数
total_test_step = 0 #记录测试的次数
epoch = 10 #训练的轮数
#添加tensorboard可视化
writer=SummaryWriter("../logs")
start_time=time.time()
for i in range(epoch):
print("--------第{}轮训练开始--------".format(i+1))#i=0,1,...9
#训练步骤开始
model.train()#只对一部分网络层有作用 eg, Dropout,BatchNorm,etc.
for data in train_dataloader:
imgs,targets=data
outputs=model(imgs)
loss=loss_fn(outputs,targets)
#优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step+=1
if total_train_step%100 == 0:
end_time=time.time()
print(end_time-start_time)
print("训练次数:{},Loss:{}".format(total_train_step,loss.item()))
writer.add_scalar("train_loss",loss.item(),total_train_step)
#loss和loss.item()输出看起来没什么区别，但是item()会把tensor数据类型转化为数字 可以为后续loss可视化做铺垫
#测试步骤开始
model.eval()#只对一部分网络层有作用 eg, Dropout,BatchNorm,etc.
total_test_loss=0
total_accuracy=0
with torch.no_grad():#不需要梯度调优 用已训练的模型进行测试
for data in test_dataloader:
imgs,targets=data
outputs=model(imgs)
loss=loss_fn(outputs,targets)#loss是一部分数据的测试误差
total_test_loss+=loss.item()#整个测试数据集上的测试误差
accuracy=(outputs.argmax(1)==targets).sum()
total_accuracy += accuracy
print("整体测试集上的Loss:{}".format(total_test_loss))
print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss",total_test_loss,total_test_step)
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step += 1
#保存每一轮训练的模型
torch.save(model,"model_{}.pth".format(i))
# torch.save(model.state_dict(),"model_{}.pth".format(i))
print("模型已保存")
writer.close()train_gpu1.py
#使用GPU 方法1
#找到网络模型、数据（输入、标注）损失函数三种变量
#调用.cuda
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time
# from model import * #从model.py文件引入搭建的神经网络
#准备数据集
train_data=torchvision.datasets.CIFAR10(root="../dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test_data=torchvision.datasets.CIFAR10(root="../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
#length 数据集长度
train_data_size=len(train_data)
test_data_size=len(test_data)
print("训练数据集的长度为:{}".format(train_data_size))
print("测试数据集的长度为:{}".format(test_data_size))
# print(f"训练数据集的长度为:{train_data_size}")
#利用DataLoader加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
# # 搭建神经网络
# # 为了规范，一般会把该部分单独放在一个文件中，然后引入 （from model import *）
class myModel(nn.Module):
def __init__(self):
super(myModel, self).__init__()
self.model=nn.Sequential(
nn.Conv2d(3,32,5,1,2),#in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self,x):
x=self.model(x)
return x
#创建网络模型
model = myModel()
if torch.cuda.is_available():
model=model.cuda()
#创建损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():
loss_fn=loss_fn.cuda()
#优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(),learning_rate)
#设置训练网络的一些参数
total_train_step = 0 #记录训练的次数
total_test_step = 0 #记录测试的次数
epoch = 10 #训练的轮数
#添加tensorboard可视化
writer=SummaryWriter("../logs")
start_time=time.time()
for i in range(epoch):
print("--------第{}轮训练开始--------".format(i+1))#i=0,1,...9
#训练步骤开始
model.train()#只对一部分网络层有作用 eg, Dropout,BatchNorm,etc.
for data in train_dataloader:
imgs,targets=data
if torch.cuda.is_available():
imgs=imgs.cuda()
targets=targets.cuda()
outputs=model(imgs)
loss=loss_fn(outputs,targets)
#优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step+=1
if total_train_step%100 == 0:
end_time = time.time()
print(end_time-start_time)
print("训练次数:{},Loss:{}".format(total_train_step,loss.item()))
writer.add_scalar("train_loss",loss.item(),total_train_step)
#loss和loss.item()输出看起来没什么区别，但是item()会把tensor数据类型转化为数字 可以为后续loss可视化做铺垫
#测试步骤开始
model.eval()#只对一部分网络层有作用 eg, Dropout,BatchNorm,etc.
total_test_loss=0
total_accuracy=0
with torch.no_grad():#不需要梯度调优 用已训练的模型进行测试
for data in test_dataloader:
imgs,targets=data
if torch.cuda.is_available():
imgs = imgs.cuda()
targets = targets.cuda()
outputs=model(imgs)
loss=loss_fn(outputs,targets)#loss是一部分数据的测试误差
total_test_loss+=loss.item()#整个测试数据集上的测试误差
accuracy=(outputs.argmax(1)==targets).sum()
total_accuracy += accuracy
print("整体测试集上的Loss:{}".format(total_test_loss))
print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss",total_test_loss,total_test_step)
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step += 1
#保存每一轮训练的模型
torch.save(model,"model_{}.pth".format(i))
# torch.save(model.state_dict(),"model_{}.pth".format(i))
print("模型已保存")
writer.close()train_gpu2.py
#使用GPU 方法2 更长远
#device=torch.device("cpu")
#.to(device)
#torch.device("cuda")
#torch.device("cuda:0") 第一张显卡
#torch.device("cuda:1") 第二张显卡
#torch.device("cuda" if torch.cuda.is_available() else "cpu")
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time
#定义训练使用的设备
# device=torch.device("cpu")
device=torch.device("cuda")
# from model import * #从model.py文件引入搭建的神经网络
#准备数据集
train_data=torchvision.datasets.CIFAR10(root="../dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)
test_data=torchvision.datasets.CIFAR10(root="../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
#length 数据集长度
train_data_size=len(train_data)
test_data_size=len(test_data)
print("训练数据集的长度为:{}".format(train_data_size))
print("测试数据集的长度为:{}".format(test_data_size))
# print(f"训练数据集的长度为:{train_data_size}")
#利用DataLoader加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
# # 搭建神经网络
# # 为了规范，一般会把该部分单独放在一个文件中，然后引入 （from model import *）
class myModel(nn.Module):
def __init__(self):
super(myModel, self).__init__()
self.model=nn.Sequential(
nn.Conv2d(3,32,5,1,2),#in_channels=3,out_channels=32,kernel_size=5,stride=1,padding=2
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self,x):
x=self.model(x)
return x
#创建网络模型
model = myModel()
model=model.to(device)
#创建损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn=loss_fn.to(device)
#优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(),learning_rate)
#设置训练网络的一些参数
total_train_step = 0 #记录训练的次数
total_test_step = 0 #记录测试的次数
epoch = 20 #训练的轮数
#添加tensorboard可视化
writer=SummaryWriter("../logs")
# start_time = time.time()
for i in range(epoch):
print("--------第{}轮训练开始--------".format(i+1))#i=0,1,...9
#训练步骤开始
model.train()#只对一部分网络层有作用 eg, Dropout,BatchNorm,etc.
for data in train_dataloader:
start_time = time.time()
imgs,targets=data
imgs=imgs.to(device)
targets=targets.to(device)
outputs=model(imgs)
loss=loss_fn(outputs,targets)
#优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step+=1
if total_train_step%100 == 0:
end_time = time.time()
print(end_time-start_time)
print("训练次数:{},Loss:{}".format(total_train_step,loss.item()))
writer.add_scalar("train_loss",loss.item(),total_train_step)
#loss和loss.item()输出看起来没什么区别，但是item()会把tensor数据类型转化为数字 可以为后续loss可视化做铺垫
#测试步骤开始
model.eval()#只对一部分网络层有作用 eg, Dropout,BatchNorm,etc.
total_test_loss=0
total_accuracy=0
with torch.no_grad():#不需要梯度调优 用已训练的模型进行测试
for data in test_dataloader:
imgs,targets=data
imgs = imgs.to(device)
targets = targets.to(device)
outputs=model(imgs)
loss=loss_fn(outputs,targets)#loss是一部分数据的测试误差
total_test_loss+=loss.item()#整个测试数据集上的测试误差
accuracy=(outputs.argmax(1)==targets).sum()
total_accuracy += accuracy
print("整体测试集上的Loss:{}".format(total_test_loss))
print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss",total_test_loss,total_test_step)
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step += 1
#保存每一轮训练的模型
torch.save(model,"model_{}.pth".format(i))
# torch.save(model.state_dict(),"model_{}.pth".format(i))
print("模型已保存")
writer.close()
test.py
import torch
import torchvision
from PIL import Image
from model import *#方式1加载保存好的模型需要copy model class或者导入model文件
#image_path="../imgs/dog.png"
image_path="../imgs/airplane.png"
image = Image.open(image_path)
print(image)#<PIL.PngImagePlugin.PngImageFile image mode=RGB size=202x213 at 0x27F1DAB0F70>
image = image.convert('RGB')#png格式有四个通道：RGB+Alph透明通道 调用convert保留其RGB通道
#model要求输入只能是32*32
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape)#torch.Size([3, 32, 32])
#载入train好的模型（数据、参数及模型结构）
#model=torch.load('model_0.pth')#方式1导入
model=torch.load('model_9.pth')#方式1导入
print(model)
image=torch.reshape(image,(1,3,32,32))#模型输入需要是四维数据
image=image.cuda()#若保存的模型是用gpu训练的，则需要将输入数据同样写为在gpu训练形式
model.eval()#进入测试状态
with torch.no_grad():
output=model(image)
print(output)
print(output.argmax(1))
#CIFAR-10 数字对应类别
# ‘airplane’=0 'automobile'=1 'bird'=2 'cat'=3 'deer'=4
# 'dog'=5 'frog'=6 'horse'=7 'ship'=8 'truck'=9 _len_=10测试输入数据：
airplane.png
dog.png
使用model_0.pth测试 airplane.png（预测正确√）
使用model_0.pth测试 dog.png（预测错误×）
使用model_9.pth测试dog.png（预测正确√）
使用model_9.pth测试airplane.png（预测正确√）
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
