YOLO11 深度学习目标检测框架

# 示例：img1.txt
0 0.5 0.3 0.2 0.4    # 类别0，中心点(0.5,0.3)，宽0.2，高0.4
1 0.8 0.6 0.15 0.3   # 类别1，中心点(0.8,0.6)，宽0.15，高0.3
2 0.2 0.7 0.1 0.2    # 类别2，中心点(0.2,0.7)，宽0.1，高0.2

# 数据增强配置
augment_config = {
    'hsv_h': 0.015,      # 色调变化
    'hsv_s': 0.7,        # 饱和度变化
    'hsv_v': 0.4,        # 亮度变化
    'degrees': 0.0,      # 旋转角度
    'translate': 0.1,    # 平移范围
    'scale': 0.5,        # 缩放范围
    'shear': 0.0,        # 剪切变换
    'perspective': 0.0,  # 透视变换
    'flipud': 0.0,       # 上下翻转
    'fliplr': 0.5,       # 左右翻转
    'mosaic': 1.0,       # 马赛克增强
    'mixup': 0.0,        # 混合增强
}

# 高级数据增强
advanced_augment = {
    'erasing': 0.0,        # 随机擦除
    'auto_augment': None,  # 自动增强
    'grid_mask': 0.0,      # 网格掩码
    'copy_paste': 0.0,     # 复制粘贴
}

import cv2
import numpy as np
from PIL import Image

