YOLO11 目标检测从安装到实战

前言

YOLO（You Only Look Once）系列是目标检测领域的经典算法，凭借速度快、精度高的特点被广泛应用。最新的 YOLO11 在模型结构和性能上进一步优化，本文将从环境搭建到实战应用，详细讲解 YOLO11 的使用方法，适合新手快速上手。

一、环境准备

1. 系统要求

• 操作系统：Windows 10/11、Ubuntu 20.04+、欧拉系统等
• 硬件：CPU 可运行，GPU（NVIDIA）可加速（推荐，需支持 CUDA）

2. 安装 Python

• 推荐版本：Python 3.8-3.11（兼容性最佳）

• 下载地址：Python 官网

• 验证安装：

  python --version  # 或 python3 --version

3. 安装 YOLO11（Ultralytics 库）

YOLO11 由 Ultralytics 团队维护，通过ultralytics库即可使用，安装命令：

# 基础安装（CPU/GPU通用）
pip install ultralytics

# 如需GPU加速，需额外安装对应版本PyTorch（带CUDA）
# 参考PyTorch官网：https://pytorch.org/get-started/locally/
# 例如CUDA 11.8版本：
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

4. 验证安装

python 运行

import ultralytics
from ultralytics import YOLO

print("Ultralytics版本：", ultralytics.__version__)  # 需≥8.1.0（支持YOLO11）
model = YOLO("yolo11n.pt")  # 加载轻量模型
print("模型加载成功！")

运行无报错则安装成功。

二、YOLO11 模型介绍

YOLO11 提供多个预训练模型，不同模型在速度和精度上有差异：

模型	大小 (MB)	输入尺寸	适合场景
yolo11n.pt	6	640x640	轻量化部署、快速推理
yolo11s.pt	23	640x640	平衡速度与精度
yolo11m.pt	66	640x640	中等精度需求
yolo11l.pt	155	640x640	高精度需求
yolo11x.pt	234	640x640	最高精度（速度较慢）

模型会自动下载，首次使用需联网。

三、实战教程：目标检测基础操作

1. 单张图片检测

from ultralytics import YOLO
import os

def detect_and_save_results(image_path, output_txt_path=None):
    """
    对图片进行目标检测，并将结果保存到TXT文件
    
    参数:
        image_path: 输入图片的路径（本地路径或URL）
        output_txt_path: 输出TXT文件的路径，默认与图片同目录、同名
    """
    # 1. 加载预训练的YOLO模型（可替换为其他模型，如yolo11s.pt、yolo11m.pt等）
    model = YOLO("yolo11n.pt")  # 轻量级模型，适合快速测试
    # model = YOLO("yolo11l.pt")  # 较大模型，精度更高但速度较慢

    # 2. 执行目标检测（使用GPU加速，若无GPU会自动切换到CPU）
    results = model(image_path, device=0)  # device=0表示使用第一个GPU，无GPU可省略

    # 3. 处理输出路径：默认与图片同目录，文件名相同，后缀改为.txt
    if output_txt_path is None:
        img_dir = os.path.dirname(image_path)
        img_name = os.path.splitext(os.path.basename(image_path))[0]
        output_txt_path = os.path.join(img_dir, f"{img_name}_detections.txt")

    # 4. 解析检测结果并写入TXT
    with open(output_txt_path, "w", encoding="utf-8") as f:
        # 遍历每张图片的检测结果（此处仅处理单张图片）
        for result in results:
            # 遍历每个检测到的目标
            for box in result.boxes:
                # 获取目标类别名称（如"person"、"car"）
                cls_name = model.names[int(box.cls)]
                # 获取置信度（保留4位小数）
                confidence = round(float(box.conf), 4)
                # 获取边界框坐标（x1, y1, x2, y2，左上角和右下角坐标）
                x1, y1, x2, y2 = map(round, box.xyxy[0].tolist())  # 转为整数
                
                # 写入TXT，格式：类别 置信度 x1 y1 x2 y2
                f.write(f"{cls_name} {confidence} {x1} {y1} {x2} {y2}\n")

    print(f"检测结果已保存至：{output_txt_path}")
    return output_txt_path


