YOLO26N 边缘部署实战：Jetson / RK3588 / 国科微 NPU

1. 边缘部署全景

YOLO26N 边缘部署方案：
├── NVIDIA Jetson 系列
│   ├── Orin NX/AGX：TensorRT FP16/INT8
│   ├── Orin Nano：TensorRT FP16
│   └── Xavier NX：TensorRT FP16/INT8
├── 瑞芯微 RK3588
│   ├── NPU：RKNN INT8
│   └── CPU：ONNX Runtime
├── 国科微 GK7206
│   ├── NPU：GMT INT8
│   └── 专用低功耗场景
└── 通用方案
    ├── OpenCV DNN：CPU/GPU
    ├── NCNN：ARM CPU
    └── TFLite：移动端

2. Jetson 部署

# Jetson TensorRT 推理
from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="engine", imgsz=640, half=True, batch=1)

# 推理
results = model.predict("test.jpg", conf=0.3)

# 性能基准（Orin NX 16GB）：
# FP16：4.5ms, 222 FPS
# INT8：3.2ms, 312 FPS

2.1 Jetson 优化配置

# 性能优化
sudo nvpmodel -m 0
sudo jetson_clocks

# 检查温度
cat /sys/devices/virtual/thermal/thermal_zone0/temp

3. RK3588 部署

3.1 ONNX → RKNN 转换

#!/usr/bin/env python3
"""onnx_to_rknn.py - RKNN 转换"""
from rknn.api import RKNN

def convert_to_rknn(onnx_path, rknn_path):
    rknn = RKNN(verbose=True)
    
    # 配置
    rknn.config(
        mean_values=[[0, 0, 0]],
        std_values=[[255, 255, 255]],
        target_platform='rk3588',
        quantized_dtype='asymmetric_quantized-8',
    )
    
    # 加载 ONNX
    ret = rknn.load_onnx(model=onnx_path)
    if ret != 0:
        print("加载 ONNX 失败")
        return
    
    # 构建（INT8 量化）
    ret = rknn.build(
        do_quantization=True,
        dataset='calibration_list.txt',  # 校准图片列表
    )
    if ret != 0:
        print("构建失败")
        return
    
    # 导出
    ret = rknn.export_rknn(rknn_path)
    if ret != 0:
        print("导出失败")
        return
    
    print(f"✅ RKNN 模型已导出: {rknn_path}")
    rknn.release()

if __name__ == "__main__":
    convert_to_rknn("yolo26n.onnx", "yolo26n.rknn")

3.2 RKNN 推理

#!/usr/bin/env python3
"""rknn_inference.py - RKNN 推理"""
from rknnlite.api import RKNNLite
import cv2
import numpy as np

class YOLO26NRKNN:
    def __init__(self, rknn_path):
        self.rknn = RKNNLite()
        self.rknn.load_rknn(rknn_path)
        self.rknn.init_runtime(core_mask=RKNNLite.NPU_CORE_0_1_2)
    
    def detect(self, image):
        # 预处理
        img = cv2.resize(image, (640, 640))
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        
        # 推理
        outputs = self.rknn.inference(inputs=[img])
        
        # 后处理
        return self.postprocess(outputs, image.shape)
    
    def postprocess(self, outputs, orig_shape):
        # YOLOv8/YOLO26 后处理
        predictions = outputs[0][0].T  # [8400, 84]
        boxes = predictions[:, :4]
        scores = predictions[:, 4:]
        
        max_scores = scores.max(axis=1)
        class_ids = scores.argmax(axis=1)
        
        mask = max_scores > 0.3
        return boxes[mask], max_scores[mask], class_ids[mask]

if __name__ == "__main__":
    model = YOLO26NRKNN("yolo26n.rknn")
    image = cv2.imread("test.jpg")
    boxes, scores, classes = model.detect(image)
    print(f"检测到 {len(boxes)} 个目标")

3.3 RK3588 性能

RK3588 NPU 性能（YOLO26N, 640x640, INT8）：
┌──────────────────┬──────────┐
│ 指标              │ 数值      │
├──────────────────┼──────────┤
│ 推理延迟          │ 8ms      │
│ FPS              │ 125      │
│ 功耗              │ 5W       │
│ NPU 核心          │ 3 核并行  │
└──────────────────┴──────────┘

4. 国科微 GK7206 NPU 部署

4.1 GMT 工具链转换

# gk7206_convert.yaml
input_shape:
  images: [1, 3, 640, 640]
input_normalize:
  images:
    - [0, 0, 0]
    - [255, 255, 255]
input_format: RGB
model_format: RGB
output:
  - /model.23/cv2.0/cv2.0.2/Conv
  - /model.23/cv3.0/cv3.0.2/Conv
  - /model.23/cv2.1/cv2.1.2/Conv
  - /model.23/cv3.1/cv3.1.2/Conv
  - /model.23/cv2.2/cv2.2.2/Conv
  - /model.23/cv3.2/cv3.2.2/Conv
quantize:
  type: int8
  calib_img_num: 200
  calib_path: ./calib/
optimize:
  op_fusion: true

# 转换流程
gmt import --onnx yolo26n_opt.onnx --config gk7206_convert.yaml --out graph.json
gmt calibrate --graph graph.json --config gk7206_convert.yaml --out quant_param.bin
gmt build --graph graph.json --quant quant_param.bin --target gk7206 --out yolo26n_gk7206.bin

4.2 GK7206 性能

GK7206 NPU 性能（YOLO26N, 640x640, INT8）：
┌──────────────────┬──────────┐
│ 指标              │ 数值      │
├──────────────────┼──────────┤
│ 推理延迟          │ 15ms     │
│ FPS              │ 67       │
│ 功耗              │ 2W       │
│ NPU 算力          │ 1 TOPS   │
└──────────────────┴──────────┘

5. 各平台性能对比

YOLO26N 各平台性能对比：
┌──────────────────┬──────────┬──────────┬──────────┬──────────┐
│ 平台              │ 延迟      │ FPS      │ 功耗      │ 能效比    │
├──────────────────┼──────────┼──────────┼──────────┼──────────┤
│ Jetson Orin NX   │ 3.2ms    │ 312      │ 15W      │ 21 FPS/W │
│ Jetson Orin Nano │ 5.5ms    │ 182      │ 10W      │ 18 FPS/W │
│ RK3588 NPU       │ 8.0ms    │ 125      │ 5W       │ 25 FPS/W │
│ GK7206 NPU       │ 15ms     │ 67       │ 2W       │ 34 FPS/W │
└──────────────────┴──────────┴──────────┴──────────┴──────────┘

能效比排名：GK7206 > RK3588 > Jetson Orin NX
绝对性能排名：Jetson Orin NX > Jetson Orin Nano > RK3588 > GK7206

6. 选型建议

选型决策：
├── 高性能场景（30+ FPS, 多路视频）
│   └── Jetson Orin NX/AGX
├── 低功耗场景（<5W, 电池供电）
│   ├── GK7206 NPU（最低功耗）
│   └── RK3588 NPU（平衡方案）
├── 成本敏感（批量部署）
│   └── RK3588（$50-80）
└── 极致能效（FPS/W）
    └── GK7206（34 FPS/W）

总结