瑞芯微板子使用探索【RK3588】

1 信息查看

1.1 查看RK系列

root@firefly:~# lspci
0002:20:00.0 PCI bridge: Fuzhou Rockchip Electronics Co., Ltd Device 3588 (rev 01)
0002:21:00.0 Network controller: Broadcom Inc. and subsidiaries Device 449d (rev 02

3588硬件信息：

• 内嵌的 NPU 支持 INT4/INT8/INT16/FP16 混合运算，算力高达 6TOP；
• 支持 8K@60fps 的H.265 和 VP9 解码器、8k@30fps 的 H.264 解码器和 4K@60fps 的 AV1 解码器；
• 支持 8K@30fps 的 H.264和 H.265 编码器，高质量的 JPEG 编码器/解码器，专门的图像预处理器和后处理器。

NPU加速：

使用NPU需要下载RKNN SDK，RKNN SDK 为带有 NPU 的 RK3588S/RK3588 芯片平台提供编程接口，能够帮助用户部署使用 RKNN-Toolkit2 导出的 RKNN 模型，加速 AI 应用的落地。

1.2 查看npu的使用情况

cat /sys/kernel/debug/rknpu/load
watch -n 1 cat /sys/kernel/debug/rknpu/load

2 瑞芯微RKNN开发流程

B站视频教程: https://www.bilibili.com/video/BV1Kj411D78q?p=3&vd_source=9138e2a910cf9bbb083cd42a6750ed10

RKNN开发流程

上图中包含了RKNN模型开发中用到的所用项目：

① RKNN工具rknn-toolkit2：https://github.com/rockchip-linux/rknn-toolkit2， RKNN-Toolkit-Lite2 provides Python programming interfaces for Rockchip NPU platform (RK3566, RK3568, RK3588, RK3588S) to help users deploy RKNN models and accelerate the implementation of AI applications.

• 提供了Python接口（RKNN， X86架构下）

• 模型转换功能，将onnx、torch、tensorflow等模型转onnx

• 模型推理，支持模拟推理和连板推理两种模式，在，若指定了target，即rknn.init_runtime(target='rk3588')，则是连板推理模式，需要通过usb连接到盒子上；若未指定target，即rknn.init_runtime(target=None)，默认在rknn-toolkit2的模拟器中进行推理；

• 性能评估，提供了模型性能分析函数，如：accuracy_analysis、eval_perf、eval_memory等接口，可以查看项目仓库中rknn-toolkit2/doc以及rknn-toolkit2/rknn_toolkit_lite2/docs中的文档。

• 开发需要的文档基本都在该仓库中，深入开发需仔细阅读对应的开发文档。

• 目录rknn-toolkit2/examples/onnx/yolov5中包含了yolov5的转换和推理文档，不过Coovally使用的yolov5在后处理阶段需要使用sigmoid，而该文档中缺失。

② RKNN工具rknn-toolkit lite 2。这个工具不是独立的，包含在rknn-toolkit2中，对应目录为rknn-toolkit2/rknn_toolkit_lite2。提供Python版本的模型推理功能，只能推理，对应RKNNLite类。

③ rknpu2：项目地址 https://github.com/rockchip-linux/rknpu2.git， 该提供了RKNN 开发的C SDK，运行在边端。

④ rknn_server：盒子中的服务程序，用于接收连板运行的名。盒子启动后，默认启动。若连板推理时，发现版本不匹配，可以从RKNPU2中复制对应的动态库， 如：rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknnrt.so。

3 模型转换

3.1 pth转ONNX

3.1.1 yolov5-det转onnx

yolov5官网提供了export.py脚本，环境配置好后，执行该脚本即可。

python3 export.py --weights ../models/yolov5s-det/13978/best.pt --include onnx --opset 12 --simplify

注意：RKNN必须使用opset=12

3.1.2 yolov8-det转onnx

参考：

• https://gitcode.net/magic_ll/yolov8-seg-to-rk3566
• https://blog.csdn.net/weixin_43999691/article/details/133307741

构建yolov8的开发环境，因为涉及修改yolov8的部分代码，所以最好直接将yolov8代码下载下来，单独构建一个yolov8的运行环境；

yolov8官方封装了YOLO类，直接调用转换即可【当前使用的版本是 Ultralytics YOLOv8.0.200】

from ultralytics import YOLO

if __name__ == "__main__":

    src_pt_model = "../models/yolov8-det/13981/best.pt"
    dst_onnx_model = "../models/yolov8-det/13981/best.onnx"

    src_pt_model = "../models/yolov8-seg/13931/best.pt"
    dst_onnx_model = "../models/yolov8-seg/13931/best.onnx"

    # Load a model
    model = YOLO(src_pt_model)  # load a custom trained model

    # Export the model
    model.export(format='onnx')

3.2 ONNX转RKNN

3.2.1 yolov5 ONNX转RKNN【服务器端操作】

RKNN工具rknn-toolkit2：https://github.com/rockchip-linux/rknn-toolkit2， RKNN-Toolkit-Lite2 provides Python programming interfaces for Rockchip NPU platform (RK3566, RK3568, RK3588, RK3588S) to help users deploy RKNN models and accelerate the implementation of AI applications.

因为使用的是RK3588板子，所以安装rknn-toolkit2

pip3 install rknn_toolkit2==1.5.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

直接使用pip3安装，提示ERROR: No matching distribution found for rknn_toolkit2==1.5.2，直接从github的release上下载，并安装，下载文件约356M，安装包为whl文件，解压后可以获得。包中仅仅支持36/38/310版本的python。

tar zxvf rknn-toolkit2-1.5.2.tar.gz
cd rknn-toolkit2-1.5.2/packages
pip3 install --no-dependencies rknn_toolkit2-1.5.2+b642f30c-cp38-cp38-linux_x86_64.whl -U -i https://pypi.tuna.tsinghua.edu.cn/simple   # 否则安装很多依赖包且报错，后续需要时再重新安装
pip3 install onnx onnxruntime onnxoptimizer onnxsim ruamel_yaml -i https://pypi.tuna.tsinghua.edu.cn/simple

如果直接在板子中安装，需要安装rknn-toolkit-lite 2。在rknn-toolkit2-1.5.2\rknn_toolkit_lite2\packages中找到rknn_toolkit_lite2-1.5.2-cp38-cp38-linux_aarch64.whl安装即可

参考：

• Python scripts performing object detection using the YOLOv8 model in ONNX：https://github.com/ibaiGorordo/ONNX-YOLOv8-Object-Detection

环境搭建好之后，调用RKNN的API转换即可。下面的代码转换为yolov5 onnx转rknn示例。RKNN模型默认精度是fp16。

import os
from rknn.api import RKNN

if __name__ == '__main__':

    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"
    src_onnx_model = "models/yolov5s-det/13978/best.onnx"
    dst_rknn_model = "models/yolov5s-det/13978/best_origin_3_output.rknn"

    # Create RKNN object
    rknn = RKNN()

    if not os.path.exists(src_onnx_model):
        print('model not exist')
        exit(-1)

    # pre-process config
    print('--> Config model')
    rknn.config(
        mean_values=[[0, 0, 0]],
        std_values=[[255, 255, 255]],
        target_platform='rk3588',
        quantized_method='channel',  # layer
        optimization_level=1  # 0  1  2  3
    )
    print('done')

    # Load ONNX model
    print('--> Loading model')
    ret = rknn.load_onnx(
        model=src_onnx_model,
        outputs=["/model.24/m.0/Conv_output_0", "/model.24/m.1/Conv_output_0", "/model.24/m.2/Conv_output_0"])
    if ret != 0:
        print('Load yolov5 failed!')
        exit(ret)
    print('done')

    # Build model
    print('--> Building model')
    ret = rknn.build(
        do_quantization=False,
        dataset=dataset,
        rknn_batch_size=1
    )
    if ret != 0:
        print('Build yolov5 failed!')
        exit(ret)
    print('done')

    # Export RKNN model
    print('--> Export RKNN model')
    ret = rknn.export_rknn(dst_rknn_model)
    if ret != 0:
        print('Export yolov5rknn failed!')
        exit(ret)
    print('done')

    ret = rknn.accuracy_analysis(inputs=[img_path])
    if ret != 0:
        print('Accuracy analysis failed!')
    print(ret)
    print('done')
    rknn.release()

• dataset.txt文本文件存放的就是用于量化的图片路径，如下：

/opt/data/code/yolov5-research/data/quantify_data/0/fa4f0905d4f1f68c07f2e0f3fc26ab39.jpg
/opt/data/code/yolov5-research/data/quantify_data/0/9dc8c98f67484b5fa921ee392fc68bc3.jpg
/opt/data/code/yolov5-research/data/quantify_data/0/8a047ffcc0c61a15632a54c73fe7f70e.jpg
/opt/data/code/yolov5-research/data/quantify_data/0/02f66416341f3224cb0123508ab98f1a.jpg
/opt/data/code/yolov5-research/data/quantify_data/0/eb6ac6aca0b14e9f766c7122d0d81fd1.jpg
/opt/data/code/yolov5-research/data/quantify_data/0/e4d231eb6464cd0f103bf72a06806264.jpg

3.2.2 yolov8 ONNX转RKNN【服务器端操作】

yolov8-det转rknn流程同yolov5。

4 模型量化

4.1 yolov5-det量化

4.1.1 普通量化

yolov5普通量化的示例代码如下，

import os
from rknn.api import RKNN

if __name__ == '__main__':

    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"
    src_onnx_model = "models/yolov5s-det/13978/best.onnx"
    dst_rknn_model = "models/yolov5s-det/13978/best_int8_3_output.rknn"

    # Create RKNN object
    rknn = RKNN()

    if not os.path.exists(src_onnx_model):
        print('model not exist')
        exit(-1)

    # pre-process config
    print('--> Config model')
    rknn.config(
        mean_values=[[0, 0, 0]],
        std_values=[[255, 255, 255]],
        target_platform='rk3588',
        quantized_dtype="asymmetric_quantized-8",
        # quantized_algorithm="mmse",  # normal
        quantized_method='channel',  # layer
        optimization_level=1  # 0  1  2  3
    )
    print('done')

    # Load ONNX model
    print('--> Loading model')
    ret = rknn.load_onnx(
        model=src_onnx_model,
        outputs=["/model.24/m.0/Conv_output_0", "/model.24/m.1/Conv_output_0", "/model.24/m.2/Conv_output_0"])
    if ret != 0:
        print('Load yolov5 failed!')
        exit(ret)
    print('done')

    # Build model
    print('--> Building model')
    ret = rknn.build(do_quantization=True, dataset=dataset, rknn_batch_size=1)
    if ret != 0:
        print('Build yolov5 failed!')
        exit(ret)
    print('done')

    # Export RKNN model
    print(f'--> Export RKNN model to {dst_rknn_model}')
    # ret = rknn.export_rknn(dst_rknn_model, cpp_gen_cfg=True, target='rk3588')
    ret = rknn.export_rknn(dst_rknn_model)
    if ret != 0:
        print('Export yolov5rknn failed!')
        exit(ret)
    print('done')

    ret = rknn.accuracy_analysis(inputs=[img_path], target='rk3588')
    if ret != 0:
        print('Accuracy analysis failed!')
    print(ret)
    print('done')

    rknn.release()

关键点：

• rknn.config中设置量化的相关参数，可以参考《Rockchip_User_Guide_RKNN_Toolkit2_CN-1.5.2.pdf》
• rknn.load_onnx，这里要指定outputs，用于截掉网络中无法使用sigmoid的层。如下图所示，红色框去除，解码绿色框部分。

yolov5_3_output.png

• rknn.build，编译模型，启用量化，设置batch_size。
• rknn.export_rknn，导出rknn模型。
• rknn.accuracy_analysis，对模型进行性能分析。

4.1.2 混合量化

混合量化就是对模型中进行int8量化之后精度损失较大的部分，再修改为fp16，不使用int8量化。包含两个步骤，具体可参考文档《Rockchip_User_Guide_RKNN_Toolkit2_CN-1.5.2.pdf》。

步骤1：hybrid_quantization_step1，yolov5-det示例代码

import os
from rknn.api import RKNN

if __name__ == "__main__":
    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"
    src_onnx_model = "models/yolov5s-det/13978/best.onnx"

    # Create RKNN object
    rknn = RKNN()

    if not os.path.exists(src_onnx_model):
        print('model not exist')
        exit(-1)

    # pre-process config
    print('--> Config model')
    rknn.config(
        mean_values=[[0, 0, 0]],
        std_values=[[255, 255, 255]],
        target_platform='rk3588'
    )
    print('done')

    # Load ONNX model
    print('--> Loading model')
    ret = rknn.load_onnx(
        model=src_onnx_model,
        outputs=["/model.24/m.0/Conv_output_0", "/model.24/m.1/Conv_output_0", "/model.24/m.2/Conv_output_0"])
    if ret != 0:
        print('Load yolov5 failed!')
        exit(ret)
    print('done')

    # Build model
    rknn.hybrid_quantization_step1(
        dataset=dataset,
        rknn_batch_size=1,
        proposal=True,
        proposal_dataset_size=1
    )

    rknn.release()

步骤2：hybrid_quantization_step2，使用步骤1的输出，作为步骤2 的输入。步骤1生成的best.quantization.cfg用于说明需要修回fp16的节点。若第一步骤中的proposal=False，这里必须手动修改。若proposal=True,则自动生成需要修改的节点。yolov5-det示例代码。

from rknn.api import RKNN

if __name__ == "__main__":
    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"
    dst_rknn_model = "models/yolov5s-det/13978/best_hybrid8_3_output.rknn"

    # Create RKNN object
    rknn = RKNN()

    # hybrid_quantization_step2, 输入均为第1步输出的文件
    rknn.hybrid_quantization_step2(
        model_input="best.model",
        data_input="best.data",
        model_quantization_cfg="best.quantization.cfg"
    )

    # Export RKNN model
    print('--> Export RKNN model')
    ret = rknn.export_rknn(dst_rknn_model, target='rk3588')
    if ret != 0:
        print('Export yolov5rknn failed!')
        exit(ret)
    print('done')

    rknn.accuracy_analysis(
        inputs=[img_path],
        target='rk3588',
    )


    rknn.release()

4.1.3 量化前后对比

注意：rknn模型也可以通过Netron进行查看，不过要使用较新的版本，下面是yolov5未量化、int8量化、混合精度的对比。

各种量化对比

4.1.4 量化过程遇到的问题

问题1：为何yolov5使用int8量化之后，推理速度反而变慢了？

量化前后，输出的维度不一样了，batch_size 变成了32。这个是因为我在服务器上量化时，把batch size设置为了32，把batch_size设置为1即可。

ret = rknn.build(do_quantization=True, dataset=dataset, rknn_batch_size=1)

问题2：按照yolov5的前处理进行时，推理结果异常

由于rknn默认使用的是data_format="nhwc"，而正常yolov5使用的顺序是data_format="nchw"，因此可以在前处理部分修改，也可以在inference调用是显示指定data_format="nchw"。但是在rk3588上使用data_format="nchw"时，提示不支持nchw，所以建议还是使用默认的“nhwc”顺序。

rk_result = self._rk_session.inference(inputs=[img], data_format="nhwc")

问题3：模型量化之后，后处理该如何做？

直接按照未量化前的数据格式输入模式，int8量化模型推理的置信度会全为0；

参考：

• https://blog.csdn.net/wave789/article/details/132446886
• https://github.com/airockchip/rknn_model_zoo
• rknn的后处理代码分析: https://zhuanlan.zhihu.com/p/648638273
• RKNPU2 从入门到实践（基于RK3588和RK3568）: https://www.bilibili.com/video/BV1Kj411D78q/?p=5&vd_source=9138e2a910cf9bbb083cd42a6750ed10
• https://github.com/wangqiqi/yolov5/tree/rknn_dev
• https://github.com/airockchip/yolov5/tree/master
• https://www.51openlab.com/article/257/

解决方法：yolov5 3个卷积之后有sigmoid操作，如果这个时候使用int8量化，则输出的结果都是0。解决方法加载onnx模型时提取卷积之后的结果，然后手动写后处理后处理操作。

# Load ONNX model
ret = rknn.load_onnx(
    model=src_onnx_model,
    outputs=["/model.24/m.0/Conv_output_0", "/model.24/m.1/Conv_output_0", "/model.24/m.2/Conv_output_0"])

问题4：yolov5 seg直接取output0和output1的输出进行后处理之后，可以获得正确的结果，但是取/model.22/Mul_2_output_0、/model.22/Split_output_1、/model.22/Concat_output_0、/model.22/proto/cv3/conv/Conv_output_0推理的结果存在截断的情况？
<img src="https://upload-images.jianshu.io/upload_images/1700062-cc11052edfe858e1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240" alt="轮廓被截断" style="zoom:50%;" />

原因分析，绘制出bbox，发现在后处理过程中，bbox缩放错误，导致了分割区域出现被切分的现象。

问题5：yolov5 seg直接转rknn，使用默认的2个输出，不进行量化，但是推理仍然无结果
原因分析：yolov5 seg训练时使用的参数是768x768，而使用export.py转onnx时，默认是640x640，虽然可以直接转rknn模型，但是推理无结果。解决方法是在导出脚本上添加模型的输入尺寸。

python3 export.py --weights ../models/yolov5s-seg/13933/best.pt --include onnx --opset 12 --simplify --img-size 768 768

4.2 yolov8-det量化

4.2.1 普通量化

不修改模型，导出默认的输出，由于sigmoid函数的影响，导致输出无结果，因此量化后保证模型可以使用，必须导出2个节点，或者6个节点。

导出两个节点的RKNN模型（无需修改模型代码直接导出即可）：

import os
from rknn.api import RKNN

if __name__ == '__main__':

    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"
    src_onnx_model = "models/yolov8s-det/13980/best_normal.onnx"
    dst_rknn_model = "models/yolov8s-det/13980/best_2_output_int8.rknn"

    # Create RKNN object
    rknn = RKNN()

    if not os.path.exists(src_onnx_model):
        print('model not exist')
        exit(-1)

    # pre-process config
    print('--> Config model')
    rknn.config(
        mean_values=[[0, 0, 0]],
        std_values=[[255, 255, 255]],
        target_platform='rk3588',
        quantized_dtype="asymmetric_quantized-8",
        quantized_method='channel',  # layer
        optimization_level=1  # 0  1  2  3
    )
    print('done')

    # Load ONNX model
    print('--> Loading model')
    ret = rknn.load_onnx(
        model=src_onnx_model,
        outputs=['/model.22/Mul_2_output_0', '/model.22/Split_output_1']
    )
    if ret != 0:
        print('Load yolov8 failed!')
        exit(ret)
    print('done')

    # Build model
    print('--> Building model')
    ret = rknn.build(do_quantization=True, dataset=dataset, rknn_batch_size=1)
    if ret != 0:
        print('Build yolov8 failed!')
        exit(ret)
    print('done')

    # Export RKNN model
    print(f'--> Export RKNN model {dst_rknn_model}')
    ret = rknn.export_rknn(dst_rknn_model)
    if ret != 0:
        print('Export yolov8rknn failed!')
        exit(ret)
    print('done')

    ret = rknn.accuracy_analysis(inputs=[img_path])
    if ret != 0:
        print('Accuracy analysis failed!')
    print(ret)
    print('done')

导出6个输出的模型，需要先修改模型代码，再导出onnx，再转换。

修改1：ultralytics/nn/modules/head.py，在class Detect新增“导出onnx增加”下的代码。同时把forward中的函数替换成下面的forward。

class Detect(nn.Module):
    """YOLOv8 Detect head for detection models."""
    dynamic = False  # force grid reconstruction
    export = False  # export mode
    shape = None
    anchors = torch.empty(0)  # init
    strides = torch.empty(0)  # init

    # 导出onnx增加
    conv1x1 = nn.Conv2d(16, 1, 1, bias=False).requires_grad_(False)
    x = torch.arange(16, dtype=torch.float)
    conv1x1.weight.data[:] = nn.Parameter(x.view(1, 16, 1, 1))
    
    def forward(self, x):
        y = []
        for i in range(self.nl):
            t1 = self.cv2[i](x[i])
            t2 = self.cv3[i](x[i])
            y.append(self.conv1x1(t1.view(t1.shape[0], 4, 16, -1).transpose(2, 1).softmax(1)))
            # y.append(t2.sigmoid())
            y.append(t2)
        return y

修改2：ultralytics/engine/exporter.py。在函数export_onnx()将output_names替换掉，如下:

# output_names = ['output0', 'output1'] if isinstance(self.model, SegmentationModel) else ['output0']
output_names = ['reg1', 'cls1',  'reg2', 'cls2',  'reg3', 'cls3']

导出onnx

import os
from ultralytics import YOLO

if __name__ == "__main__":
    input_height, input_width = 640, 640
    src_pt_model = "models/yolov8s-det/13980/best.pt"

    # Load a model
    model = YOLO(src_pt_model)  # load a custom trained model

    # Export the model
    model.export(
        format='onnx',
        imgsz=[input_height, input_width],
        opset=12,
        verbose=True,
        simplify=True
    )

    src_onnx_model = "models/yolov8s-det/13980/best.onnx"
    dst_onnx_model = "models/yolov8s-det/13980/best_6_output.onnx"
    os.rename(src_onnx_model, dst_onnx_model)
    print(f"rename {src_onnx_model} to {dst_onnx_model}")

转换为6个输出的RKNN模型

import os
from rknn.api import RKNN


if __name__ == '__main__':

    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"
    src_onnx_model = "models/yolov8s-det/13980/best_6_output.onnx"
    dst_rknn_model = "models/yolov8s-det/13980/best_6_output_int8.rknn"

    # Create RKNN object
    rknn = RKNN()

    if not os.path.exists(src_onnx_model):
        print('model not exist')
        exit(-1)

    # pre-process config
    print('--> Config model')
    rknn.config(mean_values=[[0, 0, 0]], std_values=[[255, 255, 255]], target_platform='rk3588')
    print('done')

    # Load ONNX model
    print('--> Loading model')
    ret = rknn.load_onnx(
        model=src_onnx_model,
        outputs=['reg1', 'cls1',  'reg2', 'cls2',  'reg3', 'cls3']
    )
    if ret != 0:
        print('Load yolov8 failed!')
        exit(ret)
    print('done')

    # Build model
    print('--> Building model')
    ret = rknn.build(
        do_quantization=True,
        dataset=dataset,
        rknn_batch_size = 1
    )
    if ret != 0:
        print('Build yolov8 failed!')
        exit(ret)
    print('done')

    # Export RKNN model
    print(f'--> Export RKNN model to {dst_rknn_model}')
    ret = rknn.export_rknn(dst_rknn_model)
    if ret != 0:
        print('Export yolov8rknn failed!')
        exit(ret)
    print('done')

    ret = rknn.accuracy_analysis(inputs=[img_path], target="rk3588")
    if ret != 0:
        print('Accuracy analysis failed!')
    print(ret)
    print('done')

4.2.2 混合精度量化

混合量化步骤1：

import os
import shutil
from rknn.api import RKNN


if __name__ == "__main__":
    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"

    output_node_count = 2
    if output_node_count == 2:
        src_onnx_model = "models/yolov8s-det/13980/best_normal.onnx"
        tmp_model_dir = "models/yolov8s-det/13980/best_2_output_hybrid"
        os.makedirs(tmp_model_dir, exist_ok=True)
    elif output_node_count == 6:
        # 需要修改源码，实现best_6_output.onnx的导出
        src_onnx_model = "models/yolov8s-det/13980/best_6_output.onnx"
        tmp_model_dir = "models/yolov8s-det/13980/best_6_output_hybrid"
        os.makedirs(tmp_model_dir, exist_ok=True)

    # Create RKNN object
    rknn = RKNN()

    if not os.path.exists(src_onnx_model):
        print('model not exist')
        exit(-1)

    # pre-process config
    print('--> Config model')
    rknn.config(
        mean_values=[[0, 0, 0]],
        std_values=[[255, 255, 255]],
        target_platform='rk3588'
    )
    print('done')

    # Load ONNX model
    print('--> Loading model')
    if output_node_count == 2:
        ret = rknn.load_onnx(
            model=src_onnx_model,
            outputs=['/model.22/Mul_2_output_0', '/model.22/Split_output_1']
        )
        if ret != 0:
            print('Load yolov8 failed!')
            exit(ret)
    elif output_node_count == 6:
        ret = rknn.load_onnx(
            model=src_onnx_model,
            outputs=['reg1', 'cls1',  'reg2', 'cls2',  'reg3', 'cls3']
        )
        if ret != 0:
            print('Load yolov8 failed!')
            exit(ret)
        print('done')
    else:
        raise Exception(f"invalid output_node_count = {output_node_count}")
    print(f'output_node_count = {output_node_count}, done')

    # Build model
    rknn.hybrid_quantization_step1(
        dataset=dataset,
        rknn_batch_size=1,
        proposal=True,
        proposal_dataset_size=1
    )

    rknn.release()

    # move file
    file_prefix = os.path.basename(src_onnx_model)[0:-5]
    shutil.move(file_prefix + ".model", os.path.join(tmp_model_dir, file_prefix + ".model"))
    shutil.move(file_prefix + ".data", os.path.join(tmp_model_dir, file_prefix + ".data"))
    shutil.move(file_prefix + ".quantization.cfg", os.path.join(tmp_model_dir, file_prefix + ".quantization.cfg"))
    print(f"copy files to {tmp_model_dir}")

混合量化步骤2：

import os
from rknn.api import RKNN

if __name__ == "__main__":
    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"

    output_node_count = 2
    if output_node_count == 2:
        src_onnx_model = "models/yolov8s-det/13980/best_normal.onnx"
        tmp_model_dir = "models/yolov8s-det/13980/best_2_output_hybrid"
        dst_rknn_model = "models/yolov8s-det/13980/best_2_output_hybrid_custom.rknn"
        os.makedirs(tmp_model_dir, exist_ok=True)
    elif output_node_count == 6:
        # 需要修改源码，实现best_6_output.onnx的导出
        src_onnx_model = "models/yolov8s-det/13980/best_6_output.onnx"
        tmp_model_dir = "models/yolov8s-det/13980/best_6_output_hybrid"
        dst_rknn_model = "models/yolov8s-det/13980/best_6_output_hybrid.rknn"
        os.makedirs(tmp_model_dir, exist_ok=True)

    # Create RKNN object
    rknn = RKNN()

    # hybrid_quantization_step2, 输入均为第1步输出的文件
    file_prefix = os.path.basename(src_onnx_model)[0:-5]
    rknn.hybrid_quantization_step2(
        model_input=os.path.join(tmp_model_dir, file_prefix + ".model"),
        data_input=os.path.join(tmp_model_dir, file_prefix + ".data"),
        model_quantization_cfg= os.path.join(tmp_model_dir, file_prefix + ".quantization_custom.cfg")
    )

    # Export RKNN model
    print('--> Export RKNN model')
    ret = rknn.export_rknn(dst_rknn_model, target='rk3588')
    if ret != 0:
        print('Export yolov8rknn failed!')
        exit(ret)
    print('done')

    rknn.accuracy_analysis(
        inputs=[img_path],
        target='rk3588',
    )

    rknn.release()

4.2.3 量化过程中遇到的问题

问题1：yolov8导出onnx后，量化为int8之后，为什么置信度量化后全为0？

因为sigmoid的值域(0,1)，int8量化后就为0了。所以去掉sigmoid。导出下面红色框中的两层即可，'/model.22/Mul_2_output_0', '/model.22/Split_output_1'。

yolov8去除的output

参考：

• yolov8-det转换：https://blog.csdn.net/wave789/article/details/132446886
• yolov8n_official_onnx_tensorRT_rknn_horizon：https://github.com/cqu20160901/yolov8n_official_onnx_tensorRT_rknn_horizon
• 瑞芯微rk3566部署yolov8实践： https://zhuanlan.zhihu.com/p/648031088
• yolov8 瑞芯微RKNN和地平线Horizon芯片仿真测试部署： https://blog.csdn.net/zhangqian_1/article/details/128918268

问题2：yolov8混合量化时报错？

E hybrid_quantization_step1: Catch exception when building RKNN model!
E hybrid_quantization_step1: Traceback (most recent call last):
E hybrid_quantization_step1:   File "rknn/api/rknn_base.py", line 2109, in rknn.api.rknn_base.RKNNBase.hybrid_quantization_step1
E hybrid_quantization_step1:   File "rknn/api/quantizer.py", line 265, in rknn.api.quantizer.Quantizer.save_hybrid_cfg
E hybrid_quantization_step1:   File "rknn/api/quantizer.py", line 268, in rknn.api.quantizer.Quantizer.save_hybrid_cfg
E hybrid_quantization_step1:   File "/opt/data/virtualenvs/yolov8/lib/python3.8/site-packages/ruamel/yaml/main.py", line 1229, in dump
E hybrid_quantization_step1:     error_deprecation('dump', 'dump', arg="typ='unsafe', pure=True")
E hybrid_quantization_step1:   File "/opt/data/virtualenvs/yolov8/lib/python3.8/site-packages/ruamel/yaml/main.py", line 1017, in error_deprecation
E hybrid_quantization_step1:     sys.exit(1)
E hybrid_quantization_step1: SystemExit: 1

参考：https://github.com/laitathei/YOLOv8-ONNX-RKNN-HORIZON-TensorRT-Segmentation/tree/master

ruamel_yaml版本的问题，默认安装的版本过高，导致执行失败，重新安装ruamel_yaml即可。

pip3 install ruamel_yaml==0.17.40 -i https://pypi.tuna.tsinghua.edu.cn/simple

问题3：yolov8 int8或者混合精度量化之后，无论使用1个输出、2个输出、6个输出，都无法检测结果，而fp16正常推理？

原因分析：出现该问题主要在预处理上，yolov8的预处理默认进行了归一化即除掉了255，导出时使用mean_values=[[0, 0, 0]], std_values=[[1, 1, 1]]若使用fp16时是没问题的，但int8时，先除255归一化之后，输入的值可能已经是空了，所以很难推理出结果。

解决方法，导出时使用mean_values=[[0, 0, 0]], std_values=[[255, 255, 255]]，预处理中把除255去掉。说明，量化之后在前处理时，就不能再Normalize。

# image_data = np.array(img) / 255.0

问题4：yolov8 int8量化之后，2个输出时，检测框会发生偏移，6个输出时，检测框偏大，但不偏移。

原因分析：yolov8 2输出时， int8、fp16、hybrid转换之后，使用同一套前后处理代码，int8、hybrid之后的模型均存在检测框偏移的情况，从而可以推断是模型推理的问题。6个输出之所以不存在检测结果偏移的问题，是因为6个输出后都是基于fp32推理的。基于此，如果使用混合精度量化，模仿6输出，将6输出后的层全部设置为float16，应该就可以解决检测框偏移的问题。在best_6_output.quantization.cfg文件中添加一下内容，在生成混合精度的量化时，该问题解决。

custom_quantize_layers:
    /model.22/cv2.2/cv2.2.0/conv/Conv_output_0: float16
    /model.22/cv2.2/cv2.2.0/act/Mul_output_0: float16
    /model.22/cv2.2/cv2.2.1/conv/Conv_output_0: float16
    /model.22/cv2.2/cv2.2.1/act/Mul_output_0: float16
    /model.22/cv2.2/cv2.2.2/Conv_output_0: float16
    /model.22/cv3.2/cv3.2.0/conv/Conv_output_0: float16
    /model.22/cv3.2/cv3.2.0/act/Mul_output_0: float16
    /model.22/cv3.2/cv3.2.1/conv/Conv_output_0: float16
    /model.22/cv3.2/cv3.2.1/act/Mul_output_0: float16
    /model.22/cv3.2/cv3.2.2/Conv_output_0: float16
    /model.22/Concat_2_output_0: float16
    /model.22/Reshape_2_output_0_shape4_/model.22/Concat_3: float16
    /model.22/cv2.1/cv2.1.0/conv/Conv_output_0: float16
    /model.22/cv2.1/cv2.1.0/act/Mul_output_0: float16
    /model.22/cv2.1/cv2.1.1/conv/Conv_output_0: float16
    /model.22/cv2.1/cv2.1.1/act/Mul_output_0: float16
    /model.22/cv2.1/cv2.1.2/Conv_output_0: float16
    /model.22/cv3.1/cv3.1.0/conv/Conv_output_0: float16
    /model.22/cv3.1/cv3.1.0/act/Mul_output_0: float16
    /model.22/cv3.1/cv3.1.1/conv/Conv_output_0: float16
    /model.22/cv3.1/cv3.1.1/act/Mul_output_0: float16
    /model.22/cv3.1/cv3.1.2/Conv_output_0: float16
    /model.22/Concat_1_output_0: float16
    /model.22/Reshape_1_output_0_shape4_/model.22/Concat_3: float16
    /model.22/cv2.0/cv2.0.0/conv/Conv_output_0: float16
    /model.22/cv2.0/cv2.0.0/act/Mul_output_0: float16
    /model.22/cv2.0/cv2.0.1/conv/Conv_output_0: float16
    /model.22/cv2.0/cv2.0.1/act/Mul_output_0: float16
    /model.22/cv2.0/cv2.0.2/Conv_output_0: float16
    /model.22/cv3.0/cv3.0.0/conv/Conv_output_0: float16
    /model.22/cv3.0/cv3.0.0/act/Mul_output_0: float16
    /model.22/cv3.0/cv3.0.1/conv/Conv_output_0: float16
    /model.22/cv3.0/cv3.0.1/act/Mul_output_0: float16
    /model.22/cv3.0/cv3.0.2/Conv_output_0: float16
    /model.22/Concat_output_0: float16
    /model.22/Reshape_output_0_shape4_/model.22/Concat_3: float16
    /model.22/Concat_3_output_0: float16
    /model.22/Split_output_0_shape4: float16
    /model.22/Split_output_1_shape4: float16
    /model.22/dfl/Reshape_output_0: float16
    /model.22/dfl/Softmax_pre_tp: float16
    /model.22/dfl/Softmax_new: float16
    /model.22/dfl/conv/Conv_output_0: float16
    /model.22/dfl/Reshape_1_output_0_shape4_/model.22/Slice_2split: float16
    /model.22/dfl/Reshape_1_output_0_shape4_/model.22/Slice_2split_conv_/model.22/Slice_2split: float16
    /model.22/Slice_output_0_shape4_before_conv: float16
    /model.22/Slice_1_output_0: float16
    /model.22/Slice_output_0: float16
    /model.22/Sub_output_0: float16
    /model.22/Add_1_output_0: float16
    /model.22/Sub_1_output_0: float16
    /model.22/Concat_4_swap_concat_reshape_i1_out: float16
    /model.22/Add_2_output_0: float16
    /model.22/Div_1_output_0: float16
    /model.22/Concat_4_swap_concat_reshape_i0_out: float16
    /model.22/Concat_4_output_0_shape4: float16
    /model.22/Mul_2_output_0_shape4_before: float16
    /model.22/Mul_2_output_0: float16
    /model.22/Split_output_1: float16

说明量化之后模型的检测性能存在不稳定性，需要仔细分析，慎重量化。

4.2.4 yolov8-det量化总结

主要结论如下：

• 默认输出1个output，output0，int8量化之后无推理结果，无需修改官方源码；
• 2个output，'/model.22/Mul_2_output_0', '/model.22/Split_output_1'，int8量化之后无推理结果，无需修改官方源码；
• 6个output，'reg1', 'cls1', 'reg2', 'cls2', 'reg3', 'cls3'，int8量化之后有推理结果，需要修改官方源码；
• 导出rknn时，mean_values=[[0, 0, 0]], std_values=[[255, 255, 255]]使用这两个值，前处理不进行归一化，否则量化之后无法推理；
• yolov8导出onnx前需要修改源代码，int8仅在导出2/6个输出的版本时可以正确推理；
• 量化之后，输出节点为2个时，推理结果的检测框存在向左上偏移的现象；
• 量化之后，输出节点为6个时，推理结果的检测框偏大，但不会发生偏移；
• 未量化之前，输出节点为6个或者2时，推理结果的检测框均正常；
• 建议先使用输出节点为6的量化模型，或者对2个输出节点的模型，定制化量化内容，再量化为混合精度。

4.3 yolov8-seg量化

yolov8默认输出两个节点，分别是output0和output1，output0对应的是目标检测结果和部分分割结果，output1是部分分割结果。因此可以从output0中提取/model.22/Mul_2_output_0、/model.22/Split_output_1、/model.22/Concat_output_0，从output1的上一层提取/model.22/proto/cv3/conv/Conv_output_0，构成四个节点的输出，防止量化后，因sigmoid操作导致无检测结果。

• 输出两节点：'output0', 'output1'， 量化之后无推理结果。
• 输出四节点：'/model.22/Mul_2_output_0', '/model.22/Split_output_1', '/model.22/Concat_output_0','/model.22/proto/cv3/conv/Conv_output_0，量化之后可以推理。

5 模型部署

5.1 在板子上部署

参考：yolov5篇---yolov5训练pt模型并转换为rknn模型，部署在RK3588开发板上——从训练到部署全过程 https://blog.csdn.net/m0_46825740/article/details/128818516

下载rknpu2：https://github.com/rockchip-linux/rknpu2

下面的命令是在边端设备上使用官方提供的代码，编译完成后，进行推理的示例。

git clone https://github.com/rockchip-linux/rknpu2.git

- examples/rknn_yolov5_demo => #define OBJ_CLASS_NUM 3  # 修改为对应类别数
- coco_80_labels_list.txt   # 修改对应的标签

./build-linux_RK3588.sh
./rknn_yolov5_demo ./model/RK3588/yolov5s-640-640.rknn ./model/bus.jpg
./rknn_yolov5_video_demo ./model/RK3588/yolov5s-640-640.rknn 28ab8ba8a51a8e46eabc58575b6c208e.mp4 264
./rknn_yolov5_video_demo ./model/RK3588/yolov5s-640-640.rknn vlc-record-2023-09-22-11h14m49s.mp4 264

5.2 问题

问题1：固件中rknn_server版本较低
解决方法：更新rknn_server【开发模式】

cp /root/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/restart_rknn.sh /usr/bin
cp /root/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/start_rknn.sh /usr/bin
cp /root/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/rknn_server /usr/bin

问题2：复制更新rknn_server后，执行提示库的版本不对

root@firefly:/usr/bin# 1090443 RKNN SERVER loadRuntime(110): dlsym rknn_set_input_shapes failed: /lib/librknnrt.so: undefined symbol: rknn_set_input_shapes, reuqired librknnrt.so >= 1.5.2!
E RKNN: [07:43:34.070] 6, 4
E RKNN: [07:43:34.070] Invalid RKNN model version 6
E RKNN: [07:43:34.070] rknn_init, load model failed!
1090444 RKNN SERVER init(183): rknn_init fail! ret=-6
1090444 RKNN SERVER process_msg_init(381): Client 1 init model fail!

解决方法：复制对应的库，然后重启rknn_server即可

cp /root/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknnrt.so /lib/
restart_rknn.sh

问题3：E RKNN: [12:54:27.331] Mismatch driver version, librknnrt version: 1.5.2 (c6b7b351a@2023-08-23T15:28:22) requires driver version >= 0.7.0, but you have driver version: 0.6.4 which is incompatible!

原因及解决方法：出现这个错误，说明板子的固件版本较低，在官网下载对应的固件，并重新烧写即可。

6 模型推理

6.1 使用python rknn推理【服务器端】

加载转换生成的rknn模型进行推理。这里有个关键点，即rknn.init_runtime(target='rk3588', core_mask=RKNN.NPU_CORE_AUTO)，若target设置为对应的目标设备型号，则进行连板推理，也就是通过rknn_server在边缘设备上推理。若target设置为None，则在模拟器上进行推理。

import os
import cv2
import tqdm
from rknn.api import RKNN
import multiprocessing

def process(rknn_model, img_path):
    # Create RKNN object
    rknn = RKNN()
    if not os.path.exists(rknn_model):
        print('model not exist')
        exit(-1)

    rknn.load_rknn(rknn_model)
    rknn.init_runtime(target='rk3588', core_mask=RKNN.NPU_CORE_AUTO)

    img = cv2.imread(filename=img_path)
    img = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2RGB)
    img = cv2.resize(img, (640, 640))

    for item in tqdm.trange(10):
        result = rknn.inference(inputs=[img], data_format="nhwc")
        # print(result[0].shape)

    rknn.release()