# 示例：检测本地图片并保存结果
if __name__ == "__main__":
    # 输入图片路径（可替换为本地图片路径，如"test.jpg"，或URL）
    input_image = "bus.jpg"  # 本地图片
    # input_image = "https://ultralytics.com/images/bus.jpg"  # 网络图片
    
    # 调用函数执行检测并保存结果
    detect_and_save_results(input_image)

2. 批量图片检测并生成标注图

import os
import shutil
from ultralytics import YOLO
from PIL import Image, ImageDraw, ImageFont

def batch_detect_and_annotate(input_dir, output_dir="demo"):
    """
    批量处理文件夹中的图片，生成标注后的图片和识别结果TXT
    
    参数:
        input_dir: 存放待识别图片的文件夹路径
        output_dir: 输出结果的文件夹路径（默认当前目录的demo文件夹）
    """
    # 1. 创建输出文件夹（若不存在）
    os.makedirs(output_dir, exist_ok=True)
    print(f"所有结果将保存至：{os.path.abspath(output_dir)}")

    # 2. 加载YOLO模型（可替换为其他模型，如yolo11s.pt、yolo11m.pt等）
    model = YOLO("yolo11n.pt")  # 轻量级模型，适合快速测试
    # model = YOLO("yolo11l.pt")  # 更大模型，精度更高但速度较慢

    # 3. 获取输入文件夹中所有图片文件
    image_extensions = (".jpg", ".jpeg", ".png", ".bmp", ".gif")  # 支持的图片格式
    image_files = [
        f for f in os.listdir(input_dir)
        if f.lower().endswith(image_extensions)
    ]

    if not image_files:
        print(f"错误：在{input_dir}中未找到任何图片文件！")
        return

    # 4. 批量处理每张图片
    for img_file in image_files:
        # 构建图片路径
        img_path = os.path.join(input_dir, img_file)
        img_name = os.path.splitext(img_file)[0]  # 不含扩展名的文件名

        try:
            # 5. 执行目标检测
            results = model(img_path, device=0)  # device=0启用GPU，无GPU可删除

            # 6. 生成标注后的图片
            # 从结果中获取标注后的图片（YOLO自动绘制检测框）
            annotated_img = results[0].plot()  # 返回numpy数组格式的图片
            # 转换为PIL图片并保存
            pil_img = Image.fromarray(annotated_img[..., ::-1])  # 转换BGR为RGB
            output_img_path = os.path.join(output_dir, f"{img_name}_annotated.jpg")
            pil_img.save(output_img_path)

            # 7. 保存识别结果到TXT文件
            txt_path = os.path.join(output_dir, f"{img_name}_detections.txt")
            with open(txt_path, "w", encoding="utf-8") as f:
                for box in results[0].boxes:
                    cls_name = model.names[int(box.cls)]
                    confidence = round(float(box.conf), 4)
                    x1, y1, x2, y2 = map(round, box.xyxy[0].tolist())
                    f.write(f"{cls_name} {confidence} {x1} {y1} {x2} {y2}\n")

            print(f"处理完成：{img_file} → 已保存标注图和TXT")

        except Exception as e:
            print(f"处理{img_file}时出错：{str(e)}")

    print(f"\n所有图片处理完成！结果保存在：{os.path.abspath(output_dir)}")


# 示例：运行批量处理
if __name__ == "__main__":
    # 待识别图片所在的文件夹（请替换为你的图片文件夹路径）
    input_folder = "/opt"  # 例如："D:/my_images" 或 "./test_pics"
    
    # 调用函数，结果会保存在当前目录的demo文件夹中
    batch_detect_and_annotate(input_folder)

3. 视频实时检测与播放

import cv2
from ultralytics import YOLO

# 加载YOLO模型，可根据需求更换模型，如yolo11n.pt等
model = YOLO("yolov8n.pt")

# 打开视频文件，若要使用摄像头，将路径改为0，如cap = cv2.VideoCapture(0)
video_path = "5b48211588c89.mp4"
cap = cv2.VideoCapture(video_path)

