如何在 RK3566 上部署 YOLOv8：从模型转换到边缘实时推理

在智能摄像头、工业检测、无人零售等场景中，边缘 AI（Edge AI） 已经从实验阶段走向量产落地。

而在所有主流目标检测算法中，YOLOv8 以其轻量、高速和高精度的特性，成为嵌入式端最受欢迎的模型之一。

然而，直接在嵌入式设备上运行 YOLOv8 并不简单。

以 RK3566 为代表的 AI 芯片虽然性能出色（集成 NPU、CPU、GPU），但受限于算力与内存，需要进行模型量化和架构优化，才能在低功耗下实现实时推理。

本文将带你完成从 YOLOv8 模型 → ONNX → RKNN → 边缘推理 的全过程，帮助你在 RK3566 上成功部署一个可运行的 YOLOv8 实时检测系统。

硬件概览：RK3566 是怎样的边缘 AI 平台？

RK3566 的 NPU 原生支持 INT8 量化模型，因此我们需要将原始 YOLOv8（FP32 模型）转换为 RKNN 格式，并通过校准样本进行量化，以达到最佳性能。

💡 提示：RK3566 NPU 支持多线程并发，可同时运行 2–3 个轻量 AI 任务（如目标检测 + 分类 + 跟踪）。

YOLOv8 模型简介

YOLOv8 是 Ultralytics 发布的最新一代 YOLO 系列目标检测模型，具有以下特点：

• 更轻量：YOLOv8-n 与 YOLOv8-s 适合嵌入式部署；
• 更灵活：支持自定义输入分辨率与动态 shape；
• 更高精度：采用 C2f 模块，优化了特征融合路径；
• 跨平台：原生支持 ONNX、TensorRT、CoreML、RKNN 等导出格式。

在 RK3566 上部署时，建议使用 YOLOv8-n（Nano） 版本，

输入尺寸 320×320 或 416×416，可在 NPU 上实现 15–25 FPS 的实时性能。

部署整体流程

在部署前，先整体了解整个数据与模型的流转路径：

---

title: "YOLOv8 在 RK3566 上的部署流程"

---

graph TD

%% ====== 样式定义 ======

classDef model fill:#DCE8FF,stroke:#1A5FFF,stroke-width:2,rx:10,ry:10,color:#0B2161,font-weight:bold;

classDef convert fill:#E0F7FA,stroke:#00838F,stroke-width:2,rx:10,ry:10,color:#004D40,font-weight:bold;

classDef quant fill:#FFF8E1,stroke:#F57F17,stroke-width:2,rx:10,ry:10,color:#4E342E,font-weight:bold;

classDef deploy fill:#E8F5E9,stroke:#0A7E07,stroke-width:2,rx:10,ry:10,color:#064C00,font-weight:bold;

classDef infer fill:#F1F8E9,stroke:#558B2F,stroke-width:2,rx:10,ry:10,color:#1B5E20,font-weight:bold;

classDef result fill:#FFF3D6,stroke:#E69A00,stroke-width:2,rx:10,ry:10,color:#663C00,font-weight:bold;



%% ====== 工作流程 ======

A["📘 训练或下载 YOLOv8 模型"]:::model -->

B["📤 导出为 ONNX 格式"]:::convert -->

C["🧩 使用 RKNN Toolkit 转换为 RKNN 模型"]:::convert -->

D["⚙️ 量化与优化模型（INT8）"]:::quant -->

E["🚀 部署到 RK3566 板端"]:::deploy -->

F["🧠 通过 Python / C++ API 运行推理"]:::infer -->

G["📺 实时显示检测结果"]:::result



%% ====== 连线样式 ======

linkStyle default stroke:#555,stroke-width:1.8;

该流程分为 6 个关键步骤：

1. 准备模型（训练或下载 YOLOv8 权重）
2. 导出模型（转换为 ONNX 格式）
3. 模型转换（使用 RKNN Toolkit 生成 .rknn 文件）
4. 模型量化（通过数据集优化精度与速度）
5. 部署运行（在 RK3566 上调用 RKNN Runtime）
6. 结果展示（实时摄像头画面检测）

