深度学习 Day16——P5运动鞋识别

AI对战五子棋——深度学习策略网络 在本篇博文中,我们完成了:✔ 构建一个 CNN 五子棋策略网络✔ 让神经网络输出落子概率✔ 使用 Policy Gradient 强化学习训练 AI✔ 让 AI 实现人与 AI、AI 自对弈博弈。 阅读详情


前言

本文将采用pytorch框架创建CNN网络,实现运动鞋识别。讲述实现代码与执行结果,并浅谈涉及知识点。
关键字:torch动态学习率

1 我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm2020.2.3
  • 深度学习环境:
    torch == 1.9.1+cu111
    torchvision == 0.10.1+cu111
  • 显卡:NVIDIA GeForce RTX 4070

2 代码实现与执行结果

2.1 前期准备

2.1.1 引入库

import torch
import torch.nn as nn
from torchvision import transforms, datasets
import time
from pathlib import Path
from PIL import Image
from torchinfo import summary
import torch.nn.functional as F
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100  # 分辨率
import warnings

warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印

2.1.2 设置GPU(如果设备上支持GPU就使用GPU,否则使用CPU)

"""前期准备-设置GPU"""
# 如果设备上支持GPU就使用GPU,否则使用CPU
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print("Using {} device".format(device))

输出

Using cuda device

2.1.3 导入数据

'''前期工作-导入数据'''
data_dir = r"D:\DeepLearning\data\monkeypox_recognition"
data_dir = Path(data_dir)

data_paths = list(data_dir.glob('./train/*'))
    classeNames = [str(path).split("\\")[-1] for path in data_paths]
    print(classeNames)

输出

['adidas', 'nike']

2.1.4 可视化数据

'''前期工作-可视化数据'''
subfolder = Path(data_dir)/"train"/"nike"
image_files = list(p.resolve() for p in subfolder.glob('*') if p.suffix in [".jpg", ".png", ".jpeg"])
plt.figure(figsize=(10, 6))
for i in range(len(image_files[:12])):
    image_file = image_files[i]
    ax = plt.subplot(3, 4, i + 1)
    img = Image.open(str(image_file))
    plt.imshow(img)
    plt.axis("off")
# 显示图片
plt.tight_layout()
plt.show()

在这里插入图片描述

2.1.4 图像数据变换