def main():
    img_path = "data/car.jpg"
    dataset = "data/dataset.txt"
    rknn_model = "models/yolov5s-det/13978/best_hybrid8_3_output.rknn"
    p_count = 1
    p_list = list()
    for _ in range(p_count):
        p = multiprocessing.Process(target=process, args=(rknn_model, img_path))
        p_list.append(p)
    for p in p_list:
        p.start()
    for p in p_list:
        p.join()
    print("process over")

if __name__ == '__main__':
    main()

6.2 使用python rknnlite推理【边缘设备端】

参考rknn_toolkit_lite2\examples\inference_with_lite\test.py编写测试例子。

import os
import cv2
import tqdm
import time
import platform
import numpy as np
from rknnlite.api import RKNNLite

def get_host():
    device_compatible_node = '/proc/device-tree/compatible'
    # get platform and device type
    system = platform.system()
    machine = platform.machine()
    os_machine = system + '-' + machine
    if os_machine == 'Linux-aarch64':
        try:
            with open(device_compatible_node) as f:
                device_compatible_str = f.read()
                if 'rk3588' in device_compatible_str:
                    host = 'RK3588'
                else:
                    host = 'RK356x'
        except IOError:
            print('Read device node {} failed.'.format(device_compatible_node))
            exit(-1)
    else:
        host = os_machine
    return host

