核心库:
  - ultralytics==8.3.0+  # 官方YOLO实现
  - torch>=1.8.0         # PyTorch深度学习框架
  - opencv-python        # 图像处理
  - onnx                 # 模型导出
  - onnxruntime          # ONNX推理

可选加速:
  - tensorrt             # NVIDIA GPU加速
  - openvino             # Intel CPU优化

输入：一张图像
输出：图像中所有目标的位置（边界框）和类别

每个检测结果包含：
- 边界框: (x, y, w, h) 或 (x1, y1, x2, y2)
- 类别: person, car, dog, ...
- 置信度: 0-1之间的概率值

IoU = 交集面积 / 并集面积

示例：
真实框: [100, 100, 200, 200]
预测框: [110, 110, 210, 210]

交集: 90 × 90 = 8100
并集: 100×100 + 100×100 - 8100 = 11900
IoU = 8100 / 11900 ≈ 0.68

def calculate_iou(box1, box2):
    """
    计算两个边界框的IoU

    Args:
        box1, box2: [x1, y1, x2, y2] 格式的边界框

    Returns:
        iou: 交并比值
    """
    # 计算交集
    x1_inter = max(box1[0], box2[0])
    y1_inter = max(box1[1], box2[1])
    x2_inter = min(box1[2], box2[2])
    y2_inter = min(box1[3], box2[3])

    # 交集面积
    inter_width = max(0, x2_inter - x1_inter)
    inter_height = max(0, y2_inter - y1_inter)
    inter_area = inter_width * inter_height

    # 各自面积
    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])

    # 并集面积
    union_area = box1_area + box2_area - inter_area

    # IoU
    iou = inter_area / union_area if union_area > 0 else 0

    return iou

Precision = TP / (TP + FP)
          = 正确检测数 / 总检测数

Recall = TP / (TP + FN)
       = 正确检测数 / 真实目标总数

场景：图像中有10个目标，模型检测出8个框

正确检测（TP）: 6个
错误检测（FP）: 2个
漏检（FN）: 4个

Precision = 6 / 8 = 0.75 (75%的检测是正确的)
Recall = 6 / 10 = 0.6 (找到了60%的目标)

def calculate_ap(precisions, recalls):
    """
    计算单个类别的AP

    Args:
        precisions: 精确率列表
        recalls: 召回率列表

    Returns:
        ap: 平均精确率
    """
    # 在召回率点上插值
    recalls = [0] + list(recalls) + [1]
    precisions = [0] + list(precisions) + [0]

    # 从右向左取最大值（单调递减）
    for i in range(len(precisions) - 2, -1, -1):
        precisions[i] = max(precisions[i], precisions[i + 1])

    # 计算面积
    ap = 0
    for i in range(1, len(recalls)):
        ap += (recalls[i] - recalls[i - 1]) * precisions[i]

    return ap

mAP = (1/N) × Σ AP_i

其中N是类别数

图像
  ↓
选择性搜索 → 2000个候选区域
  ↓
对每个区域:
  ├── resize到固定尺寸(227×227)
  ├── CNN提取特征(AlexNet)
  ├── SVM分类
  └── 边界框回归
  ↓
NMS后处理 → 最终检测结果

图像
  ↓
CNN → 整图特征图
  ↓
候选区域(仍用选择性搜索)
  ↓
RoI Pooling → 固定尺寸特征
  ↓
全连接层 → 分类 + 回归

def roi_pooling(feature_map, roi, output_size):
    """
    将任意大小的RoI转换为固定尺寸的特征

    Args:
        feature_map: CNN特征图 (C, H, W)
        roi: 候选区域 [x1, y1, x2, y2]
        output_size: 输出尺寸 (7, 7)

    Returns:
        pooled: (C, 7, 7) 的特征
    """
    # 将RoI划分为 output_size 个bins
    # 对每个bin做max pooling
    ...

输入特征图
    ↓
3×3卷积 (滑动窗口)
    ↓
┌────────────┴────────────┐
↓                         ↓
1×1卷积                   1×1卷积
↓                         ↓
分类层(2k通道)            回归层(4k通道)
↓                         ↓
前景/背景                 边界框调整
(是否有物体)              (dx, dy, dw, dh)

k = anchor数量(通常9个)

每个位置预设k个anchor:
- 3种尺度: 128², 256², 512²
- 3种比例: 1:1, 1:2, 2:1
共9个anchor

特征图大小: 60×40
总anchor数: 60 × 40 × 9 = 21,600