'''前期工作-图像数据变换'''
    # 关于transforms.Compose的更多介绍可以参考:https://blog.youkuaiyun.com/qq_38251616/article/details/124878863
    train_transforms = transforms.Compose([
        transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
        # transforms.RandomHorizontalFlip(), # 随机水平翻转
        transforms.ToTensor(),  # 将PIL Image或numpy.ndarray转换为tensor,并归一化到[0,1]之间
        transforms.Normalize(  # 标准化处理-->转换为标准正太分布(高斯分布),使模型更容易收敛
            mean=[0.485, 0.456, 0.406],
            std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    ])

    test_transform = transforms.Compose([
        transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
        transforms.ToTensor(),  # 将PIL Image或numpy.ndarray转换为tensor,并归一化到[0,1]之间
        transforms.Normalize(  # 标准化处理-->转换为标准正太分布(高斯分布),使模型更容易收敛
            mean=[0.485, 0.456, 0.406],
            std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    ])

    train_dataset = datasets.ImageFolder(Path(data_dir)/"train", transform=train_transforms)
    test_dataset = datasets.ImageFolder(Path(data_dir)/"test", transform=train_transforms)
    print(train_dataset.class_to_idx)

输出

{'adidas': 0, 'nike': 1}

2.1.4 加载数据

'''前期工作-加载数据'''
batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                       batch_size=batch_size,
                                       shuffle=True,
                                       num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                      batch_size=batch_size,
                                      shuffle=True,
                                      num_workers=1)

2.1.4 查看数据

'''前期工作-查看数据'''
for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

输出

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64

2.2 构建CNN网络模型

在这里插入图片描述

"""构建CNN网络"""
class Network_bn(nn.Module):
    def __init__(self):
        super(Network_bn, self).__init__()
        """
        nn.Conv2d()函数:
        第一个参数(in_channels)是输入的channel数量
        第二个参数(out_channels)是输出的channel数量
        第三个参数(kernel_size)是卷积核大小
        第四个参数(stride)是步长,默认为1
        第五个参数(padding)是填充大小,默认为0
        """
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(12)
        self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn2 = nn.BatchNorm2d(12)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv4 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn4 = nn.BatchNorm2d(24)
        self.conv5 = nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn5 = nn.BatchNorm2d(24)
        self.fc1 = nn.Linear(24 * 50 * 50, len(classeNames))

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = self.pool(x)
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = self.pool(x)
        x = x.view(-1, 24 * 50 * 50)
        x = self.fc1(x)

        return x

        
model = Network_bn().to(device)
print(model)   

输出

Network_bn(
  (conv1): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (fc1): Linear(in_features=60000, out_features=2, bias=True)
)

2.3 训练模型

2.3.1 设置超参数

"""训练模型--设置超参数"""
loss_fn = nn.CrossEntropyLoss()  # 创建损失函数,计算实际输出和真实相差多少,交叉熵损失函数,事实上,它就是做图片分类任务时常用的损失函数
learn_rate = 1e-4  # 学习率
optimizer1 = torch.optim.SGD(model.parameters(), lr=learn_rate)# 作用是定义优化器,用来训练时候优化模型参数;其中,SGD表示随机梯度下降,用于控制实际输出y与真实y之间的相差有多大
optimizer2 = torch.optim.Adam(model.parameters(), lr=learn_rate)
#测试集acc 84.2%
lr_opt = optimizer1
model_opt = optimizer1

2.3.2 编写训练函数

"""训练模型--编写训练函数"""
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小,一共60000张图片
    num_batches = len(dataloader)  # 批次数目,1875(60000/32)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 加载数据加载器,得到里面的 X(图片数据)和 y(真实标签)
        X, y = X.to(device), y.to(device) # 用于将数据存到显卡

        # 计算预测误差
        pred = model(X)  # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距,targets为真实值,计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # 清空过往梯度
        loss.backward()  # 反向传播,计算当前梯度
        optimizer.step()  # 根据梯度更新网络参数

        # 记录acc与loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss

2.3.3 编写测试函数

"""训练模型--编写测试函数"""
# 测试函数和训练函数大致相同,但是由于不进行梯度下降对网络权重进行更新,所以不需要传入优化器
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 测试集的大小,一共10000张图片
    num_batches = len(dataloader)  # 批次数目,313(10000/32=312.5,向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时,停止梯度更新,节省计算内存消耗
    with torch.no_grad(): # 测试时模型参数不用更新,所以 no_grad,整个模型参数正向推就ok,不反向更新参数
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()#统计预测正确的个数

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

2.3.4 正式训练

 """训练模型--正式训练"""
    epochs = 40
    train_loss = []
    train_acc = []
    test_loss = []
    test_acc = []
    best_test_acc=0
    PATH = './model.pth'  # 保存的参数文件名
    for epoch in range(epochs):
        milliseconds_t1 = int(time.time() * 1000)

        # 更新学习率(使用自定义学习率时使用)
        adjust_learning_rate(lr_opt, epoch, learn_rate)
        model.train()
        epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, model_opt)
        # scheduler.step() # 更新学习率(调用官方动态学习率接口时使用)

        model.eval()
        epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

        train_acc.append(epoch_train_acc)
        train_loss.append(epoch_train_loss)
        test_acc.append(epoch_test_acc)
        test_loss.append(epoch_test_loss)

        # 获取当前的学习率
        lr = lr_opt.state_dict()['param_groups'][0]['lr']

        milliseconds_t2 = int(time.time() * 1000)
        template = ('Epoch:{:2d}, duration:{}ms, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%,Test_loss:{:.3f}, Lr:{:.2E}')
        if best_test_acc < epoch_test_acc:
            best_test_acc = epoch_test_acc
            # 模型保存
            torch.save(model.state_dict(), PATH)
            template = (
                'Epoch:{:2d}, duration:{}ms, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%,Test_loss:{:.3f}, Lr:{:.2E},save model.pth')
        print(
            template.format(epoch + 1, milliseconds_t2-milliseconds_t1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss, lr))
    print('Done')

输出

