《深度学习》——调整学习率和保存使用最优模型

news2025/3/29 19:50:51

调整学习率

在使用 PyTorch 进行深度学习训练时，调整学习率是一个重要的技巧，合适的学习率调整策略可以帮助模型更好地收敛。
PyTorch 提供了多种调整学习率的方法，下面将详细介绍几种常见的学习率调整策略及实例代码：

  • torch.optim.lr_scheduler.StepLR（固定步长学习率调度器）
    StepLR 是一种简单的学习率调整策略，它会每隔一定的训练步数（epoch）将学习率乘以一个固定的衰减因子。

    import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR

# 定义一个简单的模型
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 定义 StepLR 调度器，每 3 个 epoch 将学习率乘以 0.1
scheduler = StepLR(optimizer, step_size=3, gamma=0.1)

# 模拟训练过程
for epoch in range(10):
    # 训练代码...
    print(f'Epoch {epoch}: Learning rate = {optimizer.param_groups[0]["lr"]}')
    optimizer.step()
    scheduler.step()

在这里插入图片描述

  • torch.optim.lr_scheduler.MultiStepLR（多步学习率调度器）
    MultiStepLR 允许你在指定的训练步数（epoch）处将学习率乘以一个固定的衰减因子。
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import MultiStepLR

model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 定义 MultiStepLR 调度器，在 epoch 为 3 和 7 时将学习率乘以 0.1
milestones = [3, 7]
scheduler = MultiStepLR(optimizer, milestones=milestones, gamma=0.1)

# 模拟训练过程
for epoch in range(10):
    # 训练代码...
    print(f'Epoch {epoch}: Learning rate = {optimizer.param_groups[0]["lr"]}')
    optimizer.step()
    scheduler.step()

在这里插入图片描述

  • torch.optim.lr_scheduler.ExponentialLR（指数学习率调度器）
    ExponentialLR 会在每个训练步数（epoch）将学习率乘以一个固定的衰减因子。
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import ExponentialLR

model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 定义 ExponentialLR 调度器，每个 epoch 将学习率乘以 0.9
scheduler = ExponentialLR(optimizer, gamma=0.9)

# 模拟训练过程
for epoch in range(10):
    # 训练代码...
    print(f'Epoch {epoch}: Learning rate = {optimizer.param_groups[0]["lr"]}')
    optimizer.step()
    scheduler.step()

在这里插入图片描述

  • torch.optim.lr_scheduler.ReduceLROnPlateau（自适应学习率调度器）
    ReduceLROnPlateau 会根据验证集上的指标（如损失值）来动态调整学习率。当指标在一定的训练步数内没有改善时，它会将学习率乘以一个固定的衰减因子。
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import ReduceLROnPlateau

model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 定义 ReduceLROnPlateau 调度器，当验证损失在 2 个 epoch 内没有改善时，将学习率乘以 0.1
scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=2)

# 模拟训练过程
for epoch in range(10):
    # 训练代码...
    # 假设这是验证集上的损失
    val_loss = torch.rand(1).item()
    print(f'Epoch {epoch}: Learning rate = {optimizer.param_groups[0]["lr"]}')
    optimizer.step()
    scheduler.step(val_loss)

在这里插入图片描述

保存最优模型

在深度学习训练过程中，保存最优模型是一个常见的需求，这样可以在训练结束后使用表现最好的模型进行预测或评估。通常，我们会根据验证集上的某个指标（如准确率、损失值等）来判断模型是否为最优。

  • 保存模型的状态字典（state_dict）到文件 best.pth 中。
  • 保存整个模型对象到文件 best1.pt 中。
if correct > best_acc:
    # 如果当前正确预测的样本数量大于之前记录的最优值
    best_acc = correct
    # 更新最优准确率记录为当前的正确样本数量
    
    print(model.state_dict().keys())
    # 打印模型状态字典中的所有键，这些键代表了模型中可学习参数的名称，
    # 例如各个层的权重（weight）和偏置（bias）等
    
    torch.save(model.state_dict(), 'best.pth')
    # 将模型的状态字典保存到名为 'best.pth' 的文件中。
    # 状态字典包含了模型中所有可学习参数的值，这种保存方式只保存参数，不保存模型结构，
    # 后续加载时需要先定义相同结构的模型，再加载参数
    
    torch.save(model, 'best1.pt')
    # 将整个模型对象保存到名为 'best1.pt' 的文件中。
    # 这种保存方式不仅保存了模型的参数，还保存了模型的结构信息，
    # 后续加载时可以直接加载整个模型对象