if __name__ == "__main__":
    host_name = get_host()
    print(host_name)

    rknn_file = "model/yolov5s-det/13978/best.rknn"
    rknn_file = "model/yolov5s-det/13978/best_int8.rknn"


    if not os.path.exists(rknn_file):
        print(f"{rknn_file} not exist")
        exit(0)

    rknn = RKNNLite(verbose=False, verbose_file="verbose.log")
    rknn.load_rknn(rknn_file)
    rknn.init_runtime(target=host_name, core_mask=RKNNLite.NPU_CORE_AUTO)

    ori_img = cv2.imread('./data/car.jpg')
    img = cv2.cvtColor(ori_img, cv2.COLOR_BGR2RGB)
    resized_image = cv2.resize(img, (640, 640))

    start_time = time.time()
    for i in tqdm.tqdm(range(100)):
        outputs = rknn.inference(inputs=[resized_image])
        print(len(outputs), outputs[0].shape)
    print(f"cost: {time.time() - start_time}, fps: {100 / (time.time() - start_time):.4f}")

    rknn.release()

6.3 问题

问题1：AttributeError: rknnlite/api/lib/hardware/DOLPHIN/linux-aarch64/librknn_api.so: undefined symbol: rknn_set_core_mask
解决方法：出现这个问题的原因是因为librknn_api.so的库是有问题的，直接将rknpu2库中的librknnrt.so 拷贝过去即可，执行命令如下：