Epoch: 1, duration:5323ms, Train_acc:52.2%, Train_loss:0.745, Test_acc:50.0%,Test_loss:0.700, Lr:1.00E-04,save model.pth
Epoch: 2, duration:3125ms, Train_acc:62.9%, Train_loss:0.651, Test_acc:57.9%,Test_loss:0.667, Lr:1.00E-04,save model.pth
Epoch: 3, duration:3130ms, Train_acc:66.9%, Train_loss:0.614, Test_acc:67.1%,Test_loss:0.584, Lr:9.20E-05,save model.pth
Epoch: 4, duration:3136ms, Train_acc:70.5%, Train_loss:0.567, Test_acc:72.4%,Test_loss:0.568, Lr:9.20E-05,save model.pth
Epoch: 5, duration:3346ms, Train_acc:76.1%, Train_loss:0.531, Test_acc:72.4%,Test_loss:0.537, Lr:8.46E-05
Epoch: 6, duration:3087ms, Train_acc:77.5%, Train_loss:0.510, Test_acc:72.4%,Test_loss:0.531, Lr:8.46E-05
Epoch: 7, duration:3215ms, Train_acc:77.7%, Train_loss:0.492, Test_acc:78.9%,Test_loss:0.511, Lr:7.79E-05,save model.pth
Epoch: 8, duration:3520ms, Train_acc:82.3%, Train_loss:0.467, Test_acc:77.6%,Test_loss:0.504, Lr:7.79E-05
Epoch: 9, duration:3662ms, Train_acc:83.1%, Train_loss:0.442, Test_acc:81.6%,Test_loss:0.494, Lr:7.16E-05,save model.pth
Epoch:10, duration:3410ms, Train_acc:85.7%, Train_loss:0.427, Test_acc:80.3%,Test_loss:0.464, Lr:7.16E-05
Epoch:11, duration:3486ms, Train_acc:86.3%, Train_loss:0.413, Test_acc:81.6%,Test_loss:0.469, Lr:6.59E-05
Epoch:12, duration:3356ms, Train_acc:87.6%, Train_loss:0.394, Test_acc:78.9%,Test_loss:0.452, Lr:6.59E-05
Epoch:13, duration:3453ms, Train_acc:87.6%, Train_loss:0.391, Test_acc:81.6%,Test_loss:0.494, Lr:6.06E-05
Epoch:14, duration:3226ms, Train_acc:87.8%, Train_loss:0.385, Test_acc:80.3%,Test_loss:0.450, Lr:6.06E-05
Epoch:15, duration:3290ms, Train_acc:89.0%, Train_loss:0.368, Test_acc:82.9%,Test_loss:0.486, Lr:5.58E-05,save model.pth
Epoch:16, duration:3247ms, Train_acc:90.4%, Train_loss:0.359, Test_acc:81.6%,Test_loss:0.443, Lr:5.58E-05
Epoch:17, duration:3195ms, Train_acc:90.6%, Train_loss:0.358, Test_acc:81.6%,Test_loss:0.452, Lr:5.13E-05
Epoch:18, duration:3294ms, Train_acc:90.6%, Train_loss:0.342, Test_acc:82.9%,Test_loss:0.436, Lr:5.13E-05
Epoch:19, duration:3305ms, Train_acc:91.2%, Train_loss:0.338, Test_acc:81.6%,Test_loss:0.452, Lr:4.72E-05
Epoch:20, duration:3241ms, Train_acc:91.8%, Train_loss:0.332, Test_acc:81.6%,Test_loss:0.418, Lr:4.72E-05
Epoch:21, duration:3371ms, Train_acc:93.0%, Train_loss:0.320, Test_acc:81.6%,Test_loss:0.459, Lr:4.34E-05
Epoch:22, duration:3279ms, Train_acc:92.8%, Train_loss:0.317, Test_acc:81.6%,Test_loss:0.475, Lr:4.34E-05
Epoch:23, duration:3279ms, Train_acc:93.4%, Train_loss:0.310, Test_acc:82.9%,Test_loss:0.438, Lr:4.00E-05
Epoch:24, duration:3225ms, Train_acc:93.0%, Train_loss:0.313, Test_acc:81.6%,Test_loss:0.437, Lr:4.00E-05
Epoch:25, duration:3293ms, Train_acc:94.0%, Train_loss:0.304, Test_acc:81.6%,Test_loss:0.439, Lr:3.68E-05
Epoch:26, duration:3273ms, Train_acc:94.0%, Train_loss:0.297, Test_acc:81.6%,Test_loss:0.414, Lr:3.68E-05
Epoch:27, duration:3249ms, Train_acc:94.2%, Train_loss:0.296, Test_acc:80.3%,Test_loss:0.413, Lr:3.38E-05
Epoch:28, duration:3266ms, Train_acc:94.8%, Train_loss:0.288, Test_acc:84.2%,Test_loss:0.425, Lr:3.38E-05,save model.pth
Epoch:29, duration:3248ms, Train_acc:94.4%, Train_loss:0.288, Test_acc:81.6%,Test_loss:0.400, Lr:3.11E-05
Epoch:30, duration:3243ms, Train_acc:94.6%, Train_loss:0.291, Test_acc:81.6%,Test_loss:0.445, Lr:3.11E-05
Epoch:31, duration:3250ms, Train_acc:96.4%, Train_loss:0.278, Test_acc:81.6%,Test_loss:0.465, Lr:2.86E-05
Epoch:32, duration:3193ms, Train_acc:95.2%, Train_loss:0.275, Test_acc:81.6%,Test_loss:0.438, Lr:2.86E-05
Epoch:33, duration:3283ms, Train_acc:95.2%, Train_loss:0.270, Test_acc:81.6%,Test_loss:0.402, Lr:2.63E-05
Epoch:34, duration:3542ms, Train_acc:94.8%, Train_loss:0.280, Test_acc:81.6%,Test_loss:0.407, Lr:2.63E-05
Epoch:35, duration:3592ms, Train_acc:95.8%, Train_loss:0.269, Test_acc:81.6%,Test_loss:0.442, Lr:2.42E-05
Epoch:36, duration:3592ms, Train_acc:95.4%, Train_loss:0.267, Test_acc:80.3%,Test_loss:0.413, Lr:2.42E-05
Epoch:37, duration:3588ms, Train_acc:95.0%, Train_loss:0.265, Test_acc:81.6%,Test_loss:0.432, Lr:2.23E-05
Epoch:38, duration:3736ms, Train_acc:95.0%, Train_loss:0.267, Test_acc:81.6%,Test_loss:0.438, Lr:2.23E-05
Epoch:39, duration:3431ms, Train_acc:95.2%, Train_loss:0.265, Test_acc:82.9%,Test_loss:0.400, Lr:2.05E-05
Epoch:40, duration:3417ms, Train_acc:95.8%, Train_loss:0.270, Test_acc:81.6%,Test_loss:0.379, Lr:2.05E-05
Done

