YOLO 目标检测实战

pip install ultralytics

from ultralytics import YOLO
import cv2

# 加载预训练模型
model = YOLO('yolov8n.pt')

# 对图片进行推理
results = model('bus.jpg')

# 打印检测结果
for r in results:
    print(f"检测到 {len(r.boxes)} 个目标")
    for box in r.boxes:
        cls_id = int(box.cls[0])
        conf = float(box.conf[0])
        xyxy = box.xyxy[0].cpu().numpy()
        print(f"  类别: {model.names[cls_id]}, 置信度: {conf:.2f}, 边界框: {xyxy}")

# 可视化结果（取第一张图的结果）
if len(results) > 0:
    annotated = results[0].plot()
    cv2.imwrite('result.jpg', annotated)

import numpy as np

def calculate_iou(box1, box2):
    """
    计算两个边界框的 IoU
    box格式: [x1, y1, x2, y2] (左上角，右下角)
    """
    x1 = max(box1[0], box2[0])
    y1 = max(box1[1], box2[1])
    x2 = min(box1[2], box2[2])
    y2 = min(box1[3], box2[3])
    
    intersection = max(0, x2 - x1) * max(0, y2 - y1)
    
    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
    union = area1 + area2 - intersection
    
    return intersection / union if union > 0 else 0

# 测试
box_a = [50, 50, 150, 150]
box_b = [100, 100, 200, 200]
print(f"IoU: {calculate_iou(box_a, box_b):.3f}")

# data.yaml
path: ./datasets/myproject  # 数据集根目录
train: images/train  # 训练集图片路径（相对于 path）
val: images/val    # 验证集图片路径

# 类别数量
nc: 3

# 类别名称
names:
  0: cat
  1: dog
  2: bird

# 安装 LabelImg
pip install labelImg

# 启动 LabelImg（设置保存格式为 YOLO）
labelImg --yolo --output-dir ./labels

datasets/
└── myproject/
    ├── images/
    │   ├── train/
    │   │   ├── img001.jpg
    │   │   ├── img002.jpg
    │   │   └── ...
    │   └── val/
    │       ├── img051.jpg
    │       └── ...
    └── labels/
        ├── train/
        │   ├── img001.txt  # YOLO 格式标注
        │   └── ...
        └── val/
            └── ...

import os
from pathlib import Path

def verify_yolo_annotations(dataset_path, class_names):
    """验证 YOLO 标注文件格式"""
    errors = []
    
    labels_dir = Path(dataset_path) / 'labels'
    images_dir = Path(dataset_path) / 'images'
    
    for split in ['train', 'val']:
        split_labels = labels_dir / split
        if not split_labels.exists():
            continue
            
        for label_file in split_labels.glob('*.txt'):
            img_file = images_dir / split / f"{label_file.stem}.jpg"
            if not img_file.exists():
                errors.append(f"图片缺失: {img_file}")
                continue
                
            with open(label_file, 'r') as f:
                for line_num, line in enumerate(f, 1):
                    parts = line.strip().split()
                    if len(parts) != 5:
                        errors.append(f"{label_file}:{line_num} - 格式错误，期望5个值")
                        continue
                    
                    cls_id, x, y, w, h = map(float, parts)
                    if not (0 <= cls_id < len(class_names)):
                        errors.append(f"{label_file}:{line_num} - 类别ID {int(cls_id)} 超出范围")
                    if not (0 <= x <= 1 and 0 <= y <= 1 and 0 <= w <= 1 and 0 <= h <= 1):
                        errors.append(f"{label_file}:{line_num} - 坐标值必须在 [0,1] 范围内")
    
    if errors:
        print("发现以下错误:")
        for e in errors:
            print(f"  - {e}")
    else:
        print("所有标注文件格式正确！")
    
    return len(errors) == 0

# 使用示例
verify_yolo_annotations('./datasets/myproject', ['cat', 'dog', 'bird'])

from ultralytics import YOLO

# 加载预训练模型
model = YOLO('yolov8n.pt')

# 开始训练
results = model.train(
    data='data.yaml',      # 数据集配置文件
    epochs=100,             # 训练轮数
    batch=16,               # 批次大小
    imgsz=640,              # 输入图像尺寸
    name='my_model',        # 实验名称
    
    # 优化器参数
    optimizer='SGD',        # 可选: SGD, Adam, AdamW
    lr0=0.01,               # 初始学习率
    lrf=0.01,               # 最终学习率 = lr0 * lrf
    momentum=0.937,         # 动量
    weight_decay=0.0005,    # 权重衰减
    
    # 数据增强
    hsv_h=0.015,            # 色调增强
    hsv_s=0.7,              # 饱和度增强
    hsv_v=0.4,              # 亮度增强
    degrees=0.0,            # 旋转角度
    translate=0.1,          # 平移
    scale=0.5,              # 缩放
    flipud=0.0,             # 上下翻转
    fliplr=0.5,             # 左右翻转概率
    mosaic=1.0,             # 马赛克增强
    mixup=0.0,              # MixUp 增强
    
    # 其他设置
    patience=50,            # 早停耐心值
    save=True,              # 保存模型
    save_period=10,         # 每隔多少轮保存一次
    device=''               # 空字符串表示自动选择
)