# 备份
cp /opt/virtualenvs/rknn/lib/python3.8/site-packages/rknnlite/api/lib/hardware/DOLPHIN/linux-aarch64/librknn_api.so /opt/virtualenvs/rknn/lib/python3.8/site-packages/rknnlite/api/lib/hardware/DOLPHIN/linux-aarch64/librknn_api.so.bak

# 拷贝    
cp /root/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknnrt.so /opt/virtualenvs/rknn/lib/python3.8/site-packages/rknnlite/api/lib/hardware/DOLPHIN/linux-aarch64/librknn_api.so

问题2：W RKNN: [01:59:35.391] Output(output0):size_with_stride larger than model origin size, if need run OutputOperator in NPU, please call rknn_create_memory using size_with_stride.

这个告警暂时可以忽略，可以在代码中屏蔽告警。参考yolov5的前后处理：https://github.com/Applied-Deep-Learning-Lab/Yolov5_RK3588/blob/main/base/rk3588.py

from hide_warnings import hide_warnings
@hide_warnings
def rk_infer(self, img):
    rk_result = self._rk_session.inference(inputs=[img], data_format="nhwc")
    return rk_result

问题3：如何选中使用的NPU，即如何设置core_mask？

self._rk_session.init_runtime(target=self.host_name, core_mask=RKNNLite.NPU_CORE_AUTO)
self._rk_session.init_runtime(target=self.host_name, core_mask=RKNNLite.NPU_CORE_0_1_2)