2.4 结果可视化

"""训练模型--结果可视化"""
epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

2.4 指定图片进行预测

def predict_one_image(image_path, model, transform, classes):
    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)  # 展示预测的图片
    plt.show()

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)

    model.eval()
    output = model(img)

    _, pred = torch.max(output, 1)
    pred_class = classes[pred]
    print(f'预测结果是:{pred_class}')
    
"""指定图片进行预测"""
 classes = list(total_data.class_to_idx)
# 预测训练集中的某张照片
predict_one_image(image_path=str(Path(data_dir)/"test/adidas/1.jpg"),
                  model=model,
                  transform=train_transforms,
                  classes=classes)

如果使用效果最好的模型,就先加载保存好的模型,再调用预测代码

   # 将参数加载到model当中
    model.load_state_dict(torch.load(PATH, map_location=device))

输出

预测结果是:adidas

在这里插入图片描述

2.6 保存并加载模型

"""保存并加载模型"""
# 模型保存
PATH = './model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

# 将参数加载到model当中
model.load_state_dict(torch.load(PATH, map_location=device))

3 知识点详解

3.1 torch动态学习率

3.1.1 torch.optim.lr_scheduler.StepLR

函数原型:

torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)

关键参数详解:

  • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
  • step_size(int):是学习率衰减的周期,每经过每个epoch,做一次学习率decay
  • gamma(float):学习率衰减的乘法因子。Default:0.1

用法示例:

optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)

3.1.2 lr_scheduler.LambdaLR

根据自己定义的函数更新学习率。
函数原型:

torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1, verbose=False)

关键参数详解:

  • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
  • lr_lambda(function):更新学习率的函数
    用法示例:
lambda1 = lambda epoch: (0.92 ** (epoch // 2) # 第二组参数的调整方法
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1) #选定调整方法

3.1.3 lr_scheduler.MultiStepLR

在特定的 epoch 中调整学习率
函数原型:

torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=False)

关键参数详解:

  • optimizer(Optimizer):是之前定义好的需要优化的优化器的实例名
  • milestones(list):是一个关于epoch数值的list,表示在达到哪个epoch范围内开始变化,必须是升序排列
  • gamma(float):学习率衰减的乘法因子。Default:0.1
    用法示例:
optimizer = torch.optim.SGD(net.parameters(), lr=0.001 )
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, 
                                                 milestones=[2,6,15], #调整学习率的epoch数
                                                 gamma=0.1)

更多的官方动态学习率设置方式可参考:https://pytorch.org/docs/stable/optim.html
👉调用官方接口示例:

model = [Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, 0.1)
scheduler = ExponentialLR(optimizer, gamma=0.9)

for epoch in range(20):
    for input, target in dataset:
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        optimizer.step()
    scheduler.step()

3.2 拔高尝试

尝试变更dropout失活比例为0.5,测试集acc提升至86.8%,实际上也不能确定是因为变更比例导致的效果提升,因为每次运行效果都有不同,有好有坏。

