Ultralytics-中文文档-十一-

Ultralytics 中文文档（十一）

使用 Ultralytics YOLOv8 进行队列管理 🚀

原文：docs.ultralytics.com/guides/queue-management/

什么是队列管理？

使用 Ultralytics YOLOv8 进行队列管理涉及组织和控制人群或车辆队列，以减少等待时间并提高效率。优化队列以提升客户满意度和系统性能，在零售、银行、机场和医疗设施等各种场所发挥作用。

www.youtube.com/embed/gX5kSRD56Gs

观看： 如何使用 Ultralytics YOLOv8 实施队列管理 | 机场和地铁站

队列管理的优势？

  • 减少等待时间： 队列管理系统有效地组织排队，最大限度地减少顾客等待时间。这导致顾客满意度提高，因为顾客等待时间减少，有更多时间参与产品或服务。

  • 提高效率： 实施队列管理允许企业更有效地分配资源。通过分析队列数据和优化员工部署，企业可以简化操作、降低成本，并提高整体生产效率。

实际应用场景

物流 零售
使用 Ultralytics YOLOv8 在机场售票柜台进行队列管理 使用 Ultralytics YOLOv8 在人群中进行队列监控
使用 Ultralytics YOLOv8 在机场售票柜台进行队列管理 使用 Ultralytics YOLOv8 在人群中进行队列监控

使用 YOLOv8 示例的队列管理

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")

assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

