[最新]Yolov12自定义segment分割模型转ONNX、RKNN并推理，实现在PC端进行模拟、连接板端NPU调用

于 2025-09-02 15:28:23 发布
阅读量252 收藏 2
点赞数 5
CC 4.0 BY-SA版权
分类专栏： Yolo目标检测 文章标签： YOLO 计算机视觉 人工智能 目标检测 边缘计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58280003/article/details/151103132

写在前面
本篇文章主要是记录自己在这个问题上踩的一些坑，加深个人对RKNN推理以及模型输入和输出这个方面知识的了解，如果能帮助到一些需要将Yolov12转为Onnx并推理，再将Onnx转为RKNN进行分割模型的推理的同学，那我会感到非常荣幸。网上现在有许多关于转RKNN推理的文章，但是基本都是基于yolo默认的检测模型，推理实例分割模型的文章比较少，所以做个记录进行分享。如果哪里说的有问题，欢迎各位批评指正。

目录

一.工作环境介绍

PC端：linux（以下环境都是默认在此环境，windows无法进行RKNN模拟推理）
python: 3.12
rknn toolkit2: 2.2.0
yolo模型：yolov12n-seg.pt

二.自定义pt模型转为onnx

1.目前使用的是yolov12n-seg.pt作为预训练模型，然后使用自己的分割数据集得到的best.pt，然后直接进行导出。（如果使用其他方式导出的onnx比如说其他文章里面的修改最后的输出头，可能会出现模型的输出格式不同，只影响最后推理的后处理部分，到时候只需要根据不同的输出格式修改后处理部分就行）

from ultralytics import YOLO
yolo_model_path = r'/home/files/weights/best.pt'
model = YOLO(yolo_model_path)
model.export(format='onnx',opset=11)