Epoch: 1, duration:4820ms, Train_acc:53.6%, Train_loss:1.133, Test_acc:52.6%,Test_loss:0.712, Lr:1.00E-04,save model.pth
Epoch: 2, duration:3271ms, Train_acc:73.5%, Train_loss:0.547, Test_acc:59.2%,Test_loss:0.697, Lr:1.00E-04,save model.pth
Epoch: 3, duration:3566ms, Train_acc:81.5%, Train_loss:0.396, Test_acc:77.6%,Test_loss:0.485, Lr:9.20E-05,save model.pth
Epoch: 4, duration:3309ms, Train_acc:89.4%, Train_loss:0.287, Test_acc:77.6%,Test_loss:0.470, Lr:9.20E-05
Epoch: 5, duration:3411ms, Train_acc:94.2%, Train_loss:0.219, Test_acc:82.9%,Test_loss:0.418, Lr:8.46E-05,save model.pth
Epoch: 6, duration:3239ms, Train_acc:98.2%, Train_loss:0.172, Test_acc:81.6%,Test_loss:0.385, Lr:8.46E-05
Epoch: 7, duration:3282ms, Train_acc:98.8%, Train_loss:0.127, Test_acc:85.5%,Test_loss:0.374, Lr:7.79E-05,save model.pth
Epoch: 8, duration:3277ms, Train_acc:99.2%, Train_loss:0.115, Test_acc:82.9%,Test_loss:0.332, Lr:7.79E-05
Epoch: 9, duration:3440ms, Train_acc:99.6%, Train_loss:0.091, Test_acc:86.8%,Test_loss:0.356, Lr:7.16E-05,save model.pth
Epoch:10, duration:3570ms, Train_acc:100.0%, Train_loss:0.078, Test_acc:81.6%,Test_loss:0.411, Lr:7.16E-05
Epoch:11, duration:3418ms, Train_acc:99.6%, Train_loss:0.072, Test_acc:84.2%,Test_loss:0.370, Lr:6.59E-05
Epoch:12, duration:3291ms, Train_acc:100.0%, Train_loss:0.064, Test_acc:85.5%,Test_loss:0.339, Lr:6.59E-05
Epoch:13, duration:3273ms, Train_acc:100.0%, Train_loss:0.054, Test_acc:85.5%,Test_loss:0.321, Lr:6.06E-05
Epoch:14, duration:3365ms, Train_acc:100.0%, Train_loss:0.049, Test_acc:85.5%,Test_loss:0.336, Lr:6.06E-05
Epoch:15, duration:3321ms, Train_acc:100.0%, Train_loss:0.046, Test_acc:84.2%,Test_loss:0.311, Lr:5.58E-05
Epoch:16, duration:3273ms, Train_acc:100.0%, Train_loss:0.041, Test_acc:84.2%,Test_loss:0.336, Lr:5.58E-05
Epoch:17, duration:3315ms, Train_acc:100.0%, Train_loss:0.038, Test_acc:85.5%,Test_loss:0.350, Lr:5.13E-05
Epoch:18, duration:3380ms, Train_acc:100.0%, Train_loss:0.034, Test_acc:82.9%,Test_loss:0.314, Lr:5.13E-05
Epoch:19, duration:3275ms, Train_acc:100.0%, Train_loss:0.034, Test_acc:84.2%,Test_loss:0.378, Lr:4.72E-05
Epoch:20, duration:3264ms, Train_acc:100.0%, Train_loss:0.031, Test_acc:82.9%,Test_loss:0.342, Lr:4.72E-05
Epoch:21, duration:3267ms, Train_acc:100.0%, Train_loss:0.029, Test_acc:84.2%,Test_loss:0.299, Lr:4.34E-05
Epoch:22, duration:3243ms, Train_acc:100.0%, Train_loss:0.028, Test_acc:84.2%,Test_loss:0.320, Lr:4.34E-05
Epoch:23, duration:3319ms, Train_acc:100.0%, Train_loss:0.025, Test_acc:82.9%,Test_loss:0.335, Lr:4.00E-05
Epoch:24, duration:3230ms, Train_acc:100.0%, Train_loss:0.025, Test_acc:84.2%,Test_loss:0.351, Lr:4.00E-05
Epoch:25, duration:3251ms, Train_acc:100.0%, Train_loss:0.025, Test_acc:84.2%,Test_loss:0.329, Lr:3.68E-05
Epoch:26, duration:3275ms, Train_acc:100.0%, Train_loss:0.023, Test_acc:84.2%,Test_loss:0.304, Lr:3.68E-05
Epoch:27, duration:3244ms, Train_acc:100.0%, Train_loss:0.022, Test_acc:82.9%,Test_loss:0.324, Lr:3.38E-05
Epoch:28, duration:3319ms, Train_acc:100.0%, Train_loss:0.022, Test_acc:85.5%,Test_loss:0.308, Lr:3.38E-05
Epoch:29, duration:3287ms, Train_acc:100.0%, Train_loss:0.020, Test_acc:85.5%,Test_loss:0.353, Lr:3.11E-05
Epoch:30, duration:3230ms, Train_acc:100.0%, Train_loss:0.019, Test_acc:85.5%,Test_loss:0.346, Lr:3.11E-05
Epoch:31, duration:3285ms, Train_acc:100.0%, Train_loss:0.019, Test_acc:85.5%,Test_loss:0.335, Lr:2.86E-05
Epoch:32, duration:3255ms, Train_acc:100.0%, Train_loss:0.019, Test_acc:85.5%,Test_loss:0.337, Lr:2.86E-05
Epoch:33, duration:3307ms, Train_acc:100.0%, Train_loss:0.018, Test_acc:85.5%,Test_loss:0.334, Lr:2.63E-05
Epoch:34, duration:3281ms, Train_acc:100.0%, Train_loss:0.017, Test_acc:85.5%,Test_loss:0.323, Lr:2.63E-05
Epoch:35, duration:3249ms, Train_acc:100.0%, Train_loss:0.016, Test_acc:85.5%,Test_loss:0.314, Lr:2.42E-05
Epoch:36, duration:3287ms, Train_acc:100.0%, Train_loss:0.017, Test_acc:84.2%,Test_loss:0.368, Lr:2.42E-05
Epoch:37, duration:3337ms, Train_acc:100.0%, Train_loss:0.016, Test_acc:85.5%,Test_loss:0.328, Lr:2.23E-05
Epoch:38, duration:3367ms, Train_acc:100.0%, Train_loss:0.016, Test_acc:84.2%,Test_loss:0.375, Lr:2.23E-05
Epoch:39, duration:3244ms, Train_acc:100.0%, Train_loss:0.015, Test_acc:84.2%,Test_loss:0.329, Lr:2.05E-05
Epoch:40, duration:3277ms, Train_acc:100.0%, Train_loss:0.015, Test_acc:85.5%,Test_loss:0.295, Lr:2.05E-05

