完整模型训练套路

最新推荐文章于 2024-11-06 10:55:54 发布
最新推荐文章于 2024-11-06 10:55:54 发布
阅读量37 收藏
点赞数
文章标签： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48687044/article/details/134641560
版权
  1. CIFAR 10 model 网络模型
    ① 下面用 CIFAR 10 model网络来完成分类问题，网络模型如下图所示。

在这里插入图片描述
2. dataLoader加载数据

import torchvision
from torch import nn
from torch.utils.data import DataLoader

# 准备数据集
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)       
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)       

# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# 如果train_data_size=10，则打印：训练数据集的长度为：10
print("训练数据集的长度：{}".format(train_data_size))
print("测试数据集的长度：{}".format(test_data_size))

# 利用 Dataloader 来加载数据集
train_dataloader = DataLoader(train_data_size, batch_size=64)        
test_dataloader = DataLoader(test_data_size, batch_size=64)
  1. 测试网络
import torch
from torch import nn

# 搭建神经网络
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()        
        self.model1 = nn.Sequential(
            nn.Conv2d(3,32,5,1,2),  # 输入通道3，输出通道32，卷积核尺寸5×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(),  # 展平后变成 64*4*4 了
            nn.Linear(64*4*4,64),
            nn.Linear(64,10)
        )
        
    def forward(self, x):
        x = self.model1(x)
        return x
    
if __name__ == '__main__':
    tudui = Tudui()
    input = torch.ones((64,3,32,32))
    output = tudui(input)
    print(output.shape)  # 测试输出的尺寸是不是我们想要的
  1. 网络训练数据
import torchvision
from torch import nn
from torch.utils.data import DataLoader

# from model import * 相当于把 model中的所有内容写到这里，这里直接把 model 写在这里
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()        
        self.model1 = nn.Sequential(
            nn.Conv2d(3,32,5,1,2),  # 输入通道3，输出通道32，卷积核尺寸5×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(),  # 展平后变成 64*4*4 了
            nn.Linear(64*4*4,64),
            nn.Linear(64,10)
        )
        
    def forward(self, x):
        x = self.model1(x)
        return x

# 准备数据集
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)       
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)       

# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# 如果train_data_size=10，则打印：训练数据集的长度为：10
print("训练数据集的长度：{}".format(train_data_size))
print("测试数据集的长度：{}".format(test_data_size))

# 利用 Dataloader 来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)        
test_dataloader = DataLoader(test_data, batch_size=64)

# 创建网络模型
tudui = Tudui() 

# 损失函数
loss_fn = nn.CrossEntropyLoss() # 交叉熵，fn 是 fuction 的缩写

# 优化器
learning = 0.01  # 1e-2 就是 0.01 的意思
optimizer = torch.optim.SGD(tudui.parameters(),learning)   # 随机梯度下降优化器  

# 设置网络的一些参数
# 记录训练的次数
total_train_step = 0

# 训练的轮次
epoch = 10

for i in range(epoch):
    print("-----第 {} 轮训练开始-----".format(i+1))
    
    # 训练步骤开始
    for data in train_dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets) # 计算实际输出与目标输出的差距
        
        # 优化器对模型调优
        optimizer.zero_grad()  # 梯度清零
        loss.backward() # 反向传播，计算损失函数的梯度
        optimizer.step()   # 根据梯度，对网络的参数进行调优
        
        total_train_step = total_train_step + 1
        #print("训练次数：{}，Loss：{}".format(total_train_step,loss))  # 方式一：获得loss值
        print("训练次数：{}，Loss：{}".format(total_train_step,loss.item()))  # 方式二：获得loss值
  1. item 的作用
import torch
a = torch.tensor(5)
print(a)
print(a.item())
  1. 查看训练损失
    ① 在pytorch中，tensor有一个requires_grad参数，如果设置为True，则反向传播时，该tensor就会自动求导。

② tensor的requires_grad的属性默认为False，若一个节点（叶子变量：自己创建的tensor）requires_grad被设置为True，那么所有依赖它的节点requires_grad都为True（即使其他相依赖的tensor的requires_grad = False）

③ 当requires_grad设置为False时，反向传播时就不会自动求导了，因此大大节约了显存或者说内存。

④ with torch.no_grad的作用在该模块下，所有计算得出的tensor的requires_grad都自动设置为False。

⑤ 即使一个tensor（命名为x）的requires_grad = True，在with torch.no_grad计算，由x得到的新tensor（命名为w-标量）requires_grad也为False，且grad_fn也为None,即不会对w求导。

⑥ torch.no_grad()：停止计算梯度，不能进行反向传播。

import torchvision
import torch
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# from model import * 相当于把 model中的所有内容写到这里，这里直接把 model 写在这里
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()        
        self.model1 = nn.Sequential(
            nn.Conv2d(3,32,5,1,2),  # 输入通道3，输出通道32，卷积核尺寸5×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(),  # 展平后变成 64*4*4 了
            nn.Linear(64*4*4,64),
            nn.Linear(64,10)
        )
        
    def forward(self, x):
        x = self.model1(x)
        return x