解决方法：通过RKNNLite.NPU_CORE_AUTO/RKNNLite.NPU_CORE_0_1_2/RKNNLite.NPU_CORE_0都可以设置使用那个NPU，测试发现NPU_CORE_AUTO NPU的利用率最高。

7 其他

A1 镜像烧录步骤

参考
-【ROC-RK3568-PC开发板试用体验】烧录Ubuntu20.04系统：https://dev.t-firefly.com/thread-124315-1-1.html

• 瑞芯微RK3588开发板的固件烧录完整教程 https://www.163.com/dy/article/HIE3O7VC0538CDS6.html

步骤1：安装驱动

• 下载DriverAssitant_v5.0.zip，解压，然后运行里面的DriverInstall.exe。

注意若通过linux连接到板子时，需要安装驱动adb

apt install adb

步骤2.连接设备

• 使用Type-c数据线连接设备USB_OTG接口，USB连接PC端，查看设备管理器（以下为安装驱动成功）

步骤3：整体固件【在官网下载对应的固件https://www.t-firefly.com/doc/download/183.html】

• 下载网盘上所提供的固件，或者是选择自己编译出来的固件，更新固件分为单个整体固件和分区镜像；

1）选择整体固件方式：解压RK官方烧录工具RKDevTool_Release_v2.92.zip，打开RKDevTool.exe，会自动识别到ADB设备；
2）按【切换】按钮，进入loader烧录模式；
3）按【固件】按钮，选择要升级的固件文件，加载固件之后，然后点击【升级】按钮，等待烧写为完成即可