2.当前onnx分割模型结构输出结构
!我们这里](https://i-blog.csdnimg.cn/direct/1b9bd722d2ef4d5cb80f7d3c1f34a5c4.jpeg)
只需要关注结构里面的输入和输出格式

  • inputs为单张图片，格式为[1,3,640,640],分别代表批次，通道数，高和宽。
  • outputs存在两个部分，output0为检测框数据，格式为[1，37，8400]，分别代表批次数，特征数以及最大检测框数目。
  • output1为分割的特征数据，格式为[1,32,160,160],分别代表批次数，通道数，高，宽。

三.onnx编译构建rknn模型

以下代码是转换逻辑，分为PC端模拟和PC端连板测试

1.PC端模拟推理：

只在PC端模拟推理RKNN模型，不与开发板连接，那也必然没使用开发板NPU进行推理。

代码如下：

# 初始化 RKNN 对象
rknn = RKNN()
rknn.config(mean_values=[[0, 0, 0]], 
        std_values=[[1, 1, 1]], 
        target_platform='rk3568', 
        quantized_algorithm='normal', 
        quantized_method='channel')
#加载原始 ONNX转为rknn
rknn.load_onnx(model=model_path)
# 编译模型
ret = rknn.build(do_quantization=False)#
 # 导出 RKNN 模型
 print("Exporting RKNN model...")
 ret = self.rknn.export_rknn(output_path)
 if ret != 0:
     print("Failed to export RKNN model!")
     exit(ret)
 print("RKNN导出成功!")
ret = rknn.init_runtime(target=None, perf_debug=True)
#推理
outputs = rknn.inference(inputs=[im], data_format='nchw') #'nchw'

注意：

  • 如果进行PC端模拟时（不连接板端），必须通过加载ONNX模型然后编译构建RKNN，然后进行后续的推理，同时，指定的target参数需要设置为none，如下面代码。
 #直接加载rknn,但是不能在PC模拟下使用
 ret = rknn.load_rknn(path=model_path)
 #运行初始化
 ret = self.rknn.init_runtime(target=None, perf_debug=True)
  • 模型配置里面的均值和方差使用不同的值会有很大的影响，我这使用的是默认的值，因为训练时我没有修改yolo模型的参数配置，如果此处修改的话需要和你训练模型使用的归一化参数一致。
mean_values=[[0, 0, 0]]
std_values=[[1, 1, 1]]

2.PC端连板调用NPU推理测试

  • 连接板端：通过 adb devices 命令可以列出所有连接的设备及其 device_id，出现设备号ID即成功。
adb devices
  • 启动端口：为了在PC调用板子上的端口，需要启动rknn server，启动方法如下：
    新的板子连接设置rknn server方法见：板端初始启动rknn server
    代码如下（示例）：
adb shell
chmod +x /usr/bin/rknn_server
chmod +x /usr/bin/start_rknn.sh
chmod +x /usr/bin/restart_rknn.sh
restart_rknn.sh
  • NPU推理：需要修改指定板端的target类型和device_id
    代码如下：
# 初始化 RKNN 对象
rknn = RKNN()
#配置
rknn.config(mean_values=[[0, 0, 0]],
         std_values=[[1, 1, 1]], 
         quantized_algorithm='normal',
          quantized_method='channel', 
          target_platform='rk3568')
#直接加载rknn模型
ret = rknn.load_rknn(path=model_path)
#初始化，此处需指定target类型，如果PC端连接多个开发板，
#则需要指定某个开发板的device_id
ret = rknn.init_runtime(target='rk3568', 
device_id=None, perf_debug=True)
#推理
outputs = rknn.inference(inputs=[im], data_format='nchw') #'nchw'
  • init_runtime 方法的参数，可以自行设置修改NPU核心数
target：目标硬件平台。支持的平台包括 "rk3562"、"rk3566"、"rk3568"、"rk3588"、"rv1103"、"rv1106" 等。默认值为 None，表示在 PC 上使用模拟器运行。
device_id：设备编号。如果连接了多台设备，需要指定该参数。默认值为 None。
perf_debug：进行性能评估时是否开启 debug 模式。在 debug 模式下，可以获取到每一层的运行时间，否则只能获取模型运行的总时间。默认值为 False。
eval_mem：是否进入内存评估模式。进入内存评估模式后，可以调用 eval_memory 接口获取模型运行时的内存使用情况。默认值为 False。
async_mode：是否使用异步模式。默认值为 False。在异步模式下，每次返回的推理结果都是上一帧的。
core_mask：设置运行时的 NPU 核心。支持的平台为 RK3588 / RK3576，支持的配置包括：
RKNN.NPU_CORE_AUTO：自动调度模型，运行在当前空闲的 NPU 核上。
RKNN.NPU_CORE_0：运行在 NPU0 核心上。
RKNN.NPU_CORE_1：运行在 NPU1 核心上。
RKNN.NPU_CORE_2：运行在 NPU2 核心上。
RKNN.NPU_CORE_0_1：同时运行在 NPU0 和 NPU1 核心上。
RKNN.NPU_CORE_0_1_2：同时运行在 NPU0、NPU1 和 NPU2 核心上。
RKNN.NPU_CORE_ALL：根据平台自动配置 NPU 核心数量。
默认值为 RKNN.NPU_CORE_AUTO。
fallback_prior_device：设置当 OP 超出 NPU 规格时 fallback 的优先级，当前支持 "cpu" 或 "gpu"。默认值是 "cpu"。

四.推理结果后处理

进行上诉得到推理结果后，需要将数据进行解析后处理，得到最后输出的检测框以及分割区域。
由于目前onnx和rknn的输出格式的结构是一致的，所以后处理函数可以公用，使用onnx进行推理和后处理大家也可以尝试一下，这里就不叙述了。
详细后处理函数代码如下：

    def postprocess(self, preds, im0, ratio, pad_w, pad_h, conf_threshold, iou_threshold, nm=32):
        """
        推理后的结果后处理
        Args:
            preds (Numpy.ndarray): 来自 RKNN 的推理结果
            im0 (Numpy.ndarray): [h, w, c] 原始输入图像
            ratio (tuple): 宽高比例
            pad_w (float): 宽度的填充
            pad_h (float): 高度的填充
            conf_threshold (float): 置信度阈值
            iou_threshold (float): IoU 阈值
            nm (int): 掩膜数量
        Returns:
            boxes (List): 边界框列表
            segments (List): 分割区域列表
            masks (np.ndarray): 掩膜数组
        """
        x, protos = preds[0], preds[1]  # 获取模型的两个输出：预测和原型

        # 转换维度
        x = np.einsum("bcn->bnc", x) #从 (1, 37, 8400) 转换为 (1, 8400, 37)

        # 置信度过滤
        x = x[np.amax(x[..., 4:-nm], axis=-1) > conf_threshold]

        # 合并边界框、置信度、类别和掩膜 ,合并后x存在38列
        x = np.c_[x[..., :4], np.amax(x[..., 4:-nm], axis=-1), np.argmax(x[..., 4:-nm], axis=-1), x[..., -nm:]]

        # NMS 过滤
        x = x[cv2.dnn.NMSBoxes(x[:, :4], x[:, 4], conf_threshold, iou_threshold)]

        # 解析并返回结果
        if len(x) > 0:
            # 边界框格式转换：从 cxcywh -> xyxy
            x[..., [0, 1]] -= x[..., [2, 3]] / 2
            x[..., [2, 3]] += x[..., [0, 1]]

            # 缩放边界框，使其与原始图像尺寸匹配
            x[..., :4] -= [pad_w, pad_h, pad_w, pad_h]
            x[..., :4] /= min(ratio)

            # 限制边界框在图像边界内
            x[..., [0, 2]] = x[:, [0, 2]].clip(0, im0.shape[1])
            x[..., [1, 3]] = x[:, [1, 3]].clip(0, im0.shape[0])

            # 处理掩膜
            masks = self.process_mask(protos[0], x[:, 6:], x[:, :4], im0.shape)
            segments = self.masks2segments(masks)
            return x[..., :6], segments, masks  # 返回边界框、分割区域和掩膜
        else:
            return [], [], []

五.完整代码流程

import cv2
import numpy as np
import os
import time
from rknn.api import RKNN

# 类别名称和颜色映射
CLASS_NAMES = {
    0: 'your_calss',  # 类别 0 名称
    1: 'class_name2'  # 类别 1 名称
    # 可以添加更多类别...
}

CLASS_COLORS = {
    0: (255, 255, 0),  # 类别 0 的颜色为青黄色
    1: (255, 0, 0)  # 类别 1 的颜色为红色
    # 可以为其他类别指定颜色...
}

class YOLO12SegRKNN:
    def __init__(self, model_path, output_path, target="rk3568", dataset=None):
        # 初始化 RKNN 对象
        self.rknn = RKNN()

        # self.rknn.config(mean_values=[[0.406 * 255, 0.456 * 255, 0.485 * 255]], 
        #                  std_values=[[0.225 * 255, 0.224 * 255, 0.229 * 255]],
        #                 target_platform='rk3568', quantized_algorithm='normal', quantized_method='channel')
        self.rknn.config(mean_values=[[0, 0, 0]], 
                    std_values=[[1, 1, 1]],
                target_platform='rk3568', optimization_level=2, quantized_algorithm='normal', quantized_method='channel')
        # self.rknn.config(mean_values=[[0.406 * 255, 0.456 * 255, 0.485 * 255]],
        #     std_values=[[0.225 * 255, 0.224 * 255, 0.229 * 255]],
        #     target_platform='rk3568', optimization_level=2)

        # 1.加载原始 ONNX转为rknn
        self.rknn.load_onnx(model=model_path)
        # 编译模型
        if dataset:
            self.rknn.build(target=target, dataset=dataset, pre_compile=True)
        else:
            ret = self.rknn.build(do_quantization=False)

        # #2.直接加载rknn,但是不能在模拟环境下使用
        # ret = self.rknn.load_rknn(path=model_path)

        # 导出 RKNN 模型
        print("Exporting RKNN model...")
        ret = self.rknn.export_rknn(output_path)
        if ret != 0:
            print("Failed to export RKNN model!")
            exit(ret)

        print("RKNN导出成功!")

        # 初始化运行时
        ret = self.rknn.init_runtime(target=None, perf_debug=True)
        if ret != 0:
            print('初始化运行环境失败')
            exit(ret)

        # 获取输入输出信息 ,此处进行修改模型的输入尺寸
        self.model_height, self.model_width = (640, 640)

        # 打印模型的输入尺寸
        print("YOLO11 🚀 实例分割 RKNN")
        print("模型名称：", onnx_model_path)
        print(f"模型输入尺寸：宽度 = {self.model_width}, 高度 = {self.model_height}")

        # 加载类别名称
        self.classes = CLASS_NAMES

        # 加载类别对应的颜色
        self.class_colors = CLASS_COLORS

    def get_color_for_class(self, class_id):
        return self.class_colors.get(class_id, (255, 255, 255))  # 如果没有找到类别颜色，返回白色

    def __call__(self, im0, conf_threshold=0.3, iou_threshold=0.3, nm=32):
        """
        完整的推理流程：预处理 -> 推理 -> 后处理
        Args:
            im0 (Numpy.ndarray): 原始输入图像
            conf_threshold (float): 置信度阈值
            iou_threshold (float): NMS 中的 IoU 阈值
            nm (int): 掩膜数量
        Returns:
            boxes (List): 边界框列表
            segments (List): 分割区域列表
            masks (np.ndarray): [N, H, W] 输出掩膜
        """
        # 图像预处理
        im, ratio, (pad_w, pad_h) = self.preprocess(im0)
        print("im0.shape", im0.shape)
        print("im.shape", im.shape)

        # RKNN 推理
        start_time = time.time()
        outputs = self.rknn.inference(inputs=[im], data_format='nchw') #'nchw'
        end_time = time.time()
        print(f"RKNN 模型推理时间: {(end_time - start_time) * 1000:.2f} 毫秒")

        # 后处理
        boxes, segments, masks = self.postprocess(
            outputs,
            im0=im0,
            ratio=ratio,
            pad_w=pad_w,
            pad_h=pad_h,
            conf_threshold=conf_threshold,
            iou_threshold=iou_threshold,
            nm=nm,
        )
        print("检测框：", boxes)
        print("分割：", segments)
        return boxes, segments, masks

    def preprocess(self, img):
        """
        图像预处理
        Args:
            img (Numpy.ndarray): 输入图像
        Returns:
            img_process (Numpy.ndarray): 处理后的图像
            ratio (tuple): 宽高比例
            pad_w (float): 宽度的填充
            pad_h (float): 高度的填充
        """
        # 调整输入图像大小并使用 letterbox 填充
        shape = img.shape[:2]  # 原始图像大小
        new_shape = (self.model_height, self.model_width)
        r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
        ratio = r, r
        new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
        pad_w, pad_h = (new_shape[1] - new_unpad[0]) / 2, (new_shape[0] - new_unpad[1]) / 2  # 填充宽高
        if shape[::-1] != new_unpad:  # 调整图像大小
            img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
        top, bottom = int(round(pad_h - 0.1)), int(round(pad_h + 0.1))
        left, right = int(round(pad_w - 0.1)), int(round(pad_w + 0.1))
        img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))

        # # 转换：HWC -> CHW -> BGR 转 RGB -> 除以 255 -> contiguous -> 添加维度
        img = np.ascontiguousarray(np.einsum("HWC->CHW", img)[::-1], dtype=np.float32) / 255.0
        img_process = img[None] if len(img.shape) == 3 else img

        # # 1. 转换为 CHW 格式并从 BGR 转换为 RGB
        # img = np.einsum("HWC->CHW", img)[::-1]
        # # 2. 将像素值归一化到 [0, 1] 范围
        # img = img.astype(np.float32) / 255.0
        # # 3. 应用均值和标准差归一化
        # mean_values = np.array([0.485 * 255, 0.456 * 255, 0.406 * 255]) / 255.0  # 归一化后的均值
        # std_values = np.array([0.229 * 255, 0.224 * 255, 0.225 * 255]) / 255.0  # 归一化后的标准差
        # # 确保均值和标准差是 float32 类型
        # mean_values = mean_values.astype(np.float32)
        # std_values = std_values.astype(np.float32)
        # img = (img - mean_values[:, None, None]) / std_values[:, None, None]
        # # 4. 确保数组是连续的
        # img = np.ascontiguousarray(img)
        # img_process = img[None] if len(img.shape) == 3 else img #添加一个维度


        # 转换：HWC -> NHWC
        #img_process = np.expand_dims(img, axis=0).astype(np.float32) / 255.0
        print("img_process.shape", img_process.shape)
        return img_process, ratio, (pad_w, pad_h)

    def postprocess(self, preds, im0, ratio, pad_w, pad_h, conf_threshold, iou_threshold, nm=32):
        """
        推理后的结果后处理
        Args:
            preds (Numpy.ndarray): 来自 RKNN 的推理结果
            im0 (Numpy.ndarray): [h, w, c] 原始输入图像
            ratio (tuple): 宽高比例
            pad_w (float): 宽度的填充
            pad_h (float): 高度的填充
            conf_threshold (float): 置信度阈值
            iou_threshold (float): IoU 阈值
            nm (int): 掩膜数量
        Returns:
            boxes (List): 边界框列表
            segments (List): 分割区域列表
            masks (np.ndarray): 掩膜数组
        """
        x, protos = preds[0], preds[1]  # 获取模型的两个输出：预测和原型

        # 转换维度
        x = np.einsum("bcn->bnc", x) #从 (1, 37, 8400) 转换为 (1, 8400, 37)

        # 置信度过滤
        x = x[np.amax(x[..., 4:-nm], axis=-1) > conf_threshold]

        # 合并边界框、置信度、类别和掩膜 ,合并后x存在38列
        x = np.c_[x[..., :4], np.amax(x[..., 4:-nm], axis=-1), np.argmax(x[..., 4:-nm], axis=-1), x[..., -nm:]]

        # NMS 过滤
        x = x[cv2.dnn.NMSBoxes(x[:, :4], x[:, 4], conf_threshold, iou_threshold)]

        # 解析并返回结果
        if len(x) > 0:
            # 边界框格式转换：从 cxcywh -> xyxy
            x[..., [0, 1]] -= x[..., [2, 3]] / 2
            x[..., [2, 3]] += x[..., [0, 1]]

            # 缩放边界框，使其与原始图像尺寸匹配
            x[..., :4] -= [pad_w, pad_h, pad_w, pad_h]
            x[..., :4] /= min(ratio)

            # 限制边界框在图像边界内
            x[..., [0, 2]] = x[:, [0, 2]].clip(0, im0.shape[1])
            x[..., [1, 3]] = x[:, [1, 3]].clip(0, im0.shape[0])

            # 处理掩膜
            masks = self.process_mask(protos[0], x[:, 6:], x[:, :4], im0.shape)
            segments = self.masks2segments(masks)
            return x[..., :6], segments, masks  # 返回边界框、分割区域和掩膜
        else:
            return [], [], []

    @staticmethod
    def masks2segments(masks):
        """
        将掩膜转换为分割区域
        Args:
            masks (numpy.ndarray): 模型输出的掩膜，形状为 (n, h, w)
        Returns:
            segments (List): 分割区域的列表
        """
        segments = []
        for x in masks.astype("uint8"):
            c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]  # 找到轮廓
            if c:
                c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
            else:
                c = np.zeros((0, 2))  # 如果没有找到分割区域，返回空数组
            segments.append(c.astype("float32"))
        return segments

    def crop_mask(self, masks, boxes):
        """
        裁剪掩膜，使其与边界框对齐
        Args:
            masks (Numpy.ndarray): [n, h, w] 掩膜数组
            boxes (Numpy.ndarray): [n, 4] 边界框
        Returns:
            (Numpy.ndarray): 裁剪后的掩膜
        """
        n, h, w = masks.shape
        x1, y1, x2, y2 = np.split(boxes, 4, axis=1)  # 分割边界框坐标
        x1, y1, x2, y2 = x1.flatten(), y1.flatten(), x2.flatten(), y2.flatten()  # 展平坐标数组

        # 确保边界框坐标在掩膜尺寸范围内
        x1 = np.clip(x1, 0, w - 1).astype(np.int32)
        y1 = np.clip(y1, 0, h - 1).astype(np.int32)
        x2 = np.clip(x2, 0, w - 1).astype(np.int32)
        y2 = np.clip(y2, 0, h - 1).astype(np.int32)

        # 创建网格
        r = np.arange(w, dtype=np.int32)[None, None, :]
        c = np.arange(h, dtype=np.int32)[None, :, None]

        # 裁剪掩膜
        result = np.zeros_like(masks, dtype=np.bool_)
        for i in range(n):
            result[i] = masks[i] * ((r >= x1[i]) & (r < x2[i]) & (c >= y1[i]) & (c < y2[i]))

        return result

    def process_mask(self, protos, masks_in, bboxes, im0_shape):
        """
        处理模型输出的掩膜
        Args:
            protos (numpy.ndarray): [mask_dim, mask_h, mask_w] 掩膜原型
            masks_in (numpy.ndarray): [n, mask_dim] 掩膜数量
            bboxes (numpy.ndarray): 缩放到原始图像尺寸的边界框
            im0_shape (tuple): 原始输入图像的尺寸 (h,w,c)
        Returns:
            (numpy.ndarray): 处理后的掩膜
        """
        c, mh, mw = protos.shape
        masks = np.matmul(masks_in, protos.reshape((c, -1))).reshape((-1, mh, mw)).transpose(1, 2, 0)  # HWN
        masks = np.ascontiguousarray(masks)
        masks = self.scale_mask(masks, im0_shape)  # 将掩膜从 P3 尺寸缩放到原始输入图像大小
        masks = np.einsum("HWN -> NHW", masks)  # HWN -> NHW
        masks = self.crop_mask(masks,bboxes)  # 裁剪掩膜
        return np.greater(masks, 0.5)  # 返回二值化后的掩膜

    @staticmethod
    def scale_mask(masks, im0_shape, ratio_pad=None):
        """
        将掩膜缩放至原始图像大小
        Args:
            masks (np.ndarray): 缩放和填充后的掩膜
            im0_shape (tuple): 原始图像大小
            ratio_pad (tuple): 填充与原始图像的比例
        Returns:
            masks (np.ndarray): 缩放后的掩膜
        """
        im1_shape = masks.shape[:2]
        if ratio_pad is None:  # 计算比例
            gain = min(im1_shape[0] / im0_shape[0], im1_shape[1] / im0_shape[1])  # 比例
            pad = (im1_shape[1] - im0_shape[1] * gain) / 2, (im1_shape[0] - im0_shape[0] * gain) / 2  # 填充
        else:
            pad = ratio_pad[1]

        # 计算掩膜的边界
        top, left = int(round(pad[1] - 0.1)), int(round(pad[0] - 0.1))  # y, x
        bottom, right = int(round(im1_shape[0] - pad[1] + 0.1)), int(round(im1_shape[1] - pad[0] + 0.1))
        if len(masks.shape) < 2:
            raise ValueError(f'"len of masks shape" 应该是 2 或 3，但得到 {len(masks.shape)}')
        masks = masks[top:bottom, left:right]
        masks = cv2.resize(
            masks, (im0_shape[1], im0_shape[0]), interpolation=cv2.INTER_LINEAR
        )  # 使用 INTER_LINEAR 插值调整大小
        if len(masks.shape) == 2:
            masks = masks[:, :, None]
        print("masks.shape",masks.shape)
        return masks

    def draw_and_visualize(self, im, bboxes, segments, save_path,vis=False, save=True):
        """
        绘制和可视化结果
        Args:
            im (np.ndarray): 原始图像，形状为 [h, w, c]
            bboxes (numpy.ndarray): [n, 4]，n 是边界框数量
            segments (List): 分割区域的列表
            vis (bool): 是否使用 OpenCV 显示图像
            save (bool): 是否保存带注释的图像
        Returns:
            None
        """
        # 创建图像副本
        im_canvas = im.copy()

        for (*box, conf, cls_), segment in zip(bboxes, segments):
            # 获取类别对应的颜色
            color = self.get_color_for_class(int(cls_))

            # 检查轮廓数据是否为空
            if len(segment) > 0:
                # 转换为 int32 类型
                segment = np.int32([segment])
                # 绘制轮廓
                cv2.polylines(im, segment, True, (255, 0, 0), 3)  # 绘制白色边框
                # 填充多边形
                cv2.fillPoly(im_canvas, segment, color)  # 使用类别对应的颜色填充多边形

            # 绘制边界框
            cv2.rectangle(im, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), color, 3, cv2.LINE_AA)
            # 在图像上绘制类别名称和置信度
            cv2.putText(im, f"{self.classes[cls_]}: {conf:.3f}", (int(box[0]), int(box[1] - 9)),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, color, 3, cv2.LINE_AA)

        # 将图像和绘制的多边形混合
        im = cv2.addWeighted(im_canvas, 0.3, im, 0.7, 0)

        # 显示图像
        if vis:
            cv2.imshow("seg_result_picture", im)
            cv2.waitKey(0)
            cv2.destroyAllWindows()

        # 保存图像
        if save:
            cv2.imwrite(save_path, im)

    def release(self):
        """
        释放 RKNN 资源
        """
        self.rknn.release()