注意

    1. 保存状态字典与保存整个模型的区别
    • 保存状态字典（torch.save(model.state_dict(), ‘best.pth’)）：
      • 优点：文件体积相对较小，适合在不同环境下共享模型参数，因为只需要模型结构定义代码一致，就可以加载参数。
      • 缺点：需要手动定义模型结构，再加载参数。如果模型结构发生变化，可能会导致加载失败。
    • 保存整个模型（torch.save(model, ‘best1.pt’)）：
      • 优点：加载方便，直接加载整个模型对象，不需要重新定义模型结构。
      • 缺点：文件体积较大，并且依赖于保存时的 Python 环境和 PyTorch 版本，在不同环境下加载可能会出现兼容性问题。
    1. 准确率指标的选择
      代码中使用 correct（正确预测的样本数量）作为判断模型优劣的指标，在实际应用中，更常见的做法是使用准确率（correct / total），因为 correct 的数值会受到验证集样本数量的影响，而准确率是一个相对稳定的指标。
    1. 文件路径管理
      代码中直接使用相对路径保存模型文件，在实际项目中，建议使用绝对路径或者更规范的文件路径管理方式，避免文件保存位置混乱。

使用最优模型

  • 使用best.pth 中的状态字典（state_dict） 。
  • 使用best1.pt 中的模型对象 。
# 尝试从 'best.pth' 文件中加载模型的状态字典（state_dict），
# 状态字典包含了模型中所有可学习参数（如权重、偏置）的值，
# 但不包含模型的结构信息。所以在使用此方式加载前，
# 必须先定义好与保存时结构一致的模型实例。
# torch.load('best.pth') 用于从文件中读取状态字典数据，
# model.load_state_dict() 方法将读取到的状态字典数据赋值给当前的 model 实例。
model.load_state_dict(torch.load('best.pth'))

# 这行代码会直接从 'best.pt' 文件中加载整个模型对象，
# 该文件保存时使用了 torch.save(model, 'best.pt') 方式，
# 这种保存方式不仅保存了模型的参数，还保存了模型的结构信息。
# 加载后，model 变量将指向一个完整的、可直接使用的模型对象。
# 不过需要注意的是，如果之前使用的 Python 环境、PyTorch 版本不同，
# 或者模型定义代码发生了变化，可能会导致加载失败或出现兼容性问题。
# 并且这行代码与上一行 'model.load_state_dict(...)' 存在冲突，
# 因为这里会覆盖掉上一行代码对 model 实例参数的加载结果，
# 通常在实际使用中只会选择其中一种加载方式。
model = torch.load('best.pt')

# 将模型设置为评估模式。在评估模式下，
# 一些在训练时起作用的特殊层（如 Dropout、BatchNorm 等）
# 会改变其行为。例如，Dropout 层在训练时会随机丢弃部分神经元以防止过拟合，
# 但在评估时会正常使用所有神经元；BatchNorm 层在训练时会根据当前批次的数据
# 计算均值和方差，而在评估时会使用训练过程中统计的全局均值和方差。
# 因此，在进行模型推理、验证或测试时，需要将模型设置为评估模式，
# 以确保得到准确的结果。
model.eval()

实例

数据集：照片文件：在这里插入图片描述
在这里插入图片描述

test.txt:
在这里插入图片描述

train.txt:
在这里插入图片描述

test_true.txt:
在这里插入图片描述

保存最优模型

对食物分类中food dataset2目录下的test、train中的照片进行卷积神经训练，进行食物分类并保存最优模型，并调整学习率。
代码：

import os
from PIL import Image

