Pytorch图像分类模型模型实时在线验证代码

已于 2024-05-13 14:06:40 修改
阅读量208 收藏
点赞数 2
分类专栏： 深度学习算法——Pytorch 文章标签： pytorch 分类 人工智能
于 2024-05-12 21:46:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38633279/article/details/138761587
版权

1.训练并保存自己的模型

保存的模型格式为：XXX.pth

torch.save(model, "./weight/last.pth")
            if best_acc <(validation_acc / len_val):
                torch.save(model, "./weight/best.pth")

2.转化为ONNX格式

2.1环境安装（window10）

pip install onnx
pip install onnxruntime

#验证安装配置是否成功
import torch
print('PyTorch 版本', torch.__version__)

import onnx
print('ONNX 版本', onnx.__version__)

import onnxruntime as ort
print('ONNX Runtime 版本', ort.__version__)

2.2.pth格式转ONNX格式

import torch
from torchvision import models

# 有 GPU 就用 GPU，没有就用 CPU
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print('device', device)

model = torch.load('best.pth')
model = model.eval().to(device)
x = torch.randn(1, 3, 256, 256).to(device)  #这里要构造一个数据，保证和自己输入的图片大小一致3*256*256
output = model(x)  #output.shape = torch.Size([1, 10])  这是一个10分类问题

#Pytorch模型转ONNX模型
x = torch.randn(1, 3, 256, 256).to(device)

with torch.no_grad():
    torch.onnx.export(
        model,                   # 要转换的模型
        x,                       # 模型的任意一组输入
        'best.onnx', # 导出的 ONNX 文件名
        opset_version=11,        # ONNX 算子集版本
        input_names=['input'],   # 输入 Tensor 的名称（自己起名字）
        output_names=['output']  # 输出 Tensor 的名称（自己起名字）


import onnx

# 读取 ONNX 模型
onnx_model = onnx.load('resnet18_fruit30.onnx')

# 检查模型格式是否正确
onnx.checker.check_model(onnx_model)
print('无报错，onnx模型载入成功')

这是project中就出现了“best.onnx”文件，表示转化ONNX格式成功！

3.可视化实时检测

3.1在PC电脑端查看

3.1.1环境安装（待补充）

pip install onnxruntime
需要提前保存一个类别ID和类别名称对应的文件

3.1.2 摄像头实时捕捉分类处理

import os
import cv2
import numpy as np
import pandas as pd
from tqdm import tqdm # 进度条
import torch
import torch.nn.functional as F
from torchvision import transforms
import time
import onnxruntime
from PIL import Image, ImageFont, ImageDraw
import matplotlib.pyplot as plt

# 导入中文字体，指定字体大小
font = ImageFont.truetype('SimHei.ttf', 32)

ort_session = onnxruntime.InferenceSession('resnet18_imagenet.onnx')
# 载入ImageNet 1000图像分类标签
df = pd.read_csv('imagenet_class_index.csv')
idx_to_labels = {}
for idx, row in df.iterrows():
    idx_to_labels[row['ID']] = row['Chinese']

# 测试集图像预处理-RCTN：缩放裁剪、转 Tensor、归一化
test_transform = transforms.Compose([transforms.Resize(256),
                                     transforms.CenterCrop(256),
                                     transforms.ToTensor(),
                                     transforms.Normalize(
                                         mean=[0.485, 0.456, 0.406],
                                         std=[0.229, 0.224, 0.225])
                                    ])
# 处理帧函数
def process_frame(img_bgr):
    # 记录该帧开始处理的时间
    start_time = time.time()

    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)  # BGR转RGB
    img_pil = Image.fromarray(img_rgb)  # array 转 PIL

    ## 预处理
    input_img = test_transform(img_pil)  # 预处理
    input_tensor = input_img.unsqueeze(0).numpy()

    ## onnx runtime 预测
    ort_inputs = {'input': input_tensor}  # onnx runtime 输入
    pred_logits = ort_session.run(['output'], ort_inputs)[0]  # onnx runtime 输出
    pred_logits = torch.tensor(pred_logits)
    pred_softmax = F.softmax(pred_logits, dim=1)  # 对 logit 分数做 softmax 运算

    ## 解析图像分类预测结果
    n = 5
    top_n = torch.topk(pred_softmax, n)  # 取置信度最大的 n 个结果
    pred_ids = top_n[1].cpu().detach().numpy().squeeze()  # 解析出类别
    confs = top_n[0].cpu().detach().numpy().squeeze()  # 解析出置信度

    ## 在图像上写中文
    draw = ImageDraw.Draw(img_pil)
    for i in range(len(confs)):
        pred_class = idx_to_labels[pred_ids[i]]

        # 写中文：文字坐标，中文字符串，字体，rgba颜色
        text = '{:<15} {:>.3f}'.format(pred_class, confs[i])  # 中文字符串
        draw.text((50, 100 + 50 * i), text, font=font, fill=(255, 0, 0, 1))

    img_rgb = np.array(img_pil)  # PIL 转 array
    img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)  # RGB转BGR

    # 记录该帧处理完毕的时间
    end_time = time.time()
    # 计算每秒处理图像帧数FPS
    FPS = 1 / (end_time - start_time)
    # 图片，添加的文字，左上角坐标，字体，字体大小，颜色，线宽，线型
    img_bgr = cv2.putText(img_bgr, 'FPS  ' + str(int(FPS)), (50, 80), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 0, 255), 4,
                          cv2.LINE_AA)
    return img_bgr