# 准备数据集
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)       
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)       

# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# 如果train_data_size=10，则打印：训练数据集的长度为：10
print("训练数据集的长度：{}".format(train_data_size))
print("测试数据集的长度：{}".format(test_data_size))

# 利用 Dataloader 来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)        
test_dataloader = DataLoader(test_data, batch_size=64)

# 创建网络模型
tudui = Tudui() 

# 损失函数
loss_fn = nn.CrossEntropyLoss() # 交叉熵，fn 是 fuction 的缩写

# 优化器
learning = 0.01  # 1e-2 就是 0.01 的意思
optimizer = torch.optim.SGD(tudui.parameters(),learning)   # 随机梯度下降优化器  

# 设置网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0

# 训练的轮次
epoch = 10

# 添加 tensorboard
writer = SummaryWriter("logs")

for i in range(epoch):
    print("-----第 {} 轮训练开始-----".format(i+1))
    
    # 训练步骤开始
    for data in train_dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets) # 计算实际输出与目标输出的差距
        
        # 优化器对模型调优
        optimizer.zero_grad()  # 梯度清零
        loss.backward() # 反向传播，计算损失函数的梯度
        optimizer.step()   # 根据梯度，对网络的参数进行调优
        
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step,loss.item()))  # 方式二：获得loss值
            writer.add_scalar("train_loss",loss.item(),total_train_step)
    
    # 测试步骤开始（每一轮训练后都查看在测试数据集上的loss情况）
    total_test_loss = 0
    with torch.no_grad():  # 没有梯度计算，节约内存
        for data in test_dataloader: # 测试数据集提取数据
            imgs, targets = data
            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets) # 仅data数据在网络模型上的损失
            total_test_loss = total_test_loss + loss.item() # 所有loss
    print("整体测试集上的Loss：{}".format(total_test_loss))
    writer.add_scalar("test_loss",total_test_loss,total_test_step)
    total_test_step = total_test_step + 1
        