# 定义函数用于生成训练集和测试集的文件列表及对应的标签
def train_test_file(root, dir):
    # 打开一个以dir命名的txt文件，用于写入图像路径和标签
    file_txt = open(dir + '.txt', 'w')
    # 拼接完整的路径
    path = os.path.join(root, dir)
    # 遍历指定路径下的所有文件和文件夹
    for roots, directories, files in os.walk(path):  # os.list_dir()
        # 如果存在子文件夹，将子文件夹名称存储在dirs列表中
        if len(directories) != 0:
            dirs = directories
        else:
            # 获取当前文件夹的名称
            now_dir = roots.split('\\')
            # 遍历当前文件夹下的所有文件
            for file in files:
                # 拼接图像文件的完整路径
                path_1 = os.path.join(roots, file)
                print(path_1)
                # 将图像路径和对应的标签写入txt文件，标签为当前文件夹在dirs列表中的索引
                file_txt.write(path_1 + ' ' + str(dirs.index(now_dir[-1])) + '\n')
    # 关闭文件
    file_txt.close()

# 数据集根目录
root = r'.\食物分类\food_dataset'
# 训练集文件夹名称
train_dir = 'train'
# 测试集文件夹名称
test_dir = 'test'
# 生成训练集的文件列表及标签
train_test_file(root, train_dir)
# 生成测试集的文件列表及标签
train_test_file(root, test_dir)

# 自定义类，用于演示__getitem__和__len__方法
class USE_getitem():
    def __init__(self, text):
        # 初始化传入的文本
        self.text = text

    def __getitem__(self, index):
        # 获取指定索引位置的字符并转换为大写
        result = self.text[index].upper()
        return result

    def __len__(self):
        # 返回文本的长度
        return len(self.text)

# 创建USE_getitem类的实例
p = USE_getitem('pytorch')
# 打印索引为0和1的字符
print(p[0], p[1])
# 调用__len__方法获取文本长度
len(p)

import torch
from torch.utils.data import Dataset, DataLoader
import numpy as np
from torchvision import transforms
from torch import nn

# 定义训练集和验证集的数据预处理转换
data_transforms = {
    'train':
        transforms.Compose([
            # 将图像大小调整为300x300
            transforms.Resize([300, 300]),
            # 随机旋转图像，旋转角度范围为-45到45度
            transforms.RandomRotation(45),
            # 从图像中心裁剪出256x256的区域
            transforms.CenterCrop(256),
            # 以0.5的概率随机水平翻转图像
            transforms.RandomHorizontalFlip(p=0.5),
            # 以0.5的概率随机垂直翻转图像
            transforms.RandomVerticalFlip(p=0.5),
            # 随机调整图像的亮度、对比度、饱和度和色相
            transforms.ColorJitter(brightness=0.2, contrast=0.1, saturation=0.1, hue=0.1),
            # 以0.1的概率将图像转换为灰度图
            transforms.RandomGrayscale(p=0.1),
            # 将图像转换为Tensor
            transforms.ToTensor(),
            # 对图像进行归一化处理
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
    'valid':
        transforms.Compose([
            # 将图像大小调整为256x256
            transforms.Resize([256, 256]),
            # 将图像转换为Tensor
            transforms.ToTensor(),
            # 对图像进行归一化处理
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])
}

# 自定义数据集类，继承自torch.utils.data.Dataset
class food_dataset(Dataset):
    def __init__(self, file_path, transform=None):
        # 初始化文件路径
        self.file_path = file_path
        # 用于存储图像路径的列表
        self.imgs = []
        # 用于存储图像标签的列表
        self.labels = []
        # 初始化数据预处理转换
        self.transform = transform
        # 打开文件并读取每一行
        with open(self.file_path) as f:
            # 将每一行按空格分割成图像路径和标签
            samples = [x.strip().split(' ') for x in f.readlines()]
            for img_path, label in samples:
                # 将图像路径添加到imgs列表中
                self.imgs.append(img_path)  # 图像路径
                # 将标签添加到labels列表中
                self.labels.append(label)  # 标签

    def __len__(self):
        # 返回图像的数量
        return len(self.imgs)

    def __getitem__(self, idx):
        # 打开指定索引位置的图像
        image = Image.open(self.imgs[idx])
        # 如果存在数据预处理转换，对图像进行转换
        if self.transform:
            image = self.transform(image)
        # 获取指定索引位置的标签
        label = self.labels[idx]
        # 将标签转换为torch.Tensor类型
        label = torch.from_numpy(np.array(label, dtype=np.int64))
        return image, label

# 创建训练集数据集对象
training_data = food_dataset(file_path='./train.txt', transform=data_transforms['train'])
# 创建测试集数据集对象
test_data = food_dataset(file_path='./test.txt', transform=data_transforms['valid'])

# 创建训练集数据加载器，批量大小为64，数据打乱
train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)
# 创建测试集数据加载器，批量大小为64，数据打乱
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

# 判断是否支持GPU或MPS，如果支持则使用，否则使用CPU
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f'Using {device} device')