步骤4：镜像烧录完之后，安装必要的软件

apt install git cmake g++ -y 
apt install lrzsz tree vim htop -y 

A2 RK3588运行Docker

检测板子中Docker的运行环境

git clone https://github.com/moby/moby.git
cd moby/contrib
./check-config.sh .config

参考：https://blog.csdn.net/xiaoning132/article/details/130541520

板子中安装Docker

## 卸载旧版本
sudo apt-get remove docker docker-engine docker.io containerd runc

## 设置存储库
sudo apt-get update -y
sudo apt-get install -y ca-certificates curl gnupg lsb-release

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

## 安装 Docker
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

## 验证是否安装成功

sudo docker run hello-world

参考：https://github.com/DHDAXCW/Rk3588-Docker

A3 GStreamer拉流

参考：

• 在RK3588上使用Gstreamer做推拉流并推理记录：https://blog.csdn.net/xiaoxuanxuan12/article/details/130200378
• gstreamer常用知识总结： https://blog.csdn.net/qq_32188669/article/details/103903032
• All you want, to get started with GStreamer in Python： https://sahilchachra.medium.com/all-you-want-to-get-started-with-gstreamer-in-python-2276d9ed548e
• Jetson TX2 Xvier 之 GStreamer+OpenCV读取显示摄像头: https://blog.csdn.net/yiyayi1/article/details/108793611