在这里插入图片描述

尝试变更学习率优化器及模型优化器为(SGD和Adam的四种组合),测试集acc几乎无变化
尝试变更初始学习率,尝试变更学习率不动态更新,测试集acc无提升

总结

通过本文学习到几种动态学习率的设置与调用,要想得到一个比较好的模型效果,对模型相关参数进行不同的尝试,获取一个相对适配该案例的参数。

从NASA DataPort下载到PyTorch Dataset:手把手处理USGS光谱库的AVIRIS数据 本文详细介绍了如何从NASA DataPort下载USGS光谱库的AVIRIS高光谱数据,并将其转化为PyTorch Dataset对象。内容涵盖数据获取、预处理、辐射定标及高效数据加载技巧,特别针对AVIRIS数据的水吸收波段剔除和波段分组标准化进行了重点讲解,为环境监测、地质勘探等领域的研究者提供实用指南。 阅读详情

相关推荐

Linux 桌面虚拟化技术 KVM

Linux 桌面虚拟化技术 KVM

高飞的博客 36万+

深度学习练习项目5.Pytorch实现运动鞋识别

🍨 本文为🔗365天深度学习训练营中的学习记录博客K同学啊🏡 我的环境:● 语言环境:Python3.8● 编译器:jupyter notebook● 深度学习环境:Pytorch● 数据:🔗百度网盘🔗和鲸对卷积、激活、池化层的概念开始有所参悟。对一些图像卷积动作和对应效果的关联有了一定了解,B站视频帮助很大,但不建议我一样零基础的同学直接上李沐老师的课,亲测越听越跟不上。

qq_38798712的博客 814

DEM高程数据的获取、合并与坐标转换

DEM高程数据的获取、合并与坐标转换一、DEM数据的获取二、数据合并三、投影转换方法一四、投影转换方法二 今天用DEM数据做了一个坡度分析,数据使用过程中涉及到投影坐标转换,由于不是很熟悉所以费了一番功夫。经过一番折腾总结出两个方法,方法一自认为比较便捷的方法,即通过BIGMAP软件中工具列表中的投影转换功能进行。方法二为传统方法,即在Arcgis中用投影栅格工具进行转换。 一、DEM数据的获取 在地理空间数据云网站下载DEM数据(精度包括30米和90米),数据格式为tif格式或img格式,坐标为WGS_1

weixin_48625651的博客 1万+

RNNoise-SpeexDSP-WebRTC使用说明

本文介绍RNNoise、SpeexDSP与WebRTC音频处理库的下载、调用及参数配置方法,适用于Android语音工程集成。RNNoise基于深度学习,适合非稳态噪声降噪,需48kHz输入;SpeexDSP支持多采样率与回声消除,适用于全双工场景;WebRTC提供轻量级窄带处理。三者可串联使用:麦克风信号先经前级降噪(RNNoise或SpeexDSP),再进入WebRTC媒体引擎进行编码。重点说明各库的典型应用场景、接口调用方式、关键参数调节策略及采样率转换注意事项,帮助开发者高效集成与优化语音处理链路。

知识共享,你我皆是知识的搬运工 239

MAX30102传感器实战:从寄存器配置到Arduino心率血氧监测

本文详细介绍了MAX30102传感器在Arduino平台上的实战应用,从寄存器配置到心率血氧监测的全过程。通过清晰的代码示例和实用技巧,帮助开发者快速实现脉搏血氧仪功能,包括I2C通信、FIFO数据处理及算法实现,适用于健康监测和可穿戴设备开发。

weixin_29182481的博客 511

从零开始安装使用opengauss数据库(高斯数据库)

openGauss(高斯数据库)的环境配置、安装方法、基本使用方法

qq_43764807的博客 1万+

Transformer 为什么能取代 RNN?从自注意力讲起

2017 年谷歌在《Attention Is All You Need》中提出 Transformer,核心是。它如今是 GPT、BERT、ChatGPT 的共同底座。

anew___的博客 979

华为OD机试 - 开源项目热度榜单(Java 2025 C卷 100分)

H = Wwatch X#watch + Wstar X#star +Wfork X#fork +Wissue X#issue +Wmr X#mr H表示热度值,Wwatch、Wstar、Wfork、Wissue、Wmr分别表示5个统计维度的权重,#watch、#star、#fork、#issue、#mr分别表示5个统计维度的统计值。

学Java,找哪吒 1756

基于深度学习的商品评论情感分析系统-毕业设计