环境准备

1. 硬件设备

• RK3566 开发板（如 Radxa Zero 3W、Pine64 Quartz64 或自研方案）
• 5V/3A 电源适配器
• USB 摄像头 / MIPI 摄像头
• Linux 主机（用于模型转换）
• 网络连接（用于 SSH / SCP 文件传输）

2. 软件环境

⚠️ 注意：RKNN Toolkit 仅在 x86_64 Linux 主机 上运行；RKNN Runtime 才能部署到 RK3566 板端。

3. 安装 RKNN Toolkit

在主机环境中执行以下命令：

# 创建 Python 虚拟环境
python3 -m venv rknn_env
source rknn_env/bin/activate

# 安装依赖
pip install torch onnx onnxsim ultralytics
pip install rknn-toolkit2==2.3.0

验证安装是否成功：

python -m rknn.api.rknn --version

出现版本号（如 2.3.0）即表示安装成功。

4. 导出 YOLOv8 模型为 ONNX

如果你已训练完自定义模型，或者直接使用官方权重：

yolo export model=yolov8n.pt format=onnx opset=12

导出成功后会生成：

yolov8n.onnx

该文件即为后续转换为 RKNN 的输入模型。

如何在 RK3566 上部署 YOLOv8：完整边缘推理教程（2/3）

一、从 ONNX 到 RKNN：模型转换

在 RK3566 上运行 YOLOv8，需要将模型从标准的 ONNX 格式转换为 Rockchip 专用的 RKNN 格式，才能在 NPU 上进行加速推理。

1. 编写转换脚本

在主机端创建一个脚本 convert_yolov8_to_rknn.py：

from rknn.api import RKNN

rknn = RKNN()

# 1. 加载 ONNX 模型
rknn.load_onnx(model='yolov8n.onnx')

# 2. 设置配置参数
rknn.config(
    mean_values=[[0, 0, 0]],
    std_values=[[255, 255, 255]],
    target_platform='rk3566',
    quantized_dtype='asymmetric_affine-u8'
)

# 3. 构建量化模型
rknn.build(do_quantization=True, dataset='./dataset.txt')

# 4. 导出 RKNN 文件
rknn.export_rknn('yolov8n_rk3566.rknn')

2. 关键参数说明

⚠️ 注意：量化数据集 dataset.txt 必须包含多样化的样本图像，否则模型可能出现精度漂移。

二、准备量化校准数据

在 YOLOv8 的训练集或测试集目录中生成 dataset.txt：

find ./images/ -type f -name "*.jpg" > dataset.txt

推荐选择 100–300 张图像，覆盖主要检测场景（白天/夜晚、不同背景、不同光照），确保量化后精度稳定。

三、验证 RKNN 模型

转换完成后，可在主机端通过 RKNN Toolkit 验证模型输出是否正常：

from rknn.api import RKNN
import cv2

rknn = RKNN()
rknn.load_rknn('yolov8n_rk3566.rknn')
rknn.init_runtime()

img = cv2.imread('test.jpg')
outputs = rknn.inference(inputs=[img])

print(outputs)

如果能够正常输出张量结果，则说明模型转换无误。

四、部署到 RK3566 板端

1. 文件传输

将以下文件复制至 RK3566：

yolov8n_rk3566.rknn
test.jpg
inference_rk3566.py

使用 scp 或 USB 拷贝即可：

scp yolov8n_rk3566.rknn root@192.168.1.88:/home/pi/yolo/

2. 安装运行环境

在 RK3566 板端执行：

sudo apt update
sudo apt install python3-opencv
pip3 install rknn-runtime==2.3.0

💡 RKNN Runtime 是 NPU 运行时库，仅需安装在 RK3566 设备端。

3. 推理脚本示例

创建 inference_rk3566.py：

from rknnlite.api import RKNNLite
import cv2

