Ctrl+K
dev
Tags
v0.2
v0.3
v0.4
v0.5
v0.6
v0.7
v1.0
Branches
dev
main
External links
K210 CanMV
K210 CanMV Docs
K230 Docs
K230 CanMV Docs

5. YOLO 大作战

目录

5. YOLO 大作战#

1. YOLOv5水果分类#

1.1 YOLOv5源码及训练环境搭建#

YOLOv5 训练环境搭建请参考ultralytics/yolov5: YOLOv5 🚀 in PyTorch > ONNX > CoreML > TFLite (github.com)

git clone https://github.com/ultralytics/yolov5.git
cd yolov5
pip install -r requirements.txt

如果您已搭建好环境，请忽略此步骤。

1.2 训练数据准备#

请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolov5 目录下，请使用 fruits_cls 作为水果分类任务的数据集。

cd yolov5
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

1.3 使用YOLOv5训练水果分类模型#

在 yolov5 目录下执行命令，使用 yolov5 训练三类水果分类模型：

python classify/train.py --model yolov5n-cls.pt --data datasets/fruits_cls --epochs 100 --batch-size 8 --imgsz 224 --device '0'

1.4 转换水果分类kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolov5.zip 解压到 yolov5 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolov5.zip
unzip test_yolov5.zip

按照如下命令，对 runs/train-cls/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
python export.py --weight runs/train-cls/exp/weights/best.pt --imgsz 224 --batch 1 --include onnx
cd test_yolov5/classify
# 转换kmodel,onnx模型路径请自行选择，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/train-cls/exp/weights/best.onnx --dataset ../test --input_width 224 --input_height 224 --ptq_option 0
cd ../../

1.5 在k230上使用MicroPython部署模型#

1.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

1.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

1.5.3 YOLOv5 模块#

YOLOv5 类集成了 YOLOv5 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLOv5 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLOv5

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLOv5模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