if __name__ =="__main__":
    # 初始化 RKNN 模型
    out_rknn_path = "/home/code/rknn_test/models/best_rknn.rknn"
    onnx_model_path = "/home/code/rknn_test/models/best.onnx"
    yolo_seg = YOLO12SegRKNN(onnx_model_path, out_rknn_path, target=None)#加载onnx以此编译rknn进行推理

    # 读取图像
    image_path = "/home/code/rknn_test/frame_00000.jpg"
    save_path = "/home/code/rknn_test/out_imgs/seg_result_picture.jpg"
    image = cv2.imread(image_path)

    # 进行推理
    boxes, segments, masks = yolo_seg(image, conf_threshold=0.5, iou_threshold=0.3, nm=32) 

    # 绘制和可视化结果
    result_image = yolo_seg.draw_and_visualize(image, boxes, segments, save_path, vis=False, save=True)

    # 释放资源
    yolo_seg.release()

总结与后续

以上就是个人在分割任务中使用RKNN进行推理工作的分享，本文的重心主要是在进行RKNN推理输出上，并未论述和附出结果来验证pt模型转为rknn模型后精度的变化以及使用NPU后推理速度的变化，目前我在本地测试pt和onnx,rknn三个模型的检测精度差别不大都能有较好的检测分割效果，如果需要加快推理速度后续有时间再进行研究和分享或者使用c++进行推理加快检测速度。