# 1. 加载 RKNN 模型
rknn = RKNNLite()
rknn.load_rknn('yolov8n_rk3566.rknn')
rknn.init_runtime()

# 2. 输入测试图像
img = cv2.imread('test.jpg')

# 3. 执行推理
outputs = rknn.inference(inputs=[img])

# 4. 打印结果维度
print("Inference outputs:", [x.shape for x in outputs])

运行后即可在终端看到模型输出的特征图结构。

五、实时摄像头检测

为了验证边缘实时性能，可连接 USB 摄像头，运行实时检测：

import cv2
from rknnlite.api import RKNNLite

rknn = RKNNLite()
rknn.load_rknn('yolov8n_rk3566.rknn')
rknn.init_runtime()

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    outputs = rknn.inference(inputs=[frame])
    # TODO: 后处理（解码 + NMS + 绘制框）
    cv2.imshow("YOLOv8 RK3566", frame)
    if cv2.waitKey(1) == 27:
        break

在默认配置下，YOLOv8-n 模型可达到 18~22 FPS，功耗约 3.5W，完全可满足实时目标检测场景。

六、性能测试结果

📊 结论：RK3566 在运行 YOLOv8-n 模型时，能稳定实现近实时的检测速度，适合智能监控、零售终端与工业检测等场景。

七、性能优化技巧

1. 固定输入尺寸（如 320×320） 避免动态调整尺寸造成 CPU 额外开销。
2. 使用 INT8 量化模型 可提升推理速度 2~3 倍，几乎无明显精度损失。
3. 减少后处理开销 将 NMS 逻辑下沉到 C++ 层或 NPU 后端实现。
4. 控制线程优先级 使用 taskset 或 nice 优化进程分配，提高帧率稳定性。

如何在 RK3566 上部署 YOLOv8：完整边缘推理教程（3/3）

一、YOLOv8 输出结构解析

YOLOv8 模型在经过 RKNN 转换后，会输出一个或多个张量，一般形状如下：

(1, 84, 8400)

其中：

• 8400 表示 anchor 数量（与输入分辨率相关）
• 84 表示每个 anchor 对应的 4 个框参数 + 80 类别概率

我们需要将这些原始输出经过 后处理（Post-Processing） 转化为可视化的目标框与标签。

二、YOLOv8 后处理与 NMS 实现

在 RK3566 上，为保持性能与精度平衡，建议使用 Python 实现轻量版后处理逻辑：

import numpy as np

def xywh2xyxy(x):
    y = np.zeros_like(x)
    y[:, 0] = x[:, 0] - x[:, 2] / 2
    y[:, 1] = x[:, 1] - x[:, 3] / 2
    y[:, 2] = x[:, 0] + x[:, 2] / 2
    y[:, 3] = x[:, 1] + x[:, 3] / 2
    return y

def bbox_iou(box1, boxes):
    inter_x1 = np.maximum(box1[0], boxes[:,0])
    inter_y1 = np.maximum(box1[1], boxes[:,1])
    inter_x2 = np.minimum(box1[2], boxes[:,2])
    inter_y2 = np.minimum(box1[3], boxes[:,3])
    inter_area = np.maximum(inter_x2 - inter_x1, 0) * np.maximum(inter_y2 - inter_y1, 0)
    area1 = (box1[2]-box1[0])*(box1[3]-box1[1])
    area2 = (boxes[:,2]-boxes[:,0])*(boxes[:,3]-boxes[:,1])
    return inter_area / (area1 + area2 - inter_area)

def nms(boxes, scores, iou_thresh=0.45):
    idxs = scores.argsort()[::-1]
    keep = []
    while len(idxs) > 0:
        i = idxs[0]
        keep.append(i)
        if len(idxs) == 1:
            break
        iou = bbox_iou(boxes[i], boxes[idxs[1:]])
        idxs = idxs[1:][iou < iou_thresh]
    return keep

💡 提示：在生产环境中，可使用 Rockchip 提供的 C++ YOLO 后处理 SDK（rknn_yolov5_postprocess.cc）以获得更高的帧率。

三、实时检测画面可视化