安装gstreamer

apt-get update

apt-get install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libgstreamer-plugins-bad1.0-dev gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav gstreamer1.0-doc gstreamer1.0-tools gstreamer1.0-x gstreamer1.0-alsa gstreamer1.0-gl gstreamer1.0-gtk3 gstreamer1.0-qt5 gstreamer1.0-pulseaudio

apt-get install libunwind8-dev

apt-get install libgtk2.0-dev pkg-config

# 查看安装结果
dpkg -l | grep gstreamer

使用命令测试gstreamer

# hello world
gst-launch-1.0 videotestsrc ! videoconvert ! autovideosink

# Adding a capability to the pipeline
gst-launch-1.0 videotestsrc ! video/x-raw, format=BGR ! autovideoconvert ! ximagesink

# Setting width, height and framerate
gst-launch-1.0 videotestsrc ! video/x-raw, format=BGR ! autovideoconvert ! videoconvert ! video/x-raw, width=640, height=480, framerate=1/2 ! ximagesink

# rtsp
gst-launch-1.0 rtspsrc location=rtsp://172.18.18.202:5554/T_Perimeter_ball001 latency=10 ! queue ! rtph264depay ! h264parse ! avdec_h264 ! videoconvert ! videoscale ! video/x-raw,width=640,height=480 ! ximagesink