print("训练完成！")
print(f"最佳模型: runs/detect/my_model/weights/best.pt")

# advanced_train.yaml
# 训练高级配置示例
epochs: 300
batch: 32
imgsz: 1024  # 更大尺寸提升精度但增加显存需求

# 学习率调度
lr0: 0.001
lrf: 0.0001
warmup_epochs: 3
warmup_momentum: 0.8
warmup_bias_lr: 0.1

# 骨干网络冻结（用于迁移学习）
freeze: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # 冻结前10层

# 多尺度训练
multi_scale: True

# 验证设置
val: True
plots: True

from ultralytics import YOLO

# 从中断点恢复训练
model = YOLO('runs/detect/my_model/weights/last.pt')
results = model.train(
    data='data.yaml',
    epochs=200,  # 继续训练到200轮
    name='my_model_resume',
    resume=True  # 关键参数！从 last.pt 恢复
)

from ultralytics import YOLO

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

# 在验证集上评估
metrics = model.val()

# 打印详细指标
print(f"mAP50: {metrics.box.map50:.4f}")
print(f"mAP50-95: {metrics.box.map:.4f}")
print(f"mAP per class: {metrics.box.ap50}")
print(f"Precision: {metrics.box.mp:.4f}")
print(f"Recall: {metrics.box.mr:.4f}")

# 按类别打印 AP
for i, name in enumerate(model.names):
    ap50 = metrics.box.ap50[i]
    print(f"  {name}: AP50={ap50:.4f}" if ap50 > 0 else f"  {name}: N/A")

from ultralytics import YOLO
import cv2
import numpy as np
from pathlib import Path

def analyze_bad_cases(model_path, data_yaml, output_dir='bad_cases'):
    """分析漏检和误检样本"""
    model = YOLO(model_path)
    Path(output_dir).mkdir(exist_ok=True)
    
    # 获取验证集图片
    # 假设图片在 datasets/xxx/images/val/
    val_images = Path('datasets/myproject/images/val').glob('*.jpg')
    
    false_negatives = []  # 漏检
    false_positives = []  # 误检
    
    for img_path in val_images:
        # 读取图片和真实标签
        img = cv2.imread(str(img_path))
        label_path = Path('datasets/myproject/labels/val') / f"{img_path.stem}.txt"
        
        # 推理
        results = model(img_path)
        pred_boxes = results[0].boxes
        
        # 读取真实框（简化版，实际需要解析标注文件）
        gt_boxes = []
        if label_path.exists():
            with open(label_path) as f:
                for line in f:
                    cls, x, y, w, h = map(float, line.split())
                    gt_boxes.append((int(cls), x, y, w, h))
        
        # 简单分析：检测到的但没有对应 GT 的为 FP
        # 有 GT 但没检测到的为 FN
        if len(pred_boxes) == 0 and len(gt_boxes) > 0:
            false_negatives.append((img_path, gt_boxes))
        elif len(pred_boxes) > 0 and len(gt_boxes) == 0:
            false_positives.append((img_path, pred_boxes))
    
    print(f"漏检样本数: {len(false_negatives)}")
    print(f"误检样本数: {len(false_positives)}")
    
    return false_negatives, false_positives

# 执行分析
fn, fp = analyze_bad_cases('runs/detect/my_model/weights/best.pt', 'data.yaml')

from ultralytics import YOLO
import numpy as np

# 加载模型
model = YOLO('runs/detect/my_model/weights/best.pt')

# 获取验证数据源
data_source = 'data.yaml'  # 或直接指定图片路径

# 运行验证（会输出混淆矩阵）
metrics = model.val()

# 访问混淆矩阵
cm = metrics.box.confusion_matrix
print("混淆矩阵:")
print(cm)

# 分析各类别性能
for i, name in enumerate(model.names):
    # 混淆矩阵中每一行代表真实类别，每一列代表预测类别
    true_positive = cm[i, i]
    false_positive = cm[:, i].sum() - true_positive
    false_negative = cm[i, :].sum() - true_positive
    
    precision = true_positive / (true_positive + false_positive) if (true_positive + false_positive) > 0 else 0
    recall = true_positive / (true_positive + false_negative) if (true_positive + false_negative) > 0 else 0
    
    print(f"{name}: Precision={precision:.3f}, Recall={recall:.3f}")