图像
  ↓
Backbone(VGG/ResNet) → 特征图
  ↓
RPN → 候选区域(~2000个)
  ↓
RoI Pooling → 固定尺寸特征
  ↓
分类 + 边界框回归
  ↓
NMS → 最终结果

Faster R-CNN的计算分布:
- Backbone前向: 40%
- RPN: 15%
- RoI Pooling + FC: 35%
- NMS后处理: 10%

即使用RPN，仍需要两次预测:
1. RPN: 是否有物体
2. Detection Head: 是什么物体

两阶段:
图像 → 特征 → 候选区域 → 分类/回归

单阶段:
图像 → 特征 → 直接回归位置+类别

图像 → 候选区域生成 → 特征提取 → 分类 + 边界框回归

图像 → CNN → 直接输出 [类别概率 + 边界框坐标]

输入: 448×448×3
↓
24个卷积层（受GoogLeNet启发）
↓
2个全连接层
↓
输出: 7×7×30

Loss = λcoord × 坐标损失 
     + 置信度损失（有物体）
     + λnoobj × 置信度损失（无物体）
     + 分类损失

输入: 416×416×3
↓
Darknet-19（19 conv layers）
↓
输出: 13×13×1024

输入: 256×256×3
↓
1x Conv: 32 filters
↓
2x Conv: 64 filters  ┐
↓                    │ Residual Block ×1
Skip Connection ←────┘
↓
2x Conv: 128 filters ┐
↓                    │ Residual Block ×2
Skip Connection ←────┘
↓
2x Conv: 256 filters ┐
↓                    │ Residual Block ×8
Skip Connection ←────┘
↓
2x Conv: 512 filters ┐
↓                    │ Residual Block ×8
Skip Connection ←────┘
↓
2x Conv: 1024 filters┐
↓                    │ Residual Block ×4
Skip Connection ←────┘

13×13 (大物体) ←─ Conv Layers
                  ↑
26×26 (中物体) ←─ Upsample + Concat
                  ↑
52×52 (小物体) ←─ Upsample + Concat

# CIoU Loss伪代码
CIoU = IoU - (ρ²(b, b_gt) / c²) - αv
其中：
  ρ²: 中心点距离
  c²: 最小外接矩形对角线距离
  v: 宽高比一致性
  α: 权重系数

# Focus层：将空间信息压缩到通道
def focus(x, channel):
    # 将 (b, c, w, h) → (b, 4c, w/2, h/2)
    return concat([
        x[::2, ::2],   # 左上
        x[1::2, ::2],  # 右上
        x[::2, 1::2],  # 左下
        x[1::2, 1::2]  # 右下
    ])

# YOLOv5的简洁API
from models.yolo import Model

# 加载模型
model = Model('yolov5s.yaml')
model.load_state_dict(torch.load('yolov5s.pt'))

# 推理
results = model(img)

# 训练
python train.py --data coco.yaml --weights yolov5s.pt --epochs 300

ELAN:
Input → Conv → [Conv × 2] → [Conv × 2] → Concat → Conv

E-ELAN:
Input → Conv → [Group Conv × 2] → [Shuffle] → [Conv × 2] → Concat → Conv

# 训练时
output = conv3x3(x) + conv1x1(x) + identity(x)

# 推理时（融合后）
output = fused_conv3x3(x)  # 单个3x3卷积

Input (640×640)
↓
E-ELAN Backbone
↓
SPPCSPC (Spatial Pyramid Pooling CSP)
↓
E-ELAN Neck (PA-FPN)
↓
RepConv Head
↓
Output (3个尺度)