# 定义卷积神经网络类，继承自torch.nn.Module
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一个卷积块
        self.conv_block1 = nn.Sequential(
            # 输入通道数为3，输出通道数为32，卷积核大小为3，填充为1
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            # 批量归一化
            nn.BatchNorm2d(32),
            # ReLU激活函数
            nn.ReLU(inplace=True),
            # 最大池化层，池化核大小为2
            nn.MaxPool2d(2)
        )
        # 第二个卷积块
        self.conv_block2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        # 第三个卷积块
        self.conv_block3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        # 第四个卷积块
        self.conv_block4 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        # 第五个卷积块
        self.conv_block5 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )

        # 计算经过卷积和池化后特征图的尺寸
        # 每次池化操作将尺寸缩小一半，经过5次池化，256 / 2^5 = 8
        self.fc1 = nn.Linear(512 * 8 * 8, 2048)
        self.relu = nn.ReLU(inplace=True)
        # 随机丢弃50%的神经元，防止过拟合
        self.dropout = nn.Dropout(0.5)
        # 输出层，输出20个类别
        self.fc2 = nn.Linear(2048, 20)

    def forward(self, x):
        # 前向传播，依次通过各个卷积块
        x = self.conv_block1(x)
        x = self.conv_block2(x)
        x = self.conv_block3(x)
        x = self.conv_block4(x)
        x = self.conv_block5(x)

        # 将多维的特征图展平为一维向量
        x = x.view(-1, 512 * 8 * 8)

        # 通过第一个全连接层
        x = self.fc1(x)
        x = self.relu(x)
        x = self.dropout(x)
        # 通过输出层
        output = self.fc2(x)
        return output

# 创建CNN模型实例并将其移动到指定设备上
model = CNN().to(device)

# 定义训练函数
def train(dataloader, model, loss_fn, optimizer):
    # 将模型设置为训练模式
    model.train()  
    # 记录当前批次的编号
    batch_size_num = 1
    # 遍历数据加载器中的每个批次
    for x, y in dataloader:  # 其中batch为每一个数据的编号
        # 将训练数据和标签移动到指定设备上
        x, y = x.to(device), y.to(device)  
        # 前向传播，计算模型的预测结果
        pred = model.forward(x)  
        # 通过交叉熵损失函数计算损失值
        loss = loss_fn(pred, y)  
        # 梯度值清零
        optimizer.zero_grad()  
        # 反向传播计算每一个参数的梯度值
        loss.backward()  
        # 根据梯度更新网络参数
        optimizer.step()  

        # 从tensor数据中提取损失值
        loss_value = loss.item()  
        # 每10个批次打印一次损失值
        if batch_size_num % 10 == 0:
            print(f'loss:{loss_value:7f}  [number:{batch_size_num}]')
        # 批次编号加1
        batch_size_num += 1

# 记录最佳准确率
best_acc = 0

# 定义测试函数
def test(dataloader, model, loss_fn):
    global best_acc
    # 数据集的总样本数
    size = len(dataloader.dataset)  
    # 数据加载器中的批次数量
    num_batches = len(dataloader)  
    # 将模型设置为评估模式
    model.eval()  
    # 初始化测试损失和正确预测的样本数
    test_loss, correct = 0, 0
    # 关闭梯度计算
    with torch.no_grad():  
        for x, y in dataloader:
            # 将测试数据和标签移动到指定设备上
            x, y = x.to(device), y.to(device)
            # 前向传播，计算模型的预测结果
            pred = model.forward(x)
            # 累加每个批次的损失值
            test_loss += loss_fn(pred, y).item()  
            # 计算正确预测的样本数
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            a = (pred.argmax(1) == y)  # dim=1表示每一行中的最大值对应的索引号，dim=0表示每一列中的最大值对应的索引号
            b = (pred.argmax(1) == y).type(torch.float)
    # 计算平均测试损失
    test_loss /= num_batches  
    # 计算平均准确率
    correct /= size  
    # 如果当前准确率高于最佳准确率，更新最佳准确率并保存模型
    if correct > best_acc:
        best_acc = correct
        print(model.state_dict().keys())
        # 保存模型的参数
        torch.save(model.state_dict(), 'best.pth')
        # 保存整个模型
        torch.save(model, 'best1.pt')
    print(f'Test result: \n Accuracy:{(100 * correct)}%,Avg loss:{test_loss}')