while cap.isOpened():
    # 从视频中读取一帧
    success, frame = cap.read()
    if not success:
        break

    # 对帧进行目标检测
    results = model(frame)

    # 遍历检测结果，绘制标记框
    for result in results:
        boxes = result.boxes.data.tolist()
        for box in boxes:
            x1, y1, x2, y2, conf, cls_id = box
            class_name = model.names[int(cls_id)]
            # 这里可以添加条件，只标记特定类别，如只标记bus
            # if class_name == "bus":
            cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
            label = f'{class_name} {conf:.2f}'
            cv2.putText(frame, label, (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

    # 显示标记后的帧
    cv2.imshow("Object Detection", frame)

    # 按下'q'键退出循环
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放视频捕获对象并关闭所有窗口
cap.release()
cv2.destroyAllWindows()

4. 自定义目标标记（例如只标记 "bus"）

import os
from ultralytics import YOLO
from PIL import Image, ImageDraw, ImageFont
import numpy as np

def detect_and_mark_bus(input_dir, output_dir="demo"):
    """
    批量处理图片，仅用红色框标记公交车(bus)，其他目标不标记
    """
    # 创建输出文件夹
    os.makedirs(output_dir, exist_ok=True)
    print(f"结果保存至：{os.path.abspath(output_dir)}")

    # 加载YOLO模型
    model = YOLO("yolo11n.pt")  # 可替换为其他模型

    # 获取输入文件夹中的所有图片
    image_extensions = (".jpg", ".jpeg", ".png", ".bmp", ".gif")
    image_files = [f for f in os.listdir(input_dir) if f.lower().endswith(image_extensions)]

    if not image_files:
        print(f"错误：{input_dir}中未找到图片！")
        return

    # 批量处理每张图片
    for img_file in image_files:
        img_path = os.path.join(input_dir, img_file)
        img_name = os.path.splitext(img_file)[0]

        try:
            # 执行检测
            results = model(img_path, device=0)  # 无GPU可删除device参数
            img = Image.open(img_path).convert("RGB")  # 打开原图
            draw = ImageDraw.Draw(img)  # 创建绘图对象

            # 遍历检测结果，只处理bus类别
            for box in results[0].boxes:
                cls_name = model.names[int(box.cls)]  # 获取类别名称
                if cls_name == "bus":  # 仅标记公交车
                    # 获取边界框坐标（x1, y1为左上角，x2, y2为右下角）
                    x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
                    # 绘制红色框（线宽3）
                    draw.rectangle([x1, y1, x2, y2], outline="red", width=3)
                    # 绘制类别和置信度（红色文字）
                    confidence = round(float(box.conf), 2)  # 保留2位小数
                    text = f"bus {confidence}"
                    # 设置字体（可选，避免中文乱码）
                    try:
                        font = ImageFont.truetype("arial.ttf", 18)  # 系统字体
                    except:
                        font = ImageFont.load_default()  # 默认字体
                    draw.text((x1, y1 - 20), text, fill="red", font=font)

            # 保存标注后的图片
            output_img_path = os.path.join(output_dir, f"{img_name}_bus_marked.jpg")
            img.save(output_img_path)
            print(f"已处理：{img_file} → 保存至 {output_img_path}")

        except Exception as e:
            print(f"处理{img_file}出错：{str(e)}")

    print(f"\n所有图片处理完成！结果在：{os.path.abspath(output_dir)}")


if __name__ == "__main__":
    # 待处理图片所在的文件夹（替换为你的图片文件夹路径）
    input_folder = "/opt"  # 例如："D:/my_pics" 或 "./test_images"
    detect_and_mark_bus(input_folder)

四、常见问题解决

1. 模型下载慢 ：手动下载模型（Ultralytics Assets），放入~/.cache/ultralytics/目录（Linux）或C:\Users\用户名\.cache\ultralytics\（Windows）。

2. GPU 无法使用：

   • 检查 PyTorch 是否为 CUDA 版本：python -c "import torch; print(torch.cuda.is_available())"（返回 True 则正常）。
   • 确保 CUDA 驱动版本与 PyTorch 兼容。

3. cv2.imshow () 报错：

   • Linux：安装依赖sudo apt-get install libxcb-xinerama0。
   • 无图形界面：改用保存视频方式（见 3.3 节）。

参考资料：

• 使用Ultralytics YOLO 进行模型训练 -Ultralytics YOLO 文档
• YOLO11 GitHub 仓库