面向商品评论的中文情感分析系统,支持单条预测、批量分析、情感分布与关键词、报告导出。TextCNN、BiLSTM、Transformer 在同一词表、同一数据切分、同一种子与超参下公平对比,测试集 F1 分别为 0.9101、0.9089、0.9075。结论是这一规模下模型复杂度未带来收益,但误差结构不同。附技术栈、截图、文档预览与演示视频。

csbysj2020 158

【DaVinci Developer专题】-28-Client Server Port Interface中useArgumentType、useArrayBaseType和useVoid介绍

共7页 目录 1 ImplPolicy = useArgumentType 2 ImplPolicy = useArrayBaseType 3 ImplPolicy = useVoid 4 三者代码差异部分 5 结尾 <--返回「实战篇」博文-总目录--> <--返回「Autosar从入门到精通-实战篇」专栏主页--> 关键字: 缩略语/术语 含义 DEV DaVinci Developer

「汽车电子助手」的博客 1505

如何用 Claude Code 做大型项目重构与架构优化

本文介绍了如何利用Claude Code参与大型项目重构。文章指出,大型项目重构的最大难点在于理解系统结构和控制风险,而非单纯修改代码。作者提出了五步重构法:首先分析项目结构,其次梳理模块依赖关系,然后发现架构问题,接着设计分阶段重构方案,最后逐步实施。重点强调了Claude Code的核心价值在于帮助开发者理解复杂系统、分析模块依赖、发现结构问题、评估改动风险,而非仅作为代码生成工具。文章建议将Claude Code作为架构助手,通过分阶段小范围重构来降低风险,而非一次性全面重构。

sg_knight的专栏 1575

图解循环神经网络(RNN)

RNN(循环神经网络)就是“带记忆的网络”:让网络拥有一块“记忆”,在处理当前数据时,能同时参考之前看过的内容;它不一次性看完全部输入,而是像人读书一样,一个字一个字地读,每读一个字就更新一次脑子里的记忆,然后用这份记忆去理解当前这个字。但便签一直在被改写,新信息不断挤占旧信息,传到第 40 步时,“巴黎”的痕迹已经淡得几乎没了。读到“贵”的时候,网络并没有重新去查“好看”这个词——但“好看”的影响已经融在了便签里(那个 1.5)。这三个困难的共同点:答案不在当前这一个字里,而在“前面那串东西”里。

技术管理两手抓,两手都要硬. 427

YOLOv8改进:注意力系列篇 |高效的通道先验卷积注意力(CPCA) | 中科院 2023.6

高效的通道先验卷积注意力(CPCA)方法,支持注意力权重在通道和空间维度上的动态分布;

会AI的学姐 2047

【原创深度学习项目】基于深度学习的建筑工地防护装备检测系统|安全帽与反光衣检测系统(RT-DETR-L 模型)

本文设计并实现了一套基于RT-DETR-L的建筑工地防护装备检测系统,采用Django+Vue前后端架构,实现对安全帽、反光背心等7类装备及“无PPE”“未戴安全帽”等缺失状态的精准识别。系统支持图片、视频、摄像头实时检测,具备参数可调、数据可视化与统计分析功能,有效解决小目标漏检、误检及管理难问题,助力智慧工地安全管理落地。文末可获取源码。

qq_1445749146的博客 232

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

神经网络入门指南:从 CNN、RNN 到 Attention

神经网络的学习,本质是“预测—比较—纠错”的循环;CNN 通过局部连接与权重共享理解图像;RNN 通过隐藏状态传递上下文;LSTM 和 GRU 用门控机制管理记忆;Encoder–Decoder 把理解与生成拆成两个阶段;Attention 则让模型在每一步都能主动寻找最相关的信息。到这里,我们已经走完了从普通神经网络到 Attention 的完整路线。下一篇将正式进入 Transformer,看看它如何摆脱 RNN 的顺序计算,又如何让每个 Token 直接找到与自己相关的信息。

爱敲代码的小黄 396

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

AI 学习第 15 课:变长序列不 pack 直接喂 RNN,隐状态全被 0 污染