# 创建交叉熵损失函数对象
loss_fn = nn.CrossEntropyLoss()  
# 创建Adam优化器，用于更新模型参数
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  

# 训练的轮数
epochs = 150
# 循环训练多个轮次
for t in range(epochs):
    print(f'epoch{t + 1}\n--------------------')
    # 训练模型
    train(train_dataloader, model, loss_fn, optimizer)
    # 测试模型
    test(test_dataloader, model, loss_fn)
print('Done!')

在这里插入图片描述
保存模型： 在这里插入图片描述

使用最优模型

对数据中的测试数据进行测试训练，路径文件为test_true.txt。

from PIL import Image
import torch
from torch.utils.data import Dataset, DataLoader
import numpy as np
from torchvision import transforms
from torch import nn

# 定义数据预处理转换，这里只定义了验证集的转换
data_transforms = {
    'valid':
        transforms.Compose([
            # 将图像调整为 256x256 的大小
            transforms.Resize([256, 256]),
            # 将图像转换为 PyTorch 的张量
            transforms.ToTensor(),
            # 对图像进行归一化处理，使用 ImageNet 的均值和标准差
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])
}

# 自定义食物数据集类，继承自 torch.utils.data.Dataset
class food_dataset(Dataset):
    def __init__(self, file_path, transform=None):
        # 保存数据集文件路径
        self.file_path = file_path
        # 用于存储图像路径的列表
        self.imgs = []
        # 用于存储图像标签的列表
        self.labels = []
        # 保存数据预处理转换
        self.transform = transform
        # 打开数据集文件
        with open(self.file_path) as f:
            # 读取文件的每一行，并按空格分割成图像路径和标签
            samples = [x.strip().split(' ') for x in f.readlines()]
            for img_path, label in samples:
                # 将图像路径添加到 imgs 列表中
                self.imgs.append(img_path)
                # 将标签添加到 labels 列表中
                self.labels.append(label)

    def __len__(self):
        # 返回数据集的长度，即图像的数量
        return len(self.imgs)

    def __getitem__(self, idx):
        # 打开指定索引的图像
        image = Image.open(self.imgs[idx])
        # 如果存在数据预处理转换，则对图像进行转换
        if self.transform:
            image = self.transform(image)
        # 获取指定索引的标签
        label = self.labels[idx]
        # 将标签转换为 PyTorch 的张量
        label = torch.from_numpy(np.array(label, dtype=np.int64))
        # 返回图像和标签
        return image, label

# 判断是否支持 GPU 或 MPS，如果支持则使用，否则使用 CPU
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f'Using {device} device')

# 定义卷积神经网络类，继承自 torch.nn.Module
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一个卷积块
        self.conv_block1 = nn.Sequential(
            # 输入通道数为 3，输出通道数为 32，卷积核大小为 3，填充为 1
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            # 批量归一化层
            nn.BatchNorm2d(32),
            # ReLU 激活函数
            nn.ReLU(inplace=True),
            # 最大池化层，池化核大小为 2
            nn.MaxPool2d(2)
        )
        # 第二个卷积块
        self.conv_block2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        # 第三个卷积块
        self.conv_block3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        # 第四个卷积块
        self.conv_block4 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        # 第五个卷积块
        self.conv_block5 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        # 全连接层的输入维度，经过 5 次池化后，特征图大小为 8x8，通道数为 512
        self.fc1 = nn.Linear(512 * 8 * 8, 2048)
        # ReLU 激活函数
        self.relu = nn.ReLU(inplace=True)
        # Dropout 层，防止过拟合
        self.dropout = nn.Dropout(0.5)
        # 输出层，输出 20 个类别
        self.fc2 = nn.Linear(2048, 20)

    def forward(self, x):
        # 依次通过各个卷积块
        x = self.conv_block1(x)
        x = self.conv_block2(x)
        x = self.conv_block3(x)
        x = self.conv_block4(x)
        x = self.conv_block5(x)
        # 将多维的特征图展平为一维向量
        x = x.view(-1, 512 * 8 * 8)
        # 通过第一个全连接层
        x = self.fc1(x)
        # 通过 ReLU 激活函数
        x = self.relu(x)
        # 通过 Dropout 层
        x = self.dropout(x)
        # 通过输出层
        output = self.fc2(x)
        return output