# 获取摄像头，传入0表示获取系统默认摄像头
cap = cv2.VideoCapture(1)

# 打开cap
cap.open(0)

# 无限循环，直到break被触发
while cap.isOpened():

    # 获取画面
    success, frame = cap.read()

    if not success:  # 如果获取画面不成功，则退出
        print('获取画面不成功，退出')
        break
    ## 逐帧处理
    frame = process_frame(frame)
    # 展示处理后的三通道图像
    cv2.imshow('my_window', frame)
    key_pressed = cv2.waitKey(60)  # 每隔多少毫秒毫秒，获取键盘哪个键被按下
    # print('键盘上被按下的键：', key_pressed)
    if key_pressed in [ord('q'), 27]:  # 按键盘上的q或esc退出（在英文输入法下）
        break

# 关闭摄像头
cap.release()
# 关闭图像窗口
cv2.destroyAllWindows()

使用q按钮退出！

3.1.3 视频离线分类处理

import os
import cv2
import numpy as np
import pandas as pd
from tqdm import tqdm # 进度条
import torch
import torch.nn.functional as F
from torchvision import transforms
import time
import onnxruntime
from PIL import Image, ImageFont, ImageDraw
import matplotlib.pyplot as plt

# 导入中文字体，指定字体大小
font = ImageFont.truetype('SimHei.ttf', 32)

ort_session = onnxruntime.InferenceSession('resnet18_imagenet.onnx')
# 载入ImageNet 1000图像分类标签
df = pd.read_csv('imagenet_class_index.csv')
idx_to_labels = {}
for idx, row in df.iterrows():
    idx_to_labels[row['ID']] = row['Chinese']

# 测试集图像预处理-RCTN：缩放裁剪、转 Tensor、归一化
test_transform = transforms.Compose([transforms.Resize(256),
                                     transforms.CenterCrop(256),
                                     transforms.ToTensor(),
                                     transforms.Normalize(
                                         mean=[0.485, 0.456, 0.406],
                                         std=[0.229, 0.224, 0.225])
                                    ])
import cv2
import numpy as np
import time
from tqdm import tqdm


