YOLO26N 姿态估计 INT8 量化：低算力设备极致优化

1. 量化收益

YOLO26N-Pose 量化对比：
┌──────────┬──────────┬──────────┬──────────┬──────────┐
│ 精度      │ 模型大小  │ 内存占用  │ 推理延迟  │ mAP      │
├──────────┼──────────┼──────────┼──────────┼──────────┤
│ FP32     │ 12.8MB   │ 51MB     │ 15ms     │ 68.5     │
│ FP16     │ 6.4MB    │ 26MB     │ 5.2ms    │ 68.3     │
│ INT8     │ 3.2MB    │ 13MB     │ 3.8ms    │ 67.2     │
└──────────┴──────────┴──────────┴──────────┴──────────┘

INT8 优势：
├── 模型大小：4x 压缩（12.8MB → 3.2MB）
├── 推理速度：4x 加速（15ms → 3.8ms）
├── 精度损失：仅 1.3 mAP（68.5 → 67.2）
└── 功耗降低：约 40%

2. TensorRT INT8 量化

#!/usr/bin/env python3
"""pose_int8.py - TensorRT INT8 量化"""
import tensorrt as trt
import numpy as np
import cv2
import glob

class PoseINT8Calibrator(trt.IInt8EntropyCalibrator2):
    def __init__(self, data_dir, batch_size=8, cache_file="pose_int8.cache"):
        super().__init__()
        self.batch_size = batch_size
        self.cache_file = cache_file
        self.images = sorted(glob.glob(f"{data_dir}/**/*.jpg", recursive=True))[:200]
        self.current_index = 0
        
        import pycuda.driver as cuda
        self.device_input = cuda.mem_alloc(batch_size * 3 * 640 * 640 * 4)
    
    def preprocess(self, img_path):
        img = cv2.imread(img_path)
        img = cv2.resize(img, (640, 640))
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        return (img.astype(np.float32) / 255.0).transpose(2, 0, 1)
    
    def get_batch_size(self):
        return self.batch_size
    
    def get_batch(self, names):
        import pycuda.driver as cuda
        if self.current_index >= len(self.images):
            return None
        
        batch = []
        for i in range(self.batch_size):
            if self.current_index < len(self.images):
                batch.append(self.preprocess(self.images[self.current_index]))
                self.current_index += 1
        
        if not batch:
            return None
        
        batch = np.stack(batch).astype(np.float32)
        cuda.memcpy_htod(self.device_input, batch.ravel())
        return [int(self.device_input)]
    
    def read_calibration_cache(self):
        try:
            with open(self.cache_file, "rb") as f:
                return f.read()
        except FileNotFoundError:
            return None
    
    def write_calibration_cache(self, cache):
        with open(self.cache_file, "wb") as f:
            f.write(cache)

def build_int8(onnx_path, engine_path, calib_dir):
    logger = trt.Logger(trt.Logger.WARNING)
    builder = trt.Builder(logger)
    network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
    parser = trt.OnnxParser(network, logger)
    
    with open(onnx_path, "rb") as f:
        parser.parse(f.read())
    
    config = builder.create_builder_config()
    config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 1 << 30)
    config.set_flag(trt.BuilderFlag.INT8)
    config.set_flag(trt.BuilderFlag.FP16)
    config.int8_calibrator = PoseINT8Calibrator(calib_dir, batch_size=8)
    
    engine = builder.build_serialized_network(network, config)
    with open(engine_path, "wb") as f:
        f.write(engine)
    print(f"✅ INT8 引擎已保存: {engine_path}")

if __name__ == "__main__":
    build_int8("yolo26n-pose.onnx", "yolo26n-pose_int8.engine", "calibration_images/")

3. Ultralytics 一键量化

from ultralytics import YOLO

model = YOLO("yolo26n-pose.pt")
model.export(
    format="engine",
    imgsz=640,
    int8=True,
    batch=1,
    data="coco-pose.yaml",
)

4. 精度校验

def validate_int8(fp32_engine, int8_engine, test_images):
    """校验 INT8 精度"""
    fp32 = TRTPoseDetector(fp32_engine)
    int8 = TRTPoseDetector(int8_engine)
    
    errors = []
    for img_path in test_images:
        image = cv2.imread(img_path)
        
        fp32_kpts = fp32.detect(image)
        int8_kpts = int8.detect(image)
        
        # 关键点误差
        for f_det, i_det in zip(fp32_kpts, int8_kpts):
            f_kpts = np.array(f_det['keypoints'])[:, :2]
            i_kpts = np.array(i_det['keypoints'])[:, :2]
            error = np.mean(np.linalg.norm(f_kpts - i_kpts, axis=1))
            errors.append(error)
    
    avg_error = np.mean(errors)
    print(f"平均关键点误差: {avg_error:.2f} 像素")
    
    if avg_error < 3.0:
        print("✅ INT8 精度优秀")
    elif avg_error < 5.0:
        print("⚠️ INT8 精度可接受")
    else:
        print("❌ INT8 精度不足")

5. 低算力设备部署

低算力设备部署方案：
┌──────────────────┬──────────┬──────────┬──────────┐
│ 设备              │ 算力      │ INT8 延迟 │ 推荐      │
├──────────────────┼──────────┼──────────┼──────────┤
│ Jetson Orin NX   │ 100 TOPS │ 3.8ms    │ ✅ 首选   │
│ Jetson Orin Nano │ 40 TOPS  │ 6.5ms    │ ✅ 推荐   │
│ RK3588 NPU       │ 6 TOPS   │ 12ms     │ ✅ 可用   │
│ GK7206 NPU       │ 1 TOPS   │ 25ms     │ ⚠️ 勉强   │
│ Raspberry Pi 5   │ CPU      │ 120ms    │ ❌ 不推荐  │
└──────────────────┴──────────┴──────────┴──────────┘

6. 进一步优化

极致优化方案：
├── 输入降分辨率
│   ├── 640 → 480：延迟降 40%，精度降 3 mAP
│   ├── 640 → 320：延迟降 70%，精度降 8 mAP
│   └── 适合精度要求不高的场景
├── 关键点数量裁剪
│   ├── 17 → 13（去掉耳朵/眼睛）：小模型
│   ├── 17 → 7（只保留躯干关键点）：极简
│   └── 需要重新训练
├── 模型蒸馏
│   ├── 大模型教小模型
│   ├── 保持精度，减小模型
│   └── 需要额外训练
└── 后处理优化
    ├── 关键点 NMS 简化
    ├── 骨架约束剪枝
    └── 置信度阈值提升

总结