# C3 (YOLOv5)
class C3(nn.Module):
    def __init__(self, c1, c2, n=1):
        self.cv1 = Conv(c1, c2//2)
        self.cv2 = Conv(c1, c2//2)
        self.m = nn.Sequential(*[Bottleneck(c2//2, c2//2) for _ in range(n)])
        self.cv3 = Conv(c2, c2)

# C2f (YOLOv8)
class C2f(nn.Module):
    def __init__(self, c1, c2, n=1):
        self.cv1 = Conv(c1, 2*c2)
        self.cv2 = Conv((2+n)*c2, c2)
        self.m = nn.ModuleList(Bottleneck(c2, c2) for _ in range(n))
    # 每个Bottleneck的输出都concat到一起

Feature Map
    ├── Classification Branch → Class Probabilities
    └── Regression Branch → Bounding Boxes

from ultralytics import YOLO
model = YOLO('yolov8n.pt')
results = model('image.jpg')

model = YOLO('yolov8n-seg.pt')
results = model('image.jpg')  # 返回masks

model = YOLO('yolov8n-cls.pt')
results = model('image.jpg')

model = YOLO('yolov8n-pose.pt')
results = model('person.jpg')  # 返回关键点

model = YOLO('yolov8n-obb.pt')
results = model('aerial.jpg')  # 返回旋转边界框

from ultralytics import YOLO

# 加载模型
model = YOLO('yolov8n.yaml')  # 从配置构建
model = YOLO('yolov8n.pt')    # 加载预训练权重
model = YOLO('yolov8n.yaml').load('yolov8n.pt')  # 组合

# 训练
results = model.train(
    data='coco8.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0
)

# 验证
metrics = model.val(data='coco8.yaml')
print(metrics.box.map)    # mAP50-95
print(metrics.box.map50)  # mAP50

# 推理
results = model('path/to/image.jpg')
results = model(['im1.jpg', 'im2.jpg'])  # 批量
results = model('video.mp4')             # 视频

# 导出
model.export(format='onnx')
model.export(format='engine', device=0)  # TensorRT

# 训练
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640

# 验证
yolo detect val model=yolov8n.pt data=coco8.yaml

# 推理
yolo detect predict model=yolov8n.pt source='image.jpg'

# 导出
yolo export model=yolov8n.pt format=onnx

主分支：用于推理
辅助分支：提供完整梯度信息（仅训练时）

X = v_ζ(r_ψ(X))
其中：
  r_ψ: 信息转换函数
  v_ζ: 信息恢复函数
  确保信息可逆，无损失

Input
↓
GELAN Block 1 ─┐
↓              │
GELAN Block 2 ─┤ Concatenation
↓              │
GELAN Block 3 ─┘
↓
Output

from ultralytics import YOLO

# 加载YOLOv9模型
model = YOLO('yolov9c.pt')

# 训练（注意：需要更多资源和时间）
results = model.train(
    data='coco8.yaml',
    epochs=500,
    imgsz=640,
    batch=16
)

# 推理
results = model('image.jpg')

# 导出
model.export(format='onnx')

网络输出 → 生成大量候选框 → NMS筛选 → 最终结果

网络输出 → 直接得到最终结果（每个物体一个框）

from ultralytics import YOLO

# 加载YOLOv10模型
model = YOLO('yolov10n.pt')  # 或 s/m/b/l/x

# 推理（无需NMS后处理）
results = model('image.jpg')

# 训练
model.train(
    data='coco8.yaml',
    epochs=100,
    imgsz=640
)

# 导出（部分格式支持）
model.export(format='onnx')  # ✅
model.export(format='engine')  # ✅ TensorRT
# 注意：NCNN导出可能有限制

model = YOLO('yolo11n.pt')

model = YOLO('yolo11n-seg.pt')

model = YOLO('yolo11n-cls.pt')

model = YOLO('yolo11n-pose.pt')

model = YOLO('yolo11n-obb.pt')

from ultralytics import YOLO

# 加载YOLO11模型
model = YOLO('yolo11n.pt')

# 训练
results = model.train(
    data='coco8.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0
)

# 验证
metrics = model.val(data='coco8.yaml')

# 推理
results = model('image.jpg')
results = model('video.mp4')  # 视频

# 导出
model.export(format='onnx')
model.export(format='engine')  # TensorRT
model.export(format='coreml')  # CoreML

# 传统YOLO：只能检测预定义类别
classes = ['person', 'car', 'dog']  # 训练时固定

# YOLO-World：可以检测任意物体
model.set_classes(['laptop', 'coffee mug', 'smartphone'])  # 动态设置
model.set_classes(['red car', 'person wearing hat'])  # 支持描述性文本

图像特征 ──┐
           ├─ RepVL-PAN ─→ 检测结果
文本特征 ──┘

from ultralytics import YOLOWorld

# 加载预训练模型
model = YOLOWorld('yolov8s-world.pt')

# 设置自定义类别
model.set_classes(['person', 'bus', 'car'])

# 推理
results = model('image.jpg')
results[0].show()

# 场景1：检测交通工具
model.set_classes(['car', 'bus', 'truck', 'bicycle'])
results = model('traffic.jpg')

# 场景2：检测动物
model.set_classes(['dog', 'cat', 'bird', 'horse'])
results = model('animals.jpg')

# 场景3：检测办公用品
model.set_classes(['laptop', 'mouse', 'keyboard', 'monitor'])
results = model('office.jpg')

# 设置类别后保存
model.set_classes(['person', 'car', 'dog'])
model.save('custom_yolov8s_world.pt')

# 之后可以直接加载
model = YOLOWorld('custom_yolov8s_world.pt')
results = model('image.jpg')  # 使用保存的类别

from ultralytics import YOLOWorld

# 使用worldv2模型（支持训练）
model = YOLOWorld('yolov8s-worldv2.pt')

# 在自定义数据上训练
model.train(
    data='custom_data.yaml',
    epochs=100,
    imgsz=640
)

# 导出
model.export(format='onnx')  # worldv2支持导出

2016    YOLOv1      开创单阶段检测
         ↓
2017    YOLOv2      Anchor + 多尺度
         ↓
2018    YOLOv3      多尺度预测 + Darknet-53
         ↓
2020    YOLOv4      Bag of Freebies/Specials
        YOLOv5      工程化实现
         ↓
2022    YOLOv6      工业优化
        YOLOv7      Trainable BoF
         ↓
2023    YOLOv8      Anchor-free + 多任务
         ↓
2024    YOLOv9      PGI + GELAN
        YOLOv10     NMS-free
        YOLO11      当前最优
        YOLO-World  开放词汇

# 方式1：使用pip（推荐）
pip install ultralytics

# 方式2：从源码安装（获取最新功能）
git clone https://github.com/ultralytics/ultralytics.git
cd ultralytics
pip install -e .

# 验证安装
yolo version

# check_environment.py
import torch
from ultralytics import YOLO

print(f"PyTorch版本: {torch.__version__}")
print(f"CUDA可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"CUDA版本: {torch.version.cuda}")
    print(f"GPU设备: {torch.cuda.get_device_name(0)}")

# 测试YOLO
model = YOLO('yolov8n.pt')
print("✅ Ultralytics YOLO安装成功！")

from ultralytics import YOLO

model = YOLO('yolov8n.pt')
results = model('image.jpg')

# Results是一个列表，每张图像对应一个Result对象
result = results[0]

# 主要属性
print(result.boxes)      # 边界框信息
print(result.masks)      # 分割掩码（如果是分割任务）
print(result.keypoints)  # 关键点（如果是姿态任务）
print(result.probs)      # 分类概率（如果是分类任务）
print(result.orig_img)   # 原始图像
print(result.path)       # 图像路径

# Boxes对象
boxes = result.boxes
print(boxes.xyxy)        # 坐标格式: [x1, y1, x2, y2]
print(boxes.xywh)        # 坐标格式: [x_center, y_center, width, height]
print(boxes.conf)        # 置信度
print(boxes.cls)         # 类别ID
print(boxes.data)        # 完整数据 [x1, y1, x2, y2, conf, cls]

# 方法1：直接显示
result.show()

# 方法2：保存到文件
result.save('result.jpg')

# 方法3：自定义绘制
import cv2
import numpy as np

img = result.orig_img.copy()
for box in result.boxes:
    x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
    conf = float(box.conf[0])
    cls = int(box.cls[0])
    
    # 绘制边界框
    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
    
    # 绘制标签
    label = f"{model.names[cls]} {conf:.2f}"
    cv2.putText(img, label, (x1, y1-10), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imwrite('custom_result.jpg', img)

# 单张图像
results = model('image.jpg')

# 多张图像
results = model(['img1.jpg', 'img2.jpg', 'img3.jpg'])

# 文件夹
results = model('images/')

# URL
results = model('https://ultralytics.com/images/bus.jpg')

# NumPy数组
import cv2
img = cv2.imread('image.jpg')
results = model(img)

# PIL Image
from PIL import Image
img = Image.open('image.jpg')
results = model(img)

# 视频文件
results = model('video.mp4', stream=True)

for result in results:
    result.show()  # 实时显示
    # 或保存帧
    # result.save(f'frame_{result.frame}.jpg')

# 摄像头
results = model(0, stream=True)  # 0是默认摄像头

for result in results:
    result.show()
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 批量处理以提高速度
results = model(['img1.jpg', 'img2.jpg'], batch=2)

# 调整推理参数
results = model(
    'image.jpg',
    conf=0.5,        # 置信度阈值
    iou=0.7,         # NMS的IoU阈值
    imgsz=640,       # 图像尺寸
    device=0,        # GPU设备
    half=True,       # 使用FP16
    max_det=100,     # 最大检测数
    classes=[0, 2],  # 只检测特定类别（person, car）
)

my_dataset/
├── images/
│   ├── train/
│   │   ├── img1.jpg
│   │   ├── img2.jpg
│   │   └── ...
│   ├── val/
│   │   ├── img3.jpg
│   │   └── ...
│   └── test/  (可选)
│       └── ...
├── labels/
│   ├── train/
│   │   ├── img1.txt
│   │   ├── img2.txt
│   │   └── ...
│   └── val/
│       ├── img3.txt
│       └── ...
└── data.yaml

# 每行一个目标: class x_center y_center width height
# 坐标都是归一化的 (0-1之间)
0 0.5 0.5 0.3 0.4
1 0.2 0.3 0.1 0.2

# 数据集路径（相对或绝对路径）
path: /path/to/my_dataset  # 数据集根目录
train: images/train  # 训练图像（相对于path）
val: images/val      # 验证图像（相对于path）
test:               # 测试图像（可选）

# 类别
nc: 2  # 类别数量
names:  # 类别名称
  0: class1
  1: class2

from ultralytics.data.converter import convert_coco

# 转换COCO标注为YOLO格式
convert_coco(
    labels_dir='path/to/coco/annotations/',
    save_dir='path/to/yolo/labels/',
    use_segments=False,  # True表示分割任务
    cls91to80=True  # COCO91类到80类的映射
)

model.train(
    data='data.yaml',
    epochs=100,
    # 数据增强参数
    hsv_h=0.015,      # HSV色调增强
    hsv_s=0.7,        # HSV饱和度
    hsv_v=0.4,        # HSV亮度
    degrees=0.0,      # 旋转角度
    translate=0.1,    # 平移比例
    scale=0.5,        # 缩放比例
    shear=0.0,        # 剪切角度
    perspective=0.0,  # 透视变换
    flipud=0.0,       # 上下翻转概率
    fliplr=0.5,       # 左右翻转概率
    mosaic=1.0,       # Mosaic增强概率
    mixup=0.0,        # MixUp增强概率
    copy_paste=0.0,   # Copy-Paste增强概率
)

import albumentations as A
from albumentations.pytorch import ToTensorV2

# 定义增强流程
transform = A.Compose([
    A.RandomBrightnessContrast(p=0.5),
    A.RandomGamma(p=0.5),
    A.Blur(p=0.3),
    A.MedianBlur(p=0.3),
    A.GaussNoise(p=0.3),
], bbox_params=A.BboxParams(format='yolo'))

# 应用增强（需要自己写数据加载器）

model.train(
    # === 数据相关 ===
    data='data.yaml',          # 数据集配置
    epochs=100,                # 训练轮数
    batch=16,                  # 批量大小（-1为自动）
    imgsz=640,                 # 图像尺寸
    
    # === 优化器相关 ===
    optimizer='auto',          # 优化器: SGD, Adam, AdamW, auto
    lr0=0.01,                  # 初始学习率
    lrf=0.01,                  # 最终学习率 (lr0 * lrf)
    momentum=0.937,            # SGD动量
    weight_decay=0.0005,       # 权重衰减
    warmup_epochs=3.0,         # 预热轮数
    warmup_momentum=0.8,       # 预热动量
    warmup_bias_lr=0.1,        # 预热偏置学习率
    
    # === 模型相关 ===
    pretrained=True,           # 使用预训练权重
    patience=50,               # 早停耐心值
    save=True,                 # 保存检查点
    save_period=-1,            # 每N轮保存一次(-1表示仅最后)
    
    # === 设备相关 ===
    device=0,                  # 设备: 0, [0,1], cpu
    workers=8,                 # 数据加载线程数
    amp=True,                  # 自动混合精度训练
    
    # === 验证相关 ===
    val=True,                  # 每轮后验证
    plots=True,                # 保存训练图表
    
    # === 其他 ===
    seed=0,                    # 随机种子
    deterministic=True,        # 确定性训练
    single_cls=False,          # 单类训练
    rect=False,                # 矩形训练
    cos_lr=False,              # 余弦学习率
    close_mosaic=10,           # 最后N轮禁用mosaic
    resume=False,              # 恢复训练
    project='runs/detect',     # 项目目录
    name='exp',                # 实验名称
    exist_ok=False,            # 覆盖已存在的实验
)

# 使用所有可用GPU
yolo detect train data=data.yaml model=yolov8n.pt epochs=100 device=0,1,2,3

# Python API
model.train(data='data.yaml', device=[0, 1, 2, 3])

# 从检查点恢复
model = YOLO('runs/detect/exp/weights/last.pt')
model.train(resume=True)

# 使用回调函数
from ultralytics.utils import callbacks

def on_train_epoch_end(trainer):
    print(f"Epoch {trainer.epoch}: Loss={trainer.loss}")

callbacks.on_train_epoch_end = on_train_epoch_end

model.train(data='data.yaml', epochs=100)

# 启动TensorBoard
tensorboard --logdir runs/detect

# 在浏览器打开 http://localhost:6006

from ultralytics import YOLO

# 自动集成W&B（需要先登录）
# wandb login

model = YOLO('yolov8n.pt')
model.train(
    data='data.yaml',
    epochs=100,
    project='my-yolo-project',  # W&B项目名
)

from ultralytics import YOLO

# 加载训练好的模型
model = YOLO('runs/detect/exp/weights/best.pt')

# 验证
metrics = model.val(
    data='data.yaml',
    split='val',      # 或 'test'
    imgsz=640,
    batch=16,
    conf=0.25,
    iou=0.6,
    device=0,
)

# 查看指标
print(f"mAP50-95: {metrics.box.map}")
print(f"mAP50: {metrics.box.map50}")
print(f"mAP75: {metrics.box.map75}")

# 各类别的AP
for i, ap in enumerate(metrics.box.ap_class_index):
    print(f"{model.names[i]}: {metrics.box.ap[ap]:.3f}")

# 训练时会自动生成混淆矩阵
# 查看: runs/detect/exp/confusion_matrix.png

# 或手动生成
from ultralytics.utils.plotting import plot_results

plot_results(file='runs/detect/exp/results.csv')

from ultralytics import YOLO

model = YOLO('yolov8n.pt')

# ONNX导出（最通用）
model.export(format='onnx')

# TensorRT导出（NVIDIA GPU加速）
model.export(format='engine', device=0, half=True)

# CoreML导出（iOS）
model.export(format='coreml')

# TFLite导出（移动端）
model.export(format='tflite')

import onnxruntime as ort
import numpy as np
import cv2

# 加载ONNX模型
session = ort.InferenceSession(
    'yolov8n.onnx',
    providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)

# 预处理
img = cv2.imread('image.jpg')
img = cv2.resize(img, (640, 640))
img = img.transpose(2, 0, 1)  # HWC -> CHW
img = img.astype(np.float32) / 255.0
img = np.expand_dims(img, 0)  # 添加batch维度

# 推理
input_name = session.get_inputs()[0].name
outputs = session.run(None, {input_name: img})

# 后处理
predictions = outputs[0]  # shape: (1, 84, 8400)
# 需要进行NMS等后处理...

import onnxruntime as ort
import cv2
import numpy as np

class YOLOv8ONNX:
    def __init__(self, onnx_path, conf_threshold=0.5, iou_threshold=0.5):
        self.session = ort.InferenceSession(onnx_path)
        self.conf_threshold = conf_threshold
        self.iou_threshold = iou_threshold
        self.input_name = self.session.get_inputs()[0].name
        
    def preprocess(self, img):
        img = cv2.resize(img, (640, 640))
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        img = img.transpose(2, 0, 1)
        img = img.astype(np.float32) / 255.0
        return np.expand_dims(img, 0)
    
    def postprocess(self, outputs, orig_shape):
        predictions = outputs[0].transpose(0, 2, 1)  # (1, 84, 8400) -> (1, 8400, 84)
        boxes, scores, class_ids = [], [], []
        
        for pred in predictions[0]:
            # pred: [x, y, w, h, cls0_conf, cls1_conf, ...]
            box = pred[:4]
            class_scores = pred[4:]
            class_id = np.argmax(class_scores)
            conf = class_scores[class_id]
            
            if conf > self.conf_threshold:
                # 转换坐标
                x, y, w, h = box
                x1 = x - w/2
                y1 = y - h/2
                x2 = x + w/2
                y2 = y + h/2
                
                boxes.append([x1, y1, x2, y2])
                scores.append(conf)
                class_ids.append(class_id)
        
        # NMS
        indices = cv2.dnn.NMSBoxes(
            boxes, scores, self.conf_threshold, self.iou_threshold
        )
        
        results = []
        for i in indices:
            results.append({
                'box': boxes[i],
                'score': scores[i],
                'class_id': class_ids[i]
            })
        
        return results
    
    def detect(self, img):
        orig_shape = img.shape[:2]
        input_tensor = self.preprocess(img)
        outputs = self.session.run(None, {self.input_name: input_tensor})
        return self.postprocess(outputs, orig_shape)

# 使用
detector = YOLOv8ONNX('yolov8n.onnx')
img = cv2.imread('image.jpg')
results = detector.detect(img)

from ultralytics import YOLO

model = YOLO('yolov8n.pt')

# 导出TensorRT引擎
model.export(
    format='engine',
    device=0,           # GPU设备
    half=True,          # FP16精度
    workspace=4,        # 工作空间大小(GB)
    simplify=True,      # 简化ONNX
    dynamic=False,      # 动态batch
)

from ultralytics import YOLO

# 直接加载TensorRT引擎
model = YOLO('yolov8n.engine')

# 推理（速度显著提升）
results = model('image.jpg')

# 导出CoreML
model.export(format='coreml', nms=True)

# iOS Swift代码
// import CoreML
// let model = try yolov8n(configuration: MLModelConfiguration())
// let prediction = try model.prediction(image: pixelBuffer)

# 导出TFLite
model.export(format='tflite', int8=True)  # INT8量化

# Android Kotlin代码
// import org.tensorflow.lite.Interpreter
// val interpreter = Interpreter(loadModelFile())
// interpreter.run(inputArray, outputArray)

# 导出NCNN
model.export(format='ncnn')

# C++代码
// #include "ncnn/net.h"
// ncnn::Net net;
// net.load_param("yolov8n.param");
// net.load_model("yolov8n.bin");

┌─────────────────────────────────────────┐
│          Input Sources                  │
│  (Webcam / Video / RTSP Stream)         │
└──────────────┬──────────────────────────┘
               │
               ▼
┌─────────────────────────────────────────┐
│      Frame Preprocessing                │
│  (Resize, Normalize, Format)            │
└──────────────┬──────────────────────────┘
               │
               ▼
┌─────────────────────────────────────────┐
│      YOLO Detection Engine              │
│  (Model Inference + Post-process)       │
└──────────────┬──────────────────────────┘
               │
               ▼
┌─────────────────────────────────────────┐
│      Result Rendering                   │
│  (Draw Boxes, Labels, FPS)              │
└──────────────┬──────────────────────────┘
               │
               ▼
┌─────────────────────────────────────────┐
│      Output & Storage                   │
│  (Display / Save / Stream)              │
└─────────────────────────────────────────┘

# real_time_detector.py
import cv2
import time
from ultralytics import YOLO
from collections import deque
import numpy as np

class RealTimeDetector:
    """实时目标检测系统"""
    
    def __init__(self, model_path='yolov8n.pt', conf_threshold=0.5):
        """
        Args:
            model_path: YOLO模型路径
            conf_threshold: 置信度阈值
        """
        self.model = YOLO(model_path)
        self.conf_threshold = conf_threshold
        
        # 性能监控
        self.fps_queue = deque(maxlen=30)
        self.process_times = deque(maxlen=100)
        
        # 统计信息
        self.frame_count = 0
        self.detection_count = 0
        
    def detect_frame(self, frame):
        """
        检测单帧
        
        Args:
            frame: 输入图像(BGR)
            
        Returns:
            result: YOLO检测结果
            process_time: 处理时间(ms)
        """
        start_time = time.time()
        
        # YOLO推理
        results = self.model(
            frame,
            conf=self.conf_threshold,
            verbose=False
        )
        
        process_time = (time.time() - start_time) * 1000
        self.process_times.append(process_time)
        
        return results[0], process_time
    
    def draw_results(self, frame, result):
        """
        在图像上绘制检测结果
        
        Args:
            frame: 输入图像
            result: YOLO检测结果
            
        Returns:
            frame: 绘制后的图像
        """
        # 复制图像避免修改原图
        annotated_frame = frame.copy()
        
        # 绘制边界框
        boxes = result.boxes
        if boxes is not None:
            for box in boxes:
                # 获取坐标和信息
                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
                conf = float(box.conf[0])
                cls = int(box.cls[0])
                
                # 绘制矩形
                color = self._get_color(cls)
                cv2.rectangle(annotated_frame, (x1, y1), (x2, y2), color, 2)
                
                # 绘制标签
                label = f"{self.model.names[cls]} {conf:.2f}"
                label_size, _ = cv2.getTextSize(
                    label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1
                )
                
                # 标签背景
                cv2.rectangle(
                    annotated_frame,
                    (x1, y1 - label_size[1] - 10),
                    (x1 + label_size[0], y1),
                    color,
                    -1
                )
                
                # 标签文字
                cv2.putText(
                    annotated_frame,
                    label,
                    (x1, y1 - 5),
                    cv2.FONT_HERSHEY_SIMPLEX,
                    0.5,
                    (255, 255, 255),
                    1
                )
                
                self.detection_count += 1
        
        return annotated_frame
    
    def draw_stats(self, frame):
        """
        绘制统计信息
        
        Args:
            frame: 输入图像
            
        Returns:
            frame: 添加统计信息后的图像
        """
        # 计算FPS
        if len(self.fps_queue) > 0:
            fps = len(self.fps_queue) / sum(self.fps_queue)
        else:
            fps = 0
        
        # 计算平均处理时间
        avg_process_time = np.mean(self.process_times) if self.process_times else 0
        
        # 准备统计文本
        stats = [
            f"FPS: {fps:.1f}",
            f"Process Time: {avg_process_time:.1f}ms",
            f"Frame: {self.frame_count}",
            f"Detections: {self.detection_count}",
        ]
        
        # 绘制半透明背景
        overlay = frame.copy()
        cv2.rectangle(overlay, (10, 10), (300, 120), (0, 0, 0), -1)
        cv2.addWeighted(overlay, 0.6, frame, 0.4, 0, frame)
        
        # 绘制统计文本
        y_offset = 30
        for stat in stats:
            cv2.putText(
                frame,
                stat,
                (20, y_offset),
                cv2.FONT_HERSHEY_SIMPLEX,
                0.6,
                (0, 255, 0),
                2
            )
            y_offset += 25
        
        return frame
    
    def process_video(self, source=0, output_path=None, display=True):
        """
        处理视频流
        
        Args:
            source: 视频源（0=摄像头，路径=视频文件，URL=RTSP流）
            output_path: 输出视频路径（可选）
            display: 是否显示结果
        """
        # 打开视频流
        cap = cv2.VideoCapture(source)
        
        if not cap.isOpened():
            raise ValueError(f"无法打开视频源: {source}")
        
        # 获取视频属性
        fps = int(cap.get(cv2.CAP_PROP_FPS))
        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
        
        print(f"视频源信息: {width}x{height} @ {fps}FPS")
        
        # 创建视频写入器
        writer = None
        if output_path:
            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
            writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
        
        # 重置统计
        self.frame_count = 0
        self.detection_count = 0
        
        print("开始处理... (按'q'退出)")
        
        try:
            while True:
                frame_start = time.time()
                
                # 读取帧
                ret, frame = cap.read()
                if not ret:
                    break
                
                self.frame_count += 1
                
                # 检测
                result, process_time = self.detect_frame(frame)
                
                # 绘制结果
                annotated_frame = self.draw_results(frame, result)
                
                # 绘制统计信息
                annotated_frame = self.draw_stats(annotated_frame)
                
                # 保存视频
                if writer:
                    writer.write(annotated_frame)
                
                # 显示
                if display:
                    cv2.imshow('YOLO Real-Time Detection', annotated_frame)
                    
                    # 按键处理
                    key = cv2.waitKey(1) & 0xFF
                    if key == ord('q'):
                        break
                    elif key == ord('s'):  # 截图
                        cv2.imwrite(f'screenshot_{self.frame_count}.jpg', annotated_frame)
                        print(f"截图已保存: screenshot_{self.frame_count}.jpg")
                
                # 更新FPS
                frame_time = time.time() - frame_start
                self.fps_queue.append(frame_time)
                
        finally:
            # 清理资源
            cap.release()
            if writer:
                writer.release()
            if display:
                cv2.destroyAllWindows()
            
            print(f"\n处理完成!")
            print(f"总帧数: {self.frame_count}")
            print(f"总检测数: {self.detection_count}")
            print(f"平均FPS: {self.frame_count / sum(self.fps_queue):.2f}")
    
    def _get_color(self, class_id):
        """获取类别颜色"""
        np.random.seed(class_id)
        return tuple(np.random.randint(0, 255, 3).tolist())

# 使用示例
if __name__ == '__main__':
    # 创建检测器
    detector = RealTimeDetector(
        model_path='yolov8n.pt',
        conf_threshold=0.5
    )
    
    # 处理摄像头
    detector.process_video(source=0, output_path='output.mp4')
    
    # 或处理视频文件
    # detector.process_video(source='input.mp4', output_path='output.mp4')
    
    # 或处理RTSP流
    # detector.process_video(source='rtsp://...', display=True)