# 创建 CNN 模型实例，并将其移动到指定设备上
model = CNN().to(device)

# 加载之前保存的模型参数
model.load_state_dict(torch.load('best.pth'))
# 也可以直接加载整个模型
# model = torch.load('best.pt')
# 将模型设置为评估模式
model.eval()

# 创建测试数据集实例
test_data = food_dataset(file_path='test_true.txt', transform=data_transforms['valid'])
# 创建测试数据加载器，批量大小为 1，数据打乱
test_dataloader = DataLoader(test_data, batch_size=1, shuffle=True)
# 用于存储模型的预测结果
result = []
# 用于存储真实标签
lables = []

# 定义测试函数，用于获取每个样本的预测结果和真实标签
def test_true(dataloader, model):
    # 关闭梯度计算，减少内存消耗
    with torch.no_grad():
        for x, y in dataloader:
            # 将输入数据和标签移动到指定设备上
            x, y = x.to(device), y.to(device)
            # 进行前向传播，得到模型的预测结果
            pred = model.forward(x)
            # 获取预测结果中概率最大的类别索引，并添加到 result 列表中
            result.append(pred.argmax(1).item())
            # 获取真实标签，并添加到 lables 列表中
            lables.append(y.item())

# 调用测试函数
test_true(test_dataloader, model)
# 打印模型的预测结果
print('预测值：\t', result)
# 打印真实标签
print('真实值：\t', lables)

# 定义测试函数，用于计算模型的准确率和平均损失
def test(dataloader, model, loss_fn):
    global best_acc
    # 数据集的总样本数
    size = len(dataloader.dataset)
    # 数据加载器中的批次数量
    num_batches = len(dataloader)
    # 将模型设置为评估模式
    model.eval()
    # 初始化测试损失和正确预测的样本数
    test_loss, correct = 0, 0
    # 关闭梯度计算，减少内存消耗
    with torch.no_grad():
        for x, y in dataloader:
            # 将输入数据和标签移动到指定设备上
            x, y = x.to(device), y.to(device)
            # 进行前向传播，得到模型的预测结果
            pred = model.forward(x)
            # 计算当前批次的损失，并累加到 test_loss 中
            test_loss += loss_fn(pred, y).item()
            # 统计正确预测的样本数
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            a = (pred.argmax(1) == y)  # dim=1 表示每一行中的最大值对应的索引号，dim=0 表示每一列中的最大值对应的索引号
            b = (pred.argmax(1) == y).type(torch.float)
    # 计算平均测试损失
    test_loss /= num_batches
    # 计算准确率
    correct /= size
    # 打印测试结果
    print(f'Test result: \n Accuracy:{(100 * correct)}%,Avg loss:{test_loss}')

# 创建交叉熵损失函数实例
loss_fn = nn.CrossEntropyLoss()
# 创建 Adam 优化器实例
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
# 调用测试函数，计算模型的准确率和平均损失
test(test_dataloader, model, loss_fn)

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2300112.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

零风险把数据盘挂载给根分区，给生产环境服务器扩容

零风险把数据盘挂载给根分区，给生产环境服务器扩容

背景 刚买服务器时，用户量不大，所以结合预算不多情况下，都是默认买个小点的系统盘挂载到服务器上，（或者默认服务器的40G），等到某一天业务量上来之后，发现抓肘见襟给自己一手措不及防…
阅读更多...
在vscode中拉取gitee里的项目并运行

在vscode中拉取gitee里的项目并运行

