比较好的室内设计网站,东莞市做网络维护的公司,网络推广培训学院,鹤壁市城乡一体化示范区官网入口文章目录 1. 完整模型的训练套路1.2 导入必要的包1.3 准备数据集1.3.1 使用公开数据集#xff1a;1.3.2 获取训练集、测试集长度#xff1a;1.3.3 利用 DataLoader来加载数据集 1.4 搭建神经网络1.4.1 测试搭建的模型1.4.2 创建用于训练的模型 1.5 定义损失函数和优化器1.6 使… 文章目录 1. 完整模型的训练套路1.2 导入必要的包1.3 准备数据集1.3.1 使用公开数据集1.3.2 获取训练集、测试集长度1.3.3 利用 DataLoader来加载数据集 1.4 搭建神经网络1.4.1 测试搭建的模型1.4.2 创建用于训练的模型 1.5 定义损失函数和优化器1.6 使用tensorboard非必要1.7 定义早停策略等参数1.8 训练模型1.8.1 通过训练得到best_model 1.9 验证模型1.9.1标签数据1.9.2 开始验证模型导入必要的包读取图片网上随便找的转换图像维度:加载best_model开始用模型预测 1.10 扩展知识1.10.1 使用GPU加速的方法1.10.2 使用早停策略1.10.3 两种保存模型的方法导包两种保存模型方式两种读取模型方式 完整代码获取方式 1. 完整模型的训练套路
任务给图片做分类飞机、鸟、狗、猫。。等共十种标签
ps针对不同任务只是在数据处理和模型搭建上有所不同而已模型的训练流程套路都是一样的。
1.2 导入必要的包
import torchvision
from torch import nn
import torch1.3 准备数据集
1.3.1 使用公开数据集
# 准备数据集
train_data torchvision.datasets.CIFAR10(root../data,trainTrue,transformtorchvision.transforms.ToTensor(),downloadTrue)
test_data torchvision.datasets.CIFAR10(root../data,trainFalse,transformtorchvision.transforms.ToTensor(),downloadTrue)1.3.2 获取训练集、测试集长度
# length长度
train_data_size len(train_data)
test_data_size len(test_data)print(训练数据集的长度为{}.format(train_data_size))
print(测试数据集的长度为{}.format(test_data_size))1.3.3 利用 DataLoader来加载数据集
# 利用 DataLoader来加载数据集
from torch.utils.data import DataLoader
train_dataloader DataLoader(train_data,batch_size64)
test_dataloader DataLoader(test_data,batch_size64)1.4 搭建神经网络
# 搭建神经网络
class MyModel(nn.Module):def __init__(self):super(MyModel,self).__init__()self.model nn.Sequential(nn.Conv2d(3,32,5,1,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 x1.4.1 测试搭建的模型
# 测试搭建的模型
model1 MyModel()
input torch.ones((64,3,32,32))
output model1(input)
print(output.shape) #torch.Size([64, 10])1.4.2 创建用于训练的模型
# 定义是否使用gpu加速的设备
# 支持gpu加速的pytorch版本device cuda:0,否则为cpu
device torch.device(cuda:0 if torch.cuda.is_available() else cpu)
print(device) # cuda:0# 创建模型
model MyModel()
# model.to(device) # 模型和损失函数不需要另外复制
model model.to(device)1.5 定义损失函数和优化器
# 损失函数
loss_fn nn.CrossEntropyLoss() # 交叉熵现在常用mse
loss_fn.to(device)learning_rate 1e-2
# learning_rate 0.01
# 优化器
optimizer torch.optim.SGD(model.parameters(),lrlearning_rate) #SGD现在常用Adam1.6 使用tensorboard非必要
# 使用tensorboard
from torch.utils.tensorboard.writer import SummaryWriter
# 添加tensorbord
writer SummaryWriter(../logs_train)import time
import numpy as np1.7 定义早停策略等参数
# 定义 Early Stopping 参数
early_stopping_patience 3 # 如果 3 个 epoch 后性能没有改善就停止训练
early_stopping_counter 0
best_loss float(inf) # 初始化为无穷大 # 初始化最好模型的性能为无穷大
best_valid_loss float(inf)# 初始化好的准确率
best_accuracy 0.001.8 训练模型
# 设置训练网络的一些参数# 记录测试的次数
total_test_step 0# 训练的次数
epoch 100start_time time.time()
for i in range(epoch):print(----------------第{}轮训练开始----------------.format(i1))# 训练步骤开始model.train() #训练模式对DropOut等有用train_loss []# 记录训练的次数iter_count 0for data in train_dataloader:imgs,targets dataimgs imgs.to(device)targets targets.to(device)outputs model(imgs) # 调用模型计算输出值loss loss_fn(outputs,targets) # 计算损失值train_loss.append(loss.item())# 优化器优化模型optimizer.zero_grad() # 梯度清零loss.backward() # 反向传播optimizer.step() # 优化参数iter_count iter_count 1 # 迭代次数if (iter_count %100 0):end_time time.time()
# print(cost_time:,end_time-start_time)print(训练次数{0}Loss:{1:.7f}.format(iter_count,loss.item()))writer.add_scalar(train_loss:,loss.item(),iter_count)train_loss np.average(train_loss)print(第{0}轮训练结束.format(i1))print(Epoch:{0} | Train_Loss:{1:.7f}\n.format(i1,train_loss))# 测试步骤开始model.eval()# 测试模式print(第{0}轮测试开始.format(i1))test_loss []test_accuracy 0with torch.no_grad(): # 不计算梯度for data in test_dataloader:imgs,targets dataimgs imgs.to(device)targets targets.to(device)outputs model(imgs)loss loss_fn(outputs,targets)test_loss.append(loss.item())accuracy (outputs.argmax(1) targets).sum()test_accuracy test_accuracyaccuracytest_loss np.average(test_loss)print(Epoch:{0} | Test_Loss:{1:.7f}.format(i1,test_loss))test_accuracy test_accuracy/test_data_sizeprint(Test_Accuracy:{0:.7f}.format(test_accuracy))writer.add_scalar(test_loss:,test_loss,total_test_step )writer.add_scalar(test_accuracy:,test_accuracy,total_test_step )total_test_step total_test_step 1# 每一轮保存模型# torch.save(model,model_{}.pth.format(i1))# torch.save(model.state_dict(),model_{}.pth.format(i)) # 官方推荐的保存模型方法# # 如果当前模型在验证集上的性能更好保存该模型 (以Loss为标准)# if test_loss best_valid_loss: # best_valid_loss test_loss # torch.save(model.state_dict(), ./model/best_model.pth)# print(当前第{}轮模型为best_model,已保存!.format(i1))# 以正确率为标准if best_accuracy test_accuracy: best_accuracy test_accuracy torch.save(model.state_dict(), ./model/ac_{0:.4f}_best_model.pth.format(best_accuracy))print(当前第{}轮模型为best_model,已保存!.format(i1))early_stopping_counter 0 #只要模型有更新早停patience就初始化为0else: #早停策略early_stopping_counter 1 if early_stopping_counter early_stopping_patience: print(Early stopping at epoch {}.format(i1)) breakprint(\n)writer.close()训练过程展示只给出两轮的信息 … 1.8.1 通过训练得到best_model
我自得到的best_model :ac_0.6553_best_model.pth
准确率0.65还行练手的项目就不一一调参多次训练了
1.9 验证模型
1.9.1标签数据 1.9.2 开始验证模型
导入必要的包
from PIL import Image
import torchvision
import torch读取图片网上随便找的
图1-dog1
图2-dog2
image_path ./data/dog2.png
image Image.open(image_path)
image image.convert(RGB)转换图像维度:
transform torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),torchvision.transforms.ToTensor()])
image transform(image)
print(image.shape) #torch.Size([3, 32, 32]) 加载best_model
神经网络类 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),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
因为我保存模型用了state_dict()这样的模型小省空间所以加载模型需要以下这样加载下文会给出保存模型的两种方法
best_model MyModel()
best_model.load_state_dict(torch.load(./best_model/ac_0.6553_best_model.pth))
print(best_model)输出:
MyModel((model): Sequential((0): Conv2d(3, 32, kernel_size(5, 5), stride(1, 1), padding(2, 2))(1): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse)(2): Conv2d(32, 32, kernel_size(5, 5), stride(1, 1), padding(2, 2))(3): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse)(4): Conv2d(32, 64, kernel_size(5, 5), stride(1, 1), padding(2, 2))(5): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse)(6): Flatten(start_dim1, end_dim-1)(7): Linear(in_features1024, out_features64, biasTrue)(8): Linear(in_features64, out_features10, biasTrue))
)开始用模型预测
再转换一下图片维度
image torch.reshape(image,(1,3,32,32))best_model.eval()
with torch.no_grad():output best_model(image)
print(output)
print(output.argmax(1)) # 取出预测最大概率的值输出结果由结果可知预测的十个标签中从0开始第5个结果的值最大查看标签数据知序号5为dog预测成功了
ps我得到的这个模型把图片dog1预测成了猫
tensor([[ -3.7735, -9.3045, 6.1250, 2.3422, 4.8322, 11.0666, -2.2375,7.5186, -11.7261, -8.5249]])
tensor([5])1.10 扩展知识
1.10.1 使用GPU加速的方法
GPU训练
网络模型数据输入、标注损失函数.cuda
# 使用GPU训练
import torch device torch.device(cuda:0 if torch.cuda.is_available() else cpu) # 将模型移动到 GPU
model model.to(device) # 将损失函数移动到 GPU
loss_fn loss_fn.to(device)# 将输入数据移动到 GPU
inputs inputs.to(device) # 将标签移动到 GPU
labels labels.to(device)
# 命令行的方式查看显卡配置在jupyter上
!nvidia-smi1.10.2 使用早停策略
# 使用早停策略
import torch
import torch.nn as nn
from torch.optim import Adam
from torch.utils.data import DataLoader, TensorDataset # 定义一个简单的模型
class SimpleModel(nn.Module): def __init__(self, input_dim, output_dim): super(SimpleModel, self).__init__() self.linear nn.Linear(input_dim, output_dim) def forward(self, x): return self.linear(x) # 创建数据
input_dim 10
output_dim 1
x_train torch.randn(100, input_dim)
y_train torch.randn(100, output_dim)
dataset TensorDataset(x_train, y_train)
dataloader DataLoader(dataset, batch_size10) # 初始化模型、损失函数和优化器
model SimpleModel(input_dim, output_dim)
criterion nn.MSELoss()
optimizer Adam(model.parameters(), lr0.01) # 定义 Early Stopping 参数
early_stopping_patience 5 # 如果 5 个 epoch 后性能没有改善就停止训练
early_stopping_counter 0
best_loss float(inf) # 初始化为无穷大 # 训练循环
for epoch in range(100): # 例如我们训练 100 个 epoch for inputs, targets in dataloader: optimizer.zero_grad() outputs model(inputs) loss criterion(outputs, targets) loss.backward() optimizer.step() # 计算当前 epoch 的损失 current_loss 0 with torch.no_grad(): for inputs, targets in dataloader: outputs model(inputs) current_loss criterion(outputs, targets).item() / len(dataloader) current_loss / len(dataloader) # 检查是否应提前停止训练 if current_loss best_loss: best_loss current_loss early_stopping_counter 0 else: early_stopping_counter 1 if early_stopping_counter early_stopping_patience: print(Early stopping at epoch {}.format(epoch)) break1.10.3 两种保存模型的方法
导包
import torch
import torchvision
两种保存模型方式
vgg16 torchvision.models.vgg16(weightsNone)# 保存方式1模型结构参数结构
torch.save(vgg16,vgg16_method1.pth)# 保存方式2模型参数官方推荐模型较小
torch.save(vgg16.state_dict(),vgg16_method2.pth)两种读取模型方式
# 方式1
model1 torch.load(vgg16_method1.pth)
# model1# 方式2
model2 torch.load(vgg16_method2.pth)
# model2 # 参数结构# 将方式2 恢复成模型结构
vgg16 torchvision.models.vgg16(weightsNone)
vgg16.load_state_dict(torch.load(vgg16_method2.pth))print(vgg16)输出结果
VGG((features): Sequential((0): Conv2d(3, 64, kernel_size(3, 3), stride(1, 1), padding(1, 1))(1): ReLU(inplaceTrue)(2): Conv2d(64, 64, kernel_size(3, 3), stride(1, 1), padding(1, 1))(3): ReLU(inplaceTrue)(4): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse)(5): Conv2d(64, 128, kernel_size(3, 3), stride(1, 1), padding(1, 1))(6): ReLU(inplaceTrue)(7): Conv2d(128, 128, kernel_size(3, 3), stride(1, 1), padding(1, 1))(8): ReLU(inplaceTrue)(9): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse)(10): Conv2d(128, 256, kernel_size(3, 3), stride(1, 1), padding(1, 1))(11): ReLU(inplaceTrue)(12): Conv2d(256, 256, kernel_size(3, 3), stride(1, 1), padding(1, 1))(13): ReLU(inplaceTrue)(14): Conv2d(256, 256, kernel_size(3, 3), stride(1, 1), padding(1, 1))(15): ReLU(inplaceTrue)(16): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse)(17): Conv2d(256, 512, kernel_size(3, 3), stride(1, 1), padding(1, 1))(18): ReLU(inplaceTrue)(19): Conv2d(512, 512, kernel_size(3, 3), stride(1, 1), padding(1, 1))(20): ReLU(inplaceTrue)(21): Conv2d(512, 512, kernel_size(3, 3), stride(1, 1), padding(1, 1))(22): ReLU(inplaceTrue)(23): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse)(24): Conv2d(512, 512, kernel_size(3, 3), stride(1, 1), padding(1, 1))(25): ReLU(inplaceTrue)(26): Conv2d(512, 512, kernel_size(3, 3), stride(1, 1), padding(1, 1))(27): ReLU(inplaceTrue)(28): Conv2d(512, 512, kernel_size(3, 3), stride(1, 1), padding(1, 1))(29): ReLU(inplaceTrue)(30): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse))(avgpool): AdaptiveAvgPool2d(output_size(7, 7))(classifier): Sequential((0): Linear(in_features25088, out_features4096, biasTrue)(1): ReLU(inplaceTrue)(2): Dropout(p0.5, inplaceFalse)(3): Linear(in_features4096, out_features4096, biasTrue)(4): ReLU(inplaceTrue)(5): Dropout(p0.5, inplaceFalse)(6): Linear(in_features4096, out_features1000, biasTrue))
)完整代码获取方式
点赞、收藏、加关注 加我vxls888726