# 处理帧函数
def process_frame(img_bgr):
    # 记录该帧开始处理的时间
    start_time = time.time()

    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)  # BGR转RGB
    img_pil = Image.fromarray(img_rgb)  # array 转 PIL

    ## 预处理
    input_img = test_transform(img_pil)  # 预处理
    input_tensor = input_img.unsqueeze(0).numpy()

    ## onnx runtime 预测
    ort_inputs = {'input': input_tensor}  # onnx runtime 输入
    pred_logits = ort_session.run(['output'], ort_inputs)[0]  # onnx runtime 输出
    pred_logits = torch.tensor(pred_logits)
    pred_softmax = F.softmax(pred_logits, dim=1)  # 对 logit 分数做 softmax 运算

    ## 解析图像分类预测结果
    n = 5
    top_n = torch.topk(pred_softmax, n)  # 取置信度最大的 n 个结果
    pred_ids = top_n[1].cpu().detach().numpy().squeeze()  # 解析出类别
    confs = top_n[0].cpu().detach().numpy().squeeze()  # 解析出置信度

    ## 在图像上写中文
    draw = ImageDraw.Draw(img_pil)
    for i in range(len(confs)):
        pred_class = idx_to_labels[pred_ids[i]]

        # 写中文：文字坐标，中文字符串，字体，rgba颜色
        text = '{:<15} {:>.3f}'.format(pred_class, confs[i])  # 中文字符串
        draw.text((50, 100 + 50 * i), text, font=font, fill=(255, 0, 0, 1))

    img_rgb = np.array(img_pil)  # PIL 转 array
    img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)  # RGB转BGR

    # 记录该帧处理完毕的时间
    end_time = time.time()
    # 计算每秒处理图像帧数FPS
    FPS = 1 / (end_time - start_time)
    # 图片，添加的文字，左上角坐标，字体，字体大小，颜色，线宽，线型
    img_bgr = cv2.putText(img_bgr, 'FPS  ' + str(int(FPS)), (50, 80), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 0, 255), 4,
                          cv2.LINE_AA)
    return img_bgr

# 视频逐帧处理代码模板
# 不需修改任何代码，只需定义process_frame函数即可
# 同济子豪兄 2021-7-10