拉取项目： 方法一：vscode点击查看--->终端(或者直接通过快捷键ctrol+ `打开） 在终端内通过cd命令定位到你想存放项目的文件夹 例如：cd h： 通过命令：git clone 地址 例如：git clone newbee-mall-vue-app: 前端代码 等待拉取完成即可在对应文件夹下看到项目啦 方…
阅读更多...
IDEA通过Contince接入Deepseek

IDEA通过Contince接入Deepseek

Deepseek 的出色表现，上期【Deepseek得两种访问方式与本地部署】 安装Continue插件 第一步、下载插件 在编辑栏【File】->设置【Settiings】或快捷键【CtrlAltS】,弹窗的左侧导航树，选择【plugins】,在marketplace 搜索【Continue】，点…
阅读更多...
数据结构------单向链表。

数据结构------单向链表。

一.实现单向链表的头插，头删，尾插，尾删，按位置插，按位置删，按位置修改，按元素查找，按元素修改，按元素删除，单链表的逆置，查找倒数第几个元素&…
阅读更多...
算法——结合实例了解Minimax算法（极小化极大算法）

算法——结合实例了解Minimax算法（极小化极大算法）

计算机科学中最有趣的事情之一就是编写一个人机博弈的程序。有大量的例子，最出名的是编写一个国际象棋的博弈机器。但不管是什么游戏，程序趋向于遵循一个被称为Minimax算法，伴随着各种各样的子算法在一块。本篇将简要介绍 minimax 算法&#…
阅读更多...
cornerstone3D学习笔记-MPR

cornerstone3D学习笔记-MPR

最近在研究如何利用cornerstone3D (v1.70.13) 来实现MPR功能，找到它的一个demo -- volumeBasic, 运行效果如下图 看了下主程序的示例代码，非常简单，可以说corestone3D这个库把很多细节都封装起来了，使得调用者可以很简单的快速实…
阅读更多...
C++ Primer 函数匹配

C++ Primer 函数匹配

欢迎阅读我的 【CPrimer】专栏 专栏简介：本专栏主要面向C初学者，解释C的一些基本概念和基础语言特性，涉及C标准库的用法，面向对象特性，泛型特性高级用法。通过使用标准库中定义的抽象设施，使你更加适应高级…
阅读更多...
Dav_笔记14：优化程序提示 HINTs -4

Dav_笔记14：优化程序提示 HINTs -4

指定全局表提示 指定表的提示通常是指发生提示的DELETE，SELECT或UPDATE查询块中的表，而不是指语句引用的任何视图中的表。 如果要为显示在视图中的表指定提示，Oracle建议使用全局提示，而不是在视图中嵌入提示。 您可以使用包含具…
阅读更多...
桥接模式 Bridge Pattern

桥接模式 Bridge Pattern

桥接模式Abstraction 和 Implementor 的理解 在图书馆看到一本 通过电商项目真正实战《贯穿设计模式》。拿起来翻到了 桥接模式，感觉味道不对，和我印象中不一样。 感谢这位同学提供的源码 贯穿设计模式-适配器模式桥接模式_-CSDN博客GitHub - WeiXiao…
阅读更多...
Ubuntu 安装 OpenCV (C++)

Ubuntu 安装 OpenCV (C++)

版本详情： Ubuntu: 22.04 5.15.0-133-generic gcc: 11.4.0 g: 11.4.0 OpenCV: 4.7.0 1. 卸载 OpenCV 进入原先编译 opencv 的 build 目录，在该目录下打开终端，执行以下代码（如果 build 已经删除了，可以重新编译一…
阅读更多...
前端模板引擎

前端模板引擎

前言 正常渲染拿到数据后渲染&#xff0c;三步走&#xff1a;格式化数据、编译模板、渲染数据 如下例 <!DOCTYPE html><html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice…
阅读更多...
长尾词SEO优化软件：企业官网流量提升的软件【实测】

长尾词SEO优化软件：企业官网流量提升的软件【实测】

搜索引擎流量中68%来自长尾关键词&#xff08;数据来源&#xff1a;Ahrefs 2025&#xff09;&#xff0c;但83%企业仍困于「高价值长尾词难挖掘内容生产跟不上」的双重困境。当同行用智能工具批量布局「孕妇防辐射服哪个牌子好」等精准词时&#xff0c;手动分析数据的你可能还在…
阅读更多...
用自己的数据训练yolov11目标检测

用自己的数据训练yolov11目标检测

文章目录 概要理论知识整体架构流程架构优化多任务支持多参数体量 操作实操环境配置数据准备数据标注数据放置路径 训练预测 概要 YOLOv11 是 Ultralytics 团队于 2024 年 9 月 30 日发布的最新目标检测模型&#xff0c;延续了 YOLO 系列实时推理特性&#xff0c;同时通过架构优…
阅读更多...
gsoap实现webservice服务

gsoap实现webservice服务

gsoap实现webservice服务 在实现Web服务时&#xff0c;使用gSOAP是一个很好的选择&#xff0c;因为它提供了强大的工具和库来创建SOAP和RESTful服务。gSOAP是一个C和C语言开发的库&#xff0c;它支持SOAP协议的各种版本&#xff0c;包括SOAP 1.1和SOAP 1.2。下面是如何使用gSO…
阅读更多...
项目2 数据可视化--- 第十五章 生成数据

项目2 数据可视化--- 第十五章 生成数据

数据分析是使用代码来探索数据内的规律和关联。 数据可视化是通过可视化表示来 探索和呈现数据集内的规律。 好的数据可视化&#xff0c;可以发现数据集中未知的规律和意义。 一个流行的工具是Matplotlib&#xff0c;他是一个数据绘图库&#xff1b; 还有Plotly包&#xff…
阅读更多...
QT (四）模型/视图 QFileSystemModel，QStringListModel，QStandardItemModel

QT (四）模型/视图 QFileSystemModel，QStringListModel，QStandardItemModel

思考&#xff1a;QTableWidget 在某种程度上可以等价为QStandardItemModel&#xff0c;同理&#xff0c;其他的功能也有类似的等价&#xff0c;但是以当前的QTableWidget 和QStandardItemModel为例的话&#xff0c;两者都是用于实现建立表格的相关组件&#xff0c;只不过QStand…
阅读更多...
. Unable to find a @SpringBootConfiguration（默认软件包中的 Spring Boot 应用程序）

. Unable to find a @SpringBootConfiguration（默认软件包中的 Spring Boot 应用程序）

解决&#xff1a; 新建一个包即可 问题&#xff1a; 默认软件包中的 Spring Boot 应用程序。 原因&#xff1a; 默认包的定义 &#xff1a; 如果一个 Java 类没有使用 package 声明包名&#xff0c;则该类会被放置在默认包中。Spring Boot 遵循 Java 的包管理约定&#xff…
阅读更多...
FRRouting配置与OSPF介绍，配置，命令，bfd算法：

FRRouting配置与OSPF介绍，配置，命令，bfd算法：

文章目录 1、frrouting的配置&#xff1a;2、ospf2.1、检测和维护邻居关系2.2、ospfDR和BDR2.3、odpf邻居表2.4、ospf常用命令2.5、bfd配置 1、frrouting的配置&#xff1a; sudo service zebra start sudo service ospfd start telnet localhost 2604 en configure termina…
阅读更多...
【MyBatis】预编译SQL与即时SQL

【MyBatis】预编译SQL与即时SQL

目录 1. 以基本类型参数为例测试#{ }与${ }传递参数的区别 1.1 参数为Integer类型 1.2 参数为String类型 2. 使用#{ }传参存在的问题 2.1 参数为排序方式 2.2 模糊查询 3. 使用${ }传参存在的问题 3.1 SQL注入 3.2 对比#{ } 与 ${ }在SQL注入方面存在的问题 3.3 预编译…
阅读更多...
Python数据可视化 - Matplotlib教程

Python数据可视化 - Matplotlib教程

文章目录 前言一、Matplotlib简介及安装1. Matplotlib简介2. 安装Matplotlib 二、Matplotlib Pyplot1. Pyplot介绍2. Pyplot中方法介绍2.1 创建和管理图形2.2 绘制图形2.3 设置图形属性2.4 保存和展示 三、Matplotlib绘图标记1. 介绍2. 基本用法3. 标记大小与颜色4. 标记样式列…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023