4.1. AI推理示例

旭日X3拥有高达 5TOPS 的等效算力，可以在单板上运行非常丰富的AI算法。本章将用几个简单的示例程序带大家熟悉地平线Python版本AI推理引擎API、相关数据结构和使用方法。利用API通过简单的函数调用，来完成模型加载、数据及Tensor的准备、模型推理和获取模型输出等操作。

结合从本地读取图片、从USB camera获取视频数据和从MIPI camera获取视频数据这三种方式逐步介绍地平线的Python API。

本文使用到的所有测试代码及数据都已经存放在 /app/ai_inference/ 目录下，可以参照代码来阅读文档，会有更好的效果。

4.1.1. 模块导入

旭日X3派默认已经安装了hobot_dnn可以通过导入模块，查看其基本信息。

sunrise@ubuntu:~$ sudo python3
Python 3.8.10 (default, Mar 15 2022, 12:22:08) 
Type "help", "copyright", "credits" or "license" for more information.
>>> from hobot_dnn import pyeasy_dnn as dnn
>>> dir(dnn)
['Model', 'TensorProperties', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'load', 'pyDNNTensor']

hobot_dnn 模块实现以下三个类和load接口：

  • Model ： AI 算法模型类，执行加载算法模型、推理计算， 更多信息请查阅 Model 。

  • pyDNNTensor：AI 算法输入、输出数据 tensor 类， 更多信息请查阅 pyDNNTensor 。

  • TensorProperties ：模型输入 tensor 的属性类， 更多信息请查阅 TensorProperties 。

  • load：加载算法模型，更多信息请查阅 API接口 。

4.1.2. 图像分类算法

本示例我们要实现：

  1. 在旭日X3派上加载 mobilenetv1 图像分类模型（ImageNet预训练的1000分类模型）

  2. 读取 zebra_cls.jpg 静态图片作为模型的输入

  3. 分析算法结果，得到图片中事物的类别

4.1.2.1. 快速使用

本示例的完整代码和测试数据安装在 /app/ai_inference/01_basic_sample/ 目录下，调用以下命令运行

cd /app/ai_inference/01_basic_sample/
sudo python3 ./test_mobilenetv1.py

运行成功后，会输出图像的分类结果，如下所示：

========== Classification result ==========
cls id: 340 Confidence: 0.991851

4.1.2.2. 导入python模块

  • 导入算法推理模块hobot_dnn

  • 数据处理模块numpy和opencv模块

from hobot_dnn import pyeasy_dnn as dnn
import numpy as np
import cv2

4.1.2.3. 加载AI模型

调用 load 方法加载算法模型，并返回一个 hobot_dnn.pyeasy_dnn.Model 类的 list。

例如加载 mobilenetv1_224x224_nv12.bin 图像分类模型：

models = dnn.load('../models/mobilenetv1_224x224_nv12.bin')

在执行模型加载的同时会有当前推理库的版本信息：

[C][3282][05-01][19:11:54:852][configuration.cpp:51][EasyDNN]EasyDNN version: 0.3.5
[BPU_PLAT]BPU Platform Version(1.3.1)!
[HBRT] set log level as 0. version = 3.13.27
[DNN] Runtime version = 1.8.4_(3.13.27 HBRT)
[HorizonRT] The model builder version = 1.5.2

mobilenetv1_224x224_nv12.bin 模型的输入是一个 1 x 3 x 224 x 224 的 NCHW 类型的tensor，输出是一个有 1000 个值的list，表示1000个类别的置信度。

定义一个函数用来输出 properties ：

def print_properties(pro):
    print("tensor type:", pro.tensor_type)
    print("data type:", pro.dtype)
    print("layout:", pro.layout)
    print("shape:", pro.shape)

显示算法模型的输入、输出信息：

# 打印输入 tensor 的属性
print_properties(models[0].inputs[0].properties)
# 打印输出 tensor 的属性
print_properties(models[0].outputs[0].properties)