使用opencv测试gstreamner

步骤1：重新编译opencv。opencv默认未开启gstreamer的支持，所以需要先重新编译opencv

git clone https://github.com/opencv/opencv.git
cd opencv 
mkdir build && cd build


cmake -D WITH_GSTREAMER=ON \
-D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D BUILD_opencv_python2=OFF \
-D BUILD_opencv_python3=ON \
-D PYTHON3_PACKAGES_PATH=/usr/local/lib/python3.8/dist-packages/ \
-D PYTHON3_LIBRARY=/usr/lib/python3.8/config-3.8-aarch64-linux-gnu/libpython3.8.so \
-D OPENCV_GENERATE_PKGCONFIG=YES ..


make -j6 && make install

cd /etc/ld.so.conf.d/ # 切换目录
touch opencv.conf # 新建opencv配置文件
echo /usr/local/lib/ > opencv.conf # 填写opencv编译后库所在的路径
sudo ldconfig

步骤2：使用下面脚本测试gstreamer

# opencv【需要重新编译opencv并启用WITH_GSTREAMER=ON】

import cv2
gstreamer_str = "sudo gst-launch-1.0 rtspsrc location=rtsp://172.18.18.202:5554/T_Perimeter_ball001 latency=1000 ! queue ! rtph264depay ! h264parse ! avdec_h264 ! videoconvert ! videoscale ! video/x-raw,width=640,height=480,format=BGR ! appsink drop=1"
cap = cv2.VideoCapture(gstreamer_str, cv2.CAP_GSTREAMER)
print(cap.isOpened())
while(cap.isOpened()):
    ret, frame = cap.read()
    if ret:
        cv2.imshow("Input via Gstreamer", frame)
        if cv2.waitKey(25) & 0xFF == ord('q'):
            break

cap.release()
cv2.destroyAllWindows()

遇到的问题

问题1：未安装libgtk2.0-dev导致

Traceback (most recent call last):
  File "opencv_demo.py", line 14, in <module>
    cv2.destroyAllWindows()
cv2.error: OpenCV(4.8.0-dev) /root/code/opencv/modules/highgui/src/window.cpp:1266: error: (-2:Unspecified error) The function is not implemented. Rebuild the library with Windows, GTK+ 2.x or Cocoa support. If you are on Ubuntu or Debian, install libgtk2.0-dev and pkg-config, then re-run cmake or configure script in function 'cvDestroyAllWindows'

问题2：无法运行gstream，camke之后GStreamer显示为No

Video I/O:
  DC1394:                      YES (2.2.5)
  FFMPEG:                      YES
    avcodec:                   YES (58.54.100)
    avformat:                  YES (58.29.100)
    avutil:                    YES (56.31.100)
    swscale:                   YES (5.5.100)
    avresample:                YES (4.0.0)
  GStreamer:                   NO
  v4l/v4l2:                    YES (linux/videodev2.h)

原因：没有安装apt-get install libunwind8-dev，导致的。可以使用下面的代码查看是否支持gstreamer

import cv2
print(cv2.getBuildInformation())

问题3：fail to load module gail

解决方法：出现这个问题的原因是因为librknn_api

sudo apt-get install libgail-common

GStreamer Python：https://github.com/GStreamer/gst-python
https://gist.github.com/liviaerxin/9934a5780f5d3fe5402d5986fc32d070

git clone https://github.com/GStreamer/gst-python.git
cd gst-python

GSTREAMER_VERSION=$(gst-launch-1.0 --version | grep version | tr -s ' ' '\n' | tail -1)
git checkout $GSTREAMER_VERSION

PYTHON=/usr/bin/python3.8
LIBPYTHON=$($PYTHON -c 'from distutils import sysconfig; print(sysconfig.get_config_var("LDLIBRARY"))')
LIBPYTHONPATH=$(dirname $(ldconfig -p | grep -w $LIBPYTHON | head -1 | tr ' ' '\n' | grep /))
PREFIX=$(dirname $(dirname $(which python3))) # in jetson nano, `PREFIX=~/.local` to use local site-packages,

LIBPYTHON=libpython3.8.so
LIBPYTHONPATH=/lib/aarch64-linux-gnu
PREFIX=/usr

./autogen.sh --disable-gtk-doc --noconfigure
./configure --with-libpython-dir=$LIBPYTHONPATH --prefix $PREFIX

make
make install

错误：No package 'pygobject-3.0' found

apt install -y python-gi-dev

错误：checking for headers required to compile python extensions... not found
configure: error: could not find Python headers

sudo apt-get install python3-dev libpython3-dev

checking for PYGOBJECT... yes
checking for libraries required to embed python... no
configure: error: Python libs not found. Windows requires Python modules to be explicitly linked to libpython