def preprocess_image(image_path, target_size=(640, 640)):
    """图像预处理函数"""
    # 读取图像
    image = cv2.imread(image_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    # 调整大小
    image = cv2.resize(image, target_size)

    # 归一化
    image = image.astype(np.float32) / 255.0

    return image

def validate_annotation(annotation_path, image_shape):
    """验证标注文件"""
    with open(annotation_path, 'r') as f:
        lines = f.readlines()

    for line in lines:
        parts = line.strip().split()
        if len(parts) != 5:
            return False

        class_id, x, y, w, h = map(float, parts)

        # 检查坐标范围
        if not (0 <= x <= 1 and 0 <= y <= 1 and 0 <= w <= 1 and 0 <= h <= 1):
            return False

    return True

def analyze_dataset(data_yaml_path):
    """分析数据集统计信息"""
    import yaml
    import os
    from collections import Counter

    with open(data_yaml_path, 'r') as f:
        config = yaml.safe_load(f)

    # 统计各类别数量
    class_counts = Counter()
    total_images = 0

    for split in ['train', 'val', 'test']:
        if split in config:
            images_dir = os.path.join(config['path'], config[split])
            labels_dir = images_dir.replace('images', 'labels')

            for img_file in os.listdir(images_dir):
                if img_file.endswith(('.jpg', '.png', '.jpeg')):
                    total_images += 1
                    label_file = img_file.rsplit('.', 1)[0] + '.txt'
                    label_path = os.path.join(labels_dir, label_file)

                    if os.path.exists(label_path):
                        with open(label_path, 'r') as f:
                            for line in f:
                                class_id = int(line.split()[0])
                                class_counts[class_id] += 1

    print(f"总图像数量: {total_images}")
    print(f"类别分布: {dict(class_counts)}")

    return class_counts

# 检查标注格式
def check_annotation_format(annotation_path):
    """检查标注文件格式"""
    try:
        with open(annotation_path, 'r') as f:
            for line_num, line in enumerate(f, 1):
                parts = line.strip().split()
                if len(parts) != 5:
                    print(f"第{line_num}行格式错误: {line}")
                    return False

                class_id, x, y, w, h = map(float, parts)
                if not (0 <= x <= 1 and 0 <= y <= 1 and 0 <= w <= 1 and 0 <= h <= 1):
                    print(f"第{line_num}行坐标超出范围: {line}")
                    return False
    except Exception as e:
        print(f"读取文件错误: {e}")
        return False

    return True

# 处理类别不平衡
def balance_dataset(class_counts, target_count=1000):
    """平衡数据集"""
    balanced_data = {}

    for class_id, count in class_counts.items():
        if count < target_count:
            # 数据增强
            balanced_data[class_id] = target_count
        else:
            # 随机采样
            balanced_data[class_id] = target_count

    return balanced_data

# 图像质量检查
def check_image_quality(image_path, min_size=416):
    """检查图像质量"""
    image = cv2.imread(image_path)

    if image is None:
        return False, "无法读取图像"

    h, w = image.shape[:2]
    if h < min_size or w < min_size:
        return False, f"图像尺寸过小: {w}x{h}"

    # 检查图像是否模糊
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()

    if blur_score < 100:
        return False, f"图像模糊: {blur_score}"

    return True, "图像质量良好"

# train.py
from ultralytics import YOLO
import torch

def main():
    # 检查设备
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print(f"使用设备: {device}")

    # 加载预训练模型
    model = YOLO('yolov11n.pt')  # 选择模型大小

    # 开始训练
    results = model.train(
        data='data.yaml',        # 数据集配置文件
        epochs=100,              # 训练轮数
        imgsz=640,              # 输入图像尺寸
        batch=16,               # 批次大小
        device=device,          # 设备选择
        workers=8,              # 数据加载线程数
        project='runs/train',   # 项目目录
        name='exp',             # 实验名称
        save=True,              # 保存模型
        save_period=10,         # 每10轮保存一次
        patience=50,            # 早停耐心值
        verbose=True,           # 详细输出
    )

    print("训练完成！")
    return results

if __name__ == "__main__":
    results = main()

# 高级训练配置
def advanced_training():
    model = YOLO('yolov11m.pt')

    # 训练参数
    training_args = {
        # 基础参数
        'data': 'data.yaml',
        'epochs': 200,
        'imgsz': 640,
        'batch': 16,
        'device': 0,
        'workers': 8,

        # 项目设置
        'project': 'runs/train',
        'name': 'yolo11_experiment',
        'exist_ok': True,

        # 保存设置
        'save': True,
        'save_period': 10,
        'save_last': True,
        'save_best': True,

        # 验证设置
        'val': True,
        'plots': True,
        'save_json': False,
        'save_hybrid': False,

        # 早停设置
        'patience': 50,
        'close_mosaic': 10,

        # 优化器参数
        'lr0': 0.01,
        'lrf': 0.01,
        'momentum': 0.937,
        'weight_decay': 0.0005,
        'warmup_epochs': 3.0,
        'warmup_momentum': 0.8,
        'warmup_bias_lr': 0.1,

        # 学习率调度
        'cos_lr': False,
        'scheduler': 'auto',

        # 数据增强
        'hsv_h': 0.015,
        'hsv_s': 0.7,
        'hsv_v': 0.4,
        'degrees': 0.0,
        'translate': 0.1,
        'scale': 0.5,
        'shear': 0.0,
        'perspective': 0.0,
        'flipud': 0.0,
        'fliplr': 0.5,
        'mosaic': 1.0,
        'mixup': 0.0,
        'copy_paste': 0.0,

        # 损失函数权重
        'box': 7.5,
        'cls': 0.5,
        'dfl': 1.5,
        'pose': 12.0,
        'kobj': 2.0,
        'label_smoothing': 0.0,

        # 模型架构
        'anchors': 9,
        'overlap_mask': True,
        'mask_ratio': 4,

        # 验证参数
        'conf': 0.001,
        'iou': 0.6,
        'max_det': 300,

        # 训练策略
        'rect': False,
        'multi_scale': False,

        # 其他设置
        'cache': False,
        'amp': True,
        'fraction': 1.0,
        'profile': False,
        'freeze': None,
        'multi_scale': False,
        'overlap_mask': True,
        'mask_ratio': 4,
        'dropout': 0.0,
        'verbose': True,
    }

    # 开始训练
    results = model.train(**training_args)

    return results

# 训练监控
def monitor_training():
    from ultralytics import YOLO
    import matplotlib.pyplot as plt

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

    # 开始训练
    results = model.train(
        data='data.yaml',
        epochs=100,
        imgsz=640,
        batch=16,
        device=0,
        project='runs/train',
        name='monitored_exp',
        plots=True,  # 生成训练图表
        verbose=True,
    )

    # 绘制训练曲线
    results.plot()

    return results

# 自定义训练回调
class TrainingCallback:
    def __init__(self):
        self.best_loss = float('inf')
        self.epoch_losses = []

    def on_train_epoch_end(self, trainer):
        """训练轮次结束回调"""
        current_loss = trainer.loss.item()
        self.epoch_losses.append(current_loss)

        if current_loss < self.best_loss:
            self.best_loss = current_loss
            print(f"新的最佳损失: {current_loss:.4f}")

        # 每10轮打印一次统计信息
        if trainer.epoch % 10 == 0:
            print(f"Epoch {trainer.epoch}: Loss = {current_loss:.4f}")

    def on_val_end(self, trainer):
        """验证结束回调"""
        val_loss = trainer.validator.loss.item()
        print(f"验证损失: {val_loss:.4f}")

# 使用自定义回调
def training_with_callback():
    model = YOLO('yolov11m.pt')

    # 添加回调
    callback = TrainingCallback()

    results = model.train(
        data='data.yaml',
        epochs=100,
        imgsz=640,
        batch=16,
        device=0,
        project='runs/train',
        name='callback_exp',
    )

    return results

# 多GPU训练
def multi_gpu_training():
    import torch
    from ultralytics import YOLO

    # 检查可用GPU
    if torch.cuda.device_count() > 1:
        print(f"发现 {torch.cuda.device_count()} 个GPU")

        # 设置多GPU训练
        model = YOLO('yolov11m.pt')

        results = model.train(
            data='data.yaml',
            epochs=100,
            imgsz=640,
            batch=32,  # 增加批次大小
            device=[0, 1, 2, 3],  # 使用多个GPU
            workers=16,  # 增加工作线程
            project='runs/train',
            name='multi_gpu_exp',
        )
    else:
        print("只有一个GPU，使用单GPU训练")
        model = YOLO('yolov11m.pt')
        results = model.train(
            data='data.yaml',
            epochs=100,
            imgsz=640,
            batch=16,
            device=0,
        )

    return results

# 断点续训
def resume_training():
    model = YOLO('yolov11m.pt')

    # 从断点恢复训练
    results = model.train(
        data='data.yaml',
        epochs=100,
        imgsz=640,
        batch=16,
        device=0,
        project='runs/train',
        name='resume_exp',
        resume=True,  # 恢复训练
    )

    return results

# 手动保存检查点
def manual_checkpoint():
    model = YOLO('yolov11m.pt')

    for epoch in range(100):
        # 训练一个epoch
        results = model.train(
            data='data.yaml',
            epochs=1,
            imgsz=640,
            batch=16,
            device=0,
            project='runs/train',
            name='manual_checkpoint',
        )

        # 每10个epoch保存一次
        if epoch % 10 == 0:
            model.save(f'checkpoint_epoch_{epoch}.pt')
            print(f"保存检查点: checkpoint_epoch_{epoch}.pt")

# 训练结果分析
def analyze_results(results):
    import matplotlib.pyplot as plt

    # 获取训练历史
    metrics = results.results_dict

    # 绘制损失曲线
    plt.figure(figsize=(12, 8))

    plt.subplot(2, 2, 1)
    plt.plot(metrics['train/box_loss'], label='Train Box Loss')
    plt.plot(metrics['val/box_loss'], label='Val Box Loss')
    plt.title('Box Loss')
    plt.legend()

    plt.subplot(2, 2, 2)
    plt.plot(metrics['train/cls_loss'], label='Train Cls Loss')
    plt.plot(metrics['val/cls_loss'], label='Val Cls Loss')
    plt.title('Classification Loss')
    plt.legend()

    plt.subplot(2, 2, 3)
    plt.plot(metrics['metrics/precision(B)'], label='Precision')
    plt.plot(metrics['metrics/recall(B)'], label='Recall')
    plt.title('Precision & Recall')
    plt.legend()

    plt.subplot(2, 2, 4)
    plt.plot(metrics['metrics/mAP50(B)'], label='mAP@0.5')
    plt.plot(metrics['metrics/mAP50-95(B)'], label='mAP@0.5:0.95')
    plt.title('mAP Metrics')
    plt.legend()

    plt.tight_layout()
    plt.show()

    return metrics

# 模型性能评估
def evaluate_model(model_path, data_yaml):
    from ultralytics import YOLO

    # 加载训练好的模型
    model = YOLO(model_path)

    # 在验证集上评估
    results = model.val(
        data=data_yaml,
        imgsz=640,
        batch=16,
        device=0,
        project='runs/val',
        name='evaluation',
        plots=True,
    )

    # 打印评估结果
    print(f"mAP@0.5: {results.box.map50:.4f}")
    print(f"mAP@0.5:0.95: {results.box.map:.4f}")
    print(f"Precision: {results.box.mp:.4f}")
    print(f"Recall: {results.box.mr:.4f}")

    return results

# 数据集配置示例
data_config = {
    'data': 'path/to/data.yaml',  # 数据集配置文件
    'task': 'detect',             # 任务类型
    'mode': 'train',              # 运行模式
}

# 任务类型说明
task_types = {
    'detect': '目标检测',
    'segment': '实例分割',
    'classify': '图像分类',
    'pose': '姿态估计'
}

# 根据数据集大小调整训练轮数
def get_epochs(dataset_size):
    if dataset_size < 1000:
        return 300
    elif dataset_size < 10000:
        return 200
    else:
        return 100

# 根据硬件配置调整缓存
def get_cache_config(gpu_memory_gb):
    if gpu_memory_gb >= 16:
        return True  # 开启缓存
    else:
        return False  # 关闭缓存

# 根据GPU显存选择批次大小
def get_batch_size(gpu_memory_gb, model_size):
    if gpu_memory_gb >= 24:
        return 32
    elif gpu_memory_gb >= 16:
        return 16
    elif gpu_memory_gb >= 8:
        return 8
    else:
        return 4

# 根据模型大小调整图像尺寸
def get_image_size(model_name):
    if 'n' in model_name:  # nano
        return 416
    elif 's' in model_name:  # small
        return 512
    else:  # medium, large, xlarge
        return 640

# 设备配置
device_configs = {
    'cpu': 'cpu',                    # CPU训练
    'single_gpu': 0,                 # 单GPU训练
    'multi_gpu': [0, 1, 2, 3],       # 多GPU训练
    'auto': 'auto',                  # 自动选择
}

# 混合精度训练
amp_config = {
    'amp': True,                     # 开启混合精度
    'half': False,                   # 使用FP16
    'dnn': False,                    # 使用OpenCV DNN
}

# 学习率调优函数
def optimize_learning_rate(dataset_size, model_complexity):
    """根据数据集大小和模型复杂度优化学习率"""

    # 基础学习率
    if dataset_size < 1000:
        lr0 = 0.01
    elif dataset_size < 10000:
        lr0 = 0.01
    else:
        lr0 = 0.005

    # 根据模型复杂度调整
    if model_complexity == 'nano':
        lr0 *= 1.2
    elif model_complexity == 'small':
        lr0 *= 1.0
    elif model_complexity == 'medium':
        lr0 *= 0.8
    elif model_complexity == 'large':
        lr0 *= 0.6
    else:  # xlarge
        lr0 *= 0.4

    return lr0

# 学习率调度器选择
def get_scheduler_config(optimizer_type, dataset_size):
    """选择合适的学习率调度器"""

    if optimizer_type == 'SGD':
        return {
            'scheduler': 'cosine',
            'cos_lr': True,
            'lrf': 0.01
        }
    elif optimizer_type == 'Adam':
        return {
            'scheduler': 'linear',
            'cos_lr': False,
            'lrf': 0.1
        }
    else:
        return {
            'scheduler': 'auto',
            'cos_lr': False,
            'lrf': 0.01
        }

# 基础数据增强配置
basic_augment = {
    'hsv_h': 0.015,      # 色调变化
    'hsv_s': 0.7,        # 饱和度变化
    'hsv_v': 0.4,        # 亮度变化
    'degrees': 0.0,      # 旋转角度
    'translate': 0.1,    # 平移范围
    'scale': 0.5,        # 缩放范围
    'shear': 0.0,        # 剪切变换
    'perspective': 0.0,  # 透视变换
    'flipud': 0.0,       # 上下翻转
    'fliplr': 0.5,       # 左右翻转
    'mosaic': 1.0,       # 马赛克增强
    'mixup': 0.0,        # 混合增强
    'copy_paste': 0.0,   # 复制粘贴
}

# 高级数据增强配置
advanced_augment = {
    'erasing': 0.0,        # 随机擦除
    'auto_augment': None,  # 自动增强
    'grid_mask': 0.0,      # 网格掩码
}

# 根据任务类型调整增强策略
def get_augment_config(task_type):
    """根据任务类型获取数据增强配置"""

    if task_type == 'detect':
        return {
            'mosaic': 1.0,
            'mixup': 0.0,
            'copy_paste': 0.0,
            'degrees': 0.0,
            'translate': 0.1,
            'scale': 0.5,
        }
    elif task_type == 'segment':
        return {
            'mosaic': 0.8,
            'mixup': 0.1,
            'copy_paste': 0.2,
            'degrees': 10.0,
            'translate': 0.1,
            'scale': 0.5,
        }
    elif task_type == 'pose':
        return {
            'mosaic': 0.5,
            'mixup': 0.0,
            'copy_paste': 0.0,
            'degrees': 5.0,
            'translate': 0.05,
            'scale': 0.3,
        }
    else:
        return basic_augment

# 自动增强配置
auto_augment_configs = {
    'randaugment': {
        'auto_augment': 'randaugment',
        'magnitude': 9,
        'num_layers': 2,
    },
    'augmix': {
        'auto_augment': 'augmix',
        'mixture_width': 3,
        'mixture_depth': -1,
        'aug_severity': 3,
    },
    'trivialaugment': {
        'auto_augment': 'trivialaugment',
        'num_magnitude_bins': 31,
    }
}

# 根据数据集特点选择增强策略
def select_augment_strategy(dataset_characteristics):
    """根据数据集特点选择增强策略"""

    if dataset_characteristics['small_objects']:
        return {
            'mosaic': 1.0,
            'copy_paste': 0.3,
            'mixup': 0.1,
        }
    elif dataset_characteristics['occlusion']:
        return {
            'erasing': 0.2,
            'grid_mask': 0.1,
            'mixup': 0.2,
        }
    elif dataset_characteristics['lighting_variation']:
        return {
            'hsv_h': 0.03,
            'hsv_s': 0.8,
            'hsv_v': 0.5,
        }
    else:
        return basic_augment

# 小数据集（<1000张图像）
results = model.train(
    data='data.yaml',
    epochs=300,              # 增加训练轮数
    imgsz=640,
    batch=8,                 # 减小批次大小
    lr0=0.01,               # 标准学习率
    weight_decay=0.001,     # 增加正则化
    patience=100,            # 增加早停耐心值
    cache=True,              # 开启缓存
)

# 中等数据集（1000-10000张图像）
results = model.train(
    data='data.yaml',
    epochs=200,              # 标准训练轮数
    imgsz=640,
    batch=16,                # 标准批次大小
    lr0=0.01,               # 标准学习率
    weight_decay=0.0005,    # 标准正则化
    patience=50,             # 标准早停耐心值
)

# 大数据集（>10000张图像）
results = model.train(
    data='data.yaml',
    epochs=100,              # 减少训练轮数
    imgsz=640,
    batch=32,                # 增加批次大小
    lr0=0.005,              # 降低学习率
    weight_decay=0.0001,    # 减少正则化
    patience=30,             # 减少早停耐心值
)

# 高显存GPU（>16GB）
results = model.train(
    data='data.yaml',
    epochs=100,
    imgsz=640,
    batch=32,                # 大批次
    workers=16,              # 多线程
    amp=True,                # 混合精度
    cache=True,              # 开启缓存
)

# 中等显存GPU（8-16GB）
results = model.train(
    data='data.yaml',
    epochs=100,
    imgsz=640,
    batch=16,                # 中等批次
    workers=8,               # 中等线程
    amp=True,                # 混合精度
    cache=False,             # 关闭缓存
)

# 低显存GPU（<8GB）
results = model.train(
    data='data.yaml',
    epochs=100,
    imgsz=512,               # 减小图像尺寸
    batch=8,                 # 小批次
    workers=4,               # 少线程
    amp=True,                # 混合精度
    cache=False,             # 关闭缓存
)

# 目标检测任务
results = model.train(
    data='data.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    box=7.5,                 # 边界框损失权重
    cls=0.5,                 # 分类损失权重
    dfl=1.5,                 # 分布焦点损失权重
)

# 实例分割任务
results = model.train(
    data='data.yaml',
    epochs=150,               # 增加训练轮数
    imgsz=640,
    batch=16,
    box=7.5,                 # 边界框损失权重
    cls=0.5,                 # 分类损失权重
    dfl=1.5,                 # 分布焦点损失权重
    # 分割任务可能需要更多训练
)

# 姿态估计任务
results = model.train(
    data='data.yaml',
    epochs=200,               # 增加训练轮数
    imgsz=640,
    batch=16,
    box=7.5,                 # 边界框损失权重
    cls=0.5,                 # 分类损失权重
    pose=12.0,               # 姿态损失权重
    kobj=2.0,                # 关键点目标损失权重
)

# 开启详细输出和实时监控
results = model.train(
    data='data.yaml',
    epochs=100,
    verbose=True,             # 详细输出
    plots=True,               # 生成图表
    save_period=10,           # 定期保存
    val=True,                 # 定期验证
)

# 从断点恢复训练
results = model.train(
    data='data.yaml',
    epochs=100,
    resume=True,              # 恢复训练
    # 其他参数会自动从上次训练中读取
)

# 使用多个GPU进行分布式训练
results = model.train(
    data='data.yaml',
    epochs=100,
    device='0,1,2,3',        # 使用4个GPU
    batch=64,                 # 总批次大小（每个GPU 16）
    workers=32,               # 总线程数
)

# 减少显存占用
results = model.train(
    data='data.yaml',
    epochs=100,
    imgsz=512,               # 减小图像尺寸
    batch=8,                 # 减小批次大小
    workers=4,               # 减少线程数
    cache=False,             # 关闭缓存
    amp=True,                # 开启混合精度
)

# 调整学习率和正则化
results = model.train(
    data='data.yaml',
    epochs=100,
    lr0=0.001,               # 降低学习率
    weight_decay=0.001,      # 增加正则化
    patience=100,             # 增加早停耐心值
    warmup_epochs=5,         # 增加预热轮数
)

# 防止过拟合
results = model.train(
    data='data.yaml',
    epochs=100,
    weight_decay=0.001,      # 增加正则化
    label_smoothing=0.1,     # 标签平滑
    hsv_h=0.015,             # 增加数据增强
    hsv_s=0.7,
    hsv_v=0.4,
    degrees=10.0,            # 增加旋转
    translate=0.2,           # 增加平移
    scale=0.9,               # 增加缩放
)

from ultralytics import YOLO

# 加载训练好的模型
model = YOLO('runs/train/exp/weights/best.pt')  # 加载最佳权重
# model = YOLO('runs/train/exp/weights/last.pt')  # 加载最后权重

# 对单张图片进行推理
results = model('path/to/image.jpg')

# 对多张图片进行推理
results = model(['image1.jpg', 'image2.jpg', 'image3.jpg'])

# 对视频进行推理
results = model('video.mp4')

# 对摄像头进行实时推理
results = model(source=0, show=True)  # 0表示默认摄像头

# 自定义预测参数
results = model.predict(
    source='path/to/images',     # 图片路径
    conf=0.5,                   # 置信度阈值
    iou=0.45,                   # NMS IoU阈值
    imgsz=640,                  # 输入图像尺寸
    save=True,                  # 保存结果
    save_txt=True,              # 保存标签文件
    save_conf=True,             # 保存置信度
    save_crop=True,             # 保存裁剪的目标
    project='runs/detect',      # 项目目录
    name='exp',                 # 实验名称
    exist_ok=True,              # 覆盖现有目录
    line_thickness=3,           # 边界框线条粗细
    hide_labels=False,          # 隐藏标签
    hide_conf=False,            # 隐藏置信度
    half=False,                 # 使用FP16推理
    dnn=False,                  # 使用OpenCV DNN
    vid_stride=1,              # 视频帧间隔
    stream_buffer=False,        # 流缓冲区
    visualize=False,            # 可视化特征
    augment=False,              # 测试时增强
    agnostic_nms=False,        # 类别无关NMS
    retina_masks=False,        # 高分辨率掩码
    classes=None,              # 过滤类别
    max_det=300,               # 最大检测数量
    verbose=True,              # 详细输出
)

# 处理推理结果
for result in results:
    boxes = result.boxes  # 边界框
    masks = result.masks  # 分割掩码
    keypoints = result.keypoints  # 关键点
    probs = result.probs  # 分类概率

    # 获取边界框信息
    if boxes is not None:
        # 坐标信息
        xyxy = boxes.xyxy  # 左上右下坐标
        xywh = boxes.xywh  # 中心点宽高
        xyxyn = boxes.xyxyn  # 归一化坐标
        xywhn = boxes.xywhn  # 归一化中心点宽高

        # 置信度和类别
        conf = boxes.conf  # 置信度
        cls = boxes.cls  # 类别ID
        cls_names = boxes.cls_names  # 类别名称

        # 打印检测结果
        for i in range(len(boxes)):
            print(f"检测到 {cls_names[i]}: 置信度 {conf[i]:.2f}")
            print(f"坐标: {xyxy[i]}")

# 在验证集上评估模型性能
results = model.val(
    data='data.yaml',           # 数据集配置
    split='val',                # 验证集分割
    imgsz=640,                 # 图像尺寸
    batch=16,                  # 批次大小
    device=0,                  # GPU设备
    workers=8,                 # 数据加载线程
    project='runs/val',        # 项目目录
    name='exp',                # 实验名称
    exist_ok=True,             # 覆盖现有目录
    half=True,                 # 使用FP16
    dnn=False,                 # 使用OpenCV DNN
    plots=True,                # 生成评估图表
    save=True,                 # 保存结果
    save_json=False,           # 保存JSON结果
    save_hybrid=False,         # 保存混合标签
    conf=0.001,               # 置信度阈值
    iou=0.6,                  # NMS IoU阈值
    max_det=300,              # 最大检测数量
    verbose=True,             # 详细输出
)

# 获取模型信息
model.info()  # 显示模型详细信息

# 获取模型参数数量
total_params = sum(p.numel() for p in model.parameters())
print(f"模型总参数量: {total_params:,}")

# 获取模型结构
print(model.model)  # 显示模型架构

# 获取模型配置
print(model.model.yaml)  # 显示模型配置

# 导出不同格式的模型
model = YOLO('runs/train/exp/weights/best.pt')

# 导出为 ONNX 格式（推荐用于跨平台部署）
model.export(format='onnx',
            imgsz=640,
            half=True,
            simplify=True)

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

# 导出为 OpenVINO 格式（Intel CPU/GPU 优化）
model.export(format='openvino',
            imgsz=640,
            half=True)

# 导出为 CoreML 格式（Apple 设备）
model.export(format='coreml',
            imgsz=640,
            half=True)

# 导出为 TensorFlow SavedModel 格式
model.export(format='saved_model',
            imgsz=640,
            half=True)

# 导出为 TensorFlow GraphDef 格式
model.export(format='pb',
            imgsz=640,
            half=True)

# 导出为 TFLite 格式（移动端部署）
model.export(format='tflite',
            imgsz=640,
            half=True,
            int8=True)  # 量化

# 导出为 PaddlePaddle 格式
model.export(format='paddle',
            imgsz=640,
            half=True)

# 导出为 TorchScript 格式
model.export(format='torchscript',
            imgsz=640,
            half=True)