语义控制中的交互式生成机制：Segmentation、Pose、Depth 多模态引导的实战剖析
努力分享一些人工智能、计算机视觉、影像等相关的知识干货！
06-25 1044
随着扩散模型能力的提升，如何将复杂语义结构（如语义分割图、人体姿态、深度信息）高效引入生成流程，成为控制精度与内容一致性提升的关键路径。本文聚焦三类主流语义控制方式——Segmentation、Pose、Depth，从模型结构设计、提示输入处理、交互方式设计到推理部署实战，系统解析其作用机理与落地策略。结合最新开源模型（如 ControlNet、T2I-Adapter）与平台工具（如 ComfyUI、Gradio），提供可复现的工程实践方案。
香橙派5 RK3588 RKNN开发环境配置 YOLOv8模型转换NPU部署推理 (2024.11)
weixin_45686120的博客
11-27 3933
配置的YOLOv8训练和测试环境，分别完成Windows PC YOLO模型训练机、Ubuntu PC RKNN模型开发机、RK3588 RKNPU边缘部署设备，三个平台的RKNN模型开发流程配置，使用瑞芯微提供RKNN Toolkit 2工具V2.3.0最新版，将yolov8模型转成onnx再转成rknn模型，最后交叉编译构建示例，实现在开发板使用C API调用NPU推理yolov8目标检测模型。
rk3566(泰山派)部署yolov5
2301_79057100的博客
07-11 954
泰山派rk3566部署yolov5
【华为昇腾】【Atlas 200】【青云1000】YOLOv5训练并部署到青云1000 基于Ascend 310
weixin_41973774的博客
07-01 9096
CANN（Compute Architecture for Neural Networks）是华为针对AI场景推出的异构计算架构用户在程序中调用CANN提供的接口（或包装后的接口），可以让程序利用昇腾NPU的算力进行计算地位类似于。
51c大模型~合集128
whaosoft~aiotの开发板商城
05-16 7704
例如，一系列（公认）无法在多项式时间内解决却可在多项式空间内解决的 NP-Complete（如旅行商等等），对于使用有限精度 Transformer 的 CoT 而言至少需要超越多项式（例如 exp (n)）规模的上下文长度，在真实应用中由于内存的限制完全不可行；纵观计算机科学的发展历史，这一「随时清理」的理念早已渗透到几乎所有计算模型之中：从最早的图灵机模型中，已读写的磁带符号可以被覆盖或重写，直到现在高级编程语言中，垃圾回收机制会自动清理不再可达的内存单元。随着问题规模增加，两者之间的差距愈发明显。
51c大模型~合集170
whaosoft~aiotの开发板商城
08-18 904
然而，当前的开源 dLLMs 却因一定的技术挑战 —— 例如缺少完善的 KV 缓存机制，以及未充分释放并行潜力 —— 推理速度远慢于同规模的 AR 模型。观察到，当模型的潜在空间从低维（如 4 通道）扩展到更高维（如 16 通道）时，尽管后者能表达更丰富的细节，但也偶发性地出现了一些生成 「翻车」的情况（如图 3 所示）。通过建模移动流量在时间、空间、城市环境之间的联合分布，UoMo 在多城市的预测任务中具备优越的性能表现，并且具备较好的零样本 / 小样本学习能力，体现出卓越的通用性与泛化能力。
51c大模型~合集81
whaosoft~aiotの开发板商城
11-30 1646
相比之下，本文的方法既能有效地保留主体的核心身份，又能进行多样化的、与上下文相适应的转换。为了创建用于监督扩散自蒸馏训练的成对数据集，研究者利用预训练文本到图像扩散模型的新兴多图像生成功能，生成由 LLM 生成的提示（第 3.1.2 节）所创建的潜在一致的普通图像（第 3.1.1 节）。这是一款专为移动平台量身打造的 MLLM，采用了算法与系统协同设计的创新理念，重新设计了主流 MLLM 的动态分辨率方案，并针对手机硬件特性进行了深度系统优化，从而实现了在手机上高效、流畅地运行 MLLM。
【城域网IBRAS】新华三APA（Application Awareness）单板
weixin_49199313的博客
07-16 761
智擎660的FIR硬件设计通过 ​​“分布式算法+线性相位优化+多通道DAE”​✅ ​分布式架构​：LUT分层与加法树突破乘法器资源瓶颈。✅ ​零相位失真​：对称预相加保障信号完整性。✅ ​动态可重构​：Engiant OS按需调整系数与功耗。​未来挑战⚠️ 3nm工艺下漏电流增加，需强化门控电路。⚠️ 1024阶以上FIR的LUT规模指数增长，需结合CIM（存内计算）技术突破。
MCP 协议：AI 时代的 “USB-C” 革命——从接口统一到生态重构的技术哲学
Thanks_ks 的嵌入式代码熔炉：炼出 STM32 到 RTOS 的极致效能！
04-23 940
本文解析 MCP 协议如何类比 USB-C 统一 AI 领域的模型、数据与硬件交互标准，打破“碎片化”困局。通过技术架构拆解、开发者与企业应用场景分析，探讨其加速 AI 民主化、催生新商业模式的潜力，并直面巨头博弈、安全隐私等挑战，展望其成为 AI 领域“TCP/IP”的终极愿景。
yolo学习笔记01——前置基础
qq_73960031的博客
08-28 983
本文介绍了计算机视觉中图像识别的三大任务：目标检测、图像分类和图像分割，重点分析了目标检测技术。目标检测需要识别物体类别并定位其位置，主要分为单阶段（如YOLO）和双阶段（如R-CNN）两种方法，前者速度快但精度较低，后者反之。文章详细阐述了目标检测的核心评估指标：交并比（IoU）衡量预测框与真实框的重合度，置信度反映模型对预测结果的信心程度，以及mAP通过PR曲线综合评估模型性能。这些技术在自动驾驶、安防监控、医疗影像等领域具有广泛应用。
[水果目标检测4]：YOLOv7-CA+追踪算法
cbdA_ZAI的博客
08-28 195
原文：Fruit Detection and Counting in Apple Orchards Based on Improved Yolov7 and Multi-Object Tracking Methods。
基于YOLOV5的电子围栏入侵检测
年轻即出发，
08-28 360
通过 YOLOv5 模型对监控画面中的目标（如人员、车辆）进行实时检测，输出目标的位置坐标（边界框信息）；若判定目标入侵围栏，系统即时触发告警机制（如推送弹窗、短信），同时关联视频截图或录像片段留存证据，形成 “目标检测 - 区域判定 - 告警响应” 的完整闭环，且可结合实际场景优化 YOLOv5 模型（如针对矿山场景标注数据训练，提升人员、矿车检测准确率），确保围栏判定的实时性（响应延迟≤1 秒）与准确性（入侵判定误报率≤5%）。│ └── ...（其余原始文件）转换命令（使用 ATC 工具）
无人机视角城市管理违规加盖顶棚大棚检测数据集VOC+YOLO格式1184张3类别
FL1623863129的博客
08-30 133
标注类别名称(注意yolo格式类别顺序不和这个对应，而以labels文件夹classes.txt为准):["blue_cover","green_house","others"]数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：1184。标注数量(xml文件个数)：1184。标注数量(txt文件个数)：1184。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
【完整源码+数据集+部署教程】硬币分类与识别系统源码和数据集：改进yolo11-SWC
2301_78772942的博客
08-29 1082
【完整源码+数据集+部署教程】硬币分类与识别系统源码和数据集：改进yolo11-SWC
【完整源码+数据集+部署教程】胚胎发育阶段检测系统源码和数据集：改进yolo11-SCConv
weixin_43860634的博客
08-29 2028
【完整源码+数据集+部署教程】胚胎发育阶段检测系统源码和数据集：改进yolo11-SCConv
基于YOLO11深度学习的桥梁缆索吊索缺陷检测系统【Python源码+Pyqt5界面+数据集+安装使用教程+训练代码】【附下载链接】
m0_37302966的博客
09-01 493
基于YOLO11深度学习的桥梁缆索吊索缺陷检测系统(带GUI界面)（Python源码+Pyqt5界面+1249张标注好的数据集+安装使用教程+训练好的模型+评估指标曲线+演示图片视频），开箱即用
YOLO 目标检测：YOLOv3网络结构、特征输出、FPN、多尺度预测
最新发布
2202_75674969的博客
09-01 749
YOLOv3是目标检测领域的经典模型，通过Darknet53主干网络实现高效特征提取，并引入残差连接缓解梯度消失。其核心创新在于多尺度检测机制，利用13×13、26×26、52×52三个不同分辨率的特征图分别检测大、中、小物体。通过FPN特征金字塔网络实现特征融合，结合自上而下的上采样和自下而上的卷积路径，将深层语义信息与浅层细节特征相结合，显著提升多尺度目标检测能力。模型采用CBL模块（卷积+批归一化+LeakyReLU）构建，最终输出包含边界框坐标、置信度和类别概率的预测结果。
基于YOLO11深度学习的植物叶片及缺陷检测系统【Python源码+Pyqt5界面+数据集+安装使用教程+训练代码】【附下载链接】
m0_37302966的博客
09-01 833
基于YOLO11深度学习的植物叶片及缺陷检测系统【Python源码+Pyqt5界面+数据集+安装使用教程+训练代码】【附下载链接】
YOLOv8--一些小样本数据增强方法
weixin_45679938的博客
09-01 811
水平翻转、垂直翻转、随机旋转、随机亮度调整、随机对比度调整、随机饱和度调整、随机灰度化、随机噪声添加、天气增强（云雾、亮度、对比度、饱和度等组合）、运动模糊增强、雾气增强、雨天增强、雪天增强。：场景无明确上下属性时（如卫星图像、水下拍摄），慎用于人像（翻转后不符合自然视角）。：大多数无方向属性的目标（如车辆、水果），避免用于文字、时钟等有固定方向的目标。：户外场景检测（如交通监控、无人机巡检），增强模型对雾天目标的识别能力。：增强模型对倾斜目标的识别能力（如货架上歪放的商品、倾斜停放的车辆）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值