video_writer = cv2.VideoWriter("queue_management.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

queue_region = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

queue = solutions.QueueManager(
    names=model.names,
    reg_pts=queue_region,
    line_thickness=3,
    fontsize=1.0,
    region_color=(255, 144, 31),
)

while cap.isOpened():
    success, im0 = cap.read()

    if success:
        tracks = model.track(im0, show=False, persist=True, verbose=False)
        out = queue.process_queue(im0, tracks)

        video_writer.write(im0)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
        continue

    print("Video frame is empty or video processing has been successfully completed.")
    break

cap.release()
cv2.destroyAllWindows() 

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")

assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

video_writer = cv2.VideoWriter("queue_management.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

queue_region = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

queue = solutions.QueueManager(
    names=model.names,
    reg_pts=queue_region,
    line_thickness=3,
    fontsize=1.0,
    region_color=(255, 144, 31),
)

while cap.isOpened():
    success, im0 = cap.read()

    if success:
        tracks = model.track(im0, show=False, persist=True, verbose=False, classes=0)  # Only person class
        out = queue.process_queue(im0, tracks)

        video_writer.write(im0)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
        continue

    print("Video frame is empty or video processing has been successfully completed.")
    break

cap.release()
cv2.destroyAllWindows()

参数 QueueManager

Name Type Default Description
names dict model.names 将类别 ID 映射到类别名称的字典。
reg_pts list of tuples [(20, 400), (1260, 400)] 定义计数区域多边形的点。默认为预定义的矩形。
line_thickness int 2 注释线的粗细。
track_thickness int 2 轨迹线的粗细。
view_img bool False 是否显示图像帧。
region_color tuple (255, 0, 255) 计数区域线的颜色 (BGR)。
view_queue_counts bool True 是否显示队列计数。
draw_tracks bool False 是否绘制对象的轨迹。
count_txt_color tuple (255, 255, 255) 计数文本的颜色 (BGR)。
track_color tuple None 轨迹的颜色。如果为 None，将为不同的轨迹使用不同的颜色。
region_thickness int 5 计数区域线的粗细。
fontsize float 0.7 文本注释的字体大小。

参数 model.track

Name Type Default Description
source im0 None 图像或视频的源目录
persist bool False 在帧之间持久化跟踪结果。
tracker str botsort.yaml 跟踪方法 'bytetrack' 或 'botsort'。
conf float 0.3 置信度阈值。
iou float 0.5 IOU（交并比）阈值。
classes list None 通过类别过滤结果，例如 classes=0 或 classes=[0,2,3]。
verbose bool True 显示对象跟踪结果。

常见问题解答

如何使用 Ultralytics YOLOv8 进行实时队列管理？

要使用 Ultralytics YOLOv8 进行实时队列管理，可以按照以下步骤进行：

  1. 使用YOLO("yolov8n.pt")加载 YOLOv8 模型。

  2. 使用cv2.VideoCapture捕获视频源。

  3. 定义用于队列管理的感兴趣区域（ROI）。

  4. 处理帧以检测对象并管理队列。

这是一个最小示例：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video.mp4")
queue_region = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

queue = solutions.QueueManager(
    names=model.names,
    reg_pts=queue_region,
    line_thickness=3,
    fontsize=1.0,
    region_color=(255, 144, 31),
)

while cap.isOpened():
    success, im0 = cap.read()
    if success:
        tracks = model.track(im0, show=False, persist=True, verbose=False)
        out = queue.process_queue(im0, tracks)
        cv2.imshow("Queue Management", im0)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break

cap.release()
cv2.destroyAllWindows()

利用 UltralyticsHUB可以通过提供用户友好的平台来简化部署和管理您的队列管理解决方案。

使用 Ultralytics YOLOv8 进行队列管理的关键优势是什么？

使用 Ultralytics YOLOv8 进行队列管理具有以下几个优点：

  • 大幅减少等待时间： 有效组织队列，缩短客户等待时间，提升满意度。

  • 提升效率： 分析队列数据以优化人员部署和运营，从而降低成本。

  • 实时警报： 提供长队列的实时通知，便于快速干预。

  • 可扩展性： 在零售、机场和医疗保健等不同环境中轻松扩展。

欲了解更多详情，请浏览我们的队列管理解决方案。

为什么我应该选择 Ultralytics YOLOv8 而不是像 TensorFlow 或 Detectron2 这样的竞争对手进行队列管理？

Ultralytics YOLOv8 在队列管理方面比 TensorFlow 和 Detectron2 具有多个优势：

  • 实时性能： YOLOv8 以其实时检测能力而闻名，提供更快的处理速度。

  • 易于使用： Ultralytics 提供了用户友好的体验，从训练到部署，通过Ultralytics HUB。

  • 预训练模型： 提供多种预训练模型，最小化设置时间。

  • 社区支持： 完善的文档和活跃的社区支持使问题解决更加容易。

学习如何开始使用Ultralytics YOLO。

Ultralytics YOLOv8 能处理多种类型的队列吗，例如机场和零售业务中的队列？

是的，Ultralytics YOLOv8 可以管理包括机场和零售环境在内的各种类型的队列。通过配置 QueueManager 来适应不同的队列布局和密度。

机场示例：

queue_region_airport = [(50, 600), (1200, 600), (1200, 550), (50, 550)]
queue_airport = solutions.QueueManager(
    names=model.names,
    reg_pts=queue_region_airport,
    line_thickness=3,
    fontsize=1.0,
    region_color=(0, 255, 0),
)

欲了解更多关于不同应用的信息，请查阅我们的真实世界应用部分。

Ultralytics YOLOv8 在队列管理中的一些实际应用是什么？

Ultralytics YOLOv8 在各种实际应用中用于排队管理：

  • 零售： 监控收银队列，缩短等待时间，提升顾客满意度。

  • 机场： 管理售票柜台和安检点的排队，以提升乘客体验流畅度。

  • 医疗： 优化诊所和医院的患者流程。

  • 银行： 通过高效管理排队优化客户服务。

查看我们的博客，了解真实世界的排队管理。

使用 Ultralytics YOLOv8 进行停车管理 🚀

原文：docs.ultralytics.com/guides/parking-management/

什么是停车管理系统？

使用 Ultralytics YOLOv8 进行停车管理可通过组织空间和监控可用性来确保高效且安全的停车。YOLOv8 通过实时车辆检测和停车位占用情况的洞察，可以改善停车场管理。

停车管理系统的优势？

  • 效率: 停车场管理优化停车位的使用，并减少拥堵。

  • 安全与保安: 使用 YOLOv8 进行停车管理通过监控和安全措施提升了人员和车辆的安全性。

  • 减少排放: 使用 YOLOv8 进行停车管理可以控制交通流，最小化停车场的闲置时间和排放。

现实世界应用

停车管理系统 停车管理系统
Ultralytics YOLOv8 使用停车场分析 Ultralytics YOLOv8 使用停车管理的俯视图
使用 Ultralytics YOLOv8 进行停车管理的航拍视图 使用 Ultralytics YOLOv8 进行停车管理的俯视图

停车管理系统代码工作流程

点的选择

现在轻松选择点

在停车管理系统中，选择停车点是一项关键且复杂的任务。Ultralytics 通过提供一个工具来定义停车场区域，后续可用于进一步处理，从而简化了这一过程。

  • 从视频或摄像头流中捕获一个帧，用于管理停车场的位置。

  • 使用提供的代码启动一个图形界面，在那里您可以选择一张图像，并通过鼠标点击开始轮廓化停车区域，以创建多边形。

图像大小

支持最大图像大小为 1920 * 1080

Ultralytics YOLOv8 停车槽标注器

from ultralytics import solutions

solutions.ParkingPtsSelection()
  • 定义停车区域的多边形后，点击 保存 将数据存储为 JSON 文件到您的工作目录中。

Ultralytics YOLOv8 点选演示

Python 停车管理代码

使用 YOLOv8 进行停车管理的示例

import cv2

from ultralytics import solutions

# Path to json file, that created with above point selection app
polygon_json_path = "bounding_boxes.json"

# Video capture
cap = cv2.VideoCapture("Path/to/video/file.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

# Video writer
video_writer = cv2.VideoWriter("parking management.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Initialize parking management object
management = solutions.ParkingManagement(model_path="yolov8n.pt")

while cap.isOpened():
    ret, im0 = cap.read()
    if not ret:
        break

    json_data = management.parking_regions_extraction(polygon_json_path)
    results = management.model.track(im0, persist=True, show=False)

    if results[0].boxes.id is not None:
        boxes = results[0].boxes.xyxy.cpu().tolist()
        clss = results[0].boxes.cls.cpu().tolist()
        management.process_data(json_data, im0, boxes, clss)

    management.display_frames(im0)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

可选参数 ParkingManagement

名称 类型 默认 描述
model_path str None YOLOv8 模型的路径。
txt_color tuple (0, 0, 0) 文本的 RGB 颜色元组。
bg_color tuple (255, 255, 255) 背景的 RGB 颜色元组。
occupied_region_color tuple (0, 255, 0) 已占用区域的 RGB 颜色元组。
available_region_color tuple (0, 0, 255) 可用区域的 RGB 颜色元组。
margin int 10 文本显示的边距。

参数 model.track

名称 类型 默认 描述
source im0 None 图像或视频的源目录。
persist bool False 在帧之间持续跟踪
tracker str botsort.yaml 跟踪方法'bytetrack'或'botsort'
conf float 0.3 置信阈值
iou float 0.5 IOU 阈值
classes list None 按类别过滤结果，例如 classes=0 或 classes=[0,2,3]
verbose bool True 显示对象跟踪结果

常见问题

Ultralytics YOLOv8 如何增强停车管理系统？

Ultralytics YOLOv8 通过提供实时车辆检测和监控，极大增强了停车管理系统。这导致停车位的优化使用，减少拥堵，并通过持续监控增强安全性。停车管理系统通过有效的交通流程，最小化停车场中的空转时间和排放，从而促进环境可持续性。有关详细信息，请参阅停车管理代码工作流程。

使用 Ultralytics YOLOv8 进行智能停车的好处是什么？

使用 Ultralytics YOLOv8 进行智能停车可以获得多个好处：

  • 效率：优化停车位的使用并减少拥堵。

  • 安全与安全性：增强监视并确保车辆和行人的安全。

  • 环境影响：通过减少车辆空转时间来帮助减少排放。有关优势的更多细节可以在这里看到。

如何使用 Ultralytics YOLOv8 定义停车位？

使用 Ultralytics YOLOv8 定义停车位非常简单：

  1. 从视频或摄像头流中捕获一帧。

  2. 使用提供的代码启动 GUI，选择图像并绘制多边形以定义停车位。

  3. 将标记的数据保存为 JSON 格式以便进一步处理。有关详细说明，请查看点选部分的选择。

我可以为特定的停车管理需求定制 YOLOv8 模型吗？

是的，Ultralytics YOLOv8 允许根据特定的停车管理需求进行定制。您可以调整参数，例如占用和可用区域的颜色，文本显示的边距等。利用ParkingManagement类的可选参数，您可以调整模型以满足特定的需求，确保最大的效率和效果。

Ultralytics YOLOv8 在停车场管理中的一些真实应用是什么？

Ultralytics YOLOv8 在包括停车场管理在内的各种真实应用中被使用：

  • 停车位检测：准确识别可用和占用空间。

  • 监视：通过实时监控增强安全性。

  • 交通流管理：通过高效的交通处理减少空转时间和拥堵。可以在真实应用中找到展示这些应用的图片。

使用 Ultralytics YOLOv8 和 Streamlit 应用程序进行实时推理

原文：docs.ultralytics.com/guides/streamlit-live-inference/

简介

Streamlit 简化了构建和部署交互式 Web 应用程序的过程。结合 Ultralytics YOLOv8，可以在浏览器中进行实时目标检测和分析。YOLOv8 的高准确性和速度确保了对实时视频流的无缝性性能，非常适合安全、零售等领域的应用。

水产养殖 动物饲养
使用 Ultralytics YOLOv8 进行鱼类检测 使用 Ultralytics YOLOv8 进行动物检测
使用 Ultralytics YOLOv8 进行鱼类检测 使用 Ultralytics YOLOv8 进行动物检测

实时推理的优势

  • 无缝实时目标检测：Streamlit 结合 YOLOv8，可以直接从您的网络摄像头实时进行目标检测。这样可以进行即时分析和洞察，非常适合需要即时反馈的应用程序。

  • 用户友好的部署：Streamlit 的交互界面使得应用程序的部署和使用变得简单，无需深厚的技术知识。用户只需点击一下即可开始实时推理，增强了可访问性和可用性。

  • 高效的资源利用：YOLOv8 优化算法确保在最小计算资源的情况下进行高速处理。这种效率使得即使在标准硬件上，也能够实现平滑可靠的网络摄像头推理，使先进的计算机视觉技术更易于被更广泛的人群接受。

Streamlit 应用程序代码

Ultralytics 安装

在开始构建应用程序之前，请确保已安装 Ultralytics Python 包。您可以使用命令 pip install ultralytics 进行安装。

Streamlit 应用程序

from ultralytics import solutions

solutions.inference()

### Make sure to run the file using command `streamlit run <file-name.py>` 

yolo  streamlit-predict

这将在您的默认网络浏览器中启动 Streamlit 应用程序。您将看到主标题、副标题和侧边栏配置选项。选择您期望的 YOLOv8 模型，设置置信度和 NMS 阈值，然后点击“开始”按钮开始实时目标检测。

您可以选择在 Python 中提供特定模型：

使用自定义模型的 Streamlit 应用程序

from ultralytics import solutions

# Pass a model as an argument
solutions.inference(model="path/to/model.pt")

### Make sure to run the file using command `streamlit run <file-name.py>`

结论

通过遵循本指南，您成功创建了一个使用 Streamlit 和 Ultralytics YOLOv8 进行实时目标检测的应用程序。该应用程序允许您通过网络摄像头体验 YOLOv8 在检测对象方面的强大功能，具有用户友好的界面，并可以随时停止视频流。

要进一步增强功能，您可以探索添加更多功能，如录制视频流、保存标注帧或与其他计算机视觉库集成。

与社区分享您的想法

与社区互动，了解更多信息，解决问题并分享您的项目：

获取帮助和支持的位置

官方文档

  • Ultralytics YOLOv8 文档：请参阅官方 YOLOv8 文档，获取关于各种计算机视觉任务和项目的全面指南和见解。

常见问题解答

如何使用 Streamlit 和 Ultralytics YOLOv8 设置实时物体检测应用程序？

使用 Streamlit 和 Ultralytics YOLOv8 设置实时物体检测应用程序非常简单。首先，确保您已安装 Ultralytics Python 包：

pip  install  ultralytics

然后，您可以创建一个基本的 Streamlit 应用程序来进行实时推理：

Streamlit 应用程序

from ultralytics import solutions

solutions.inference()

### Make sure to run the file using command `streamlit run <file-name.py>` 

yolo  streamlit-predict

获取有关实际设置的更多详细信息，请参阅文档的 Streamlit 应用代码部分。

使用 Ultralytics YOLOv8 结合 Streamlit 进行实时物体检测的主要优势是什么？

使用 Ultralytics YOLOv8 结合 Streamlit 进行实时物体检测具有多个优势：

  • 无缝实时检测：直接从网络摄像头视频流进行高准确度的实时物体检测。

  • 用户友好界面：Streamlit 直观的界面允许轻松使用和部署，无需广泛的技术知识。

  • 资源效率：YOLOv8 的优化算法确保高速处理，最小化计算资源消耗。

在这里了解更多关于这些优势的信息。

如何在我的网络浏览器中部署 Streamlit 物体检测应用程序？

编码完毕后，将您的 Streamlit 应用程序与 Ultralytics YOLOv8 集成，可以通过运行来部署：

streamlit  run  <file-name.py>

此命令将在您的默认网络浏览器中启动应用程序，使您能够选择 YOLOv8 模型，设置置信度和 NMS 阈值，并通过简单点击开始实时物体检测。详细指南，请参阅 Streamlit 应用代码部分。

使用 Streamlit 和 Ultralytics YOLOv8 进行实时物体检测的一些用例是什么？

使用 Streamlit 和 Ultralytics YOLOv8 进行实时物体检测可应用于各个领域：

  • 安全性：实时监控未经授权的访问。

  • 零售：客户计数，货架管理等。

  • 野生动物和农业：监测动物和作物状况。

获取更深入的用例和示例，请探索Ultralytics 解决方案。

Ultralytics YOLOv8 与 YOLOv5 和 RCNN 等其他物体检测模型相比有何优势？

Ultralytics YOLOv8 相比之前的模型如 YOLOv5 和 RCNN，提供了多项增强功能：

  • 更高的速度和准确性：提升了实时应用的性能。

  • 易于使用：简化的界面和部署。

  • 资源效率：优化以提高速度，同时最小化计算需求。

如需全面比较，请查看Ultralytics YOLOv8 文档以及相关博客文章，讨论模型性能。

Ultralytics YOLO 的全面教程

原文：docs.ultralytics.com/guides/

欢迎来到 Ultralytics 的 YOLO 🚀 指南！我们全面的教程涵盖了 YOLO 目标检测模型的各个方面，从训练和预测到部署。基于 PyTorch，YOLO 以其在实时目标检测任务中的卓越速度和准确性脱颖而出。

无论您是深度学习的初学者还是专家，我们的教程都为您提供了有关实现和优化 YOLO 的宝贵见解，以用于计算机视觉项目。让我们开始吧！

www.youtube.com/embed/96NkhsV-W1U

观看：Ultralytics YOLOv8 指南概述

指南

这里是一系列深入指南的汇编，帮助您掌握 Ultralytics YOLO 的不同方面。

  • YOLO 常见问题 ⭐ 推荐：处理 Ultralytics YOLO 模型时经常遇到的问题的实用解决方案和故障排除提示。

  • YOLO 性能指标 ⭐ 必读：理解用于评估 YOLO 模型性能的关键指标，如 mAP、IoU 和 F1 分数。包括实际示例和如何提高检测精度和速度的提示。

  • 模型部署选项：关于 YOLO 模型部署格式如 ONNX、OpenVINO 和 TensorRT 的概述，以及每种格式的优缺点，帮助您制定部署策略。

  • K 折交叉验证 🚀 新：使用 K 折交叉验证技术来提升模型泛化能力的方法。

  • 超参数调整 🚀 新：通过微调超参数和遗传演化算法优化 YOLO 模型的方法。

  • SAHI 分片推理 🚀 新：利用 SAHI 的切片推理能力与 YOLOv8 结合，用于高分辨率图像中的目标检测的全面指南。

  • AzureML 快速入门 🚀 新：在 Microsoft 的 Azure 机器学习平台上快速启动 Ultralytics YOLO 模型。学习如何在云中训练、部署和扩展您的目标检测项目。

  • Conda 快速入门 🚀 新：使用Conda环境设置 Ultralytics 的逐渐学习包的逐渐学习包的逐渐学习包。学习如何高效地安装和使用 Conda 环境。

  • Docker 快速入门 🚀 新：使用Docker设置和使用 Ultralytics YOLO 模型的完整指南。学习如何安装 Docker，管理 GPU 支持，并在隔离容器中运行 YOLO 模型，以确保开发和部署的一致性。

  • Raspberry Pi 🚀 新：在最新的 Raspberry Pi 硬件上运行 YOLO 模型的快速入门教程。

  • NVIDIA Jetson 🚀 新：在 NVIDIA Jetson 设备上部署 YOLO 模型的快速入门指南。

  • NVIDIA Jetson 🚀 新：使用 DeepStream 和 TensorRT 在 NVIDIA Jetson 设备上部署 YOLO 模型的快速入门指南。

  • Triton 推理服务器集成 🚀 新增：深入了解 Ultralytics YOLOv8 与 NVIDIA 的 Triton 推理服务器的集成，以实现可扩展和高效的深度学习推理部署。

  • YOLO 线程安全推理 🚀 新增：关于以线程安全的方式执行 YOLO 模型推理的指南。了解线程安全的重要性以及防止竞争条件和确保一致预测的最佳实践。

  • 隔离分割对象 🚀 新增：逐步指导和解释如何使用 Ultralytics 分割从图像中提取和/或隔离对象。

  • Raspberry Pi 上的 Edge TPU：Google Edge TPU加速Raspberry Pi上的 YOLO 推理。

  • 在终端中查看推理图像：使用 VSCode 的集成终端查看使用远程隧道或 SSH 会话时的推理结果。

  • OpenVINO 延迟与吞吐量模式 - 学习延迟和吞吐量优化技术，以实现 YOLO 推理性能的峰值。

  • 计算机视觉项目的步骤 🚀 新增：了解计算机视觉项目中涉及的关键步骤，包括定义目标、选择模型、准备数据和评估结果。

  • 定义计算机视觉项目的目标 🚀 新增：逐步介绍如何有效地定义计算机视觉项目的清晰和可衡量的目标。了解明确的问题陈述的重要性，以及它如何为你的项目创建路线图。

  • 数据收集与标注 🚀 新增：探索收集和标注数据的工具、技术和最佳实践，以为你的计算机视觉模型创建高质量的输入。

  • 预处理标注数据 🚀 新增：了解在计算机视觉项目中使用 YOLOv8 对图像数据进行预处理和增强，包括归一化、数据集增强、拆分和探索性数据分析（EDA）。

  • 模型训练技巧 🚀 新增：探索优化批量大小、使用混合精度、应用预训练权重等技巧，使训练你的计算机视觉模型变得轻松。

  • 模型评估与微调的见解 🚀 新增：获取关于评估和微调计算机视觉模型的策略和最佳实践的见解。了解优化结果的模型精炼的迭代过程。

  • 模型测试指南 🚀 新增：关于在现实环境中测试计算机视觉模型的全面指南。了解如何验证准确性、可靠性和性能，以符合项目目标。

  • 模型部署的最佳实践 🚀 新增：逐步介绍在计算机视觉项目中高效部署模型的技巧和最佳实践，重点关注优化、故障排除和安全性。

  • 维护你的计算机视觉模型 🚀 新增：了解监控、维护和记录计算机视觉模型的关键实践，以确保准确性、发现异常并减轻数据漂移。

  • ROS 快速入门 🚀 新功能：学习如何将 YOLO 与机器人操作系统（ROS）集成，用于机器人应用中的实时物体检测，包括点云和深度图像。

为我们的指南贡献内容

我们欢迎社区的贡献！如果您精通 Ultralytics YOLO 的某一方面，而我们的指南中尚未涵盖，请分享您的专业知识。撰写指南是回馈社区、帮助我们使文档更加全面和用户友好的绝佳方式。

要开始，请阅读我们的贡献指南，了解如何发起拉取请求（PR）的指导方针 🛠️。我们期待您的贡献！

让我们共同努力，使 Ultralytics YOLO 生态系统更加强大和多功能 🙏！

常见问题解答（FAQ）

如何使用 Ultralytics YOLO 训练自定义物体检测模型？

使用 Ultralytics YOLO 训练自定义物体检测模型非常简单。首先，准备正确格式的数据集并安装 Ultralytics 软件包。使用以下代码启动训练：

示例

from ultralytics import YOLO

model = YOLO("yolov8s.pt")  # Load a pre-trained YOLO model
model.train(data="path/to/dataset.yaml", epochs=50)  # Train on custom dataset 

yolo  task=detect  mode=train  model=yolov8s.pt  data=path/to/dataset.yaml  epochs=50

关于详细的数据集格式化和其他选项，请参考我们的模型训练提示指南。

我应该使用什么性能指标来评估我的 YOLO 模型？

评估 YOLO 模型的性能对了解其有效性至关重要。关键指标包括平均精度均值（mAP）、交并比（IoU）和 F1 分数。这些指标有助于评估物体检测任务的准确性和精度。您可以在我们的 YOLO 性能指标指南中了解更多关于这些指标以及如何改进模型的信息。

为什么我应该在我的计算机视觉项目中使用 Ultralytics HUB？

Ultralytics HUB 是一个无代码平台，简化了管理、训练和部署 YOLO 模型的过程。它支持无缝集成、实时跟踪和云训练，非常适合初学者和专业人士使用。通过我们的Ultralytics HUB快速入门指南，了解更多其功能以及如何优化您的工作流程。

在 YOLO 模型训练过程中常见的问题及其解决方法是什么？

YOLO 模型训练中的常见问题包括数据格式错误、模型架构不匹配和训练数据不足。要解决这些问题，请确保数据集格式正确，检查模型版本兼容性，并增加训练数据。要获取更全面的解决方案列表，请参考我们的 YOLO 常见问题指南。

我如何在边缘设备上实时部署我的 YOLO 模型进行物体检测？

在 NVIDIA Jetson 和 Raspberry Pi 等边缘设备上部署 YOLO 模型需要将模型转换为 TensorRT 或 TFLite 等兼容格式。按照我们的 NVIDIA Jetson 和 Raspberry Pi 部署逐步指南开始实时物体检测的安装、配置和性能优化。这些指南将指导您完成整个过程。

解决常见 YOLO 问题

原文：docs.ultralytics.com/guides/yolo-common-issues/

YOLO 常见问题图片

介绍

本指南旨在全面帮助解决在 Ultralytics 项目中使用 YOLOv8 时遇到的常见问题。通过正确的指导，您可以轻松地解决这些问题，确保项目按计划进行，避免不必要的延迟。

www.youtube.com/embed/TG9exsBlkDE

观看： Ultralytics YOLOv8 常见问题 | 安装错误，模型训练问题

常见问题

安装错误

安装错误可能由多种原因引起，例如不兼容的版本、缺少依赖项或不正确的环境设置。首先，确保您正在执行以下操作：

  • 建议使用 Python 3.8 或更高版本。

  • 确保您安装了正确版本的 PyTorch（1.8 或更高）。

  • 考虑使用虚拟环境以避免冲突。

  • 逐步按照官方安装指南操作。

另外，这里列出了一些用户遇到的常见安装问题及其解决方案：

  • 导入错误或依赖问题 - 如果在导入 YOLOv8 时遇到错误，或者存在与依赖相关的问题，请考虑以下故障排除步骤：

    • 全新安装：有时，从全新安装开始可以解决意外问题。特别是在像 Ultralytics 这样的库中，更新可能会改变文件树结构或功能。

    • 定期更新：确保使用最新版本的库。旧版本可能与最新更新不兼容，可能导致冲突或问题。

    • 检查依赖项：验证所有必需的依赖项是否正确安装，并且版本兼容。

    • 审查更改：如果最初克隆或安装了旧版本，请注意重大更新可能会影响库的结构或功能。始终参考官方文档或变更日志了解任何重大更改。

    • 请记住，保持库和依赖项的更新对于平稳且无错误的体验至关重要。

  • 在 GPU 上运行 YOLOv8 - 如果您在 GPU 上运行 YOLOv8 时遇到问题，请考虑以下故障排除步骤：

    • 验证 CUDA 兼容性和安装：确保您的 GPU 支持 CUDA，并且 CUDA 已正确安装。使用nvidia-smi命令检查您的 NVIDIA GPU 状态和 CUDA 版本。

    • 检查 PyTorch 和 CUDA 集成：确保 PyTorch 可以利用 CUDA，在 Python 终端中运行import torch; print(torch.cuda.is_available())。如果返回'True'，则 PyTorch 已设置为使用 CUDA。

    • 环境激活：确保您处于正确的环境中，其中安装了所有必要的软件包。

    • 更新您的包：过时的包可能与您的 GPU 不兼容。保持它们更新。

    • 程序配置：检查程序或代码是否指定了 GPU 使用情况。在 YOLOv8 中，这可能在设置或配置中。

模型训练问题

本节将讨论训练过程中常见的问题及其相应的解释和解决方案。

配置设置验证

问题：不确定 .yaml 文件中的配置设置在模型训练过程中是否正确应用。

解决方案：在使用 model.train() 函数时应用 .yaml 文件中的配置设置。为确保这些设置正确应用，请按照以下步骤操作：

  • 确认您的 .yaml 配置文件路径是否正确。

  • 当调用 model.train() 时，请确保将 .yaml 文件的路径作为 data 参数传递，如下所示：

model.train(data="/path/to/your/data.yaml", batch=4)

使用多个 GPU 加速训练

问题：单个 GPU 上的训练速度较慢，您希望通过多个 GPU 加速该过程。

解决方案：增加批量大小可以加速训练，但是必须考虑 GPU 内存容量。要使用多个 GPU 加速训练，请按照以下步骤操作：

  • 确保您有多个 GPU 可用。

  • 修改您的 .yaml 配置文件以指定要使用的 GPU 数量，例如，gpus: 4。

  • 根据需要增加批量大小，以充分利用多个 GPU 而不超出内存限制。

  • 修改您的训练命令以利用多个 GPU：

# Adjust the batch size and other settings as needed to optimize training speed
model.train(data="/path/to/your/data.yaml", batch=32, multi_scale=True)

连续监控参数

问题：您想知道在训练过程中除了损失之外应该持续监控哪些参数。

解决方案：虽然损失是一个关键的监控指标，但跟踪其他模型性能优化指标同样重要。在训练过程中需要监控的一些关键指标包括：

  • 精度

  • 召回率

  • 平均精度 (mAP)

您可以从训练日志中访问这些指标，或者使用像 TensorBoard 或 wandb 这样的工具进行可视化。根据这些指标实施早停机制可以帮助您获得更好的结果。

跟踪训练进度的工具

问题：您正在寻找跟踪训练进度的工具建议。

解决方案：要跟踪和可视化训练进度，可以考虑使用以下工具：

  • TensorBoard：TensorBoard 是一个流行的选择，用于可视化训练指标，包括损失、准确度等。您可以将其与 YOLOv8 训练过程集成。

  • Comet：Comet 提供了广泛的实验跟踪和比较工具包。它允许您跟踪指标、超参数，甚至模型权重。与 YOLO 模型的集成也很简单，为您提供完整的实验周期概览。

  • Ultralytics HUB：Ultralytics HUB 提供了一个专门的环境，用于跟踪 YOLO 模型，为您提供一个一站式平台来管理指标、数据集，甚至与团队合作。由于其专注于 YOLO，它提供了更多定制的跟踪选项。

每种工具都有其独特的优势，因此在选择时可能需要考虑项目的特定需求。

如何检查训练是否在 GPU 上进行

问题：训练日志中 'device' 的值为 'null'，您不确定训练是否在 GPU 上进行。

解决方案：在训练日志中，'device' 的值为 'null' 通常意味着训练过程设置为自动使用可用的 GPU，这是默认行为。要确保在特定 GPU 上进行训练，可以在您的 .yaml 配置文件中手动设置 'device' 值为 GPU 索引（例如，第一个 GPU 的 '0'）：

device:  0

这将显式地将训练过程分配到指定的 GPU。如果希望在 CPU 上训练，请将 'device' 设置为 'cpu'。

注意 'runs' 文件夹中的日志和指标，以有效监控训练进度。

有效模型训练的关键考虑因素

如果您遇到与模型训练相关的问题，以下是一些需要牢记的事项。

数据集格式和标签

  • 重要性：任何机器学习模型的基础在于其训练数据的质量和格式。

  • 建议：确保您的自定义数据集及其关联的标签符合预期的格式。验证注释的准确性和高质量至关重要。不正确或次优的注释可能会使模型的学习过程出现偏差，导致不可预测的结果。

模型收敛

  • 重要性：确保模型收敛意味着模型已充分从训练数据中学习。

  • 建议：在从头开始训练模型时，确保模型达到令人满意的收敛水平至关重要。与微调现有模型相比，这可能需要更长的训练时间和更多的 epoch。

学习率和批大小

  • 重要性：这些超参数在确定模型如何在训练过程中更新权重方面起着关键作用。

  • 建议：定期评估所选的学习率和批大小是否适合您特定的数据集。与数据集特征不协调的参数可能会影响模型的性能。

类分布

  • 重要性：数据集中类的分布可能影响模型的预测倾向。

  • 建议：定期评估数据集中类的分布。如果存在类别不平衡，模型可能会对更普遍的类别产生偏见。这种偏见可能会在混淆矩阵中显现，其中模型可能主要预测多数类。

与预训练权重进行交叉验证

  • 重要性：利用预训练权重可以为模型训练提供坚实的起点，特别是在数据有限的情况下。

  • 建议：作为诊断步骤，考虑使用相同数据训练模型，但使用预训练权重进行初始化。如果此方法生成了良好形成的混淆矩阵，则可能表明“从头开始”模型可能需要进一步训练或调整。

与模型预测相关的问题

本节将解决模型预测过程中常见的问题。

获取 YOLOv8 自定义模型的边界框预测

问题：在使用自定义 YOLOv8 模型运行预测时，关于边界框坐标格式和可视化存在挑战。

解决方案：

  • 坐标格式：YOLOv8 提供绝对像素值的边界框坐标。要将其转换为相对坐标（范围从 0 到 1），需要通过图像尺寸进行除法。例如，假设您的图像尺寸为 640x640。然后您需要执行以下操作：
# Convert absolute coordinates to relative coordinates
x1 = x1 / 640  # Divide x-coordinates by image width
x2 = x2 / 640
y1 = y1 / 640  # Divide y-coordinates by image height
y2 = y2 / 640
  • 文件名：要获取正在进行预测的图像的文件名，请直接从结果对象中访问图像文件路径。

YOLOv8 预测中的对象过滤

问题：在使用 Ultralytics 库运行 YOLOv8 时，如何筛选并仅显示特定对象的预测结果存在问题。

解决方案：要检测特定类别，请使用 classes 参数指定要包含在输出中的类别。例如，要仅检测汽车（假设 'cars' 的类别索引为 2）：

yolo  task=detect  mode=segment  model=yolov8n-seg.pt  source='path/to/car.mp4'  show=True  classes=2

理解 YOLOv8 中的精度指标

问题：对于 YOLOv8 中框精度、掩膜精度和混淆矩阵精度之间的差异存在困惑。

解决方案：框精度衡量预测边界框与实际标准边界框之间的准确性，使用 IoU（交并比）作为度量标准。掩膜精度评估预测分割掩膜与标准掩膜在像素级对象分类上的一致性。混淆矩阵精度则侧重于跨所有类别的整体分类准确性，不考虑预测的几何准确性。需要注意的是，即使类别预测错误，边界框在几何上可能也是准确的（真正例），这导致框精度和混淆矩阵精度之间存在差异。这些度量标准评估模型性能的不同方面，反映了在各种任务中需要不同的评估指标。

提取 YOLOv8 中的对象尺寸

问题：在检测到多个对象的情况下，特别是在 YOLOv8 中检测到的难以获取长度和高度。

解决方案：要获取边界框尺寸，请首先使用 Ultralytics 的 YOLOv8 模型在图像中预测对象。然后，从预测结果中提取边界框的宽度和高度信息。

from ultralytics import YOLO

# Load a pre-trained YOLOv8 model
model = YOLO("yolov8n.pt")

# Specify the source image
source = "https://ultralytics.com/images/bus.jpg"

# Make predictions
results = model.predict(source, save=True, imgsz=320, conf=0.5)

# Extract bounding box dimensions
boxes = results[0].boxes.xywh.cpu()
for box in boxes:
    x, y, w, h = box
    print(f"Width of Box: {w}, Height of Box: {h}")

部署挑战

GPU 部署问题

问题： 在多 GPU 环境中部署模型有时会导致意外行为，例如意外的内存使用、GPU 之间结果不一致等问题。

解决方案： 检查默认 GPU 初始化。一些框架（如 PyTorch）可能会在过渡到指定的 GPU 之前在默认 GPU 上初始化 CUDA 操作。为了避免意外的默认初始化，部署和预测时直接指定 GPU，并使用工具实时监控 GPU 利用率和内存使用情况以识别任何异常。此外，请确保您使用的是框架或库的最新版本。

模型转换/导出问题

问题： 在将机器学习模型转换或导出到不同格式或平台的过程中，用户可能会遇到错误或意外行为。

解决方案：

  • 兼容性检查：确保您使用的库和框架版本彼此兼容。版本不匹配可能导致转换过程中出现意外错误。

  • 环境重置：如果您使用像 Jupyter 或 Colab 这样的交互式环境，在进行重要更改或安装后，请考虑重新启动环境。重新启动有时可以解决潜在的问题。

  • 官方文档：始终参考您用于转换的工具或库的官方文档。它通常包含模型导出的具体指南和最佳实践。

  • 社区支持：检查库或框架的官方代码库，查看其他用户报告的类似问题。维护者或社区可能已在讨论线程中提供了解决方案或解决方法。

  • 定期更新：确保您使用的是工具或库的最新版本。开发人员经常发布更新，修复已知问题或改进功能。

  • 逐步测试：在执行完整转换之前，请使用较小的模型或数据集测试流程，以尽早识别潜在问题。

社区和支持

与志同道合的社区互动可以显著增强您在使用 YOLOv8 方面的体验和成功。以下是您可能会发现有帮助的一些频道和资源。

获取帮助的论坛和频道

GitHub 问题： GitHub 上的 YOLOv8 代码库有一个问题标签页，您可以在这里提问、报告错误和建议新功能。社区和维护者在此处活跃，这是解决特定问题的好地方。

Ultralytics Discord 服务器： Ultralytics 拥有一个Discord 服务器，您可以在这里与其他用户和开发人员交流。

官方文档和资源

Ultralytics YOLOv8 文档： 官方文档提供了 YOLOv8 的全面概述，以及安装、使用和故障排除指南。

这些资源应为您的 YOLOv8 项目的故障排除和改进提供坚实的基础，同时与 YOLOv8 社区中的其他人联系。

结论

故障排除是任何开发过程中不可或缺的部分，具备正确的知识可以显著减少解决问题所需的时间和精力。本指南旨在解决 Ultralytics 生态系统中 YOLOv8 模型用户常见的挑战。通过理解和解决这些常见问题，您可以确保项目进展更加顺利，并在计算机视觉任务中取得更好的结果。

记住，Ultralytics 社区是一个宝贵的资源。与其他开发者和专家互动可以提供额外的见解和解决方案，这些可能未在标准文档中涵盖。始终保持学习、实验和分享经验，以贡献于社区的集体知识。

祝您顺利排除故障！

常见问题解答

如何解决 YOLOv8 的安装错误？

安装错误通常是由兼容性问题或缺少依赖项引起的。确保您使用的是 Python 3.8 或更新版本，并已安装 PyTorch 1.8 或更新版本。建议使用虚拟环境以避免冲突。若需逐步安装指南，请参阅我们的官方安装指南。如果遇到导入错误，请尝试进行新的安装或更新库至最新版本。

为什么我的 YOLOv8 模型在单个 GPU 上训练速度较慢？

使用单个 GPU 进行训练可能由于批量大小过大或内存不足而导致速度较慢。为加快训练速度，请使用多个 GPU。确保系统有多个可用的 GPU，并调整您的 .yaml 配置文件以指定 GPU 数量，例如 gpus: 4。相应增加批量大小，以充分利用 GPU 而不超过内存限制。示例命令：

model.train(data="/path/to/your/data.yaml", batch=32, multi_scale=True)

如何确保我的 YOLOv8 模型在 GPU 上训练？

如果在训练日志中 'device' 值显示为 'null'，通常意味着训练进程设置为自动使用可用的 GPU。若需显式分配特定的 GPU，请在您的 .yaml 配置文件中设置 'device' 值。例如：

device:  0

将训练过程设置为第一个 GPU。请使用 nvidia-smi 命令确认您的 CUDA 设置。

如何监视和跟踪我的 YOLOv8 模型的训练进度？

通过像TensorBoard、Comet和Ultralytics HUB这样的工具，可以高效地跟踪和可视化训练进度。这些工具允许您记录和可视化诸如损失、精度、召回率和 mAP 等指标。基于这些指标实施早停策略也有助于实现更好的训练结果。

YOLOv8 无法识别我的数据集格式时应该怎么办？

确保您的数据集和标签符合预期格式。验证注释准确且质量高。如果遇到任何问题，请参考数据收集和标注指南，了解最佳实践。如需更多特定数据集的指导，请查看文档中的数据集部分。

深入了解性能指标

原文：docs.ultralytics.com/guides/yolo-performance-metrics/

介绍

性能指标是评估目标检测模型准确性和效率的关键工具。它们揭示了模型在图像中有效识别和定位目标的能力。此外，它们有助于了解模型对假阳性和假阴性的处理方式。这些见解对于评估和提升模型性能至关重要。在本指南中，我们将探讨与 YOLOv8 相关的各种性能指标，它们的意义以及如何解读它们。

www.youtube.com/embed/q7LwPoM7tSQ

观看： Ultralytics YOLOv8 性能指标 | MAP, F1 分数, 精确率, IoU 和 准确性

目标检测指标

让我们首先讨论一些不仅对 YOLOv8 重要，而且在不同目标检测模型中广泛适用的指标。

  • 交并比（IoU）： IoU 是一种衡量预测边界框与真实边界框重叠的度量。它在评估目标定位准确性中起着基础性作用。

  • 平均精度（AP）： AP 计算精确率-召回率曲线下的面积，提供了一个单一值，概括了模型的精确率和召回率性能。

  • 平均精度均值（mAP）： mAP 扩展了 AP 的概念，通过计算多个目标类别的平均 AP 值，对多类目标检测场景中的模型性能进行全面评估是非常有用的。

  • 精确率和召回率： 精确率量化了所有正预测中真正例的比例，评估了模型避免假阳性的能力。另一方面，召回率计算了所有实际正例中真正例的比例，衡量了模型检测类别所有实例的能力。

  • F1 分数： F1 分数是精确率和召回率的调和平均值，提供了对模型性能的平衡评估，同时考虑了假阳性和假阴性。

如何计算 YOLOv8 模型的指标

现在，我们可以探索 YOLOv8 的验证模式，该模式可用于计算上述讨论的评估指标。

使用验证模式非常简单。一旦您有了训练好的模型，可以调用 model.val() 函数。该函数将处理验证数据集并返回多种性能指标。但是这些指标的含义是什么？以及如何解释它们？

解读输出

让我们分解模型的输出函数 model.val() 并理解输出的每个部分。

类别指标

输出的一个部分是对性能指标进行类别分解。这些细致的信息对于理解模型在每个特定类别上的表现非常有用，特别是在包含多种对象类别的数据集中。对于数据集中的每个类别，提供了以下信息:

  • 类别: 表示对象类别的名称，例如"人"、"车"或"狗"。

  • 图片: 这个指标告诉您验证集中包含该对象类别的图片数量。

  • 实例: 这提供了验证集中所有图片中出现该类别的次数。

  • Box(P, R, mAP50, mAP50-95): 这个指标提供了关于模型检测对象性能的见解。

    • P (精确率): 检测到的对象的准确性，指示多少检测结果是正确的。

    • R (召回率): 模型识别图片中所有对象实例的能力。

    • mAP50: 在 IoU 阈值为 0.50 时计算的平均平均精度。这是考虑仅“易”检测的模型准确性的度量。

    • mAP50-95: 在不同 IoU 阈值（从 0.50 到 0.95）下计算的平均平均精度的平均值，全面展示了模型在不同检测难度级别上的表现。

速度指标

推理速度与准确性同样重要，特别是在实时物体检测场景中。本节详细介绍了从预处理到后处理的验证过程各个阶段所需的时间。

COCO 指标评估

对于在 COCO 数据集上验证的用户，使用 COCO 评估脚本计算了额外的指标。这些指标可以揭示在不同 IoU 阈值和不同物体尺寸下的精确率和召回率。

视觉输出

除了生成数值指标外，model.val()函数还产生了可视化输出，可以更直观地理解模型的表现。以下是您可以期待的可视化输出的详细说明:

  • F1 分数曲线 (F1_curve.png): 这条曲线代表了在不同阈值下的 F1 分数。解读这条曲线可以提供关于模型在不同阈值下误报和漏报的平衡性。

  • 精确率-召回率曲线 (PR_curve.png): 对于任何分类问题来说，这条曲线展示了在不同阈值下精确率和召回率之间的权衡。在处理不平衡类别时尤为重要。

  • 精确率曲线 (P_curve.png): 在不同阈值下精确率值的图形表示。这条曲线有助于理解精确率随着阈值变化的情况。

  • 召回率曲线 (R_curve.png): 对应的图表展示了不同阈值下召回率的变化情况。

  • 混淆矩阵（confusion_matrix.png）：混淆矩阵提供了结果的详细视图，展示了每个类别的真正例、真负例、假正例和假负例的计数。

  • 标准化混淆矩阵（confusion_matrix_normalized.png）：这种可视化是混淆矩阵的标准化版本。它表示数据的比例而不是原始计数。这种格式使得跨类别比较性能更加简单。

  • 验证批次标签（val_batchX_labels.jpg）：这些图像展示了验证数据集中不同批次的地面真实标签。它们清晰展示了数据集中对象及其位置。

  • 验证批次预测（val_batchX_pred.jpg）：与标签图像对比，这些图像展示了 YOLOv8 模型对相应批次的预测结果。通过将其与标签图像进行比较，可以轻松评估模型在视觉上的检测和分类效果。

结果存储

为了以后参考，结果保存在通常命名为 runs/detect/val 的目录中。

选择正确的指标

选择正确的评估指标通常取决于具体的应用场景。

  • mAP：适用于模型性能的广泛评估。

  • IoU：当精确的对象位置至关重要时不可或缺。

  • 精确度（Precision）：当最小化误检测是首要任务时很重要。

  • 召回率：在重要检测每个对象实例时至关重要。

  • F1 分数：在需要精确度和召回率之间平衡时很有用。

对于实时应用程序，FPS（每秒帧数）和延迟等速度指标对于确保及时结果至关重要。

结果解释

理解指标很重要。以下是一些常见的较低分数可能暗示的内容：

  • 低 mAP：表明模型可能需要一般性改进。

  • 低 IoU：模型可能难以准确定位对象。不同的边界框方法可能有所帮助。

  • 低精确度：模型可能检测到太多不存在的对象。调整置信阈值可能会减少这种情况。

  • 低召回率：模型可能错过了真实对象。改善特征提取或使用更多数据可能有助于解决这个问题。

  • 不平衡 F1 分数：精确度和召回率之间存在差异。

  • 类别特定的 AP：在这里得分低可能突显出模型难以应对的类别。

案例研究

实际案例可以帮助澄清这些指标在实践中的工作原理。

案例 1

  • 情境：mAP 和 F1 分数不理想，但是回溯率良好，精确度不佳。

  • 解释与行动：可能存在过多的错误检测。调整置信阈值可以减少这些错误，尽管可能会略微降低召回率。

案例 2

  • 情境：mAP 和回溯率可接受，但 IoU 不足。

  • 解释与行动： 模型能够良好地检测对象，但可能无法精确定位它们。优化边界框预测可能会有所帮助。

案例 3

  • 情况： 一些类别的平均精度（AP）远低于其他类别，即使整体 mAP 也还不错。

  • 解释与行动： 这些类别可能对模型更具挑战性。在训练过程中使用更多的数据或调整类别权重可能会有所帮助。

连接和合作

利用爱好者和专家社区的力量，可以增强您与 YOLOv8 的旅程。以下是一些可以促进学习、故障排除和网络的途径。

与更广泛的社区互动

  • GitHub Issues： GitHub 上的 YOLOv8 代码库有一个问题标签，您可以在这里提问、报告错误和建议新功能。社区和维护者在这里积极参与，这是解决特定问题的好地方。

  • Ultralytics Discord 服务器： Ultralytics 拥有一个Discord 服务器，您可以在这里与其他用户和开发人员互动。

官方文档和资源：

  • Ultralytics YOLOv8 文档： 官方文档全面介绍了 YOLOv8，包括安装、使用和故障排除指南。

使用这些资源不仅将指导您克服任何挑战，还将使您了解 YOLOv8 社区中的最新趋势和最佳实践。

结论

在本指南中，我们深入探讨了 YOLOv8 的关键性能指标。这些指标对于了解模型的表现如何至关重要，对于那些希望对模型进行微调的人来说尤为重要。它们提供了改进所需的见解，并确保模型在实际场景中有效运行。

请记住，YOLOv8 和 Ultralytics 社区是一个宝贵的资产。与其他开发人员和专家互动可以为您带来标准文档中找不到的见解和解决方案。在探索目标检测的旅程中，保持学习的精神，尝试新策略并分享您的发现。通过这样做，您为社区的集体智慧做出了贡献，确保其不断发展。

祝您愉快地进行对象检测！

FAQ

评估 YOLOv8 模型性能的平均精度（mAP）在哪些方面具有重要意义？

平均精度（mAP）对于评估 YOLOv8 模型至关重要，因为它提供了一个单一的指标，涵盖了多类别的精确度和召回率。 mAP@0.50 以 IoU 阈值为 0.50 衡量精度，专注于模型正确检测对象的能力。 mAP@0.50:0.95 对多个 IoU 阈值的精确度进行平均，提供了对检测性能的全面评估。高 mAP 分数表明模型有效地平衡了精确度和召回率，在自动驾驶和监控等应用中至关重要。

如何解释 YOLOv8 对象检测中的 IoU 值？

交并比（IoU）测量预测边界框与真实边界框之间的重叠。IoU 值从 0 到 1，其中较高的值表示更好的定位精度。IoU 为 1.0 表示完美对齐。通常，mAP 等指标中使用 IoU 阈值为 0.50 来定义真阳性。较低的 IoU 值表明模型在精确对象定位方面存在困难，可以通过优化边界框回归或增加注释精度来改善。

为什么 F1 分数在评估 YOLOv8 模型在对象检测中的重要性？

F1 分数对评估 YOLOv8 模型至关重要，因为它提供精度和回溯的谐波均值，平衡假阳性和假阴性。在处理不平衡数据集或仅精度或仅回溯不足的应用程序时，它特别有价值。高 F1 分数表明模型在最小化漏检和误报的同时有效检测对象，适用于安全系统和医学成像等关键应用。

使用 Ultralytics YOLOv8 进行实时对象检测的关键优势是什么？

Ultralytics YOLOv8 为实时对象检测提供了多重优势：

  • 速度和效率：优化了高速推断，适用于需要低延迟的应用程序。

  • 高精度：先进的算法确保高 mAP 和 IoU 分数，平衡精度和回溯。

  • 灵活性：支持包括对象检测、分割和分类在内的各种任务。

  • 易用性：用户友好的界面、广泛的文档和与 Ultralytics HUB（HUB Quickstart）等平台的无缝集成。

这使得 YOLOv8 在从自动驾驶车辆到智能城市解决方案等多样的应用中都非常理想。

如何通过 YOLOv8 的验证指标提高模型性能？

从 YOLOv8 的验证指标如精度、回溯、mAP 和 IoU 中，通过提供对检测不同方面的洞察，帮助诊断和改进模型性能：

  • 精度：帮助识别和最小化假阳性。

  • 回溯：确保检测到所有相关对象。

  • mAP：提供总体性能快照，指导整体改进。

  • IoU：帮助优化对象定位精度。

通过分析这些指标，可以针对特定弱点进行调整，例如调整置信阈值以提高精度或收集更多多样化数据以增强回溯。有关这些指标及其解释的详细说明，请参阅对象检测指标。

使用 YOLO 模型进行线程安全推理

原文：docs.ultralytics.com/guides/yolo-thread-safe-inference/

在多线程环境中运行 YOLO 模型需要仔细考虑以确保线程安全。Python 的threading模块允许您同时运行多个线程，但在使用这些线程跨越 YOLO 模型时，有重要的安全问题需要注意。本页将指导您创建线程安全的 YOLO 模型推理。

理解 Python 线程

Python 线程是一种并行形式，允许程序同时运行多个操作。然而，Python 的全局解释器锁（GIL）意味着只有一个线程可以同时执行 Python 字节码。

单线程与多线程示例

尽管听起来像是一个限制，线程仍然可以提供并发性，特别是对于 I/O 绑定操作或使用释放 GIL 的操作，例如 YOLO 底层的 C 库操作。

共享模型实例的危险

在您的线程外部实例化 YOLO 模型并在多个线程之间共享此实例可能会导致竞争条件，其中模型的内部状态由于并发访问而不一致地修改。当模型或其组件持有不设计为线程安全的状态时，这尤为严重。

非线程安全示例：单个模型实例

当在 Python 中使用线程时，重要的是要识别可能导致并发问题的模式。以下是应该避免的情况：在多个线程之间共享单个 YOLO 模型实例。

# Unsafe: Sharing a single model instance across threads
from threading import Thread

from ultralytics import YOLO

# Instantiate the model outside the thread
shared_model = YOLO("yolov8n.pt")

def predict(image_path):
  """Predicts objects in an image using a preloaded YOLO model, take path string to image as argument."""
    results = shared_model.predict(image_path)
    # Process results

# Starting threads that share the same model instance
Thread(target=predict, args=("image1.jpg",)).start()
Thread(target=predict, args=("image2.jpg",)).start()

在上面的例子中，shared_model被多个线程使用，这可能导致不可预测的结果，因为predict可能会被多个线程同时执行。

非线程安全示例：多个模型实例

同样，这里是一个不安全的模式，涉及多个 YOLO 模型实例：

# Unsafe: Sharing multiple model instances across threads can still lead to issues
from threading import Thread

from ultralytics import YOLO

# Instantiate multiple models outside the thread
shared_model_1 = YOLO("yolov8n_1.pt")
shared_model_2 = YOLO("yolov8n_2.pt")

def predict(model, image_path):
  """Runs prediction on an image using a specified YOLO model, returning the results."""
    results = model.predict(image_path)
    # Process results

# Starting threads with individual model instances
Thread(target=predict, args=(shared_model_1, "image1.jpg")).start()
Thread(target=predict, args=(shared_model_2, "image2.jpg")).start()

即使有两个单独的模型实例，仍然存在并发问题的风险。如果YOLO的内部实现不是线程安全的，使用单独的实例可能无法防止竞争条件，特别是如果这些实例共享任何非线程本地的底层资源或状态。

线程安全推理

要执行线程安全推理，您应该在每个线程内部实例化一个单独的 YOLO 模型。这确保每个线程都有自己的隔离模型实例，消除竞争条件的风险。

线程安全示例

这是如何在每个线程内部实例化 YOLO 模型以进行安全并行推理的方法：

# Safe: Instantiating a single model inside each thread
from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(image_path):
  """Predict on an image using a new YOLO model instance in a thread-safe manner; takes image path as input."""
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results

# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

在这个例子中，每个线程创建自己的YOLO实例。这可以防止任何线程干扰另一个模型状态，从而确保每个线程安全地执行推理，而不会与其他线程发生意外交互。

结论

在使用 Python 的threading时，始终在将使用模型的线程内实例化模型，以确保线程安全。这种做法可以避免竞态条件，并确保推理任务可靠运行。

对于更高级的场景和进一步优化多线程推理性能，考虑使用基于进程的并行化multiprocessing或者利用任务队列和专用工作进程。

常见问题解答

如何在多线程 Python 环境中使用 YOLO 模型避免竞态条件？

为了在多线程 Python 环境中使用 Ultralytics YOLO 模型时避免竞态条件，应在每个线程内实例化一个独立的 YOLO 模型。这确保每个线程有其自己的隔离模型实例，避免对模型状态的并发修改。

示例：

from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(image_path):
  """Predict on an image in a thread-safe manner."""
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results

Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

欲了解更多关于确保线程安全的信息，请访问“使用 YOLO 模型进行线程安全推理”的章节。

在 Python 中运行多线程 YOLO 模型推理的最佳实践是什么？

要安全地在 Python 中运行多线程 YOLO 模型推理，请遵循以下最佳实践：

  1. 在每个线程内实例化 YOLO 模型，而不是在多个线程之间共享单个模型实例。

  2. 使用 Python 的multiprocessing模块进行并行处理以避免与全局解释器锁（GIL）相关的问题。

  3. 通过使用 YOLO 底层 C 库执行的操作释放 GIL。

线程安全模型实例化示例：

from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(image_path):
  """Runs inference in a thread-safe manner with a new YOLO model instance."""
    model = YOLO("yolov8n.pt")
    results = model.predict(image_path)
    # Process results

# Initiate multiple threads
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

欲了解更多背景，请参阅“线程安全推理”部分。

为什么每个线程应该有自己的 YOLO 模型实例？

每个线程应该有自己的 YOLO 模型实例以避免竞态条件。当多个线程共享单个模型实例时，同时访问可能导致不可预测的行为和对模型内部状态的修改。通过使用独立实例，确保线程隔离，使得多线程任务可靠和安全。

欲了解详细指南，请查看“非线程安全示例：单一模型实例和线程安全示例”部分。

Python 的全局解释器锁（GIL）如何影响 YOLO 模型推理？

Python 的全局解释器锁（GIL）每次只允许一个线程执行 Python 字节码，这可能限制 CPU 绑定的多线程任务的性能。然而，对于 I/O 绑定的操作或使用释放 GIL 的库（如 YOLO 的 C 库）的进程，仍然可以实现并发性。为了提高性能，考虑使用 Python 的multiprocessing模块进行基于进程的并行化。

想了解 Python 中线程的更多信息，请参阅“理解 Python 线程”部分。

在 YOLO 模型推理中，使用基于进程的并行化是否比使用线程更安全？

是的，使用 Python 的 multiprocessing 模块在并行运行 YOLO 模型推理时更安全且通常更高效。基于进程的并行处理创建了独立的内存空间，避免了全局解释器锁（GIL）并减少并发问题的风险。每个进程将独立运行其自己的 YOLO 模型实例。

关于使用 YOLO 模型的基于进程的并行处理的详细信息，请参阅线程安全推理页面。

理解 YOLOv8 的部署选项

原文：docs.ultralytics.com/guides/model-deployment-options/

介绍

在您的 YOLOv8 之旅中走过了很长的一段路。您勤奋地收集数据，细致地标注它，并花费时间训练和严格评估您的定制 YOLOv8 模型。现在，是时候将您的模型应用于您特定的应用、用例或项目了。但在您面前有一个关键决策：如何有效地导出和部署您的模型。

本指南将带您了解 YOLOv8 的部署选项以及选择适合您项目的正确选项所需考虑的关键因素。

如何为您的 YOLOv8 模型选择合适的部署选项

当需要部署您的 YOLOv8 模型时，选择合适的导出格式非常重要。如 Ultralytics YOLOv8 Modes 文档中所述，model.export() 函数可将训练好的模型转换为多种格式，以满足不同环境和性能要求。

理想的格式取决于您模型的预期操作环境，平衡速度、硬件限制和集成的便利性。在接下来的部分中，我们将详细查看每个导出选项，了解何时选择每个选项。

YOLOv8 的部署选项

让我们详细了解不同的 YOLOv8 部署选项。有关导出过程的详细步骤，请访问 Ultralytics 的导出文档页面。

PyTorch

PyTorch 是一个广泛用于深度学习和人工智能应用的开源机器学习库。它提供了高度的灵活性和速度，使其成为研究人员和开发人员喜爱的选择。

  • 性能基准：PyTorch 因其易用性和灵活性而闻名，与其他更专业和优化的框架相比，可能会稍微牺牲一些原始性能。

  • 兼容性和集成：与 Python 中各种数据科学和机器学习库具有良好的兼容性。

  • 社区支持和生态系统：拥有最活跃的社区之一，提供丰富的学习和故障排除资源。

  • 案例研究：在研究原型中常用，许多学术论文引用在 PyTorch 中部署的模型。

  • 维护和更新：定期更新，积极开发并支持新功能。

  • 安全性考虑：定期修补安全问题，但安全性在很大程度上取决于部署环境的整体情况。

  • 硬件加速：支持 CUDA 进行 GPU 加速，对于加速模型训练和推断至关重要。

TorchScript

TorchScript 通过允许将模型导出到 C++ 运行时环境来扩展 PyTorch 的能力。这使其适用于 Python 不可用的生产环境。

  • 性能基准测试：在生产环境中，可以比原生 PyTorch 提供更好的性能。

  • 兼容性和集成：设计用于从 PyTorch 无缝过渡到 C++生产环境，尽管一些高级功能可能无法完美转换。

  • 社区支持和生态系统：受益于 PyTorch 庞大的社区，但专业开发者范围较窄。

  • 案例研究：广泛用于产业设置中，Python 的性能开销是一个瓶颈。

  • 维护和更新：与 PyTorch 并行维护，并保持持续更新。

  • 安全考虑：通过允许在没有完整 Python 安装的环境中运行模型，提供了改进的安全性。

  • 硬件加速：继承了 PyTorch 的 CUDA 支持，确保了有效的 GPU 利用率。

ONNX

开放神经网络交换（ONNX）是一种允许模型在不同框架之间互操作的格式，在部署到各种平台时尤为关键。

  • 性能基准测试：ONNX 模型在特定运行时上的性能可能有所不同。

  • 兼容性和集成：由于其与框架无关的特性，高度支持多平台和硬件的互操作性。

  • 社区支持和生态系统：得到许多组织的支持，导致一个广泛的生态系统，并提供多种优化工具。

  • 案例研究：经常用于在不同机器学习框架之间转移模型，展示了其灵活性。

  • 维护和更新：作为一个开放标准，ONNX 定期更新以支持新的操作和模型。

  • 安全考虑：与任何跨平台工具一样，确保在转换和部署流程中采用安全实践至关重要。

  • 硬件加速：使用 ONNX Runtime，模型可以利用各种硬件优化。

OpenVINO

OpenVINO 是 Intel 工具包，旨在促进在 Intel 硬件上部署深度学习模型，提升性能和速度。

  • 性能基准测试：专为 Intel CPU、GPU 和 VPU 优化，可在兼容硬件上显著提升性能。

  • 兼容性和集成：在 Intel 生态系统内表现最佳，但也支持一系列其他平台。

  • 社区支持和生态系统：由 Intel 支持，尤其在计算机视觉领域拥有坚实的用户群体。

  • 案例研究：通常在物联网和边缘计算场景中使用，其中 Intel 硬件占据主导地位。

  • 维护和更新：Intel 定期更新 OpenVINO，以支持最新的深度学习模型和 Intel 硬件。

  • 安全考虑：提供强大的安全功能，适合在敏感应用中部署。

  • 硬件加速：专为在 Intel 硬件上加速而设计，利用专门的指令集和硬件功能。

若要了解更多关于使用 OpenVINO 进行部署的详细信息，请参阅 Ultralytics Integration documentation: Intel OpenVINO Export。

TensorRT

TensorRT 是 NVIDIA 提供的高性能深度学习推理优化器和运行时，非常适合需要速度和效率的应用。

  • 性能基准测试：在 NVIDIA GPU 上提供顶级性能，支持高速推理。

  • 兼容性和集成：最适合 NVIDIA 硬件，对于这个环境之外的支持有限。

  • 社区支持和生态系统：通过 NVIDIA 的开发者论坛和文档提供强大的支持网络。

  • 案例研究：在需要对视频和图像数据进行实时推理的行业中广泛采用。

  • 维护和更新：NVIDIA 定期维护 TensorRT，以增强性能并支持新的 GPU 架构。

  • 安全考虑：像许多 NVIDIA 产品一样，它非常重视安全性，但具体情况取决于部署环境。

  • 硬件加速：专为 NVIDIA GPU 设计，提供深度优化和加速。

CoreML

CoreML 是苹果的机器学习框架，专为 iOS、macOS、watchOS 和 tvOS 等 Apple 生态系统的设备性能优化。

  • 性能基准测试：在 Apple 硬件上优化设备性能，电池使用率最小化。

  • 兼容性和集成：专为 Apple 生态系统设计，为 iOS 和 macOS 应用提供流畅的工作流程。

  • 社区支持和生态系统：得到 Apple 和专门开发者社区的大力支持，具备广泛的文档和工具。

  • 案例研究：在需要 Apple 产品上设备内机器学习能力的应用中广泛使用。

  • 维护和更新：由 Apple 定期更新，以支持最新的机器学习进展和 Apple 硬件。

  • 安全考虑：受益于 Apple 对用户隐私和数据安全的关注。

  • 硬件加速：充分利用 Apple 的神经引擎和 GPU，加速机器学习任务。

TF SavedModel

TF SavedModel 是 TensorFlow 用于保存和提供机器学习模型的格式，特别适用于可扩展的服务器环境。

  • 性能基准测试：在服务器环境中提供可扩展的性能，特别是与 TensorFlow Serving 一起使用时。

  • 兼容性和集成：在 TensorFlow 生态系统内具有广泛的兼容性，包括云和企业服务器部署。

  • 社区支持和生态系统：由于 TensorFlow 的流行，拥有庞大的社区支持，提供大量用于部署和优化的工具。

  • 案例研究：在生产环境中广泛应用，用于大规模提供深度学习模型。

  • 维护和更新：由 Google 和 TensorFlow 社区支持，确保定期更新和新功能。

  • 安全考虑：使用 TensorFlow Serving 部署时，包含了面向企业级应用的强大安全功能。

  • 硬件加速：通过 TensorFlow 后端支持各种硬件加速。

TF GraphDef

TF GraphDef 是一种表示模型为图的 TensorFlow 格式，对于需要静态计算图的环境非常有益。

  • 性能基准测试：提供静态计算图的稳定性能，侧重于一致性和可靠性。

  • 兼容性和集成：在 TensorFlow 基础架构内易于集成，但与 SavedModel 相比不够灵活。

  • 社区支持和生态系统：TensorFlow 生态系统的良好支持，提供许多用于优化静态图的资源。

  • 案例研究：在需要静态图的场景中非常有用，例如某些嵌入式系统。

  • 维护和更新：与 TensorFlow 核心更新一起定期更新。

  • 安全考虑：确保使用 TensorFlow 已建立的安全实践进行安全部署。

  • 硬件加速：可以利用 TensorFlow 的硬件加速选项，尽管不如 SavedModel 灵活。

TF Lite

TF Lite 是 TensorFlow 针对移动和嵌入式设备的解决方案，提供轻量级库进行设备端推理。

  • 性能基准测试：专为移动和嵌入式设备的速度和效率设计。

  • 兼容性和集成：由于其轻量化特性，可在广泛设备上使用。

  • 社区支持和生态系统：由 Google 支持，拥有强大的社区和越来越多的开发者资源。

  • 案例研究：在需要在设备上推理并保持最小占用空间的移动应用中流行。

  • 维护和更新：定期更新，包括最新功能和优化，适用于移动设备。

  • 安全考虑：为在终端用户设备上运行模型提供安全环境。

  • 硬件加速：支持包括 GPU 和 DSP 在内的多种硬件加速选项。

TF Edge TPU

TF Edge TPU 专为在 Google Edge TPU 硬件上进行高速、高效计算设计，非常适合需要实时处理的物联网设备。

  • 性能基准测试：专门针对 Google Edge TPU 硬件的高速、高效计算进行优化。

  • 兼容性和集成：仅在 Edge TPU 设备上与 TensorFlow Lite 模型配合使用。

  • 社区支持和生态系统：得到 Google 和第三方开发者提供的资源支持的增长。

  • 案例研究：用于物联网设备和需要低延迟实时处理的应用。

  • 维护和更新：持续改进以利用新的 Edge TPU 硬件发布的能力。

  • 安全考虑：与 Google 为物联网和边缘设备提供的强大安全集成。

  • 硬件加速：定制设计以充分利用 Google Coral 设备的性能。

TF.js

TensorFlow.js（TF.js）是一个库，将机器学习能力直接带到浏览器中，为 web 开发者和用户提供了新的可能性。它允许在 web 应用中集成机器学习模型，无需后端基础设施支持。

  • 性能基准：可以依据客户端设备的性能，在浏览器中直接实现机器学习。

  • 兼容性和集成：与 web 技术高度兼容，易于集成到 web 应用中。

  • 社区支持和生态系统：得到 web 和 Node.js 开发者社区的支持，提供多种部署 ML 模型的工具。

  • 案例研究：适合需要客户端机器学习支持的交互式 web 应用，无需服务器端处理。

  • 维护和更新：由 TensorFlow 团队维护，并得到开源社区的贡献。

  • 安全考虑：在浏览器的安全环境中运行，利用 web 平台的安全模型。

  • 硬件加速：通过访问像 WebGL 这样的 web API，可增强性能。

PaddlePaddle

PaddlePaddle 是百度开发的开源深度学习框架。它旨在为研究人员提供高效的同时，也为开发者提供易用性。在中国特别受欢迎，并且提供专门支持中文语言处理。

  • 性能基准：提供竞争性能，注重易用性和可扩展性。

  • 兼容性和集成：在百度生态系统内良好集成，并支持广泛的应用场景。

  • 社区支持和生态系统：虽然全球社区规模较小，但在中国特别是快速增长。

  • 案例研究：在中国市场普遍使用，并受开发者青睐，作为其他主要框架的替代选择。

  • 维护和更新：定期更新，专注于服务于中文语言的 AI 应用和服务。

  • 安全考虑：注重数据隐私和安全，符合中国的数据治理标准。

  • 硬件加速：支持包括百度鲲鹏芯片在内的各种硬件加速。

NCNN

NCNN 是一个专为移动平台优化的高性能神经网络推断框架。它因其轻量和高效而脱颖而出，特别适用于资源有限的移动和嵌入式设备。

  • 性能基准：针对移动平台高度优化，能在基于 ARM 的设备上提供高效的推断。

  • 兼容性和集成：适用于基于 ARM 架构的手机和嵌入式系统应用。

  • 社区支持和生态系统：得到专注于移动和嵌入式 ML 应用的小众但活跃的社区支持。

  • 案例研究：适用于移动应用，特别是在 Android 和其他基于 ARM 的系统上，效率和速度至关重要。

  • 维护和更新：持续改进，以保持在各种 ARM 设备上的高性能。

  • 安全考虑：侧重于在设备上本地运行，利用设备处理的固有安全性。

  • 硬件加速：专为 ARM CPU 和 GPU 定制，针对这些架构进行了特定的优化。

YOLOv8 部署选项的比较分析

以下表格展示了 YOLOv8 模型的各种部署选项，帮助您根据几个关键标准评估哪种最适合您的项目需求。要深入了解每种部署选项的格式，请查看 Ultralytics 的文档页面上的导出格式。

部署选项 性能基准 兼容性和集成 社区支持和生态系统 案例研究 维护和更新 安全考虑 硬件加速
PyTorch 灵活性强；可能会在原始性能上做出一些让步 与 Python 库兼容性优秀 广泛的资源和社区支持 研究和原型开发 持续、活跃的开发 取决于部署环境 支持 CUDA 进行 GPU 加速
TorchScript 用于生产比 PyTorch 更好 从 PyTorch 迁移到 C++ 更加顺畅 比 PyTorch 更专业但范围较窄 在 Python 是瓶颈的行业 与 PyTorch 一致的更新 在没有完整 Python 的情况下提高安全性 继承自 PyTorch 的 CUDA 支持
ONNX 取决于运行时变量 在不同框架中表现良好 广泛的生态系统，得到许多组织的支持 在 ML 框架中具有灵活性 定期更新以支持新操作 确保安全的转换和部署实践 各种硬件优化
OpenVINO 优化于 Intel 硬件 在 Intel 生态系统内表现最佳 在计算机视觉领域具有坚实基础 IoT 和边缘计算中的 Intel 硬件 针对 Intel 硬件的定期更新 针对敏感应用提供强大的功能 专为 Intel 硬件定制
TensorRT 在 NVIDIA GPU 上处于顶尖水平 最适合 NVIDIA 硬件 通过 NVIDIA 形成强大的网络 实时视频和图像推理 针对新 GPU 的频繁更新 重视安全性 设计用于 NVIDIA GPU
CoreML 优化用于设备上的 Apple 硬件 专属于 Apple 生态系统 强大的 Apple 和开发者支持 在 Apple 产品上的设备 ML Apple 定期更新 专注于隐私和安全 Apple 神经引擎和 GPU
TF SavedModel 在服务器环境中可扩展 TensorFlow 生态系统中广泛兼容 由于 TensorFlow 的流行性得到大量支持 大规模服务模型 谷歌和社区的定期更新 企业级强大功能 各种硬件加速选项
TF GraphDef 适用于静态计算图的稳定性 与 TensorFlow 基础设施良好集成 用于优化静态图的资源 需要静态图的场景 与 TensorFlow 核心同时更新 已建立的 TensorFlow 安全实践 TensorFlow 加速选项
TF Lite 在移动/嵌入式设备上的速度和效率 广泛的设备支持 强大的社区，由 Google 支持 在端用户设备上的安全环境 移动应用程序的最新功能 GPU 和 DSP 等多种硬件加速
TF Edge TPU 针对谷歌 Edge TPU 硬件优化 专为 Edge TPU 设备独家设计 与谷歌及第三方资源一起增长 需要实时处理的 IoT 设备 为新的 Edge TPU 硬件进行改进 谷歌强大的 IoT 安全性 专为谷歌 Coral 定制设计
TF.js 在浏览器中表现合理 与 Web 技术高度集成 支持 Web 和 Node.js 开发者 交互式 Web 应用程序 TensorFlow 团队和社区的贡献 Web 平台安全模型 通过 WebGL 和其他 API 增强
PaddlePaddle 具有竞争力、易于使用和可扩展性 百度生态系统，广泛的应用支持 快速增长，特别是在中国 中文市场和语言处理 专注于中国人工智能应用 强调数据隐私和安全性 包括百度的昆仑芯片
NCNN 针对移动基于 ARM 设备进行优化 移动和嵌入式 ARM 系统 小众但活跃的移动/嵌入式 ML 社区 Android 和 ARM 系统的效率 在 ARM 上的高性能维护 设备上的安全优势 ARM CPU 和 GPU 的优化

这份比较分析为您提供了高层次的概述。在部署时，重要的是考虑您项目的具体要求和限制，并参考每个选项的详细文档和资源。

社区与支持

当您开始使用 YOLOv8 时，拥有一个乐于助人的社区和支持可以产生重要影响。以下是如何与分享您兴趣的其他人联系并获取所需帮助的方法。

与更广泛的社区互动

  • GitHub 讨论： GitHub 上的 YOLOv8 仓库有一个 "讨论" 部分，您可以在此提问、报告问题和建议改进。

  • Ultralytics Discord 服务器： Ultralytics 拥有一个 Discord 服务器，您可以在此与其他用户和开发者交流。

官方文档和资源

  • Ultralytics YOLOv8 文档： 官方文档提供了 YOLOv8 的全面概述，以及有关安装、使用和故障排除的指南。

这些资源将帮助您解决挑战，并保持对 YOLOv8 社区最新趋势和最佳实践的更新。

结论

在本指南中，我们探讨了 YOLOv8 的不同部署选项。我们还讨论了在做出选择时需要考虑的重要因素。这些选项允许您根据不同的环境和性能要求定制您的模型，使其适用于实际应用。

不要忘记，YOLOv8 和 Ultralytics 社区是帮助的宝贵来源。与其他开发人员和专家联系，学习您在常规文档中找不到的独特技巧和解决方案。继续追求知识，探索新思路，并分享您的经验。

部署愉快！

常见问题解答

YOLOv8 在不同硬件平台上的部署选项有哪些？

Ultralytics YOLOv8 支持各种部署格式，每种都针对特定的环境和硬件平台设计。关键格式包括：

  • PyTorch 用于研究和原型设计，具有优秀的 Python 集成。

  • TorchScript 用于在 Python 不可用的生产环境中。

  • ONNX 用于跨平台兼容性和硬件加速。

  • OpenVINO 用于在 Intel 硬件上优化性能。

  • TensorRT 用于在 NVIDIA GPU 上进行高速推断。

每种格式都有独特的优势。详细步骤请参阅我们的导出过程文档。

如何提高在 Intel CPU 上的 YOLOv8 模型推断速度？

要提高在 Intel CPU 上的推断速度，可以使用 Intel 的 OpenVINO 工具包部署 YOLOv8 模型。OpenVINO 通过优化模型以高效利用 Intel 硬件，显著提升性能。

  1. 使用model.export()函数将您的 YOLOv8 模型转换为 OpenVINO 格式。

  2. 在 Intel OpenVINO 导出文档中，按照详细的设置指南进行设置。

获得更多见解，请查看我们的博客文章。

我能在移动设备上部署 YOLOv8 模型吗？

是的，YOLOv8 模型可以使用 TensorFlow Lite（TF Lite）在 Android 和 iOS 平台上的移动设备上进行部署。TF Lite 专为移动和嵌入式设备设计，提供高效的设备端推断能力。

示例

# Export command for TFLite format
model.export(format="tflite") 

# CLI command for TFLite export
yolo  export  --format  tflite

有关在移动设备上部署模型的详细信息，请参阅我们的 TF Lite 集成指南。

选择 YOLOv8 模型部署格式时应考虑哪些因素？

在选择 YOLOv8 部署格式时，需要考虑以下因素：

  • 性能：像 TensorRT 这样的格式在 NVIDIA GPU 上提供卓越的速度，而 OpenVINO 则针对 Intel 硬件进行了优化。

  • 兼容性：ONNX 在不同平台上具有广泛的兼容性。

  • 集成便捷性：像 CoreML 或 TF Lite 这样的格式专为 iOS 和 Android 等特定生态系统量身定制。

  • 社区支持：像 PyTorch 和 TensorFlow 这样的格式拥有丰富的社区资源和支持。

要进行比较分析，请参阅我们的导出格式文档。

如何在 Web 应用程序中部署 YOLOv8 模型？

要在 Web 应用程序中部署 YOLOv8 模型，您可以使用 TensorFlow.js（TF.js），它允许在浏览器中直接运行机器学习模型。这种方法消除了后端基础设施的需求，并提供实时性能。

  1. 将 YOLOv8 模型导出到 TF.js 格式。

  2. 将导出的模型集成到您的 Web 应用程序中。

对于逐步说明，请参阅我们关于 TensorFlow.js 集成的指南。

使用 Ultralytics 进行 K 折交叉验证

原文：docs.ultralytics.com/guides/kfold-cross-validation/

介绍

这份全面的指南演示了在 Ultralytics 生态系统内实施物体检测数据集的 K 折交叉验证的过程。我们将利用 YOLO 检测格式和关键的 Python 库（如 sklearn、pandas 和 PyYaml）来指导您完成必要的设置，生成特征向量以及执行 K 折数据集拆分的过程。

K 折交叉验证概述

无论您的项目涉及 Fruit Detection 数据集还是自定义数据源，本教程旨在帮助您理解并应用 K 折交叉验证来增强机器学习模型的可靠性和健壮性。虽然本教程中应用了k=5折，但请注意，最优折数可能因您的数据集和项目的特定情况而异。

言归正传，让我们开始吧！

设置

  • 您的标注应采用 YOLO 检测格式。

  • 本指南假定注释文件已在本地可用。

  • 我们使用的是Fruit Detection数据集进行演示。

    • 该数据集共包含 8479 张图像。

    • 它包含 6 个类别标签，每个标签的总实例数如下所示。

类别标签 实例计数
苹果 7049
葡萄 7202
菠萝 1613
橙子 15549
香蕉 3536
西瓜 1976

  • 必要的 Python 包括：

    • ultralytics

    • sklearn

    • pandas

    • pyyaml

  • 本教程使用k=5折。但是，您应确定适合您特定数据集的最佳折数。

  • 为项目初始化一个新的 Python 虚拟环境（venv）并激活它。使用pip（或您偏好的包管理器）安装：

    • Ultralytics 库：pip install -U ultralytics。或者，您可以克隆官方repo。

    • Scikit-learn、pandas 和 PyYAML：pip install -U scikit-learn pandas pyyaml。

  • 确保您的标注采用 YOLO 检测格式。

    • 对于本教程，所有的标注文件都位于Fruit-Detection/labels目录中。

生成物体检测数据集的特征向量

  1. 首先，创建一个名为example.py的新 Python 文件，进行以下步骤。

  2. 继续检索数据集的所有标签文件。

    from pathlib import Path

dataset_path = Path("./Fruit-detection")  # replace with 'path/to/dataset' for your custom data
labels = sorted(dataset_path.rglob("*labels/*.txt"))  # all data in 'labels'

  3. 现在，读取数据集的 YAML 文件内容，并提取类别标签的索引。

    yaml_file = "path/to/data.yaml"  # your data YAML with data directories and names dictionary
with open(yaml_file, "r", encoding="utf8") as y:
    classes = yaml.safe_load(y)["names"]
cls_idx = sorted(classes.keys())

  4. 初始化一个空的pandas DataFrame。

    import pandas as pd

indx = [l.stem for l in labels]  # uses base filename as ID (no extension)
labels_df = pd.DataFrame([], columns=cls_idx, index=indx)

  5. 统计每个类别标签在标注文件中的实例数。

    from collections import Counter

for label in labels:
    lbl_counter = Counter()

    with open(label, "r") as lf:
        lines = lf.readlines()

    for l in lines:
        # classes for YOLO label uses integer at first position of each line
        lbl_counter[int(l.split(" ")[0])] += 1

    labels_df.loc[label.stem] = lbl_counter

labels_df = labels_df.fillna(0.0)  # replace `nan` values with `0.0`

  6. 下面是填充的 DataFrame 的示例视图：

     0    1    2    3    4    5
'0000a16e4b057580_jpg.rf.00ab48988370f64f5ca8ea4...'  0.0  0.0  0.0  0.0  0.0  7.0
'0000a16e4b057580_jpg.rf.7e6dce029fb67f01eb19aa7...'  0.0  0.0  0.0  0.0  0.0  7.0
'0000a16e4b057580_jpg.rf.bc4d31cdcbe229dd022957a...'  0.0  0.0  0.0  0.0  0.0  7.0
'00020ebf74c4881c_jpg.rf.508192a0a97aa6c4a3b6882...'  0.0  0.0  0.0  1.0  0.0  0.0
'00020ebf74c4881c_jpg.rf.5af192a2254c8ecc4188a25...'  0.0  0.0  0.0  1.0  0.0  0.0
 ...                                                  ...  ...  ...  ...  ...  ...
'ff4cd45896de38be_jpg.rf.c4b5e967ca10c7ced3b9e97...'  0.0  0.0  0.0  0.0  0.0  2.0
'ff4cd45896de38be_jpg.rf.ea4c1d37d2884b3e3cbce08...'  0.0  0.0  0.0  0.0  0.0  2.0
'ff5fd9c3c624b7dc_jpg.rf.bb519feaa36fc4bf630a033...'  1.0  0.0  0.0  0.0  0.0  0.0
'ff5fd9c3c624b7dc_jpg.rf.f0751c9c3aa4519ea3c9d6a...'  1.0  0.0  0.0  0.0  0.0  0.0
'fffe28b31f2a70d4_jpg.rf.7ea16bd637ba0711c53b540...'  0.0  6.0  0.0  0.0  0.0  0.0

行索引标签文件，每个文件对应数据集中的一个图像，列对应类别标签索引。每行代表一个伪特征向量，其中包含数据集中每个类别标签的计数。这种数据结构使得可以将 K 折交叉验证应用于目标检测数据集。

K 折数据集分割

  1. 现在，我们将使用sklearn.model_selection中的KFold类来生成数据集的k个分割。

    • 重要：

      • 设置shuffle=True可确保在分割中类别的随机分布。

      • 通过设置random_state=M，其中M是选择的整数，可以获得可重复的结果。

    from sklearn.model_selection import KFold

ksplit = 5
kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)  # setting random_state for repeatable results

kfolds = list(kf.split(labels_df))

  2. 数据集现已分为k折，每折都有一个train和val索引列表。我们将构建一个数据框架来更清楚地显示这些结果。

    folds = [f"split_{n}" for n in range(1, ksplit + 1)]
folds_df = pd.DataFrame(index=indx, columns=folds)

for idx, (train, val) in enumerate(kfolds, start=1):
    folds_df[f"split_{idx}"].loc[labels_df.iloc[train].index] = "train"
    folds_df[f"split_{idx}"].loc[labels_df.iloc[val].index] = "val"

  3. 现在，我们将计算每个折中val中类别标签与train中类别标签的分布比率。

    fold_lbl_distrb = pd.DataFrame(index=folds, columns=cls_idx)

for n, (train_indices, val_indices) in enumerate(kfolds, start=1):
    train_totals = labels_df.iloc[train_indices].sum()
    val_totals = labels_df.iloc[val_indices].sum()

    # To avoid division by zero, we add a small value (1E-7) to the denominator
    ratio = val_totals / (train_totals + 1e-7)
    fold_lbl_distrb.loc[f"split_{n}"] = ratio

    理想情况是每个分割中所有类别的比例都相对均衡，并且跨类别也相似。然而，这将取决于您数据集的具体情况。

  4. 接下来，我们为每个分割创建目录和数据集 YAML 文件。

    import datetime

supported_extensions = [".jpg", ".jpeg", ".png"]

# Initialize an empty list to store image file paths
images = []

# Loop through supported extensions and gather image files
for ext in supported_extensions:
    images.extend(sorted((dataset_path / "images").rglob(f"*{ext}")))

# Create the necessary directories and dataset YAML files (unchanged)
save_path = Path(dataset_path / f"{datetime.date.today().isoformat()}_{ksplit}-Fold_Cross-val")
save_path.mkdir(parents=True, exist_ok=True)
ds_yamls = []

for split in folds_df.columns:
    # Create directories
    split_dir = save_path / split
    split_dir.mkdir(parents=True, exist_ok=True)
    (split_dir / "train" / "images").mkdir(parents=True, exist_ok=True)
    (split_dir / "train" / "labels").mkdir(parents=True, exist_ok=True)
    (split_dir / "val" / "images").mkdir(parents=True, exist_ok=True)
    (split_dir / "val" / "labels").mkdir(parents=True, exist_ok=True)

    # Create dataset YAML files
    dataset_yaml = split_dir / f"{split}_dataset.yaml"
    ds_yamls.append(dataset_yaml)

    with open(dataset_yaml, "w") as ds_y:
        yaml.safe_dump(
            {
                "path": split_dir.as_posix(),
                "train": "train",
                "val": "val",
                "names": classes,
            },
            ds_y,
        )

  5. 最后，将图像和标签复制到相应的目录（'train'或'val'）中的每个分割。

    • 注意： 此部分代码所需的时间取决于数据集的大小和系统硬件。
    import shutil

for image, label in zip(images, labels):
    for split, k_split in folds_df.loc[image.stem].items():
        # Destination directory
        img_to_path = save_path / split / k_split / "images"
        lbl_to_path = save_path / split / k_split / "labels"

        # Copy image and label files to new directory (SamefileError if file already exists)
        shutil.copy(image, img_to_path / image.name)
        shutil.copy(label, lbl_to_path / label.name)

保存记录（可选）

可选地，您可以将 K 折分割和标签分布数据框架的记录保存为 CSV 文件以供将来参考。

folds_df.to_csv(save_path / "kfold_datasplit.csv")
fold_lbl_distrb.to_csv(save_path / "kfold_label_distribution.csv")

使用 K 折数据分割训练 YOLO

  1. 首先，加载 YOLO 模型。

    from ultralytics import YOLO

weights_path = "path/to/weights.pt"
model = YOLO(weights_path, task="detect")

  2. 接下来，迭代数据集 YAML 文件以运行训练。结果将保存到由project和name参数指定的目录中。默认情况下，该目录为 'exp/runs#'，其中#是整数索引。

    results = {}

# Define your additional arguments here
batch = 16
project = "kfold_demo"
epochs = 100

for k in range(ksplit):
    dataset_yaml = ds_yamls[k]
    model.train(data=dataset_yaml, epochs=epochs, batch=batch, project=project)  # include any train arguments
    results[k] = model.metrics  # save output metrics for further analysis

结论

在本指南中，我们探讨了如何使用 K 折交叉验证来训练 YOLO 目标检测模型的过程。我们学习了如何将数据集分割成 K 个分区，确保在不同分区之间有平衡的类分布。

我们还探讨了创建报告数据框架的过程，以可视化数据分割和标签分布，为我们提供了对训练和验证集结构的清晰洞察。

可选地，我们保存了我们的记录以供将来参考，在大型项目或解决模型性能问题时尤其有用。

最后，我们使用循环在每个分割中实现了实际的模型训练，保存了我们的训练结果以供进一步分析和比较。

K 折交叉验证技术是利用可用数据的一种强大方法，有助于确保模型在不同数据子集上的性能可靠和一致。这将导致更具泛化性和可靠性的模型，不太可能过度拟合特定数据模式。

请记住，虽然我们在本指南中使用了 YOLO，但这些步骤大部分是可以迁移到其他机器学习模型的。了解这些步骤可以帮助您有效地在自己的机器学习项目中应用交叉验证。祝编程愉快！

常见问题

什么是 K 折交叉验证，以及在目标检测中它为什么有用？

K 折交叉验证是一种技术，将数据集分为'k'个子集（折叠），以更可靠地评估模型性能。每个折叠都用作训练和验证数据。在目标检测的背景下，使用 K 折交叉验证有助于确保您的 Ultralytics YOLO 模型在不同数据拆分下的性能稳健且具有泛化能力，从而增强其可靠性。有关设置 Ultralytics YOLO 的 K 折交叉验证的详细说明，请参阅 K 折交叉验证与 Ultralytics。

如何使用 Ultralytics YOLO 实现 K 折交叉验证？

要使用 Ultralytics YOLO 实现 K 折交叉验证，需要按照以下步骤操作：

  1. 验证注释是否符合 YOLO 检测格式。

  2. 使用 Python 库，如sklearn、pandas和pyyaml。

  3. 从你的数据集中创建特征向量。

  4. 使用sklearn.model_selection中的KFold来分割你的数据集。

  5. 在每个拆分上训练 YOLO 模型。

欲了解详细指南，请查看我们文档中的 K-Fold 数据集分割部分。

为什么应该使用 Ultralytics YOLO 进行目标检测？

Ultralytics YOLO 提供了高精度高效率的实时目标检测，支持多种计算机视觉任务，如检测、分割和分类。此外，它与 Ultralytics HUB 等工具无缝集成，用于无代码模型训练和部署。有关更多详细信息，请探索我们的Ultralytics YOLO 页面上的优点和功能。

如何确保我的注释符合 Ultralytics YOLO 的正确格式？

你的注释应该遵循 YOLO 检测格式。每个注释文件必须列出对象类别及其在图像中的边界框坐标。YOLO 格式确保了训练目标检测模型时数据处理的流畅性和标准化。有关正确注释格式的更多信息，请访问 YOLO 检测格式指南。

我可以在除了 Fruit Detection 以外的自定义数据集上使用 K 折交叉验证吗？

是的，只要注释符合 YOLO 检测格式，你可以在任何自定义数据集上使用 K 折交叉验证。用你自定义数据集的路径和类标签替换数据集路径和类标签。这种灵活性确保了任何目标检测项目都能通过 K 折交叉验证进行强大的模型评估。有关实际示例，请查看我们的生成特征向量部分。

posted @ 2024-08-08 13:58  绝不原创的飞龙  阅读(19)  评论(0)  编辑  收藏  举报