将推理与后处理结合，通过 OpenCV 实时显示检测框：

import cv2
from rknnlite.api import RKNNLite

def draw_boxes(img, boxes, scores, classes, names):
    for box, score, cls in zip(boxes, scores, classes):
        x1, y1, x2, y2 = map(int, box)
        label = f"{names[cls]} {score:.2f}"
        cv2.rectangle(img, (x1, y1), (x2, y2), (0,255,0), 2)
        cv2.putText(img, label, (x1, y1-10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)
    return img

rknn = RKNNLite()
rknn.load_rknn('yolov8n_rk3566.rknn')
rknn.init_runtime()

cap = cv2.VideoCapture(0)
class_names = open("coco.names").read().strip().split("\n")

while True:
    ret, frame = cap.read()
    if not ret:
        break
    outputs = rknn.inference(inputs=[frame])
    boxes, scores, classes = postprocess_yolov8(outputs)
    frame = draw_boxes(frame, boxes, scores, classes, class_names)
    cv2.imshow("YOLOv8 on RK3566", frame)
    if cv2.waitKey(1) == 27:
        break

📷 在 RK3566 上使用 USB 摄像头时，YOLOv8-n（320×320 输入）通常可达到 15~20 FPS，检测延迟低于 80ms。

四、部署为系统服务（自动启动）

在工业或零售终端应用中，通常希望设备上电即可自动运行 YOLO 推理服务。

可通过 systemd 实现自启动。

1. 创建服务文件

sudo nano /etc/systemd/system/yolov8_inference.service

写入以下内容：

[Unit]
Description=YOLOv8 Edge AI Inference on RK3566
After=network.target

[Service]
ExecStart=/usr/bin/python3 /home/pi/yolo/inference_rk3566.py
Restart=always
User=pi
WorkingDirectory=/home/pi/yolo/

[Install]
WantedBy=multi-user.target

2. 启用服务

sudo systemctl enable yolov8_inference.service
sudo systemctl start yolov8_inference.service

系统启动后会自动运行 YOLOv8 推理程序，即便断电重启也能恢复。

五、Docker 容器化部署

若需要在多台 RK3566 设备上批量部署，可以使用 Docker 来统一运行环境。

Dockerfile 示例

FROM arm64v8/python:3.9
RUN apt update && apt install -y python3-opencv
COPY requirements.txt /tmp/
RUN pip install -r /tmp/requirements.txt
COPY yolov8n_rk3566.rknn /app/
COPY inference_rk3566.py /app/
WORKDIR /app
CMD ["python3", "inference_rk3566.py"]

构建与运行

docker build -t yolov8-rk3566 .
docker run --privileged --device /dev/video0:/dev/video0 yolov8-rk3566

🧩 这样即可快速部署到多台 RK3566 边缘设备，无需重复环境配置。

与云端/本地系统联动

部署完 YOLOv8 后，往往还需将检测结果与上层系统交互。以下是常见的三种方式：

例如，通过 Python 实现 MQTT 数据上报：

import paho.mqtt.client as mqtt
import json

client = mqtt.Client()
client.connect("broker.local", 1883)
payload = {"object": "person", "confidence": 0.94, "timestamp": "2025-10-14T18:23:00"}
client.publish("edge/yolov8/events", json.dumps(payload))

🚀 可轻松与 Home Assistant、Node-RED、ZedAIoT Cloud 等系统集成，实现 IoT 场景闭环。

系统验证与发布 checklist ✅

通过以上流程，你就完成了一个可在 RK3566 上 稳定运行 YOLOv8 的边缘 AI 检测系统。

总结

至此，你已完成 YOLOv8 在 RK3566 上的完整部署流程，从模型训练到量化、推理、自动启动与云端连接。

RK3566 结合 Rockchip 的 RKNN 工具链，为开发者提供了一个高性价比、低功耗且可商用的 边缘视觉计算平台，

无论是智能安防、零售识别、生产质检还是交通检测，都可以以此为基础实现本地 AI 感知与实时分析。