def generate_video(input_path='videos/robot.mp4'):
    filehead = input_path.split('/')[-1]
    output_path = "out-" + filehead

    print('视频开始处理', input_path)

    # 获取视频总帧数
    cap = cv2.VideoCapture(input_path)
    frame_count = 0
    while (cap.isOpened()):
        success, frame = cap.read()
        frame_count += 1
        if not success:
            break
    cap.release()
    print('视频总帧数为', frame_count)

    # cv2.namedWindow('Crack Detection and Measurement Video Processing')
    cap = cv2.VideoCapture(input_path)
    frame_size = (cap.get(cv2.CAP_PROP_FRAME_WIDTH), cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    # fourcc = int(cap.get(cv2.CAP_PROP_FOURCC))
    # fourcc = cv2.VideoWriter_fourcc(*'XVID')
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    fps = cap.get(cv2.CAP_PROP_FPS)

    out = cv2.VideoWriter(output_path, fourcc, fps, (int(frame_size[0]), int(frame_size[1])))

    # 进度条绑定视频总帧数
    with tqdm(total=frame_count - 1) as pbar:
        try:
            while (cap.isOpened()):
                success, frame = cap.read()
                if not success:
                    break

                # 处理帧
                # frame_path = './temp_frame.png'
                # cv2.imwrite(frame_path, frame)
                try:
                    frame = process_frame(frame)
                except:
                    print('报错！', error)
                    pass

                if success == True:
                    # cv2.imshow('Video Processing', frame)
                    out.write(frame)

                    # 进度条更新一帧
                    pbar.update(1)

                # if cv2.waitKey(1) & 0xFF == ord('q'):
                # break
        except:
            print('中途中断')
            pass

    cv2.destroyAllWindows()
    out.release()
    cap.release()
    print('视频已保存', output_path)

generate_video(input_path='video_4.mp4')

参考：https://www.bilibili.com/video/BV1AM4y187yR/?spm_id_from=333.788&vd_source=47e66af6a90e9c41c341fd3c692ced14

小维_
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于 jupyter notebook pytorch使用卷积网络的图像10分类附完整代码+数据集可直接运行 毕业设计
02-03
在 anaconda3 上配置 python3.6 的新环境，安装 pytorch 框架，使用 jupyter notebook 编辑、运行代码。使用 numpy.load 读取.npy 文件，pandas.read_csv 读取.csv 文件；创建 ImgDataset 类，用于载入和读取图片和类别标签；创建 DataLoader 迭代器，一个 batch 的大小设为 32，用于分批读出数据。测试网络的过程中，为了更方便地判断、比较网络性能，从 30000 张训练图片中随机分出 5000 张作为验证集，每个 echo 结束后做一次测试和验证，从验证集的损失和精确度中能基本预测测试集的准确率。 本次作业需要利用深度学习的方法对 10 类图片进行分类，图片类别及示例如图 1 所示。提供的数据包含 30000 张带类别标签的图片组成的训练集，和 5000 张无类别的测试集，需要用训练好的模型对测试集图片进行分类，并将结果生成 csv 文件上传提交。选用 python 编写网络架构，深度学习框架在 pytorch/tensorflow/caffe 中任选其一。
pytorch-classification:使用PyTorch训练图像分类模型
05-27
PyTorch中的ImageNet培训 这将对ImageNet数据集上的流行模型架构（例如ResNet，AlexNet和VGG）进行训练。 要求 安装PyTorch（ ） pip install -r requirements.txt 下载ImageNet数据集并将验证图像移动到带标签的子文件夹中 为此，您可以使用以下脚本： : 训练 要训​​练模型， main.py使用所需的模型架构和ImageNet数据集的路径运行main.py ： python main.py -a resnet18 [imagenet-folder with train and val folders] 默认学习率计划从0.1开始，每30个时代衰减10倍。 这对于ResNet和具有批处理归一化的模型是合适的，但对于AlexNet和VGG来说太高了。 使用0.01作为AlexNet或VGG的初始学习率：
计算机视觉CV-Pytorch 经典图像分类模型介绍
lw19155275856的博客
04-29 525
计算机视觉CV-Pytorch 经典图像分类模型介绍
python卷积神经网络CNN图像分类验证大模型性能PyTorch框架torchvision在MNIST大数据集测试代码
09-01
在每个训练周期中，我们将损失值打印出来。但是，为了确保模型在验证集上表现良好，我们还需要定期在验证集上评估模型性能。我们可以使用 `验证集策略` 为了确保模型在验证集上表现良好，我们还需要定期在验证集上评估模型性能。我们可以使用 `验证集策略` 在这个例子中，我们使用一个简单的验证集策略，每隔 100 个训练样本评估一次验证集上的性能。我们计算验证集上的损失和准确率，并将它们打印出来。这有助于我们了解模型在训练过程中的表现，并确保模型在验证集上表现良好。
利用Pytorch搭建简单的图像分类模型（完整模型，从读取数据到最后训练验证）
09-27
这是一个完整的基于Pytorch 的分类模型，下载以后根据博客中讲的读取数据、搭建模型、训练验证等可以自行修改代码，以符合自身需求。整个项目都有比较清晰的注释，比较适合新手上手学习。
深度学习系列2——Pytorch 图像分类(AlexNet)
霁风AI
11-25 1797
深度学习系列2——Pytorch 图像分类(AlexNet)
pyTorch 图像分类模型训练教程
dwSun的博客
04-27 2982
pyTorch 图像识别教程 这里以 TinyMind 《汉字书法识别》比赛数据为例，展示使用 Pytorch 进行图像数据分类模型训练的整个流程。 数据地址请参考: https://www.tinymind.cn/competitions/41#property_23 或到这里下载： 自由练习赛数据下载地址： 训练集：链接: https://pan.baidu.com/s/1UxvN7nVpa0...
pytorch图像分类模型在测试时精度变差
OUTMAN80的博客
05-08 1190
训练好的模型在单张图像测试时模型精度大幅下降，对该问题进行查找并解决问题
使用pytorch训练你自己的图像分类模型（包括模型训练、推理预测、误差分析）
胖胖大海的博客
06-26 7977
待完成
【MRI脑肿瘤】【代码＋数据集+中文注释】医学图像分类，使用3种深度学习网络，pytorch框架
05-10
1、 数据集：155张脑部肿瘤切片MRI图像与98张正常MRI图像，以9：1的比例划分训练集验证集 2、 代码通过3种不同深度学习神经网络（AlexNet/LeNet/ResNet）实现肿瘤图像的2分类（有无肿瘤）; ResNet部分采用迁移学习...
PyTorch 之 基于经典网络架构训练图像分类模型
每天进步一点点！
03-24 2609
我们可以进入 pytorch 的官方网站，对模型的基本架构和训练好的参数进行直接调用，具体链接如下。
使用PyTorch建立图像分类模型
TensorFlowNews
11-06 5784
概述 在PyTorch中构建自己的卷积神经网络(CNN)的实践教程 我们将研究一个图像分类问题——CNN的一个经典和广泛使用的应用 我们将以实用的格式介绍深度学习概念 介绍 我被神经网络的力量和能力所吸引。在机器学习和深度学习领域，几乎每一次突破都以神经网络模型为核心。 这在计算机视觉领域尤为普遍。无论是简单的图像分类还是更高级的东西(如对象检测)，神经网络开辟了处理图像数据的可能性。简而...
Pytorch创建张量
qq_44815135的博客
05-27 1018
torch.normal() 是 PyTorch 中用于创建具有指定均值和标准差的正态分布随机值的张量的函数。torch.randn() 是 PyTorch 中用于创建具有正态分布（高斯分布）随机值的张量的函数。torch.zeros() 函数是 PyTorch 中用于创建元素全为零的张量的函数。torch.ones() 函数是 PyTorch 中用于创建元素全为一的张量的函数。torch.rand() 是 PyTorch 中用于创建具有随机值的张量的函数。
Pytorch实用教程：pytorch中nn.Linear()用法详解 | 构建多层感知机 | nn.Module的作用 | nn.Sequential的作用
最新发布
惊鸿若梦一书生
05-30 195
Pytorch实用教程：pytorch中nn.Linear()用法详解 | 构建多层感知机 | nn.Module的作用 | nn.Sequential的作用
Pytorch 笔记
985小菜鸡
05-28 957
就地操作会直接修改原始张量的值，通常以a.mul_(b)：就地进行元素级相乘非就地操作会创建新的张量并返回结果，而不改变输入张量的值。这些不同的乘法操作方式在不同的应用场景中有不同的用途，根据需要选择适合的乘法方式。
Pytorch-Reduction Ops
qq_44815135的博客
05-29 717
torch.argmax() 是 PyTorch 中的一个函数，用于在指定维度上获取张量中最大值的索引。input：输入张量。dim：可选参数，指定在哪个维度上进行操作。如果未指定，则默认在最后一个维度上进行操作。keepdim：可选参数，指定是否保持输出张量的维度与输入张量相同。默认为 False，表示不保持维度"""# 创建一个张量# 沿着第一个维度获取最大值的索引print(max_indices) # 输出: tensor([1, 1, 1])
Pytorch索引、切片、连接
qq_44815135的博客
05-28 608
torch.hstack() 是 PyTorch 中的一个函数，用于沿着水平方向（列维度）堆叠张量来创建一个新的张量。torch.column_stack() 是 PyTorch 中的一个函数，用于按列堆叠张量来创建一个新的张量。torch.masked_select() 是 PyTorch 中的一个函数，用于根据给定的掩码从输入张量中选择元素并返回一个新的张量。torch.index_select() 是 PyTorch 中的一个函数，用于按索引从输入张量中选择元素并返回一个新的张量。
Pytorch环境配置2.0.1+ Cuda11.7
TanJingV的博客
05-28 390
右上角为CUDA 版本，可以看到该电脑可以支持的cuda版本最高是12.3，驱动是向下兼容的，所以cuda版本小于等于12.3的都可以安装上（建议11.8版本可以兼容大部分的库）我的显卡驱动是Driver Version：535.40.，那么左边对应的CUDA都可以兼容。找到了pytorch1.7版本的conda安装命令。如果想配置不同版本的cuda，可以看这个。Cuda硬件驱动工具包安装教程。查询可支持的最高cuda版本。查看支持的cuda的版本。显示如下，表明已经安装。
pytorch图像分类 代码
10-03
Pytorch实现图像分类的代码可以参考以下示例代码： ```python import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms # 设置数据的根目录 data_dir = "path_to_your_data_directory" # 定义训练和验证的数据转换 data_transforms = { 'train': transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } # 加载数据集 image_datasets = {x: datasets.ImageFolder(data_dir, data_transforms[x]) for x in ['train', 'val']} dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, shuffle=True, num_workers=4) for x in ['train', 'val']} class_names = image_datasets['train'].classes # 定义模型 model = ... # 定义损失函数 criterion = nn.CrossEntropyLoss() # 定义优化器 optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) # 训练模型 num_epochs = 10 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model.to(device) for epoch in range(num_epochs): for inputs, labels in dataloaders['train']: inputs = inputs.to(device) labels = labels.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # 在验证集上评估模型 correct = 0 total = 0 with torch.no_grad(): for inputs, labels in dataloaders['val']: inputs = inputs.to(device) labels = labels.to(device) outputs = model(inputs) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = correct / total print(f'Epoch {epoch+1}/{num_epochs}, Validation Accuracy: {accuracy:.4f}') # 相关问题:

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值