writer.close()
@天翼:-O
关注
12. 完整模型训练套路
qq_54932411的博客
08-27 5万+
对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。② tensor的requires_grad的属性默认为False，若一个节点（叶子变量：自己创建的tensor）requires_grad被设置为True，那么所有依赖它的节点requires_grad都为True（即使其他相依赖的tensor的requires_grad = False）在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。
网络模型训练完整套路
悠眠小虫的博客
01-15 1241
本文是使用神经网络进行模型训练的一套完整流程，各个模块通俗易懂，十分适于深度学习小白前期对于模型训练过程的理解，有助于更快地掌握训练流程及相关方法。
神经网络完整模型训练套路
深浅卡布星的博客
10-19 2118
pytorch
基于CIFAR10的完整模型训练套路
m0_51311105的博客
02-21 2277
首先准备数据集： train_data = torchvision.datasets.CIFAR10('./dataset', train=True, transform=torchvision.transforms.ToTensor(), download=True)#训练数据集 test_data = torchvision.datasets.CIFAR10('./dataset', train=False, transform=torchvision.transforms.ToTensor(),
完整的模型训练套路
2301_79718375的博客
05-14 318
其对一些网络层对有作用，比如Dropout层、BatchNorm层，这时就需要调用，将模型调为训练和测试模式，但不输入这两个代码，我们的模型仍可进行训练和测试。因为我们的模型中并不存在这两个类型的网络层，所以不调用也可以正常运行。在训练和测试步骤开始时，需要分别使用。搭建神经网络，作为一个模块。在官方文档中有详细说明。
pytorch完整模型训练套路
weixin_46351593的博客
05-23 1920
CIFAR-10数据集包含60000张32x32彩色图像，分为10个类，每类6000张。有50000张训练图片和10000张测试图片。数据集分为五个训练batches和一个测试batch，每个batch有10000张图像。测试batch包含从每个类中随机选择的1000个图像。训练batches以随机顺序包含剩余的图像，但有些训练batches可能包含一个类的图像多于另一个类的图像。在它们之间，训练batches包含来自每个类的5000张图像。
完整的模型训练套路（pytorch）
ggj0727的博客
08-06 6174
（联邦学习笔记，资料来源于b站小土堆） 训练模板 1、准备数据集 2、获取数据集长度，可以用来辅助计算精确度 3、加载数据集（DataLoader） 4、搭建网络模型（一般单独一个python文件） 5、创建网络模型（实例化） 6、定义损失函数、优化器 7、设置训练网络的一些参数（如训练次数、轮数等等） 8、模型训练 具体代码实现如下（简单示例）： 1、准备数据集 train_data = torchvision.datasets.CIFAR10("../data",train=
Pytorch教程[10]完整模型训练套路
YOLOv8项目贡献者
03-23 3544
手把手教你从0开始训练神经网络
pytorch深度学习基础快速入门7：完整模型训练套路
qq_55655082的博客
06-27 1088
因此在训练文件中要引入model（model和train文件一定要在一个文件夹下） -----------------测试数据集评估（不需要调优） 加限制条件（避免无用信息） 优化：tensorboard进行画图 输出1,1（横着看） 计算对应位置正确的个数： 57： 74： 网络层中是否有特殊层 顺序： 6.具体实例 网络模型 加载网络模型 预测最大结果：...
完整模型训练套路 试写 以CIFAR10分类数据集为例
08-02
包含GPU 训练测试 ...这个例子提供了一个完整的模型训练流程,包括数据处理、模型定义、训练、评估和可视化。你可以根据具体需求进行修改和扩展,比如添加学习率调度、早停等技术来进一步优化训练过程。
Pytorch深度学习-----完整神经网络模型训练套路
LGL
08-12 1236
定义适当的损失函数来计算模型预测结果于真实标签之间的差异。选择适当的优化器算法来更新模型参数，如随机梯度下降（SGD）、Adam等。使用torchvision库加载CIFAR10数据集。将训练集和测试集分别存放在train_data和test_data中。引用model.py文件，在其中创建名为"Lgl"的模型。定义损失函数为交叉熵损失（nn.CrossEntropyLoss）。定义优化器为随机梯度下降（SGD）优化器，并将模型参数传递给优化器。
机器学习—矩阵乘法
最新发布
yn3535_的博客
11-06 371
让我们来看看向量矩阵乘法，也就是当你把一个向量乘以一个矩阵，又得到一个向量，列向量a转置后得到行向量a，所以与其把这看作是一个2×1的矩阵，转置后就变成了1×2的矩阵，现在用这四个元素创建一个2×2的矩阵w，如果你想计算Z，Z=a转置W，结果z是一个2×1的矩阵，计算z的第一个值，我们要做一个a转置乘w1，所以要计算z的第一个元素，最终得到(1*3)+(2*4),然后计算第二个元素，现在将转置乘w2，，所以计算第二个元素，最终得到(1*5)+(2*6)。如何在向量之间取点积？
【机器学习】18. 反向传播 Backpropagation algorithm, 学习率，动量Momenetum, Xavier，梯度消失
weixin_48846514的博客
11-01 1085
反向传播 Backpropagation algorithm, 学习率，动量Momenetum, Xavier，梯度消失
机器学习—推理:做出预测(前向传播)
yn3535_的博客
11-01 326
这是一对零的可能性有多大，所以让我们逐步通过计算的序列，神经网络将需要从输入X这个8乘8或64个数字到预测概率a3，第一个计算是从X到1，这就是第一层或第一层隐藏层的作用，它对上标方括号进行计算，25代表这个隐层有25个单元，所以参数从W1到W25以及b1到b25，但也可以在这里写一个，因为按照惯例，零层的激活，即。最后一步是计算三，我们使用一个非常相似的计算来做到这一点，只是现在是第三层，输出层只有一个单元，所以这里只有一个输出所以3只是一个标量，你可以选择下标1，把它设为0.5得出一个二进制分类标签。
机器学习—构建一个神经网络
yn3535_的博客
11-02 449
然后把第一层的激活传递到第二层，相反，我们可以告诉Tensorflow我们喜欢它，把第一层和第二层串在一起形成一个神经网络，这就是张量流中的序列函数所做的，上边写着，亲爱的张量流，请为我创建一个神经网络通过顺序串在一起，我刚刚创建的这两层，事实证明，有了顺序框架，TensorFlow可以为你做很多工作。事实证明，TensorFlow是实现前向支柱的不同方式，在学习的同时，展示一种在Tensorflow中构建神经网络的不同方法，和之前一样你要创建第一层和第二层，但现在。
【机器学习】回归树
2303_80346267的博客
11-02 844
回归树是一种用于数值型目标变量的监督学习算法，通过将特征空间划分为多个区域，并在每个区域内使用简单的预测模型（如区域均值）来进行回归。回归树以“递归划分-计算区域均值”的方式逐层生成树节点，最终形成叶节点预测值。相比于线性回归，回归树更适合处理非线性和复杂数据结构。
【机器学习】决策树
2303_80346267的博客
11-02 1100
决策树是一种用于分类和回归任务的监督学习算法，它以树形结构递归地将数据分割成不同区域，使得最终的预测值尽可能纯净（即减少分类问题中的混杂度，或回归问题中的误差）。决策树算法简单直观、易于理解、解释性强，广泛应用于各类场景。本教程将详细介绍决策树的原理，重点解析构建决策树过程中的关键概念及其实现。
用pytorch搭建完整的神经网络的套路
03-21
首先，需要定义网络的结构，包括输入层、隐藏层和输出层的神经元数量，以及每层的激活函数。然后，需要定义损失函数和优化器，以便在训练过程中计算损失并更新模型参数。...这是用pytorch搭建完整的神经网络的套路。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值