以上代码中input是 pyDNNTensor 类型的输入数据，properties 是TensorProperties 类型的数据，用于描述tensor的属性信息。

4.1.2.4. 准备输入数据

使用opencv打开图片zebra_cls.jpg，是一只斑马的图片（在ImageNet对应类别 340: ‘zebra’ ），把图片缩放到符合模型输入tensor的尺寸（244 x 224),最后把bgr格式的图像转换成符合模型输入的 NV12 格式。这一步操作一般也称为算法数据的前处理。

# 打开图片
img_file = cv2.imread('./zebra_cls.jpg')
# 把图片缩放到模型的输入尺寸
# 获取算法模型的输入tensor 的尺寸
h, w = models[0].inputs[0].properties.shape[2], models[0].inputs[0].properties.shape[3]
print("input tensor size: %d x %d" % (h, w))
des_dim = (w, h)
resized_data = cv2.resize(img_file, des_dim, interpolation=cv2.INTER_AREA)

zebra_cls

定义 bgr2nv12_opencv 函数用来完成对图像格式的转换：

# bgr格式图片转换成 NV12格式
def bgr2nv12_opencv(image):
    height, width = image.shape[0], image.shape[1]
    area = height * width
    yuv420p = cv2.cvtColor(image, cv2.COLOR_BGR2YUV_I420).reshape((area * 3 // 2,))
    y = yuv420p[:area]
    uv_planar = yuv420p[area:].reshape((2, area // 4))
    uv_packed = uv_planar.transpose((1, 0)).reshape((area // 2,))

    nv12 = np.zeros_like(yuv420p)
    nv12[:height * width] = y
    nv12[height * width:] = uv_packed
    return nv12

把bgr格式的图片转换成 NV12 格式， nv12_data 是一个numpy类型的符合 mobilenetv1_224x224_nv12 模型输入要求的数据，详细信息请参考工具链开发手册。

nv12_data = bgr2nv12_opencv(resized_data)

4.1.2.5. 模型推理

调用 Model 类的 forward 接口进行算法推理，得到算法结果，mobilenetv1_224x224_nv12 的输出是一个有 1000 个值的list，表示1000个类别的预测概率值。

outputs = models[0].forward(nv12_data)

4.1.2.6. 算法后处理

算法模型的直接输出一般都是抽象的数字信息，比如分类算法返回每个类别的概率，检测算法一般会返回大量冗余的检测框，所以我们要对这些结果做一些处理。

ImageNet的1000个类别对应的名称可以查看 imagenet1000_clsidx_to_labels.txt 文件。

print("=" * 10, "Classification result", "=" * 10)
# 从输出结果中得到值最大的那个序号，比如 zebra 就是第 340 个值，应该大于 0.99
np.argmax(outputs[0].buffer)
# 输出类别序号和预测概率值
print("cls id: %d Confidence: %f" % (np.argmax(outputs[0].buffer), outputs[0].buffer[0][np.argmax(outputs[0].buffer)]))

4.1.3. 图像目标检测算法

本示例我们要实现：

  1. 在旭日X3派上加载 fcos 图像目标检测算法模型（基于COCO数据集训练的80个类别的目标检测）

  2. 从USB摄像头读取视频图像

  3. 把检测结果渲染到图片上

  4. 把图像数据通过 hdmi 输出到显示器上，了解如何使用地平线 hobot_vio 模块的Display功能，查看 Display部分 了解更多信息。

4.1.3.1. 快速使用

请查阅 USB摄像头 了解如何快速运行本示例。

4.1.3.2. 导入python模块

  • 导入算法推理模块hobot_dnn

  • 通过hdmi向显示器输出视频的模块 hobot_vio

  • 数据处理依赖numpy和opencv模块

  • colorsys 用于在绘制检测框时候的颜色处理

from hobot_dnn import pyeasy_dnn as dnn
from hobot_vio import libsrcampy as srcampy
import numpy as np
import cv2
import colorsys

4.1.3.3. 加载AI模型

调用 load 方法加载算法模型，并返回一个 hobot_dnn.pyeasy_dnn.Model 类的 list。

models = dnn.load('../models/fcos_512x512_nv12.bin')

在执行模型加载的同时会有当前推理库的版本信息：

[C][3282][05-01][19:11:54:852][configuration.cpp:51][EasyDNN]EasyDNN version: 0.3.5
[BPU_PLAT]BPU Platform Version(1.3.1)!
[HBRT] set log level as 0. version = 3.13.27
[DNN] Runtime version = 1.8.4_(3.13.27 HBRT)
[HorizonRT] The model builder version = 1.5.2

fcos_512x512_nv12.bin 模型的输入是一个 1 x 3 x 512 x 512 的 NCHW 类型的tensor，输出15组数据，用来表示检测到的物体检测框。

定义一个函数用来输出 properties ：

def print_properties(pro):
    print("tensor type:", pro.tensor_type)
    print("data type:", pro.dtype)
    print("layout:", pro.layout)
    print("shape:", pro.shape)

显示算法模型的输入、输出信息：

# 打印输入 tensor 的属性
print_properties(models[0].inputs[0].properties)
# 打印输出 tensor 的属性
print(len(models[0].outputs))
for output in models[0].outputs:
    print_properties(output.properties)

以上代码中input是 pyDNNTensor 类型的输入数据，properties 是TensorProperties 类型的数据，用于描述tensor的属性信息。

4.1.3.4. 准备输入数据

使用opencv打开USB 摄像头（/dev/video8），获取实时的视频帧图像，把图像缩放到符合模型输入tensor的尺寸（512x 512), 最后把bgr格式的图像转换成符合模型输入的 NV12 格式。这一步操作一般也称为算法数据的前处理。

# 打开 usb camera: /dev/video8
cap = cv2.VideoCapture(8)
if(not cap.isOpened()):
    exit(-1)
print("Open usb camera successfully")
# 设置usb camera的输出图像格式为 MJPEG， 分辨率 640 x 480
# 可以通过 v4l2-ctl -d /dev/video8 --list-formats-ext 命令查看摄像头支持的分辨率
# 根据应用需求调整该采集图像的分辨率
codec = cv2.VideoWriter_fourcc( 'M', 'J', 'P', 'G' )
cap.set(cv2.CAP_PROP_FOURCC, codec)
cap.set(cv2.CAP_PROP_FPS, 30) 
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

定义 bgr2nv12_opencv 函数用来完成对图像格式的转换：

# bgr格式图片转换成 NV12格式
def bgr2nv12_opencv(image):
    height, width = image.shape[0], image.shape[1]
    area = height * width
    yuv420p = cv2.cvtColor(image, cv2.COLOR_BGR2YUV_I420).reshape((area * 3 // 2,))
    y = yuv420p[:area]
    uv_planar = yuv420p[area:].reshape((2, area // 4))
    uv_packed = uv_planar.transpose((1, 0)).reshape((area // 2,))

    nv12 = np.zeros_like(yuv420p)
    nv12[:height * width] = y
    nv12[height * width:] = uv_packed
    return nv12

把bgr格式的图片转换成 NV12 格式， nv12_data 是一个numpy类型的符合 fcos_512x512_nv12 模型输入要求的数据，详细信息请参考工具链开发手册。

nv12_data = bgr2nv12_opencv(resized_data)

4.1.3.5. 模型推理

调用 Model 类的 forward 接口进行算法推理，得到算法结果，fcos_512x512_nv12 输出15组数据，用来表示检测到的物体检测框。

outputs = models[0].forward(nv12_data)

4.1.3.6. 算法后处理

算法模型的直接输出一般都是抽象的数字信息，比如分类算法返回每个类别的概率，检测算法一般会返回大量冗余的检测框，所以我们要对这些结果做一些处理。

fcos算法返回物件类别、检测框和每个检测框的置信度信息，总共包含COCO数据集的80个类别。

# 对算法结果进行过滤，去掉执行度低的检测框，计算检测框的交并比去除冗余框，把检测框的坐标还原到原图位置上
prediction_bbox = postprocess(outputs, input_shape, origin_img_shape=(1080,1920))

4.1.3.7. 检测结果可视化

到此我们已经完成了数据的采集，算法运算和算法结果的后处理，但是现在的结果很不直观，不方便观察，所以我们接下来把物体检测框绘制到图像上，在把绘制后的图像输出到显示器上，就可以直观的观察算法的运行效果了。其中用到了地平线的 hobot_vio模块的 Display功能，更多关于该模块的信息请查看 Display部分 。

# 获取 Display 实例
disp = srcampy.Display()
# 初始化视频输出通道0， 输出分辨率 1920 x 1080
disp.display(0, 1920, 1080)

# 如果图像分辨率不是 1920 x 1080, 则对图像进行缩放
if frame.shape[0]!=1080 and frame.shape[1]!=1920:
	frame = cv2.resize(frame, (1920,1080), interpolation=cv2.INTER_AREA)

# 把算法运行后得到的物体检测框绘制到图像上
box_bgr = draw_bboxs(frame, prediction_bbox)

# X3 的HDMI输出模块的输入图像格式需要是NV12的，所以需要先把bgr格式转成NV12
box_nv12 = bgr2nv12_opencv(box_bgr)
# 把 NV12 格式的图像输出给显示器
disp.set_img(box_nv12.tobytes())

4.1.4. 基于MIPI Camera的目标检测 HDMI 展示

本示例我们要实现：

  1. 在旭日X3派上加载 fcos 图像目标检测算法模型（基于COCO数据集训练的80个类别的目标检测）

  2. 从MIPI摄像头（F37）读取视频图像，了解如何使用地平线 hobot_vio 模块的Camera功能，查看 Camera部分 了解更多信息。

  3. 把检测结果渲染到图片上

  4. 把图像数据通过 hdmi 输出到显示器上，了解如何使用地平线 hobot_vio 模块的Display功能，查看 Display部分 了解更多信息。

4.1.4.1. 快速使用

请查阅 MIPI摄像头 了解如何快速运行本示例。

4.1.4.2. 导入python模块

  • 导入算法推理模块hobot_dnn

  • 通过hdmi向显示器输出视频的模块 hobot_vio

  • 数据处理依赖numpy和opencv模块

  • colorsys 用于在绘制检测框时候的颜色处理

import numpy as np
import cv2
import colorsys

from hobot_dnn import pyeasy_dnn as dnn
from hobot_vio import libsrcampy as srcampy

4.1.4.3. 加载AI模型

调用 load 方法加载算法模型，并返回一个 hobot_dnn.pyeasy_dnn.Model 类的 list。

models = dnn.load('../models/fcos_512x512_nv12.bin')

在执行模型加载的同时会有当前推理库的版本信息：

[C][3282][05-01][19:11:54:852][configuration.cpp:51][EasyDNN]EasyDNN version: 0.3.5
[BPU_PLAT]BPU Platform Version(1.3.1)!
[HBRT] set log level as 0. version = 3.13.27
[DNN] Runtime version = 1.8.4_(3.13.27 HBRT)
[HorizonRT] The model builder version = 1.5.2

fcos_512x512_nv12.bin 模型的输入是一个 1 x 3 x 512 x 512 的 NCHW 类型的tensor，输出15组数据，用来表示检测到的物体检测框。

定义一个函数用来输出 properties ：

def print_properties(pro):
    print("tensor type:", pro.tensor_type)
    print("data type:", pro.dtype)
    print("layout:", pro.layout)
    print("shape:", pro.shape)

显示算法模型的输入、输出信息：

# 打印输入 tensor 的属性
print_properties(models[0].inputs[0].properties)
# 打印输出 tensor 的属性
print(len(models[0].outputs))
for output in models[0].outputs:
    print_properties(output.properties)

以上代码中input是 pyDNNTensor 类型的输入数据，properties 是TensorProperties 类型的数据，用于描述tensor的属性信息。

4.1.4.4. 准备输入数据

通过调用srcampy.Camera类的get_cam方法获取MIPI摄像头实时的视频帧图像，把图像缩放到符合模型输入tensor的尺寸（512x 512), 最后把bgr格式的图像转换成符合模型输入的 NV12 格式。这一步操作一般也称为算法数据的前处理。查看 Camera部分 了解更多信息。

# 获取 Camera 句柄
cam = srcampy.Camera()
# 打开 f37 摄像头，并且把输出突出缩小成算法模型的输入尺寸
# For the meaning of parameters, please refer to the relevant documents of camera
h, w = get_hw(models[0].inputs[0].properties)
# 打开 F37, 初始化视频 pipeline 0 ，设置帧率30fps，缩放图像为 512 x 512，并且设置一路1080P的输出给显示器
cam.open_cam(0, 1, 30, [1920, w], [1080, h])

# 从相机获取分辨率为 512x512 的nv12格式的图像数据， 参数 2 代表从硬件模块IPU中获取
img = cam.get_img(2, 512, 512)
# 把图像数据转成 numpy 数据类型
img = np.frombuffer(img, dtype=np.uint8)

4.1.4.5. 图像输入输出绑定

为了减少图像的操作达到提高帧率的效果, 我们将原始图像进行了输入输出的绑定, 在底层将原始图像直接送到显示器. 这一操作是通过 bind 接口实现的. 查看 Camera部分 了解更多信息。

disp = srcampy.Display()
# For the meaning of parameters, please refer to the relevant documents of HDMI display
disp.display(0, 1920, 1080)

# bind camera directly to display
srcampy.bind(cam, disp)

4.1.4.6. 模型推理

调用 Model 类的 forward 接口进行算法推理，得到算法结果，fcos_512x512_nv12 输出15组数据，用来表示检测到的物体检测框。

outputs = models[0].forward(img)

4.1.4.7. 算法后处理

算法模型的直接输出一般都是抽象的数字信息，比如分类算法返回每个类别的概率，检测算法一般会返回大量冗余的检测框，所以我们要对这些结果做一些处理。

fcos算法返回物件类别、检测框和每个检测框的置信度信息，总共包含COCO数据集的80个类别。

# 对算法结果进行过滤，去掉执行度低的检测框，计算检测框的交并比去除冗余框，把检测框的坐标还原到原图位置上
prediction_bbox = postprocess(outputs)

4.1.4.8. 检测结果可视化

到此我们已经完成了数据的采集，算法运算和算法结果的后处理，但是现在的结果很不直观，不方便观察，所以我们接下来把物体检测框绘制到输出图像上，在把绘制后的图像输出到显示器上，就可以直观的观察算法的运行效果了。

for index, bbox in enumerate(prediction_bbox):
...
	if index == 0:
		disp.set_graph_rect(coor[0], coor[1], coor[2], coor[3], 2, 1,
							box_color_ARGB)
		disp.set_graph_word(coor[0], coor[1] - 2, bbox_string, 2, 1,
							box_color_ARGB)
	else:
		disp.set_graph_rect(coor[0], coor[1], coor[2], coor[3], 2, 0,
							box_color_ARGB)
		disp.set_graph_word(coor[0], coor[1] - 2, bbox_string, 2, 0,
							box_color_ARGB)

4.1.5. 图像分割算法

本示例我们要实现：

  1. 在旭日X3派上加载 mobilenet_unet_1024x2048_nv12 图像分割模型（cityscapes预训练的分割模型）

  2. 读取 segmentation.png 静态图片作为模型的输入

  3. 分析算法结果，渲染分割结果

4.1.5.1. 快速使用

本示例的完整代码和测试数据安装在 /app/ai_inference/04_segment_sample/ 目录下，调用以下命令运行

cd /app/ai_inference/04_segment_sample/
sudo python3 ./test_mobilenet_unet.py

运行成功后，会输出图像的分割结果，并且dump出分割效果图: segment_result.png，打开后显示效果如下：

image-20220624105144784

4.1.5.2. 导入python模块

  • 导入算法推理模块hobot_dnn

  • 数据处理模块numpy和opencv模块

from hobot_dnn import pyeasy_dnn as dnn
import numpy as np
import cv2

4.1.5.3. 加载AI模型

调用 load 方法加载算法模型，并返回一个 hobot_dnn.pyeasy_dnn.Model 类的 list。

例如加载 mobilenet_unet_1024x2048_nv12.bin 图像分割模型：

models = dnn.load('../models/mobilenet_unet_1024x2048_nv12.bin')

在执行模型加载的同时会有当前推理库的版本信息：

[C][3282][05-01][19:11:54:852][configuration.cpp:51][EasyDNN]EasyDNN version: 0.3.5
[BPU_PLAT]BPU Platform Version(1.3.1)!
[HBRT] set log level as 0. version = 3.13.27
[DNN] Runtime version = 1.8.4_(3.13.27 HBRT)
[HorizonRT] The model builder version = 1.5.2

mobilenet_unet_1024x2048_nv12.bin 模型的输入是一个 1024 x 2048 的 NV12 类型的tensor，输出是一个有 256 x 512 x 19 大小的tensor， 表示在 256 x 512 尺度下，每个像素点分别含有19个分类信息，最后还原原图效果图时需要resize到原尺寸。

4.1.5.4. 模型推理

模型输入数据前处理，以及模型推理的步骤与 01_basic_sample 一致

4.1.5.5. 算法后处理

分割模型的后处理与分类模型类似，只不过分割模型的后处理是对每一个像素点进行argmax处理，详细如下：

# 获取每个像素点的最大得分的id
pred_result = np.argmax(model_output[0], axis=-1)
# 渲染结果
plot_image(origin_image, pred_result)

4.1.6. 基于MIPI Camera的目标检测 web 端展示

本示例我们要实现：

  1. 在旭日X3派上加载 fcos 图像目标检测算法模型（基于COCO数据集训练的80个类别的目标检测）

  2. 从MIPI摄像头（F37）读取视频图像，了解如何使用地平线 hobot_vio 模块的Camera功能，查看 Camera部分 了解更多信息。

  3. 把检测结果在web端展示

数据准备、模型推理以及后处理部分的处理与上一小节的内容一致，此处不同的地方为渲染展示模块。

4.1.6.1. 启动 web_service 服务

在使用 web 展示之前，确保板子与个人PC机处于同一网段，并且PC可以访问板子的IP。

执行如下命令启动web service

cd /app/ai_inference/05_web_display_camera_sample/
sudo sh ./start_nginx.sh
sudo python3 ./mipi_camera_web.py

注意事项：

如果在运行start_nginx.sh时报以下错误，那么说明可能 tcp的80端口被使用了。

image-20220719003947031

可能的原因：

1、有可能是重复执行start_nginx.sh导致，这种情况不用处理

2、有可能设备上已经有运行httpd的服务，需要找到设备上是什么程序占用了80端口，把它停掉，然后重新运行 start_nginx.sh

4.1.6.2. protobuf 序列化

web端接收的是序列化之后的数据，板端作为服务端需要将检测之后的框、分类名称数据，按照一定的数据格式进行打包， 用户可以把检测出来的box信息直接输入 serialize 函数，可以得到系列化之后的数据包

def serialize(FrameMessage, prediction_bbox):
    if (prediction_bbox.shape[0] > 0):
        for i in range(prediction_bbox.shape[0]):
            # get class name
            Target = x3_pb2.Target()
            id = int(prediction_bbox[i][5])
            Target.type_ = classes[id]
            Box = x3_pb2.Box()
            Box.type_ = classes[id]
            Box.score_ = prediction_bbox[i][4]

            Box.top_left_.x_ = prediction_bbox[i][0]
            Box.top_left_.y_ = prediction_bbox[i][1]
            Box.bottom_right_.x_ = prediction_bbox[i][2]
            Box.bottom_right_.y_ = prediction_bbox[i][3]

            Target.boxes_.append(Box)
            FrameMessage.smart_msg_.targets_.append(Target)
    prot_buf = FrameMessage.SerializeToString()
    return prot_buf

4.1.6.3. 服务端发送 protobuf 数据包

服务端通过 websockets 插件完成对数据的发送，在此之前需要获取本机地址：

# python 可以通过调用 shell 命令，捕获本机 ip
    ifconfig_cmd = subprocess.check_output("ifconfig | grep broadcast | awk '{print $2}'", shell=True)
    board_ip = str(ifconfig_cmd, 'UTF-8')[:-1]

启动 websockets ，其中8080为固定网络端口，与 webservice 的程序有关，此处为固定值。

start_server = websockets.serve(web_service, board_ip, 8080)

web_service 为发送数据的函数

async def web_service(websocket, path):
    while True:
       # 获取 protobuf 的message对象
        FrameMessage = x3_pb2.FrameMessage()
       # 输入图片的原始宽高数据，以及图片的类型
        FrameMessage.img_.height_ = 1080
        FrameMessage.img_.width_ = 1920
        FrameMessage.img_.type_ = "JPEG"

       # 获取camera图像用于推理
        img = cam.get_img(2, 512, 512)
        img = np.frombuffer(img, dtype=np.uint8)
        outputs = models[0].forward(img)
        # Do post process
        prediction_bbox = postprocess(outputs, input_shape, origin_img_shape=(1080, 1920))
        print(prediction_bbox)

       # 获取camera图像用于渲染
        origin_image = cam.get_img(2, 1920, 1080)
       # 将nv12图像数据编码为jpeg，此处enc为libsrcampy.Encoder()对象，详细脚本参考示例
        enc.encode_file(origin_image)
       # 将jpeg赋值给message对象
        FrameMessage.img_.buf_ = enc.get_img()
       # 记录时间戳
        FrameMessage.smart_msg_.timestamp_ = int(time.time())
       # 将原始图像数据和检测结果序列化
        prot_buf = serialize(FrameMessage, prediction_bbox)
       # 发送数据
        await websocket.send(prot_buf)
    cam.close_cam()

4.1.6.4. web端查看展示效果

在google浏览器上输入旭日X3派的ip地址，即可实时查看模型检测结果。

image-20220719003512782

4.1.7. Yolov3检测模型示例

本示例我们要实现：

  1. 在旭日X3派上加载 yolov3_darknet53_416x416_nv12 图像检测模型

  2. 读取 kite.jpg 静态图片作为模型的输入

  3. 分析算法结果，渲染检测结果

4.1.7.1. 快速使用

本示例的完整代码和测试数据安装在 /app/ai_inference/06_yolov3_sample/ 目录下，调用以下命令运行

cd /app/ai_inference/06_yolov3_sample/
sudo python3 ./test_yolov3.py

运行成功后，会输出图像的分割结果，并且dump出分割效果图: result.jpg，如果如下所示：

image-20220624105321684

4.1.8. Yolov5检测模型示例

本示例我们要实现：

  1. 在旭日X3派上加载 yolov5s_672x672_nv12 图像检测模型

  2. 读取 kite.jpg 静态图片作为模型的输入

  3. 分析算法结果，渲染检测结果

4.1.8.1. 快速使用

本示例的完整代码和测试数据安装在 /app/ai_inference/07_yolov5_sample/ 目录下，调用以下命令运行

cd /app/ai_inference/07_yolov5_sample/
sudo python3 ./test_yolov5.py

运行成功后，会输出图像的分割结果，并且dump出分割效果图: result.jpg

image-20220624105432872