NLP 的 batch 里句子长短不一,短句垫 0 补齐后直接喂 RNN,看似能跑,实际上每个 0 垫步都在更新隐状态——短序列的最后一步输出根本不是它真实句子的结果。这一课用 torch 2.15(

aifannihao的博客 161

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

CNN 卷积神经网络深度解析:卷积、池化与特征提取的底层原理

卷积核(Kernel),也叫滤波器(Filter),本质上是一个可以训练的权重矩阵。1 0 -11 0 -11 0 -1这个卷积核可以对图像中的局部像素进行加权计算。不同的卷积核能够提取不同类型的特征:水平边缘特征垂直边缘特征纹理特征角点特征局部形状特征在传统图像处理中,滤波器通常由人工设计。而在 CNN 中,卷积核的权重通过训练数据和反向传播自动学习得到。这也是 CNN 能够自动提取图像特征的关键。# 第一层卷积padding=1# 第二层卷积padding=1。

2503_90237586的博客 294

图解常用深度学习优化器

来隐式构造 Hessian 逆的近似,从而直接估计出“谷底在哪”,而非仅仅判断“哪边最陡”。即SGD/Adam 主要看“当前坡度”,LBFGS 还会看“最近几步坡度怎么变”,像用局部地形图来规划路线。训练 Transformer 时,有些层梯度大,有些层梯度小。如果用 Adam + L2,梯度大的参数反而可能被“少衰减”,正则效果不稳定;:你要下山,但每次迈步前都要派侦察兵把整座山的每一个坡面都测量一遍,算出“绝对最陡”的方向才走一步。:还是下山,但这次你只问身边一个路人“哪边最陡”,然后就走。

技术管理两手抓,两手都要硬. 219

【无标题】无人机视角道路坑洞坑洼目标检测数据集深度学习 目标检测 无人机航拍 道路坑洞 路面病害 YOLO格式 数据集发布9032期

(一)类别构成该数据集聚焦单一类别——坑洞(类别 ID 为 0),任务指向明确,围绕无人机俯视视角下的道路坑洞目标开展检测标注。类别体系精简,与公路路面病害巡检的实际需求高度契合,图像中的坑洞样本可直接作为路面破损识别的核心正样本,便于对接道路养护排查流程。(二)数据数量数据集规模为 3285 张无人机俯视航拍图像,采用标准 YOLO txt 标注格式,标注框总计 4457 个,其中带有效标注的图片 2007 张,全部图片均带有有效标注。

qq_2529413168的博客 187

基于深度学习的猫图像目标检测方法研究:YOLOv8s模型海选、多种子对比训练与Django+ONNX部署实现详解

本课题基于深度学习研究猫图像目标检测问题。数据集含1000张猫图像、1188个标注框,按固定比例划分并冻结清单;训练前在多个候选族中短训海选,确定YOLOv8s为主模型,经学习率搜索与显存标定后完成150轮训练,验证集mAP50达到0.92,并以7个随机种子的对比实验验证稳定性。最优权重导出为ONNX接入Django系统,提供图片、视频、摄像头三种识别方式,配套识别记录管理与统计大屏,形成从训练到应用的完整闭环。

WEIXIN_JSJBSZDS的博客 221

第 05/24 期:计算图与自动微分:深度学习如何计算梯度

本文系统阐述了神经网络训练中梯度计算的本质:损失对参数的敏感性。通过构建计算图,将复杂函数分解为基本运算,利用链式法则实现反向传播。核心在于反向模式自动微分——以一次前向计算为基础,通过传播输出对中间变量的敏感性,高效求得所有参数梯度。相比前向模式,反向模式在参数多、目标为标量的场景下更高效。计算图不仅适用于神经网络,也广泛适用于任意可微程序。关键思想是:梯度是局部导数与上游敏感性的乘积,分支路径的贡献需累加,从而保证导数计算的正确性与效率。

weixin_47502228的博客 331

【深度学习项目实战·30】PM2.5短期预测:用LSTM构造没有未来信息的滑动窗口

本文基于北京PM2.5数据,使用LSTM实现从最近24小时历史观测预测下一小时PM2.5。重点解决时间切分、因果填补、滑动窗口构建与标准化等关键问题,确保模型仅依赖过去信息,避免未来泄漏。通过滚动单步预测与持续性基线对比,评估在原始单位下的MAE/RMSE,验证模型有效性。强调时间顺序与数据完整性,为时序预测提供可复现的实践框架。

银尘博客 519

深度学习 目标检测 无人机巡检 防震锤 电力设备 YOLO格式 数据集发布

深度学习 目标检测 无人机巡检 防震锤 电力设备 YOLO格式 数据集发布 9038期

qq_2529413168的博客 335

无人机巡检道路路面异常检测数据集 深度学习 目标检测 无人机巡检 道路病害 路面异常 YOLO格式 数据集发布9028期

无人机巡检道路路面异常检测数据集 深度学习 目标检测 无人机巡检 道路病害 路面异常 YOLO格式 数据集发布9028期

qq_2529413168的博客 213

AI 学习第 14 课:CNN 训 6 轮卡在 0.5352,数据没打乱

第 13 课把 Conv2d 的参数量和池化后的尺寸算清了,这课把卷积块拼成一个能训练的完整网络,跑满 6 个 epoch。第一版直接卡死:loss 从 2.6104 掉到 0.6989 就再也不动,

aifannihao的博客 252

深度学习基本原理:从数学基础到神经网络训练

深度学习训练的核心,是先确定模型结构,再通过前向计算得到损失,利用链式法则和反向传播计算梯度,最后借助优化器与学习率不断更新参数。真正理解这条链路,后续学习更复杂的网络结构才有可靠的基础。

chh563的博客 167
上一篇: 深度学习 Day15——P4猴痘病识别
下一篇: 深度学习 Day17——P6好莱坞明星识别
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值