1.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLOv5
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test_apple.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    model_input_size=[224,224]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLOv5实例
    yolo=YOLOv5(task_type="classify",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

1.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLOv5
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[1280,720]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    # 模型路径
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    model_input_size=[224,224]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLOv5实例
    yolo=YOLOv5(task_type="classify",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

2. YOLOv5水果检测#

2.1 YOLOv5源码及训练环境搭建#

YOLOv5 训练环境搭建请参考ultralytics/yolov5: YOLOv5 🚀 in PyTorch > ONNX > CoreML > TFLite (github.com)

git clone https://github.com/ultralytics/yolov5.git
cd yolov5
pip install -r requirements.txt

如果您已搭建好环境，请忽略此步骤。

2.2 训练数据准备#

请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolov5 目录下，请使用 fruits_yolo 作为水果检测任务的数据集。

cd yolov5
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

2.3 使用YOLOv5训练水果检测模型#

在 yolov5 目录下执行命令，使用 yolov5 训练三类水果检测模型：

python train.py --weight yolov5n.pt --cfg models/yolov5n.yaml --data datasets/fruits_yolo.yaml --epochs 300 --batch-size 8 --imgsz 320 --device '0'

2.4 转换水果检测kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolov5.zip 解压到 yolov5 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolov5.zip
unzip test_yolov5.zip

按照如下命令，对 runs/train/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
python export.py --weight runs/train/exp/weights/best.pt --imgsz 320 --batch 1 --include onnx
cd test_yolov5/detect
# 转换kmodel,onnx模型路径请自定义，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/train/exp/weights/best.onnx --dataset ../test --input_width 320 --input_height 320 --ptq_option 0
cd ../../

2.5 在k230上使用MicroPython部署模型#

2.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

2.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

2.5.3 YOLOv5 模块#

YOLOv5 类集成了 YOLOv5 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLOv5 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLOv5

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLOv5模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

2.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLOv5
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    model_input_size=[320,320]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLOv5实例
    yolo=YOLOv5(task_type="detect",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

2.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLOv5
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[1280,720]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.8
    nms_threshold=0.45
    model_input_size=[320,320]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLOv5实例
    yolo=YOLOv5(task_type="detect",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

3. YOLOv5水果分割#

3.1 YOLOv5源码及训练环境搭建#

YOLOv5 训练环境搭建请参考ultralytics/yolov5: YOLOv5 🚀 in PyTorch > ONNX > CoreML > TFLite (github.com)

git clone https://github.com/ultralytics/yolov5.git
cd yolov5
pip install -r requirements.txt

如果您已搭建好环境，请忽略此步骤。

3.2 训练数据准备#

请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolov5 目录下，请使用 fruits_seg 作为水果分割任务的数据集。

cd yolov5
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

3.3 使用YOLOv5训练水果分割模型#

在 yolov5 目录下执行命令，使用 yolov5 训练三类水果分割模型：

python segment/train.py --weight yolov5n-seg.pt --cfg models/segment/yolov5n-seg.yaml --data datasets/fruits_seg.yaml --epochs 100 --batch-size 8 --imgsz 320 --device '0'

3.4 转换水果分割kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolov5.zip 解压到 yolov5 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolov5.zip
unzip test_yolov5.zip

按照如下命令，对 runs/train-seg/exp/weights 下的模型先导出为 onnx 模型，再转换成 kmodel 模型：

python export.py --weight runs/train-seg/exp/weights/best.pt --imgsz 320 --batch 1 --include onnx
cd test_yolov5/segment
# 转换kmodel,onnx模型路径请自定义，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/train-seg/exp/weights/best.onnx --dataset ../test --input_width 320 --input_height 320 --ptq_option 0
cd ../../

3.5 在k230上使用MicroPython部署模型#

3.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

3.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

3.5.3 YOLOv5 模块#

YOLOv5 类集成了 YOLOv5 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLOv5 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLOv5

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLOv5模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

3.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLOv5
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    mask_threshold=0.5
    model_input_size=[320,320]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLOv5实例
    yolo=YOLOv5(task_type="segment",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,mask_thresh=mask_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

3.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLOv5
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[320,320]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    mask_threshold=0.5
    model_input_size=[320,320]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLOv5实例
    yolo=YOLOv5(task_type="segment",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,mask_thresh=mask_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

4. YOLOv8水果分类#

4.1 YOLOv8源码及训练环境搭建#

YOLOv8 训练环境搭建请参考ultralytics/ultralytics: Ultralytics YOLO 🚀 (github.com)

# Pip install the ultralytics package including all requirements in a Python>=3.8 environment with PyTorch>=1.8.
pip install ultralytics

如果您已搭建好环境，请忽略此步骤。

4.2 训练数据准备#

您可以先创建一个新文件夹 yolov8， 请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolov8 目录下，请使用 fruits_cls 作为水果分类任务的数据集。

cd yolov8
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

4.3 使用YOLOv8训练水果分类模型#

在 yolov8 目录下执行命令，使用 yolov8 训练三类水果分类模型：

yolo classify train data=datasets/fruits_cls model=yolov8n-cls.pt epochs=100 imgsz=224

4.4 转换水果分类kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolov8.zip 解压到 yolov8 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolov8.zip
unzip test_yolov8.zip

按照如下命令，对 runs/classify/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
yolo export model=runs/classify/train/weights/best.pt format=onnx imgsz=224
cd test_yolov8/classify
# 转换kmodel,onnx模型路径请自行选择，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/classify/train/weights/best.onnx --dataset ../test --input_width 224 --input_height 224 --ptq_option 0
cd ../../

4.5 在k230上使用MicroPython部署模型#

4.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

4.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

4.5.3 YOLOv8 模块#

YOLOv8 类集成了 YOLOv8 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLOv8 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLOv8

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLOv8模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

4.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLOv8
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test_apple.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    model_input_size=[224,224]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLOv8实例
    yolo=YOLOv8(task_type="classify",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

4.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLOv8
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[1280,720]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.8
    model_input_size=[224,224]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLOv8实例
    yolo=YOLOv8(task_type="classify",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

5. YOLOv8水果检测#

5.1 YOLOv8源码及训练环境搭建#

YOLOv8 训练环境搭建请参考ultralytics/ultralytics: Ultralytics YOLO 🚀 (github.com)

# Pip install the ultralytics package including all requirements in a Python>=3.8 environment with PyTorch>=1.8.
pip install ultralytics

如果您已搭建好环境，请忽略此步骤。

5.2 训练数据准备#

您可以先创建一个新文件夹 yolov8， 请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolov8 目录下，请使用 fruits_yolo 作为水果检测任务的数据集。

cd yolov8
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

5.3 使用YOLOv8训练水果检测模型#

在 yolov8 目录下执行命令，使用 yolov8 训练三类水果检测模型：

yolo detect train data=datasets/fruits_yolo.yaml model=yolov8n.pt epochs=300 imgsz=320

5.4 转换水果检测kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolov8.zip 解压到 yolov8 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolov8.zip
unzip test_yolov8.zip

按照如下命令，对 runs/detect/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
yolo export model=runs/detect/train/weights/best.pt format=onnx imgsz=320
cd test_yolov8/detect
# 转换kmodel,onnx模型路径请自行选择，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/detect/train/weights/best.onnx --dataset ../test --input_width 320 --input_height 320 --ptq_option 0
cd ../../

5.5 在k230上使用MicroPython部署模型#

5.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

5.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

5.5.3 YOLOv8 模块#

YOLOv8 类集成了 YOLOv8 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLOv8 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLOv8

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLOv8模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

5.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLOv8
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    model_input_size=[320,320]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLOv8实例
    yolo=YOLOv8(task_type="detect",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

5.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLOv8
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[1280,720]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.8
    nms_threshold=0.45
    model_input_size=[320,320]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLOv8实例
    yolo=YOLOv8(task_type="detect",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

6. YOLOv8水果分割#

6.1 YOLOv8源码及训练环境搭建#

YOLOv8 训练环境搭建请参考ultralytics/ultralytics: Ultralytics YOLO 🚀 (github.com)

# Pip install the ultralytics package including all requirements in a Python>=3.8 environment with PyTorch>=1.8.
pip install ultralytics

如果您已搭建好环境，请忽略此步骤。

6.2 训练数据准备#

您可以先创建一个新文件夹 yolov8， 请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolov8 目录下，请使用 fruits_seg 作为水果分割任务的数据集。

cd yolov8
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

6.3 使用YOLOv8训练水果分割模型#

在 yolov8 目录下执行命令，使用 yolov8 训练三类水果分割模型：

yolo segment train data=datasets/fruits_seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=320

6.4 转换水果分割kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolov8.zip 解压到 yolov8 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolov8.zip
unzip test_yolov8.zip

按照如下命令，对 runs/segment/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
yolo export model=runs/segment/train/weights/best.pt format=onnx imgsz=320
cd test_yolov8/segment
# 转换kmodel,onnx模型路径请自行选择，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/segment/train/weights/best.onnx --dataset ../test --input_width 320 --input_height 320 --ptq_option 0
cd ../../

6.5 在k230上使用MicroPython部署模型#

6.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

6.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

6.5.3 YOLOv8 模块#

YOLOv8 类集成了 YOLOv8 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLOv8 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLOv8

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLOv8模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

6.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLOv8
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    mask_threshold=0.5
    model_input_size=[320,320]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLOv8实例
    yolo=YOLOv8(task_type="segment",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,mask_thresh=mask_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

6.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLOv8
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[320,320]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    mask_threshold=0.5
    model_input_size=[320,320]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLOv8实例
    yolo=YOLOv8(task_type="segment",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,mask_thresh=mask_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        print(e)
    finally:
        yolo.deinit()
        pl.destroy()

7. YOLO11水果分类#

7.1 YOLO11源码及训练环境搭建#

YOLO11 训练环境搭建请参考ultralytics/ultralytics: Ultralytics YOLO 🚀 (github.com)

# Pip install the ultralytics package including all requirements in a Python>=3.8 environment with PyTorch>=1.8.
pip install ultralytics

如果您已搭建好环境，请忽略此步骤。

7.2 训练数据准备#

您可以先创建一个新文件夹 yolo11， 请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolo11 目录下，请使用 fruits_cls 作为水果分类任务的数据集。

cd yolo11
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

7.3 使用YOLO11训练水果分类模型#

在 yolo11 目录下执行命令，使用 yolo11 训练三类水果分类模型：

yolo classify train data=datasets/fruits_cls model=yolo11n-cls.pt epochs=100 imgsz=224

7.4 转换水果分类kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolo11.zip 解压到 yolo11 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolo11.zip
unzip test_yolo11.zip

按照如下命令，对 runs/classify/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
yolo export model=runs/classify/train/weights/best.pt format=onnx imgsz=224
cd test_yolo11/classify
# 转换kmodel,onnx模型路径请自行选择，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/classify/train/weights/best.onnx --dataset ../test --input_width 224 --input_height 224 --ptq_option 0
cd ../../

7.5 在k230上使用MicroPython部署模型#

7.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

7.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

7.5.3 YOLO11 模块#

YOLO11 类集成了 YOLO11 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLO11 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLO11

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLO11模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

7.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLO11
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test_apple.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    model_input_size=[224,224]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLO11实例
    yolo=YOLO11(task_type="classify",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

7.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLO11
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[1280,720]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.8
    model_input_size=[224,224]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLO11实例
    yolo=YOLO11(task_type="classify",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

8. YOLO11水果检测#

8.1 YOLO11源码及训练环境搭建#

YOLO11 训练环境搭建请参考ultralytics/ultralytics: Ultralytics YOLO 🚀 (github.com)

# Pip install the ultralytics package including all requirements in a Python>=3.8 environment with PyTorch>=1.8.
pip install ultralytics

如果您已搭建好环境，请忽略此步骤。

8.2 训练数据准备#

您可以先创建一个新文件夹 yolo11， 请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolo11 目录下，请使用 fruits_yolo 作为水果检测任务的数据集。

cd yolo11
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

8.3 使用YOLO11训练水果检测模型#

在 yolo11 目录下执行命令，使用 yolo11 训练三类水果检测模型：

yolo detect train data=datasets/fruits_yolo.yaml model=yolo11n.pt epochs=300 imgsz=320

8.4 转换水果检测kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolo11.zip 解压到 yolo11 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolo11.zip
unzip test_yolo11.zip

按照如下命令，对 runs/detect/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
yolo export model=runs/detect/train/weights/best.pt format=onnx imgsz=320
cd test_yolo11/detect
# 转换kmodel,onnx模型路径请自行选择，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/detect/train/weights/best.onnx --dataset ../test --input_width 320 --input_height 320 --ptq_option 0
cd ../../

8.5 在k230上使用MicroPython部署模型#

8.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

8.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

8.5.3 YOLO11 模块#

YOLO11 类集成了 YOLO11 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLO11 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLO11

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLO11模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

8.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLO11
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    model_input_size=[320,320]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLO11实例
    yolo=YOLO11(task_type="detect",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

8.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLO11
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[1280,720]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.8
    nms_threshold=0.45
    model_input_size=[320,320]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLO11实例
    yolo=YOLO11(task_type="detect",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

9. YOLO11水果分割#

9.1 YOLO11源码及训练环境搭建#

YOLO11 训练环境搭建请参考ultralytics/ultralytics: Ultralytics YOLO 🚀 (github.com)

# Pip install the ultralytics package including all requirements in a Python>=3.8 environment with PyTorch>=1.8.
pip install ultralytics

如果您已搭建好环境，请忽略此步骤。

9.2 训练数据准备#

您可以先创建一个新文件夹 yolo11， 请下载提供的示例数据集，示例数据集中包含以三类水果（apple，banana，orange）为场景分别提供了分类、检测和分割数据集。将数据集解压到 yolo11 目录下，请使用 fruits_seg 作为水果分割任务的数据集。

cd yolo11
wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/datasets.zip
unzip datasets.zip

如果您已下载好数据，请忽略此步骤。

9.3 使用YOLO11训练水果分割模型#

在 yolo11 目录下执行命令，使用 yolo11 训练三类水果分割模型：

yolo segment train data=datasets/fruits_seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=320

9.4 转换水果分割kmodel#

模型转换需要在训练环境安装如下库：

# linux平台：nncase和nncase-kpu可以在线安装，nncase-2.x 需要安装 dotnet-7
sudo apt-get install -y dotnet-sdk-7.0
pip install --upgrade pip
pip install nncase==2.9.0
pip install nncase-kpu==2.9.0

# windows平台：请自行安装dotnet-7并添加环境变量,支持使用pip在线安装nncase，但是nncase-kpu库需要离线安装，在https://github.com/kendryte/nncase/releases下载nncase_kpu-2.*-py2.py3-none-win_amd64.whl
# 进入对应的python环境，在nncase_kpu-2.*-py2.py3-none-win_amd64.whl下载目录下使用pip安装
pip install nncase_kpu-2.*-py2.py3-none-win_amd64.whl

# 除nncase和nncase-kpu外，脚本还用到的其他库包括：
pip install onnx
pip install onnxruntime
pip install onnxsim

下载脚本工具，将模型转换脚本工具 test_yolo11.zip 解压到 yolo11 目录下；

wget https://kendryte-download.canaan-creative.com/developer/k230/yolo_files/test_yolo11.zip
unzip test_yolo11.zip

按照如下命令，对 runs/segment/exp/weights 下的 pt 模型先导出为 onnx 模型，再转换成 kmodel 模型：

# 导出onnx，pt模型路径请自行选择
yolo export model=runs/segment/train/weights/best.pt format=onnx imgsz=320
cd test_yolo11/segment
# 转换kmodel,onnx模型路径请自行选择，生成的kmodel在onnx模型同级目录下
python to_kmodel.py --target k230 --model ../../runs/segment/train/weights/best.onnx --dataset ../test --input_width 320 --input_height 320 --ptq_option 0
cd ../../

9.5 在k230上使用MicroPython部署模型#

9.5.1 烧录镜像并安装CanMV IDE#

请按照开发板下载链接下的镜像，并烧录：Release PreRelease · kendryte/canmv_k230。下载并安装 CanMV IDE (下载链接：CanMV IDE download)，在 IDE 中编写代码实现部署。

9.5.2 模型文件拷贝#

连接IDE，将转换好的模型和测试图片拷贝到路径 CanMV/data 目录下。该路径可以自定义，只需要在编写代码时修改对应路径即可。

9.5.3 YOLO11 模块#

YOLO11 类集成了 YOLO11 的三种任务，包括分类(classify)、检测(detect)、分割(segment)；支持两种推理模式，包括图片(image)和视频流(video)；该类封装了 YOLO11 的 kmodel 推理流程。

  • 导入方法

from libs.YOLO import YOLO11

  • 参数说明

参数名称

描述

说明

类型

task_type

任务类型

支持三类任务，可选项为’classify’/’detect’/’segment’；

str

mode

推理模式

支持两种推理模式，可选项为’image’/’video’，’image’表示推理图片，’video’表示推理摄像头采集的实时视频流；

str

kmodel_path

kmodel路径

拷贝到开发板上kmodel路径；

str

labels

类别标签列表

不同类别的标签名称；

list[str]

rgb888p_size

推理帧分辨率

推理当前帧分辨率，如[1920,1080]、[1280,720]、[640,640];

list[int]

model_input_size

模型输入分辨率

YOLO11模型训练时的输入分辨率，如[224,224]、[320,320]、[640,640]；

list[int]

display_size

显示分辨率

推理模式为’video’时设置，支持hdmi([1920,1080])和lcd([800,480]);

list[int]

conf_thresh

置信度阈值

分类任务类别置信度阈值，检测分割任务的目标置信度阈值，如0.5；

float【0~1】

nms_thresh

nms阈值

非极大值抑制阈值，检测和分割任务必填；

float【0~1】

mask_thresh

mask阈值

分割任务中的对检测框中对象做分割时的二值化阈值；

float【0~1】

max_boxes_num

最大检测框数

一帧图像中允许返回的最多检测框数目；

int

debug_mode

调试模式

计时函数是否生效，可选项0/1，0为不计时，1为计时；

int【0/1】

9.5.4 部署模型实现图片推理#

图片推理，请参考下述代码，根据实际情况修改 __main__ 中的定义参数变量；

from libs.YOLO import YOLO11
import os,sys,gc
import ulab.numpy as np
import image

# 从本地读入图片，并实现HWC转CHW
def read_img(img_path):
    img_data = image.Image(img_path)
    img_data_rgb888=img_data.to_rgb888()
    img_hwc=img_data_rgb888.to_numpy_ref()
    shape=img_hwc.shape
    img_tmp = img_hwc.reshape((shape[0] * shape[1], shape[2]))
    img_tmp_trans = img_tmp.transpose()
    img_res=img_tmp_trans.copy()
    img_return=img_res.reshape((shape[2],shape[0],shape[1]))
    return img_return,img_data_rgb888

if __name__=="__main__":
    img_path="/data/test.jpg"
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    mask_threshold=0.5
    model_input_size=[320,320]
    img,img_ori=read_img(img_path)
    rgb888p_size=[img.shape[2],img.shape[1]]
    # 初始化YOLO11实例
    yolo=YOLO11(task_type="segment",mode="image",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,mask_thresh=mask_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        res=yolo.run(img)
        yolo.draw_result(res,img_ori)
        gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()

9.5.5 部署模型实现视频推理#

视频推理，请参考下述代码，根据实际情况修改 __main__ 中的定义变量；

from libs.PipeLine import PipeLine, ScopedTiming
from libs.YOLO import YOLO11
import os,sys,gc
import ulab.numpy as np
import image

if __name__=="__main__":
    # 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
    display_mode="hdmi"
    rgb888p_size=[320,320]
    if display_mode=="hdmi":
        display_size=[1920,1080]
    else:
        display_size=[800,480]
    kmodel_path="/data/best.kmodel"
    labels = ["apple","banana","orange"]
    confidence_threshold = 0.5
    nms_threshold=0.45
    mask_threshold=0.5
    model_input_size=[320,320]
    # 初始化PipeLine
    pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
    pl.create()
    # 初始化YOLO11实例
    yolo=YOLO11(task_type="segment",mode="video",kmodel_path=kmodel_path,labels=labels,rgb888p_size=rgb888p_size,model_input_size=model_input_size,display_size=display_size,conf_thresh=confidence_threshold,nms_thresh=nms_threshold,mask_thresh=mask_threshold,max_boxes_num=50,debug_mode=0)
    yolo.config_preprocess()
    try:
        while True:
            os.exitpoint()
            with ScopedTiming("total",1):
                # 逐帧推理
                img=pl.get_frame()
                res=yolo.run(img)
                yolo.draw_result(res,pl.osd_img)
                pl.show_image()
                gc.collect()
    except Exception as e:
        sys.print_exception(e)
    finally:
        yolo.deinit()
        pl.destroy()

10. kmodel转换验证#

不同模型下载的模型转换脚本工具包( test_yolov5/test_yolov8/test_yolo11 )中包含 kmodel 验证的脚本。

注意：执行验证脚本需要添加环境变量

linux：

# 下述命令中的路径为安装 nncase 的 Python 环境的路径，请按照您的环境适配修改
export NNCASE_PLUGIN_PATH=$NNCASE_PLUGIN_PATH:/usr/local/lib/python3.9/site-packages/
export PATH=$PATH:/usr/local/lib/python3.9/site-packages/
source /etc/profile

windows：

将安装 nncase 的 Python 环境下的 Lib/site-packages 路径添加到环境变量的系统变量 Path 中。

10.1 对比onnx输出和kmodel输出#

10.1.1 生成输入bin文件#

进入到 classify/detect/segment 目录下，执行下述命令：

python save_bin.py --image ../test_images/test.jpg --input_width 224 --input_height 224

执行脚本将在当前目录下生成bin文件 onnx_input_float32.bin 和 kmodel_input_uint8.bin ，作为 onnx 模型和 kmodel 模型的输入文件。

10.1.2 对比输出#

将转换的模型 best.onnx 和 best.kmodel 拷贝到 calssify/detect/segment 目录下，然后执行验证脚本，执行命令如下：

python simulate.py --model best.onnx --model_input onnx_input_float32.bin --kmodel best.kmodel --kmodel_input kmodel_input_uint8.bin --input_width 224 --input_height 224

得到如下输出：

output 0 cosine similarity : 0.9985673427581787

脚本将依次对比输出的 cosine 相似度，如果相似度在0.99以上，一般认为模型是可用的；否则，需要实际推理测试或者更换量化参数重新导出 kmodel。如果模型有多个输出，会有多行相似度对比信息，比如分割任务，有两个输出，相似度对比信息如下：

output 0 cosine similarity : 0.9999530911445618
output 1 cosine similarity : 0.9983288645744324

10.2 onnx模型推理图片#

进入 classify/detect/segment 目录下，打开 test_cls_onnx.py，修改 main() 中的参数以适配你的模型，然后执行命令：

python test_cls_onnx.py

命令执行成功后会保存结果到 onnx_cls_results.jpg 。

检测任务和分割任务类似，分别执行 test_det_onnx.py 和 test_seg_onnx.py 。

10.3 kmodel模型推理图片#

进入 classify/detect/segment 目录下，打开 test_cls_kmodel.py , 修改 main() 中的参数以适配你的模型，然后执行命令：

python test_cls_kmodel.py

命令执行成功后会保存结果到 kmodel_cls_results.jpg 。

检测任务和分割任务类似，分别执行 test_det_kmodel.py 和 test_seg_kmodel.py 。

11. 调优指南#

当模型在 K230 上运行效果不理想时，一般考虑从阈值设置、模型大小、输入分辨率、量化方法、训练数据质量等方面入手进行调优。

11.1 调整阈值#

调整置信度阈值、nms 阈值、mask 阈值，在不改变模型的前提下调优部署效果。在检测任务中，提高置信度阈值和降低nms阈值会导致检测框的数量减少，反之，降低置信度阈值和提高nms阈值会导致检测框的数量增多。在分割任务中mask阈值会影响分割区域的划分。您可以根据实际场景先进行调整，找到较优效果下的阈值。

11.2 更换模型#

选择不同大小的模型以平衡速度、内存占用和准确性。可以根据实际需求选择n/s/m/l的模型进行训练和转换。

下述数据以三类水果数据集训练得到的kmodel为例，在 01Studio CanMV K230 开发板上运行粗测，实际部署中，后处理时间会受到结果数的影响增加，同时内存管理 gc.collect() 的耗时也会随着后处理的复杂程度增加：

模型

输入分辨率

任务

kpu推理耗时

kpu推理帧率

整帧推理耗时

整帧推理帧率

yolov5n

224×224

cls

3ms

333fps

17ms

58fps

yolov5s

224×224

cls

7ms

142fps

19ms

52fps

yolov5m

224×224

cls

12ms

83fps

24ms

41fps

yolov5l

224×224

cls

22ms

45fps

33ms

30fps

yolov8n

224×224

cls

6ms

166fps

16ms

62fps

yolov8s

224×224

cls

13ms

76fps

24ms

41fps

yolov8m

224×224

cls

27ms

37fps

39ms

25fps

yolov8l

224×224

cls

53ms

18fps

65ms

15fps

yolo11n

224×224

cls

7ms

142fps

19ms

52fps

yolo11s

224×224

cls

15ms

66fps

26ms

38fps

yolo11m

224×224

cls

23ms

43fps

35ms

28fps

yolo11l

224×224

cls

31ms

32fps

43ms

23fps

yolov5n

320×320

det

25ms

40fps

105ms

9fps

yolov5s

320×320

det

30ms

33fps

109ms

9fps

yolov5m

320×320

det

44ms

22fps

124ms

8fps

yolov5l

320×320

det

73ms

13fps

149ms

6fps

yolov8n

320×320

det

25ms

40fps

62ms

16fps

yolov8s

320×320

det

44ms

22fps

77ms

12fps

yolov8m

320×320

det

78ms

12fps

109ms

9fps

yolov8l

320×320

det

126ms

7fps

160ms

6fps

yolo11n

320×320

det

28ms

35fps

63ms

15fps

yolo11s

320×320

det

49ms

20fps

81ms

12fps

yolo11m

320×320

det

77ms

12fps

112ms

8fps

yolo11l

320×320

det

94ms

10fps

132ms

7fps

yolov5n

320×320

seg

67ms

14fps

178ms

5fps

yolov5s

320×320

seg

80ms

12fps

180ms

5fps

yolov5m

320×320

seg

95ms

10fps

206ms

4fps

yolov5l

320×320

seg

122ms

8fps

235ms

4fps

yolov8n

320×320

seg

28ms

35fps

131ms

7fps

yolov8s

320×320

seg

52ms

19fps

151ms

6fps

yolov8m

320×320

seg

87ms

11fps

215ms

4fps

yolov8l

320×320

seg

143ms

6fps

246ms

4fps

yolo11n

320×320

seg

31ms

32fps

135ms

7fps

yolo11s

320×320

seg

55ms

18fps

156ms

6fps

yolo11m

320×320

seg

97ms

10fps

205ms

4fps

yolo11l

320×320

seg

112ms

8fps

214ms

4fps

11.3 更改输入分辨率#

更改模型的输入分辨率以适配您的场景，较大的分辨率可以提升效果，但会耗费更多的推理时间。

下述数据以三类水果数据集训练得到的kmodel为例，在 01Studio CanMV K230 开发板上运行粗测，实际部署中，后处理时间会受到结果数的影响增加，同时内存管理 gc.collect() 的耗时也会随着后处理的复杂程度增加：

模型

输入分辨率

任务

kpu推理耗时

kpu推理帧率

整帧推理耗时

整帧推理帧率

yolov5n

224×224

cls

3ms

333fps

17ms

58fps

yolov5n

320×320

cls

5ms

200fps

18ms

55fps

yolov5n

320×320

det

25ms

40fps

105ms

9fps

yolov5n

640×640

det

73ms

13fps

322ms

3fps

yolov5n

320×320

seg

67ms

14fps

178ms

5fps

yolov5n

640×640

seg

252ms

3fps

398ms

2fps

yolov8n

224×224

cls

6ms

166fps

16ms

62fps

yolov8n

320×320

cls

7ms

142fps

21ms

47fps

yolov8n

320×320

det

25ms

40fps

62ms

16fps

yolov8n

640×640

det

85ms

11fps

183ms

5fps

yolov8n

320×320

seg

28ms

35fps

131ms

7fps

yolov8n

640×640

seg

98ms

10fps

261ms

3fps

yolo11n

224×224

cls

7ms

142fps

19ms

52fps

yolo11n

320×320

cls

9ms

111fps

22ms

45fps

yolo11n

320×320

det

28ms

35fps

63ms

15fps

yolo11n

640×640

det

92ms

10fps

191ms

5fps

yolo11n

320×320

seg

31ms

32fps

135ms

7fps

yolo11n

640×640

seg

104ms

9fps

263ms

3fps

11.4 修改量化方法#

模型转换脚本中提供了3种量化参数，对 data 和 weights 进行 uint8 量化或 int16 量化。

在转换kmodel脚本中，通过选择不同的 ptq_option 值指定不同的量化方式。

ptq_option

data

weights

0

uint8

uint8

1

uint8

int16

2

int16

uint8

下述数据以三类水果数据集训练得到的kmodel为例，在 01Studio CanMV K230 开发板上运行粗测，实际部署中，后处理时间会受到结果数的影响增加，同时内存管理 gc.collect() 的耗时也会随着后处理的复杂程度增加：

模型

输入分辨率

任务

量化参数[data,weights]

kpu推理耗时

kpu推理帧率

整帧推理耗时

整帧推理帧率

yolov5n

320×320

det

[uint8,uint8]

25ms

333fps

105ms

58fps

yolov5n

320×320

det

[uint8,int16]

25ms

200fps

103ms

55fps

yolov5n

320×320

det

[int16,uint8]

30ms

40fps

110ms

9fps

yolov8n

320×320

det

[uint8,uint8]

25ms

13fps

62ms

3fps

yolov8n

320×320

det

[uint8,int16]

27ms

14fps

65ms

5fps

yolov8n

320×320

det

[int16,uint8]

33ms

3fps

72ms

2fps

yolo11n

320×320

det

[uint8,uint8]

28ms

166fps

63ms

62fps

yolo11n

320×320

det

[uint8,int16]

33ms

142fps

71ms

47fps

yolo11n

320×320

det

[int16,uint8]

35ms

40fps

78ms

16fps

11.5 提高数据质量#

如果训练结果较差，请提高数据集质量，从数据量、合理的数据分布、标注质量、训练参数设置等方面优化。

11.6 调优技巧#

  • 量化参数在YOLOv8和YOLO11上对效果的影响比YOLOv5大，对比不同量化模型可见；

  • 输入分辨率比模型大小对推理速度的影响更大；

  • 训练数据和K230摄像头数据分布差异可能会对部署效果造成影响，可以使用K230采集部分数据，自行标注训练；

目录