Ultralytics-中文文档-一-
Ultralytics 中文文档(一)
首页
中文 | 한국어 | 日本語 | Русский | Deutsch | Français | Español | Português | Türkçe | Tiếng Việt | हिन्दी | العربية
介绍 Ultralytics YOLOv8,这是备受赞誉的实时目标检测和图像分割模型的最新版本。YOLOv8 基于深度学习和计算机视觉的前沿进展,提供无与伦比的速度和准确性。其简化的设计使其适用于各种应用,并且可以轻松适应不同的硬件平台,从边缘设备到云 API。
探索 YOLOv8 文档,这是一个全面的资源,旨在帮助您理解和利用其功能和能力。无论您是经验丰富的机器学习从业者还是新手,本中心旨在最大化 YOLOv8 在您项目中的潜力。
从哪里开始
-
使用 pip 安装
ultralytics
,几分钟内即可开始使用 开始使用 -
使用 YOLOv8 预测 新的图像和视频 在图像上预测
-
Train 在您自己的定制数据集上训练新的 YOLOv8 模型 训练一个模型
-
Tasks YOLOv8 任务如分段、分类、姿势和跟踪 探索任务
-
NEW 🚀 探索 带有高级语义和 SQL 搜索功能的数据集 探索数据集
www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs
Watch: 如何在 Google Colab 上训练 YOLOv8 模型的视频。
YOLO:简史
YOLO(You Only Look Once)是一种流行的目标检测和图像分割模型,由华盛顿大学的 Joseph Redmon 和 Ali Farhadi 开发。YOLO 由于其高速和高准确性,在 2015 年发布后迅速受到欢迎。
-
YOLOv2,发布于 2016 年,通过引入批量归一化、锚框和维度聚类,改进了原始模型。
-
YOLOv3,于 2018 年发布,通过更高效的骨干网络、多个锚点和空间金字塔池化进一步提升了模型的性能。
-
YOLOv4 于 2020 年发布,引入了 Mosaic 数据增强、新的无锚检测头部和新的损失函数等创新。
-
YOLOv5 进一步提升了模型的性能,并增加了超参数优化、集成实验追踪和自动导出到流行的导出格式等新功能。
-
YOLOv7 在 COCO 关键点数据集上增加了姿势估计等附加任务。
-
YOLOv8 是由 Ultralytics 推出的最新版本 YOLO。作为先进的模型,YOLOv8 在之前版本的成功基础上引入了新功能和改进,提升了性能、灵活性和效率。YOLOv8 支持包括检测、分割、姿势估计、跟踪和分类在内的全方位视觉 AI 任务。这种多功能性使用户可以在各种应用和领域中充分利用 YOLOv8 的能力。
-
YOLOv9 引入了像可编程梯度信息(PGI)和广义高效层聚合网络(GELAN)等创新方法。
-
YOLOv10 是由 清华大学 的研究人员使用 Ultralytics 的 Python package 创建的。这个版本通过引入端到端头部消除了非最大抑制(NMS)要求,提供了实时目标检测的进展。
YOLO 许可证:Ultralytics YOLO 如何许可?
Ultralytics 提供两种许可选项以适应不同的使用场景:
-
AGPL-3.0 许可证:这个OSI 批准的开源许可证非常适合学生和爱好者,促进开放协作和知识共享。详见LICENSE文件获取更多详情。
-
企业许可证:设计用于商业使用,此许可证允许无缝集成 Ultralytics 软件和 AI 模型到商业产品和服务中,绕过 AGPL-3.0 许可证的开源要求。如果您的情况涉及将我们的解决方案嵌入到商业产品中,请通过Ultralytics Licensing联系。
我们的许可策略旨在确保对我们开源项目的任何改进都能回馈给社区。我们深知开源原则的重要性 ❤️,我们的使命是确保我们的贡献可以以有益于所有人的方式被利用和扩展。
常见问题解答
什么是 Ultralytics YOLO 以及它如何改善目标检测?
Ultralytics YOLO 是备受赞誉的 YOLO(You Only Look Once)系列的最新进展,用于实时目标检测和图像分割。它通过引入新功能和改进来建立在之前版本的基础上,提升了性能、灵活性和效率。YOLOv8 支持多种视觉 AI 任务,如检测、分割、姿态估计、跟踪和分类。其先进的架构确保了超高的速度和精度,适用于各种应用场景,包括边缘设备和云 API。
如何开始使用 YOLO 进行安装和设置?
快速开始 YOLO 非常简单直接。您可以使用 pip 安装 Ultralytics 包,并在几分钟内运行起来。以下是一个基本的安装命令:
pip install ultralytics
对于全面的逐步指南,请访问我们的快速入门指南。这个资源将帮助您完成安装指导、初始设置和运行您的第一个模型。
如何在我的数据集上训练自定义 YOLO 模型?
在您的数据集上训练自定义 YOLO 模型涉及几个详细步骤:
-
准备您的标注数据集。
-
在一个 YAML 文件中配置训练参数。
-
使用
yolo train
命令开始训练。
这里是一个示例命令:
yolo train model=yolov8n.pt data=coco128.yaml epochs=100 imgsz=640
欲了解详细步骤,请查看我们的模型训练指南,其中包括示例和优化训练过程的技巧。
Ultralytics YOLO 有哪些许可选项?
Ultralytics 为 YOLO 提供了两种许可选项:
-
AGPL-3.0 许可证:这个开源许可证非常适合教育和非商业用途,促进开放协作。
-
企业许可证:这个许可证专为商业应用设计,允许无缝集成 Ultralytics 软件到商业产品中,无需遵守 AGPL-3.0 许可证的限制。
欲了解更多详情,请访问我们的许可页面。
Ultralytics YOLO 如何用于实时目标跟踪?
Ultralytics YOLO 支持高效且可定制的多目标跟踪。要利用跟踪功能,可以使用yolo track
命令,如下所示:
yolo track model=yolov8n.pt source=video.mp4
有关设置和运行目标跟踪的详细指南,请查看我们的跟踪模式文档,其中解释了配置和在实时场景中的实际应用。
快速入门
安装 Ultralytics
Ultralytics 提供各种安装方法,包括 pip、conda 和 Docker。通过ultralytics
pip 包安装最新稳定版本的 YOLOv8,或通过克隆Ultralytics GitHub 仓库获取最新版本。Docker 可用于在隔离的容器中执行该软件包,避免本地安装。
www.youtube.com/embed/_a7cVL9hqnk
观看: Ultralytics YOLO 快速入门指南
安装
使用 pip 安装ultralytics
包,或通过运行pip install -U ultralytics
更新现有安装。有关ultralytics
包的更多详情,请访问 Python 包索引(PyPI):pypi.org/project/ultralytics/
。
# Install the ultralytics package from PyPI
pip install ultralytics
您还可以直接从 GitHub 仓库安装ultralytics
包。如果您需要最新的开发版本,这可能很有用。请确保在系统上安装了 Git 命令行工具。@main
命令安装main
分支,并可以修改为其他分支,例如@my-branch
,或完全删除以默认使用main
分支。
# Install the ultralytics package from GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main
Conda 是 pip 的另一种替代包管理器,也可用于安装。有关更多细节,请访问 Anaconda:anaconda.org/conda-forge/ultralytics
。更新 conda 包的 Ultralytics feedstock 仓库位于github.com/conda-forge/ultralytics-feedstock/
。
# Install the ultralytics package using conda
conda install -c conda-forge ultralytics
注意
如果您在 CUDA 环境中安装,最佳做法是在同一命令中安装ultralytics
,pytorch
和pytorch-cuda
,以允许 conda 包管理器解决任何冲突,或者安装pytorch-cuda
时最后进行以允许其覆盖 CPU 特定的pytorch
包。
# Install all packages together using conda
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
Conda Docker 镜像
Ultralytics Conda Docker 镜像也可从DockerHub获取。这些镜像基于Miniconda3,是在 Conda 环境中开始使用ultralytics
的简单方法。
# Set image name as a variable
t=ultralytics/ultralytics:latest-conda
# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t
# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
如果您有兴趣贡献代码或希望使用最新的源代码进行实验,请克隆ultralytics
仓库。克隆后,进入目录并使用 pip 以可编辑模式-e
安装包。
# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics
# Navigate to the cloned directory
cd ultralytics
# Install the package in editable mode for development
pip install -e .
利用 Docker 在隔离的容器中轻松执行ultralytics
包,确保在各种环境中保持一致且流畅的性能。通过选择Docker Hub 中的官方ultralytics
镜像之一,您不仅避免了本地安装的复杂性,还能从验证过的工作环境中获益。Ultralytics 提供了 5 种主要支持的 Docker 镜像,每种都设计用于不同平台和用例的高兼容性和效率:
-
Dockerfile: 推荐用于训练的 GPU 镜像。
-
Dockerfile-arm64: 针对 ARM64 架构优化,允许在像树莓派和其他基于 ARM64 的平台上部署。
-
Dockerfile-cpu: 基于 Ubuntu 的仅 CPU 版本,适用于推理和没有 GPU 的环境。
-
Dockerfile-jetson: 专为 NVIDIA Jetson 设备定制,集成了针对这些平台优化的 GPU 支持。
-
Dockerfile-python: 只包含 Python 和必要依赖项的最小镜像,非常适合轻量级应用和开发。
-
Dockerfile-conda: 基于 Miniconda3,通过 conda 安装
ultralytics
包。
下面是获取最新镜像并执行的命令:
# Set image name as a variable
t=ultralytics/ultralytics:latest
# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t
# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
上述命令初始化了一个带有最新ultralytics
镜像的 Docker 容器。-it
标志分配了一个伪 TTY 并保持标准输入打开,使您能够与容器进行交互。--ipc=host
标志设置 IPC(进程间通信)命名空间为主机,这对于在进程之间共享内存至关重要。--gpus all
标志启用了对容器内所有可用 GPU 的访问,这对需要 GPU 计算的任务至关重要。
注意:要在容器内与本地机器上的文件一起工作,请使用 Docker 卷将本地目录挂载到容器中:
# Mount local directory to a directory inside the container
sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
使用本地机器上的目录路径替换/path/on/host
,并在 Docker 容器中使用所需路径替换/path/in/container
以便访问。
对于高级的 Docker 使用,请随时查阅 Ultralytics Docker 指南。
查看ultralytics
pyproject.toml 文件以获取依赖项列表。请注意,上述所有示例均安装了所有所需的依赖项。
提示
PyTorch 的要求因操作系统和 CUDA 要求而异,因此建议首先根据pytorch.org/get-started/locally
的说明安装 PyTorch。
使用 CLI 与 Ultralytics
Ultralytics 命令行界面(CLI)允许简单的单行命令,无需 Python 环境。CLI 无需定制或 Python 代码。您可以通过yolo
命令直接从终端运行所有任务。查看 CLI 指南,了解更多关于如何从命令行使用 YOLOv8 的信息。
示例
Ultralytics yolo
命令使用以下语法:
yolo TASK MODE ARGS
-
TASK
(可选)是(detect, segment, classify, pose, obb)之一 -
MODE
(必需)是(train, val, predict, export, track, benchmark)之一 -
ARGS
(可选)是arg=value
对,例如imgsz=640
,用于覆盖默认值。
请查看完整的配置指南或使用yolo cfg
CLI 命令中的所有ARGS
。
使用初始学习率为 0.01 训练 10 个 epoch 的检测模型
yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
预测使用预训练分割模型在图像大小为 320 的 YouTube 视频:
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
在批量大小为 1 且图像大小为 640 时评估预训练检测模型:
yolo val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640
将 YOLOv8n 分类模型导出到 ONNX 格式,图像大小为 224 乘以 128(无需任务要求)
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
运行特殊命令以查看版本、查看设置、运行检查等:
yolo help
yolo checks
yolo version
yolo settings
yolo copy-cfg
yolo cfg
警告
参数必须以arg=val
对形式传递,由等号=
分隔,并且在对中使用空格分隔。不要使用--
前缀或逗号,
分隔参数。
-
yolo predict model=yolov8n.pt imgsz=640 conf=0.25
✅ -
yolo predict model yolov8n.pt imgsz 640 conf 0.25
❌(缺少=
) -
yolo predict model=yolov8n.pt, imgsz=640, conf=0.25
❌(不要使用,
) -
yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25
❌(不要使用--
)
CLI 指南
使用 Python 与 Ultralytics
YOLOv8 的 Python 接口允许将其无缝集成到您的 Python 项目中,使您能够轻松加载、运行和处理模型的输出。设计时考虑了简易性和易用性,Python 接口使用户能够快速实现对象检测、分割和分类。这使得 YOLOv8 的 Python 接口成为任何希望将这些功能集成到其 Python 项目中的人的宝贵工具。
例如,用户可以加载模型,训练模型,在验证集上评估其性能,甚至仅使用几行代码将其导出为 ONNX 格式。查看 Python 指南,了解如何在 Python 项目中使用 YOLOv8 更多信息。
示例
from ultralytics import YOLO
# Create a new YOLO model from scratch
model = YOLO("yolov8n.yaml")
# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolov8n.pt")
# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)
# Evaluate the model's performance on the validation set
results = model.val()
# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")
# Export the model to ONNX format
success = model.export(format="onnx")
Python 指南
Ultralytics 设置
Ultralytics 库提供了一个强大的设置管理系统,可以精细控制您的实验。通过使用ultralytics.utils
模块中的SettingsManager
,用户可以轻松访问和修改他们的设置。这些设置存储在一个 YAML 文件中,可以直接在 Python 环境中或通过命令行界面(CLI)中查看或修改。
检查设置
要了解当前设置的配置,您可以直接查看它们:
查看设置
您可以使用 Python 查看您的设置。首先从ultralytics
模块导入settings
对象。使用以下命令打印和返回设置:
from ultralytics import settings
# View all settings
print(settings)
# Return a specific setting
value = settings["runs_dir"]
或者,命令行界面允许您使用简单的命令检查您的设置:
yolo settings
修改设置
Ultralytics 允许用户轻松修改其设置。可以通过以下方式进行更改:
更新设置
在 Python 环境中,调用settings
对象的update
方法来更改您的设置:
from ultralytics import settings
# Update a setting
settings.update({"runs_dir": "/path/to/runs"})
# Update multiple settings
settings.update({"runs_dir": "/path/to/runs", "tensorboard": False})
# Reset settings to default values
settings.reset()
如果您更喜欢使用命令行界面,以下命令将允许您修改您的设置:
# Update a setting
yolo settings runs_dir='/path/to/runs'
# Update multiple settings
yolo settings runs_dir='/path/to/runs' tensorboard=False
# Reset settings to default values
yolo settings reset
理解设置
下表提供了在 Ultralytics 中可调整的设置概述。每个设置都包括示例值、数据类型和简要描述。
名称 | 示例值 | 数据类型 | 描述 |
---|---|---|---|
settings_version |
'0.0.4' |
str |
Ultralytics settings版本(与 Ultralytics pip版本不同) |
datasets_dir |
'/path/to/datasets' |
str |
存储数据集的目录 |
weights_dir |
'/path/to/weights' |
str |
存储模型权重的目录 |
runs_dir |
'/path/to/runs' |
str |
存储实验运行的目录 |
uuid |
'a1b2c3d4' |
str |
当前设置的唯一标识符 |
sync |
True |
bool |
是否将分析和崩溃同步到 HUB |
api_key |
'' |
str |
Ultralytics HUB API Key |
clearml |
True |
bool |
是否使用 ClearML 进行日志记录 |
comet |
True |
bool |
是否使用Comet ML进行实验跟踪和可视化 |
dvc |
True |
bool |
是否使用DVC 进行实验跟踪和版本控制 |
hub |
True |
bool |
是否使用Ultralytics HUB集成 |
mlflow |
True |
bool |
是否使用 MLFlow 进行实验跟踪 |
neptune |
True |
bool |
是否使用 Neptune 进行实验跟踪 |
raytune |
True |
bool |
是否使用 Ray Tune 进行超参数调优 |
tensorboard |
True |
bool |
是否使用 TensorBoard 进行可视化 |
wandb |
True |
bool |
是否使用 Weights & Biases 日志记录 |
当您浏览您的项目或实验时,请确保定期检查这些设置,以确保它们针对您的需求进行了最佳配置。
常见问题解答
如何使用 pip 安装 Ultralytics YOLOv8?
要使用 pip 安装 Ultralytics YOLOv8,请执行以下命令:
pip install ultralytics
对于最新的稳定版本发布,这将直接从 Python 包索引(PyPI)安装 ultralytics
包。欲了解更多详细信息,请访问 PyPI 上的 ultralytics 包。
或者,您可以直接从 GitHub 安装最新的开发版本:
pip install git+https://github.com/ultralytics/ultralytics.git
确保在你的系统上安装了 Git 命令行工具。
我能使用 conda 安装 Ultralytics YOLOv8 吗?
是的,你可以通过以下 conda 命令安装 Ultralytics YOLOv8:
conda install -c conda-forge ultralytics
这种方法是 pip 的一个很好的替代方案,并确保与您环境中的其他包兼容。对于 CUDA 环境,最好同时安装 ultralytics
、pytorch
和 pytorch-cuda
以解决任何冲突:
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
欲获取更多指导,请查看 Conda 快速入门指南。
使用 Docker 运行 Ultralytics YOLOv8 的优势是什么?
使用 Docker 运行 Ultralytics YOLOv8 可提供隔离和一致的环境,确保在不同系统上的平稳运行。它还消除了本地安装的复杂性。Ultralytics 官方提供了适用于 GPU、CPU、ARM64、NVIDIA Jetson 和 Conda 环境的不同变体的 Docker 镜像,可以在 Docker Hub 上获取最新镜像并运行以下命令:
# Pull the latest ultralytics image from Docker Hub
sudo docker pull ultralytics/ultralytics:latest
# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all ultralytics/ultralytics:latest
欲了解更详细的 Docker 指南,请查看 Docker 快速入门指南。
如何克隆 Ultralytics 代码库以进行开发?
要克隆 Ultralytics 代码库并设置开发环境,请按以下步骤操作:
# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics
# Navigate to the cloned directory
cd ultralytics
# Install the package in editable mode for development
pip install -e .
这种方法允许您贡献到项目或使用最新的源代码进行实验。欲了解更多详细信息,请访问 Ultralytics GitHub 代码库。
为什么要使用 Ultralytics YOLOv8 CLI?
Ultralytics YOLOv8 命令行界面(CLI)简化了运行对象检测任务的流程,无需编写 Python 代码。您可以直接从终端执行单行命令,例如训练、验证和预测任务。yolo
命令的基本语法如下:
yolo TASK MODE ARGS
例如,使用指定参数训练检测模型:
yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
查看完整的 CLI 指南以探索更多命令和用法示例。
Ultralytics YOLOv8 模式
介绍
Ultralytics YOLOv8 不仅仅是另一个目标检测模型;它是一个多功能框架,旨在覆盖机器学习模型的整个生命周期——从数据摄入和模型训练到验证、部署和实时跟踪。每种模式都有特定的目的,并且旨在为不同任务和用例提供所需的灵活性和效率。
www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM
观看: Ultralytics 模式教程:训练、验证、预测、导出和基准测试。
模式一览
了解 Ultralytics YOLOv8 支持的不同模式对于充分利用您的模型至关重要:
-
训练模式:在自定义或预加载数据集上进行模型微调。
-
验证模式:用于验证模型性能的训练后检查点。
-
预测模式:释放您的模型在真实世界数据上的预测能力。
-
导出模式:使您的模型能够在各种格式下进行部署。
-
追踪模式:将您的目标检测模型扩展到实时跟踪应用程序中。
-
基准测试模式:分析您的模型在不同部署环境中的速度和准确性。
本全面指南旨在为您提供每种模式的概述和实用见解,帮助您充分利用 YOLOv8 的潜力。
训练
训练模式用于在自定义数据集上训练 YOLOv8 模型。在此模式下,使用指定的数据集和超参数训练模型。训练过程涉及优化模型的参数,以便它能够准确预测图像中对象的类别和位置。
训练示例
验证
验证模式用于在模型训练后验证 YOLOv8 模型。在此模式下,模型在验证集上评估其准确性和泛化性能。可以使用此模式调整模型的超参数以提高其性能。
验证示例
预测
预测模式用于在新图像或视频上使用训练后的 YOLOv8 模型进行预测。在这种模式下,模型从检查点文件加载,用户可以提供图像或视频进行推理。模型预测输入图像或视频中对象的类别和位置。
预测示例
导出
导出模式用于将 YOLOv8 模型导出为可用于部署的格式。在此模式下,模型被转换为其他软件应用程序或硬件设备可以使用的格式。在将模型部署到生产环境时,此模式非常有用。
导出示例
追踪
Track mode 用于使用 YOLOv8 模型实时跟踪对象。在此模式下,模型从检查点文件加载,用户可以提供实时视频流执行实时对象跟踪。此模式适用于监视系统或自动驾驶汽车等应用。
Track Examples
Benchmark
Benchmark 模式用于分析 YOLOv8 各种导出格式的速度和准确性。基准测试提供了关于导出格式大小、mAP50-95
指标(用于目标检测、分割和姿态)或 accuracy_top5
指标(用于分类)以及每张图像的推理时间(以毫秒为单位),跨多种导出格式如 ONNX、OpenVINO、TensorRT 等。此信息可帮助用户根据其对速度和准确性要求选择最佳的导出格式。
Benchmark Examples
FAQ
如何使用 Ultralytics YOLOv8 训练自定义目标检测模型?
使用 Ultralytics YOLOv8 训练自定义目标检测模型涉及使用训练模式。您需要一个格式为 YOLO 的数据集,包含图像和相应的标注文件。使用以下命令开始训练过程:
Example
from ultralytics import YOLO
# Train a custom model
model = YOLO("yolov8n.pt")
model.train(data="path/to/dataset.yaml", epochs=100, imgsz=640)
yolo train data=path/to/dataset.yaml epochs=100 imgsz=640
欲获取更详细的说明,请参阅 Ultralytics Train Guide。
Ultralytics YOLOv8 使用哪些指标来验证模型的性能?
Ultralytics YOLOv8 在验证过程中使用多种指标评估模型性能。这些指标包括:
-
mAP (平均精度均值):评估目标检测的准确性。
-
IOU (预测框与真实框的交并比):衡量预测框与真实框之间的重叠度。
-
精确率和召回率:精确率衡量真正检测到的正例与所有检测到的正例的比例,而召回率衡量真正检测到的正例与所有实际正例的比例。
您可以运行以下命令开始验证:
Example
from ultralytics import YOLO
# Validate the model
model = YOLO("yolov8n.pt")
model.val(data="path/to/validation.yaml")
yolo val data=path/to/validation.yaml
欲了解更多详细信息,请参阅 Validation Guide。
如何导出我的 YOLOv8 模型以进行部署?
Ultralytics YOLOv8 提供导出功能,将您训练好的模型转换为各种部署格式,如 ONNX、TensorRT、CoreML 等。使用以下示例导出您的模型:
Example
from ultralytics import YOLO
# Export the model
model = YOLO("yolov8n.pt")
model.export(format="onnx")
yolo export model=yolov8n.pt format=onnx
每种导出格式的详细步骤可在 Export Guide 中找到。
Ultralytics YOLOv8 的 Benchmark 模式的目的是什么?
Ultralytics YOLOv8 中的 Benchmark 模式用于分析各种导出格式(如 ONNX、TensorRT 和 OpenVINO)的速度和准确性。它提供了模型大小、目标检测的 mAP50-95
以及在不同硬件设置下的推理时间等指标,帮助您选择最适合部署需求的格式。
Example
from ultralytics.utils.benchmarks import benchmark
# Benchmark on GPU
benchmark(model="yolov8n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
欲获取更多细节,请参阅 Benchmark Guide。
如何使用 Ultralytics YOLOv8 进行实时对象跟踪?
使用 Ultralytics YOLOv8 中的跟踪模式可以实现实时对象跟踪。该模式扩展了对象检测能力,可以跨视频帧或实时流跟踪对象。使用以下示例启用跟踪:
示例
from ultralytics import YOLO
# Track objects in a video
model = YOLO("yolov8n.pt")
model.track(source="path/to/video.mp4")
yolo track source=path/to/video.mp4
欲了解详细说明,请访问跟踪指南。
使用 Ultralytics YOLO 进行模型训练
介绍
训练深度学习模型涉及提供数据并调整其参数,以便它能进行准确预测。Ultralytics YOLOv8 的训练模式专为有效和高效地训练目标检测模型而设计,充分利用现代硬件能力。本指南旨在涵盖使用 YOLOv8 丰富功能集训练自己的模型所需的所有详细信息。
www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs
观看: 如何在 Google Colab 上训练自定义数据集的 YOLOv8 模型。
为什么选择 Ultralytics YOLO 进行训练?
以下是选择 YOLOv8 训练模式的一些引人注目的理由:
-
效率: 充分利用您的硬件资源,无论您使用单 GPU 设置还是跨多 GPU 扩展。
-
多功能性: 除了像 COCO、VOC 和 ImageNet 这样的现成数据集外,还可以训练自定义数据集。
-
用户友好: 简单而强大的 CLI 和 Python 接口,提供直观的训练体验。
-
超参数灵活性: 广泛的可定制超参数范围,以微调模型性能。
训练模式的关键特点
以下是 YOLOv8 训练模式的一些显著特点:
-
自动数据集下载: 类似 COCO、VOC 和 ImageNet 的标准数据集在首次使用时会自动下载。
-
多 GPU 支持: 跨多个 GPU 无缝扩展训练效果,加快进程。
-
超参数配置: 可通过 YAML 配置文件或 CLI 参数修改超参数的选项。
-
可视化与监控: 实时跟踪训练指标,并可视化学习过程,以获取更好的见解。
提示
- YOLOv8 数据集如 COCO、VOC、ImageNet 等,在第一次使用时会自动下载,例如
yolo train data=coco.yaml
使用示例
在图像大小为 640 的 COCO8 数据集上对 YOLOv8n 进行 100 个 epoch 的训练。可以使用device
参数指定训练设备。如果未传递参数,则如果可用,则将使用 GPU device=0
,否则将使用device='cpu'
。有关所有训练参数的完整列表,请参见下面的参数部分。
单 GPU 和 CPU 训练示例
设备会自动确定。如果 GPU 可用,则会使用 GPU,否则将在 CPU 上开始训练。
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.yaml") # build a new model from YAML
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
model = YOLO("yolov8n.yaml").load("yolov8n.pt") # build from YAML and transfer weights
# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
# Build a new model from YAML and start training from scratch
yolo detect train data=coco8.yaml model=yolov8n.yaml epochs=100 imgsz=640
# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
# Build a new model from YAML, transfer pretrained weights to it and start training
yolo detect train data=coco8.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
多 GPU 训练
多 GPU 训练通过在多个 GPU 上分发训练负载,有效利用可用硬件资源。此功能可通过 Python API 和命令行界面使用。要启用多 GPU 训练,请指定要使用的 GPU 设备 ID。
多 GPU 训练示例
要使用 2 个 GPU 进行训练,CUDA 设备 0 和 1,请使用以下命令。根据需要扩展到更多 GPU。
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
# Train the model with 2 GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])
# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
Apple M1 和 M2 MPS 训练
支持 Apple M1 和 M2 芯片集成在 Ultralytics YOLO 模型中,现在可以在使用强大的 Metal Performance Shaders(MPS)框架的设备上训练模型。MPS 提供了在 Apple 定制硅上执行计算和图像处理任务的高性能方式。
要在 Apple M1 和 M2 芯片上进行训练,你应该在启动训练过程时将'device'指定为'mps'。以下是在 Python 中和通过命令行如何实现的示例:
MPS 训练示例
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
# Train the model with 2 GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")
# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
在利用 M1/M2 芯片的计算能力的同时,这使得训练任务的处理更加高效。有关更详细的指导和高级配置选项,请参阅PyTorch MPS 文档。
恢复中断的训练
当使用深度学习模型时,从先前保存的状态恢复训练是一个关键特性。这在各种情况下都很有用,例如当训练过程意外中断或希望使用新数据或更多 epochs 继续训练模型时。
当恢复训练时,Ultralytics YOLO 会从最后保存的模型加载权重,并恢复优化器状态、学习率调度器和轮数。这样可以无缝地从中断的地方继续训练过程。
在 Ultralytics YOLO 中通过将resume
参数设置为True
并指定包含部分训练模型权重的.pt
文件的路径,可以轻松恢复训练。
以下是如何使用 Python 和命令行恢复中断训练的示例:
恢复训练示例
from ultralytics import YOLO
# Load a model
model = YOLO("path/to/last.pt") # load a partially trained model
# Resume training
results = model.train(resume=True)
# Resume an interrupted training
yolo train resume model=path/to/last.pt
通过设置resume=True
,train
函数将从存储在'path/to/last.pt'文件中的状态继续训练。如果省略resume
参数或将其设置为False
,train
函数将启动新的训练会话。
请记住,默认情况下,每个 epoch 结束时或使用save_period
参数以固定间隔保存检查点,所以您必须完成至少 1 个 epoch 才能恢复训练运行。
训练设置
YOLO 模型的训练设置涵盖了训练过程中使用的各种超参数和配置。这些设置影响模型的性能、速度和准确性。关键的训练设置包括批量大小、学习率、动量和权重衰减。此外,优化器的选择、损失函数和训练数据集的组成也会影响训练过程。精心调整和对这些设置进行实验对于优化性能至关重要。
参数 | 默认值 | 描述 |
---|---|---|
model |
None |
指定用于训练的模型文件。接受.pt 预训练模型或.yaml 配置文件的路径。定义模型结构或初始化权重至关重要。 |
data |
None |
数据集配置文件的路径(例如coco8.yaml )。该文件包含数据集特定的参数,包括训练和验证数据的路径、类名和类的数量。 |
epochs |
100 |
总训练轮数。每个 epoch 表示对整个数据集的完整遍历。调整此值会影响训练持续时间和模型性能。 |
time |
None |
最大训练时间(小时)。如果设置了此参数,则会覆盖epochs 参数,允许在指定的持续时间后自动停止训练。适用于时间受限的训练场景。 |
patience |
100 |
在验证指标没有改善的情况下等待的轮数(epochs),用于提前停止训练以防止过拟合。 |
batch |
16 |
批量大小,有三种模式:设置为整数(例如batch=16 )、自动模式以利用 60%的 GPU 内存(batch=-1 )或带有指定利用率分数的自动模式(batch=0.70 )。 |
imgsz |
640 |
训练的目标图像尺寸。所有图像在输入模型之前都会被调整到这个尺寸。影响模型的准确性和计算复杂度。 |
save |
True |
启用训练检查点和最终模型权重的保存。有助于恢复训练或模型部署。 |
save_period |
-1 |
模型检查点保存频率,以 epochs 为单位。设置为-1 时禁用此功能。在长时间训练会话中保存中间模型非常有用。 |
cache |
False |
启用数据集图像的缓存,可选True /ram (内存中)、disk (磁盘中)或禁用False 。减少磁盘 I/O 以提高训练速度,但会增加内存使用。 |
device |
None |
指定用于训练的计算设备:单个 GPU(device=0 )、多个 GPU(device=0,1 )、CPU(device=cpu )或 Apple Silicon 的 MPS(device=mps )。 |
workers |
8 |
数据加载的工作线程数(每个RANK 如果是多 GPU 训练)。影响数据预处理和输入模型的速度,特别适用于多 GPU 设置。 |
project |
None |
训练输出保存的项目目录名称。允许组织不同实验的存储。 |
name |
None |
训练运行的名称。用于在项目文件夹内创建子目录,存储训练日志和输出。 |
exist_ok |
False |
如果为 True,允许覆盖现有项目/名称目录。有助于在不需手动清除先前输出的情况下进行迭代实验。 |
pretrained |
True |
确定是否从预训练模型开始训练。可以是布尔值或指定模型路径的字符串,以加载权重。提升训练效率和模型性能。 |
optimizer |
'auto' |
训练的优化器选择。选项包括 SGD 、Adam 、AdamW 、NAdam 、RAdam 、RMSProp 等,或者 auto 根据模型配置自动选择。影响收敛速度和稳定性。 |
verbose |
False |
在训练过程中启用详细输出,提供详细日志和进度更新。用于调试和紧密监控训练过程。 |
seed |
0 |
设置训练的随机种子,确保在相同配置下运行时结果的可重现性。 |
deterministic |
True |
强制使用确定性算法,确保结果的可重现性,但可能会影响性能和速度,因为对非确定性算法施加了限制。 |
single_cls |
False |
在训练期间将多类数据集中的所有类别视为单一类别。适用于二元分类任务或关注对象存在而非分类。 |
rect |
False |
启用矩形训练,优化批次构成以减少填充。可以提高效率和速度,但可能影响模型精度。 |
cos_lr |
False |
使用余弦学习率调度器,在 epochs 上按余弦曲线调整学习率。有助于管理学习率以实现更好的收敛。 |
close_mosaic |
10 |
在完成训练之前的最后 N 个 epochs 禁用马赛克数据增强,以稳定训练。设置为 0 会禁用此功能。 |
resume |
False |
从最后保存的检查点恢复训练。自动加载模型权重、优化器状态和 epoch 计数,无缝继续训练。 |
amp |
True |
启用自动混合精度(AMP)训练,减少内存使用并可能加快训练速度,对精度影响较小。 |
fraction |
1.0 |
指定用于训练的数据集分数。允许在完整数据集的子集上进行训练,适用于实验或资源有限的情况。 |
profile |
False |
在训练期间启用 ONNX 和 TensorRT 速度的分析,有助于优化模型部署。 |
freeze |
None |
冻结模型的前 N 层或指定索引的层,减少可训练参数的数量。用于微调或迁移学习。 |
lr0 |
0.01 |
初始学习率(例如 SGD=1E-2 ,Adam=1E-3 )。调整此值对优化过程至关重要,影响模型权重更新的速度。 |
lrf |
0.01 |
最终学习率作为初始学习率的一部分 = (lr0 * lrf ),与调度器配合使用以随时间调整学习率。 |
momentum |
0.937 |
SGD 的动量因子或 Adam 优化器的 beta1,影响当前更新中过去梯度的纳入。 |
weight_decay |
0.0005 |
L2 正则化项,惩罚大权重以防止过拟合。 |
warmup_epochs |
3.0 |
学习率预热的轮数,逐渐将学习率从低值增加到初始学习率,以稳定早期训练。 |
warmup_momentum |
0.8 |
预热阶段的初始动量,逐渐调整到预热期间设定的动量。 |
warmup_bias_lr |
0.1 |
预热阶段偏置参数的学习率,帮助稳定模型在初始轮次的训练。 |
box |
7.5 |
损失函数中框损失组件的权重,影响对准确预测边界框坐标的重视程度。 |
cls |
0.5 |
分类损失在总损失函数中的权重,影响正确类别预测相对于其他组件的重要性。 |
dfl |
1.5 |
分布焦点损失的权重,在某些 YOLO 版本中用于细粒度分类。 |
pose |
12.0 |
在为姿态估计训练的模型中,姿态损失的权重,影响对准确预测姿态关键点的重视程度。 |
kobj |
2.0 |
关键点物体性损失在姿态估计模型中的权重,平衡检测置信度与姿态准确性。 |
label_smoothing |
0.0 |
应用标签平滑,将硬标签软化为目标标签和标签均匀分布的混合,有助于提高泛化能力。 |
nbs |
64 |
用于损失归一化的名义批量大小。 |
overlap_mask |
True |
确定在训练期间分割掩码是否应重叠,适用于实例分割任务。 |
mask_ratio |
4 |
分割掩码的下采样比例,影响训练期间使用的掩码分辨率。 |
dropout |
0.0 |
分类任务中的正则化丢弃率,通过在训练期间随机省略单元来防止过拟合。 |
val |
True |
在训练期间启用验证,允许定期评估模型在单独数据集上的性能。 |
plots |
False |
生成并保存训练和验证指标的图表,以及预测示例,提供对模型性能和学习进展的可视化洞察。 |
批量大小设置说明 |
batch
参数可以通过三种方式进行配置: |
-
固定批量大小:设置一个整数值(例如,
batch=16
),直接指定每个批次的图像数量。 | -
自动模式(60% GPU 内存):使用
batch=-1
自动调整批量大小,以实现大约 60%的 CUDA 内存利用率。 | -
自动模式与利用率分数:设置一个分数值(例如,
batch=0.70
),根据指定的 GPU 内存使用分数调整批量大小。 |
增强设置和超参数 |
数据增强技术对改善 YOLO 模型的鲁棒性和性能至关重要,通过向训练数据引入变异性,帮助模型更好地泛化到未见数据。以下表格详细描述了每种增强参数的目的和效果:
参数 | 类型 | 默认 | 范围 | 描述 |
---|---|---|---|---|
hsv_h |
float |
0.015 |
0.0 - 1.0 |
通过颜色轮的一部分调整图像的色调,引入颜色变化。有助于模型在不同光照条件下泛化。 |
hsv_s |
float |
0.7 |
0.0 - 1.0 |
改变图像的饱和度,影响颜色的强度。模拟不同环境条件很有用。 |
hsv_v |
float |
0.4 |
0.0 - 1.0 |
通过一部分修改图像的值(亮度),帮助模型在各种光照条件下表现良好。 |
degrees |
float |
0.0 |
-180 - +180 |
在指定角度范围内随机旋转图像,提高模型识别各种方向物体的能力。 |
translate |
float |
0.1 |
0.0 - 1.0 |
通过图像尺寸的一部分水平和垂直平移图像,有助于学习检测部分可见对象。 |
scale |
float |
0.5 |
>=0.0 |
通过增益因子缩放图像,模拟相机距离不同的物体。 |
shear |
float |
0.0 |
-180 - +180 |
按指定角度剪切图像,模拟从不同角度观察物体的效果。 |
perspective |
float |
0.0 |
0.0 - 0.001 |
对图像应用随机透视变换,增强模型理解三维空间中的物体能力。 |
flipud |
float |
0.0 |
0.0 - 1.0 |
将图像上下翻转,指定的概率下,增加数据的变异性,而不影响物体的特征。 |
fliplr |
float |
0.5 |
0.0 - 1.0 |
将图像左右翻转,指定的概率下,有助于学习对称物体并增加数据集的多样性。 |
bgr |
float |
0.0 |
0.0 - 1.0 |
将图像通道从 RGB 翻转为 BGR,指定的概率为,有助于增强对不正确通道排序的鲁棒性。 |
mosaic |
float |
1.0 |
0.0 - 1.0 |
将四个训练图像合并成一个,模拟不同的场景组合和物体交互。对于复杂场景理解非常有效。 |
mixup |
float |
0.0 |
0.0 - 1.0 |
混合两幅图像及其标签,创建混合图像。通过引入标签噪声和视觉变化,增强模型的泛化能力。 |
copy_paste |
float |
0.0 |
0.0 - 1.0 |
从一幅图像复制对象并粘贴到另一幅图像中,有助于增加对象实例并学习对象遮挡。 |
auto_augment |
str |
randaugment |
- | 自动应用预定义的增强策略(randaugment 、autoaugment 、augmix ),通过增加视觉特征的多样性来优化分类任务。 |
erasing |
float |
0.4 |
0.0 - 0.9 |
在分类训练期间随机擦除图像的一部分,鼓励模型专注于识别不太明显的特征。 |
crop_fraction |
float |
1.0 |
0.1 - 1.0 |
将分类图像裁剪为其大小的一部分,以突出中央特征并适应对象的比例,减少背景干扰。 |
可以调整这些设置以满足数据集和当前任务的具体要求。尝试不同的值可以帮助找到最佳的增强策略,从而获得最佳的模型性能。
信息
获取有关训练增强操作的更多信息,请参阅参考部分。
记录
在训练 YOLOv8 模型时,您可能会发现跟踪模型随时间性能变化很有价值。这就是记录的作用。Ultralytics 的 YOLO 支持三种类型的记录器 - Comet、ClearML 和 TensorBoard。
要使用记录器,请从上面的代码片段的下拉菜单中选择并运行它。所选记录器将被安装和初始化。
Comet
Comet 是一个平台,允许数据科学家和开发人员跟踪、比较、解释和优化实验和模型。它提供实时指标、代码差异和超参数跟踪等功能。
要使用 Comet:
示例
# pip install comet_ml
import comet_ml
comet_ml.init()
记得在 Comet 的网站上登录您的账户并获取您的 API 密钥。您需要将其添加到环境变量或脚本中以记录您的实验。
ClearML
ClearML是一个开源平台,自动化实验跟踪,并帮助高效共享资源。它旨在帮助团队更有效地管理、执行和复现他们的机器学习工作。
使用 ClearML:
示例
# pip install clearml
import clearml
clearml.browser_login()
运行此脚本后,您需要在浏览器上登录您的CearML账户并验证您的会话。
TensorBoard
TensorBoard是 TensorFlow 的可视化工具包。它允许您可视化 TensorFlow 图,绘制关于图执行的定量指标,并显示通过图像传递的其他数据。
要在Google Colab中使用 TensorBoard:
示例
load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory
要在本地使用 TensorBoard,请运行下面的命令,并在 http://localhost:6006/ 查看结果。
示例
tensorboard --logdir ultralytics/runs # replace with 'runs' directory
这将加载 TensorBoard 并将其定向到保存训练日志的目录。
设置好记录器后,您可以开始模型训练。所有训练指标将自动记录在您选择的平台上,您可以访问这些日志以随时监控模型的性能,比较不同模型,并确定改进的方向。
常见问题
如何使用 Ultralytics YOLOv8 训练目标检测模型?
要使用 Ultralytics YOLOv8 训练目标检测模型,您可以使用 Python API 或 CLI。以下是两者的示例:
单 GPU 和 CPU 训练示例
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
欲了解更多详情,请参阅训练设置部分。
Ultralytics YOLOv8 的训练模式的关键特性是什么?
Ultralytics YOLOv8 的训练模式的关键特性包括:
-
自动数据集下载: 自动下载标准数据集,如 COCO、VOC 和 ImageNet。
-
多 GPU 支持: 可以跨多个 GPU 进行训练,加速处理速度。
-
超参数配置: 通过 YAML 文件或 CLI 参数自定义超参数。
-
可视化和监控: 实时跟踪训练指标,以获得更好的洞察力。
这些功能使得训练高效且可根据您的需求定制。有关详细信息,请参阅训练模式的关键特性部分。
如何从中断的会话中恢复 Ultralytics YOLOv8 的训练?
要从中断的会话恢复训练,请将resume
参数设置为True
并指定最后保存的检查点路径。
恢复训练示例
from ultralytics import YOLO
# Load the partially trained model
model = YOLO("path/to/last.pt")
# Resume training
results = model.train(resume=True)
yolo train resume model=path/to/last.pt
查看中断训练部分以获取更多信息。
我能在 Apple M1 和 M2 芯片上训练 YLOv8 模型吗?
是的,Ultralytics YOLOv8 支持在 Apple M1 和 M2 芯片上使用 Metal Performance Shaders(MPS)框架进行训练。请将训练设备设置为 'mps'。
MPS 训练示例
from ultralytics import YOLO
# Load a pretrained model
model = YOLO("yolov8n.pt")
# Train the model on M1/M2 chip
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
欲了解更多详情,请参阅 Apple M1 和 M2 MPS 训练部分。
常见的训练设置是什么,如何配置它们?
Ultralytics YOLOv8 允许通过参数配置各种训练设置,如批量大小、学习率、时代等。以下是简要概述:
Argument | Default | Description |
---|---|---|
model |
None |
用于训练的模型文件路径。 |
data |
None |
数据集配置文件的路径(例如 coco8.yaml )。 |
epochs |
100 |
总训练时期数。 |
batch |
16 |
批量大小,可以设置为整数或自动模式。 |
imgsz |
640 |
训练的目标图像尺寸。 |
device |
None |
用于训练的计算设备,例如 cpu 、0 、0,1 或mps 。 |
save |
True |
启用保存训练检查点和最终模型权重。 |
欲了解训练设置的详细指南,请参阅训练设置部分。
使用 Ultralytics YOLO 进行模型验证
简介
验证是机器学习流程中的关键步骤,允许您评估训练模型的质量。Ultralytics YOLOv8 的 Val 模式提供了一套强大的工具和指标,用于评估您的目标检测模型的性能。本指南作为一个完整的资源,帮助您有效地使用 Val 模式,确保您的模型既准确又可靠。
www.youtube.com/embed/j8uQc0qB91s?start=47
观看: Ultralytics 模式教程:验证
为什么要使用 Ultralytics YOLO 进行验证?
使用 YOLOv8 的 Val 模式的优势如下:
-
精度: 获取像 mAP50、mAP75 和 mAP50-95 这样的准确度指标,全面评估您的模型。
-
便利性: 利用内置功能记住训练设置,简化验证流程。
-
灵活性: 使用相同或不同的数据集和图像大小验证您的模型。
-
超参数调整: 使用验证指标对模型进行微调,以提高性能。
Val 模式的主要特性
这些是 YOLOv8 的 Val 模式提供的显著功能:
-
自动设置: 模型记住其训练配置,使验证过程简单直接。
-
多指标支持: 基于一系列准确度指标评估您的模型。
-
CLI 和 Python API: 根据您的喜好选择命令行界面或 Python API 进行验证。
-
数据兼容性: 与训练阶段使用的数据集以及自定义数据集无缝配合。
小贴士
- YOLOv8 模型自动记住其训练设置,因此您可以轻松地以相同的图像大小和原始数据集验证模型,只需执行
yolo val model=yolov8n.pt
或model('yolov8n.pt').val()
使用示例
在 COCO8 数据集上验证训练后的 YOLOv8n 模型的准确性。不需要传递任何参数,因为 model
保留其训练 data
和参数作为模型属性。请参阅下面的参数部分,了解完整的导出参数列表。
示例
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom model
# Validate the model
metrics = model.val() # no arguments needed, dataset and settings remembered
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # a list contains map50-95 of each category
yolo detect val model=yolov8n.pt # val official model
yolo detect val model=path/to/best.pt # val custom model
YOLO 模型验证参数
在验证 YOLO 模型时,可以调整多个参数以优化评估过程。这些参数控制诸如输入图像大小、批处理和性能阈值等方面。以下是每个参数的详细说明,帮助您有效地定制验证设置。
参数 | 类型 | 默认值 | 描述 |
---|---|---|---|
data |
str |
None |
指定数据集配置文件的路径(例如 coco8.yaml )。该文件包含验证数据的路径、类名以及类的数量。 |
imgsz |
int |
640 |
定义输入图像的大小。所有图像在处理之前都会被调整到这个尺寸。 |
batch |
int |
16 |
设置每批图像的数量。使用 -1 进行自动批处理,根据 GPU 内存的可用性自动调整。 |
save_json |
bool |
False |
如果为 True ,将结果保存到 JSON 文件,以便进一步分析或与其他工具集成。 |
save_hybrid |
bool |
False |
如果为 True ,保存一个混合版本的标签,将原始注释与额外的模型预测结合起来。 |
conf |
float |
0.001 |
设置检测的最小置信度阈值。置信度低于此阈值的检测结果将被丢弃。 |
iou |
float |
0.6 |
设置非极大值抑制(NMS)的交并比(IoU)阈值。有助于减少重复检测结果。 |
max_det |
int |
300 |
限制每个图像的最大检测数。在密集场景中有助于防止过多的检测结果。 |
half |
bool |
True |
启用半精度(FP16)计算,减少内存使用量,可能提高速度,对精度影响最小。 |
device |
str |
None |
指定用于验证的设备(cpu 、cuda:0 等)。允许在 CPU 或 GPU 资源中灵活选择。 |
dnn |
bool |
False |
如果为 True ,使用 OpenCV 的 DNN 模块进行 ONNX 模型推理,提供了 PyTorch 推理方法的替代方案。 |
plots |
bool |
False |
当设置为 True 时,生成并保存预测与地面真实值的图表,以视觉方式评估模型性能。 |
rect |
bool |
False |
如果为 True ,使用矩形推理进行批处理,减少填充,可能提高速度和效率。 |
split |
str |
val |
确定用于验证的数据集拆分(val 、test 或 train )。允许在选择数据段进行性能评估时灵活选择。 |
这些设置在验证过程中各自扮演重要角色,允许定制化和高效的 YOLO 模型评估。根据您的特定需求和资源调整这些参数可以帮助实现精度和性能的最佳平衡。
使用参数进行示例验证
下面的示例展示了在 Python 和 CLI 中使用自定义参数进行 YOLO 模型验证。
示例
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt")
# Customize validation settings
validation_results = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.6, device="0")
yolo val model=yolov8n.pt data=coco8.yaml imgsz=640 batch=16 conf=0.25 iou=0.6 device=0
常见问题解答
如何验证我的 YOLOv8 模型使用 Ultralytics?
要验证您的 YOLOv8 模型,可以使用 Ultralytics 提供的 Val 模式。例如,使用 Python API,您可以加载模型并运行验证:
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt")
# Validate the model
metrics = model.val()
print(metrics.box.map) # map50-95
或者,您可以使用命令行界面(CLI):
yolo val model=yolov8n.pt
若要进行进一步定制,可以在 Python 和 CLI 模式下调整诸如 imgsz
、batch
和 conf
等各种参数。请查看 YOLO 模型验证参数部分以获取完整的参数列表。
YOLOv8 模型验证可以得到哪些指标?
YOLOv8 模型验证提供了几个关键指标,用于评估模型性能。这些包括:
-
mAP50(IoU 阈值为 0.5 的平均精度)
-
mAP75(IoU 阈值为 0.75 的平均精度)
-
mAP50-95(跨多个 IoU 阈值从 0.5 到 0.95 的平均精度)
使用 Python API,您可以按以下方式访问这些指标:
metrics = model.val() # assumes `model` has been loaded
print(metrics.box.map) # mAP50-95
print(metrics.box.map50) # mAP50
print(metrics.box.map75) # mAP75
print(metrics.box.maps) # list of mAP50-95 for each category
对于完整的性能评估,审查所有这些指标至关重要。有关更多详细信息,请参阅 Val Mode 的关键功能。
使用 Ultralytics YOLO 进行验证的优势有哪些?
使用 Ultralytics YOLO 进行验证提供了多个优势:
-
精确性: YOLOv8 提供准确的性能指标,包括 mAP50、mAP75 和 mAP50-95。
-
便捷性: 模型记住它们的训练设置,使验证变得简单直接。
-
灵活性: 您可以针对相同或不同的数据集和图像尺寸进行验证。
-
超参数调整: 验证指标有助于优化模型以获得更好的性能。
这些优势确保您的模型经过全面评估,并可以优化以获得卓越的结果。详细了解这些优势,请参阅为什么要使用 Ultralytics YOLO 进行验证部分。
我可以使用自定义数据集验证我的 YOLOv8 模型吗?
是的,您可以使用自定义数据集验证您的 YOLOv8 模型。请使用data
参数指定您的数据集配置文件的路径。该文件应包括验证数据的路径、类名和其他相关详细信息。
Python 示例:
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt")
# Validate with a custom dataset
metrics = model.val(data="path/to/your/custom_dataset.yaml")
print(metrics.box.map) # map50-95
CLI 示例:
yolo val model=yolov8n.pt data=path/to/your/custom_dataset.yaml
对于在验证过程中更可定制的选项,请参阅示例验证参数部分。
如何在 YOLOv8 中将验证结果保存到 JSON 文件?
要将验证结果保存到 JSON 文件中,在运行验证时,可以将save_json
参数设置为True
。无论是在 Python API 还是 CLI 中均可完成此操作。
Python 示例:
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt")
# Save validation results to JSON
metrics = model.val(save_json=True)
CLI 示例:
yolo val model=yolov8n.pt save_json=True
此功能特别适用于进一步分析或与其他工具集成。有关更多详细信息,请查看 YOLO 模型验证参数部分。
使用 Ultralytics YOLO 进行模型预测
介绍
在机器学习和计算机视觉领域,从视觉数据中获取信息的过程称为“推理”或“预测”。Ultralytics YOLOv8 提供了一个强大的功能,称为预测模式,专为在广泛的数据源上进行高性能、实时推理而设计。
www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14
观看: 如何从 Ultralytics YOLOv8 模型中提取自定义项目的输出。
实际应用场景
制造业 | 体育 | 安全 |
---|---|---|
![]() |
![]() |
![]() |
车辆零部件检测 | 足球运动员检测 | 人员摔倒检测 |
为什么要使用 Ultralytics YOLO 进行推理?
以下是考虑使用 YOLOv8 预测模式满足各种推理需求的原因:
-
多功能性: 能够对图像、视频甚至实时流进行推理。
-
性能: 针对实时高速处理而设计,同时保持精度。
-
易于使用: 提供直观的 Python 和 CLI 界面,用于快速部署和测试。
-
高度可定制: 可根据您的具体要求调整模型推理行为的各种设置和参数。
预测模式的关键特性
YOLOv8 的预测模式设计坚固多变,具备以下特点:
-
多数据源兼容性: 无论您的数据是单独的图像、图像集合、视频文件还是实时视频流,预测模式都能覆盖。
-
流模式: 使用流特性生成内存高效的
Results
对象的生成器。通过在预测器的调用方法中设置stream=True
来启用此功能。 -
批处理处理: 能够在单个批次中处理多个图像或视频帧,进一步加快推理时间。
-
集成友好: 由于其灵活的 API,可以轻松集成到现有的数据流水线和其他软件组件中。
Ultralytics YOLO 模型返回的结果可以是 Python 列表的Results
对象,或者当在推理过程中传递stream=True
给模型时,返回内存高效的Results
对象的 Python 生成器:
预测
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # pretrained YOLOv8n model
# Run batched inference on a list of images
results = model(["im1.jpg", "im2.jpg"]) # return a list of Results objects
# Process results list
for result in results:
boxes = result.boxes # Boxes object for bounding box outputs
masks = result.masks # Masks object for segmentation masks outputs
keypoints = result.keypoints # Keypoints object for pose outputs
probs = result.probs # Probs object for classification outputs
obb = result.obb # Oriented boxes object for OBB outputs
result.show() # display to screen
result.save(filename="result.jpg") # save to disk
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # pretrained YOLOv8n model
# Run batched inference on a list of images
results = model(["im1.jpg", "im2.jpg"], stream=True) # return a generator of Results objects
# Process results generator
for result in results:
boxes = result.boxes # Boxes object for bounding box outputs
masks = result.masks # Masks object for segmentation masks outputs
keypoints = result.keypoints # Keypoints object for pose outputs
probs = result.probs # Probs object for classification outputs
obb = result.obb # Oriented boxes object for OBB outputs
result.show() # display to screen
result.save(filename="result.jpg") # save to disk
推理来源
YOLOv8 可以处理不同类型的输入源进行推理,如下表所示。这些源包括静态图像、视频流和各种数据格式。表格还指示了是否可以使用stream=True
参数在流模式下使用每个源 ✅。流模式对于处理视频或直播流非常有用,因为它创建了一个结果生成器,而不是将所有帧加载到内存中。
提示
对于处理长视频或大型数据集,可以使用stream=True
来高效管理内存。当stream=False
时,所有帧或数据点的结果都会存储在内存中,这可能会快速累积并导致大输入时的内存不足错误。相比之下,stream=True
利用生成器,只在内存中保留当前帧或数据点的结果,大大减少内存消耗并防止内存不足问题。
源 | 示例 | 类型 | 注释 |
---|---|---|---|
图像 | 'image.jpg' |
str 或 Path |
单个图像文件。 |
网址 | 'https://ultralytics.com/images/bus.jpg' |
str |
图像的网址。 |
截图 | 'screen' |
str |
捕获屏幕截图。 |
PIL | Image.open('im.jpg') |
PIL.Image |
HWC 格式,带有 RGB 通道。 |
OpenCV | cv2.imread('im.jpg') |
np.ndarray |
HWC 格式,带有 BGR 通道 uint8 (0-255) 。 |
numpy | np.zeros((640,1280,3)) |
np.ndarray |
HWC 格式,带有 BGR 通道 uint8 (0-255) 。 |
torch | torch.zeros(16,3,320,640) |
torch.Tensor |
BCHW 格式,带有 RGB 通道 float32 (0.0-1.0) 。 |
CSV | 'sources.csv' |
str 或 Path |
包含图像、视频或目录路径的 CSV 文件。 |
video ✅ | 'video.mp4' |
str 或 Path |
MP4、AVI 等视频文件格式。 |
目录 ✅ | 'path/' |
str 或 Path |
包含图像或视频的目录路径。 |
glob ✅ | 'path/*.jpg' |
str |
匹配多个文件的通配符模式。使用 * 字符作为通配符。 |
YouTube ✅ | 'https://youtu.be/LNwODJXcvt4' |
str |
YouTube 视频的网址。 |
stream ✅ | 'rtsp://example.com/media.mp4' |
str |
用于流协议(如 RTSP、RTMP、TCP 或 IP 地址)的网址。 |
multi-stream ✅ | 'list.streams' |
str 或 Path |
*.streams 文本文件,每行一个流的 URL,例如批处理大小为 8 的 8 个流将同时运行。 |
下面是每种源类型的代码示例:
预测源
在图像文件上进行推理。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define path to the image file
source = "path/to/image.jpg"
# Run inference on the source
results = model(source) # list of Results objects
对当前屏幕内容(截图)进行推理。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define current screenshot as source
source = "screen"
# Run inference on the source
results = model(source) # list of Results objects
在远程托管的图像或视频上进行推理。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define remote image or video URL
source = "https://ultralytics.com/images/bus.jpg"
# Run inference on the source
results = model(source) # list of Results objects
对使用 Python Imaging Library(PIL)打开的图像进行推理。
from PIL import Image
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Open an image using PIL
source = Image.open("path/to/image.jpg")
# Run inference on the source
results = model(source) # list of Results objects
在使用 OpenCV 读取的图像上运行推理。
import cv2
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Read an image using OpenCV
source = cv2.imread("path/to/image.jpg")
# Run inference on the source
results = model(source) # list of Results objects
在表示为 numpy 数组的图像上运行推理。
import numpy as np
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Create a random numpy array of HWC shape (640, 640, 3) with values in range [0, 255] and type uint8
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype="uint8")
# Run inference on the source
results = model(source) # list of Results objects
在表示为 PyTorch 张量的图像上运行推理。
import torch
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)
# Run inference on the source
results = model(source) # list of Results objects
在 CSV 文件中列出的图像、URL、视频和目录集合上进行推理。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define a path to a CSV file with images, URLs, videos and directories
source = "path/to/file.csv"
# Run inference on the source
results = model(source) # list of Results objects
在视频文件上进行推理。通过使用stream=True
,您可以创建一个 Results 对象的生成器来减少内存使用。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define path to video file
source = "path/to/video.mp4"
# Run inference on the source
results = model(source, stream=True) # generator of Results objects
在目录中的所有图像和视频上运行推断。要还包括子目录中的图像和视频,请使用 glob 模式,例如 path/to/dir/**/*
。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define path to directory containing images and videos for inference
source = "path/to/dir"
# Run inference on the source
results = model(source, stream=True) # generator of Results objects
对匹配带有 *
字符的 glob 表达式的所有图像和视频运行推断。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define a glob search for all JPG files in a directory
source = "path/to/dir/*.jpg"
# OR define a recursive glob search for all JPG files including subdirectories
source = "path/to/dir/**/*.jpg"
# Run inference on the source
results = model(source, stream=True) # generator of Results objects
在 YouTube 视频上运行推断。通过使用 stream=True
,可以创建 Results 对象的生成器,以减少长视频的内存使用。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Define source as YouTube video URL
source = "https://youtu.be/LNwODJXcvt4"
# Run inference on the source
results = model(source, stream=True) # generator of Results objects
在远程流媒体源(使用 RTSP、RTMP、TCP 和 IP 地址协议)上运行推断。如果在 *.streams
文本文件中提供了多个流,则将运行批处理推断,即 8 个流将以批大小 8 运行,否则单个流将以批大小 1 运行。
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Single stream with batch-size 1 inference
source = "rtsp://example.com/media.mp4" # RTSP, RTMP, TCP or IP streaming address
# Multiple streams with batched inference (i.e. batch-size 8 for 8 streams)
source = "path/to/list.streams" # *.streams text file with one streaming address per row
# Run inference on the source
results = model(source, stream=True) # generator of Results objects
推断参数
model.predict()
在推断时接受多个参数,可用于覆盖默认设置:
示例
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Run inference on 'bus.jpg' with arguments
model.predict("bus.jpg", save=True, imgsz=320, conf=0.5)
推断参数:
参数 | 类型 | 默认值 | 描述 |
---|---|---|---|
source |
str |
'ultralytics/assets' |
指定推断的数据源。可以是图像路径、视频文件、目录、URL 或用于实时视频流的设备 ID。支持多种格式和来源,适用于不同类型的输入。 |
conf |
float |
0.25 |
设置检测的最小置信度阈值。置信度低于此阈值的检测对象将被忽略。调整此值有助于减少误检。 |
iou |
float |
0.7 |
非最大抑制(NMS)的交并比(IoU)阈值。较低的值通过消除重叠的框来减少检测,有助于减少重复检测。 |
imgsz |
int or tuple |
640 |
定义推断时的图像大小。可以是一个整数 640 用于正方形调整,或者是一个 (height, width) 元组。正确的尺寸可以提高检测的准确性和处理速度。 |
half |
bool |
False |
启用半精度(FP16)推断,可以在支持的 GPU 上加速模型推断,对准确性影响最小。 |
device |
str |
None |
指定推断时使用的设备(例如 cpu 、cuda:0 或 0 )。允许用户选择在 CPU、特定 GPU 或其他计算设备上执行模型。 |
max_det |
int |
300 |
每个图像允许的最大检测数。限制模型在单次推断中可以检测的对象总数,避免在密集场景中输出过多对象。 |
vid_stride |
int |
1 |
视频输入的帧步进。允许跳过视频中的帧以加快处理速度,但会降低时间分辨率。值为 1 表示处理每一帧,更高的值表示跳过帧。 |
stream_buffer |
bool |
False |
确定处理视频流时是否应缓冲所有帧 (True ),或者模型是否应返回最近的帧 (False )。对实时应用非常有用。 |
visualize |
bool |
False |
在推理过程中激活模型特征可视化,展示模型所“看到”的内容。用于调试和模型解释。 |
augment |
bool |
False |
启用测试时增强(TTA),可能提高检测的鲁棒性但会降低推理速度。 |
agnostic_nms |
bool |
False |
启用无关类别的非最大抑制(NMS),合并不同类别的重叠框。适用于多类别检测场景中常见的类别重叠情况。 |
classes |
list[int] |
None |
将预测结果过滤为一组类别 ID。仅返回属于指定类别的检测结果。用于多类检测任务中聚焦相关对象。 |
retina_masks |
bool |
False |
如果模型可用,使用高分辨率分割掩模。对于分割任务可提供更精细的掩模质量。 |
embed |
list[int] |
None |
指定提取特征向量或嵌入的层。用于聚类或相似性搜索等下游任务。 |
可视化参数:
参数 | 类型 | 默认值 | 描述 |
---|---|---|---|
show |
bool |
False |
如果为True ,在窗口中显示带有注释的图像或视频。用于开发或测试过程中的即时视觉反馈。 |
save |
bool |
False |
启用保存带有注释的图像或视频文件。用于文档、进一步分析或共享结果。 |
save_frames |
bool |
False |
在处理视频时,将各个帧保存为图像。用于提取特定帧或进行详细的逐帧分析。 |
save_txt |
bool |
False |
将检测结果保存为文本文件,格式为[class] [x_center] [y_center] [width] [height] [confidence] 。用于与其他分析工具集成。 |
save_conf |
bool |
False |
在保存的文本文件中包含置信度分数。增强后处理和分析的详细信息。 |
save_crop |
bool |
False |
保存检测到的物体的裁剪图像。用于数据增强、分析或创建特定对象的专注数据集。 |
show_labels |
bool |
True |
在视觉输出中显示每个检测结果的标签。提供检测到的对象的直观理解。 |
show_conf |
bool |
True |
显示每个检测结果的置信度分数和标签。提供模型对每个检测结果的确定性见解。 |
show_boxes |
bool |
True |
在检测到的物体周围绘制边界框。对于图像或视频帧中对象的视觉识别和定位至关重要。 |
line_width |
None 或 int |
None |
指定边界框的线宽。如果为None ,则根据图像大小自动调整线宽。提供视觉上的自定义以增强清晰度。 |
图像和视频格式
YOLOv8 支持多种图像和视频格式,详见ultralytics/data/utils.py。查看下表获取有效后缀和示例预测命令。
图像
下表列出了有效的 Ultralytics 图像格式。
图像后缀 | 示例预测命令 | 参考 |
---|---|---|
.bmp |
yolo 预测 源=image.bmp |
Microsoft BMP 文件格式 |
.dng |
yolo 预测 源=image.dng |
Adobe DNG |
.jpeg |
yolo 预测 源=image.jpeg |
JPEG |
.jpg |
yolo 预测 源=image.jpg |
JPEG |
.mpo |
yolo 预测 源=image.mpo |
多图片对象 |
.png |
yolo 预测 源=image.png |
便携式网络图形 |
.tif |
yolo 预测 源=image.tif |
标签图像文件格式 |
.tiff |
yolo 预测 源=image.tiff |
标签图像文件格式 |
.webp |
yolo 预测 源=image.webp |
WebP |
.pfm |
yolo 预测 源=image.pfm |
便携式浮点图 |
视频
下表列出了有效的 Ultralytics 视频格式。
视频后缀 | 示例预测命令 | 参考 |
---|---|---|
.asf |
yolo 预测 源=video.asf |
高级系统格式 |
.avi |
yolo 预测 源=video.avi |
音频视频交互式格式 |
.gif |
yolo 预测 源=video.gif |
图形交换格式 |
.m4v |
yolo 预测 源=video.m4v |
MPEG-4 第十四部分 |
.mkv |
yolo 预测 源=video.mkv |
Matroska |
.mov |
yolo 预测 源=video.mov |
QuickTime 文件格式 |
.mp4 |
yolo 预测 源=video.mp4 |
MPEG-4 第十四部分 - Wikipedia |
.mpeg |
yolo 预测 源=video.mpeg |
MPEG-1 第二部分 |
.mpg |
yolo 预测 源=video.mpg |
MPEG-1 第二部分 |
.ts |
yolo 预测 源=video.ts |
MPEG 传输流 |
.wmv |
yolo 预测 源=video.wmv |
Windows 媒体视频 |
.webm |
yolo 预测 源=video.webm |
WebM 项目 |
处理结果
所有 Ultralytics 的 predict()
调用将返回 Results
对象的列表:
Results
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Run inference on an image
results = model("bus.jpg") # list of 1 Results object
results = model(["bus.jpg", "zidane.jpg"]) # list of 2 Results objects
Results
对象具有以下属性:
属性 | 类型 | 描述 |
---|---|---|
orig_img |
numpy.ndarray |
原始图像的 numpy 数组。 |
orig_shape |
tuple |
原始图像形状,格式为 (height, width)。 |
boxes |
Boxes, optional |
包含检测边界框的 Boxes 对象。 |
masks |
Masks, optional |
包含检测遮罩的 Masks 对象。 |
probs |
Probs, optional |
包含分类任务每个类别概率的 Probs 对象。 |
keypoints |
Keypoints, optional |
包含每个对象检测关键点的 Keypoints 对象。 |
obb |
OBB, optional |
包含有向边界框的 OBB 对象。 |
speed |
dict |
预处理、推断和后处理速度的毫秒数字典。 |
names |
dict |
类名字典。 |
path |
str |
图像文件的路径。 |
Results
对象具有以下方法:
方法 | 返回类型 | 描述 |
---|---|---|
update() |
None |
更新结果对象的 boxes、masks 和 probs 属性。 |
cpu() |
Results |
返回所有张量在 CPU 内存上的 Results 对象副本。 |
numpy() |
Results |
返回所有张量转换为 numpy 数组的 Results 对象副本。 |
cuda() |
Results |
返回所有张量在 GPU 内存上的 Results 对象副本。 |
to() |
Results |
返回所有张量在指定设备和数据类型上的 Results 对象副本。 |
new() |
Results |
返回具有相同图像、路径和名称的新 Results 对象。 |
plot() |
numpy.ndarray |
绘制检测结果。返回带注释的图像的 numpy 数组。 |
show() |
None |
在屏幕上显示注释结果。 |
save() |
None |
将注释结果保存到文件。 |
verbose() |
str |
返回每个任务的日志字符串。 |
save_txt() |
None |
将预测保存到 txt 文件中。 |
save_crop() |
None |
将裁剪后的预测保存到 save_dir/cls/file_name.jpg 。 |
tojson() |
str |
将对象转换为 JSON 格式。 |
有关更多详情,请参阅 Results
类的文档。
Boxes
Boxes
对象可用于索引、操作和将边界框转换为不同格式。
Boxes
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Run inference on an image
results = model("bus.jpg") # results list
# View results
for r in results:
print(r.boxes) # print the Boxes object containing the detection bounding boxes
下面是 Boxes
类的方法和属性的表格,包括它们的名称、类型和描述:
名称 | 类型 | 描述 |
---|---|---|
cpu() |
方法 | 将对象移动到 CPU 内存。 |
numpy() |
方法 | 将对象转换为 numpy 数组。 |
cuda() |
方法 | 将对象移动到 CUDA 内存。 |
to() |
方法 | 将对象移动到指定设备。 |
xyxy |
属性 (torch.Tensor ) |
返回 xyxy 格式的边界框。 |
conf |
属性 (torch.Tensor ) |
返回边界框的置信度值。 |
cls |
属性 (torch.Tensor ) |
返回边界框的类别值。 |
id |
属性 (torch.Tensor ) |
返回框的轨迹 ID(如果可用)。 |
xywh |
属性 (torch.Tensor ) |
返回 xywh 格式的框。 |
xyxyn |
属性 (torch.Tensor ) |
返回以原始图像大小归一化的 xyxy 格式的框。 |
xywhn |
属性 (torch.Tensor ) |
返回以原始图像大小归一化的 xywh 格式的框。 |
更多详情请参阅 Boxes
类文档。
掩码
Masks
对象可用于索引、操作和将掩码转换为分段。
掩码
from ultralytics import YOLO
# Load a pretrained YOLOv8n-seg Segment model
model = YOLO("yolov8n-seg.pt")
# Run inference on an image
results = model("bus.jpg") # results list
# View results
for r in results:
print(r.masks) # print the Masks object containing the detected instance masks
下面是 Masks
类方法和属性的表格,包括它们的名称、类型和描述:
名称 | 类型 | 描述 |
---|---|---|
cpu() |
方法 | 返回在 CPU 内存上的掩码张量。 |
numpy() |
方法 | 将掩码张量返回为 numpy 数组。 |
cuda() |
方法 | 返回在 GPU 内存上的掩码张量。 |
to() |
方法 | 返回指定设备和数据类型的掩码张量。 |
xyn |
属性 (torch.Tensor ) |
归一化分段列表,表示为张量。 |
xy |
属性 (torch.Tensor ) |
像素坐标表示的分段列表,表示为张量。 |
更多详情请参阅 Masks
类文档。
关键点
Keypoints
对象可用于索引、操作和标准化坐标。
关键点
from ultralytics import YOLO
# Load a pretrained YOLOv8n-pose Pose model
model = YOLO("yolov8n-pose.pt")
# Run inference on an image
results = model("bus.jpg") # results list
# View results
for r in results:
print(r.keypoints) # print the Keypoints object containing the detected keypoints
下面是总结 Keypoints
类方法和属性的表格,包括它们的名称、类型和描述:
名称 | 类型 | 描述 |
---|---|---|
cpu() |
方法 | 返回在 CPU 内存上的关键点张量。 |
numpy() |
方法 | 将关键点张量返回为 numpy 数组。 |
cuda() |
方法 | 返回在 GPU 内存上的关键点张量。 |
to() |
方法 | 返回指定设备和数据类型的关键点张量。 |
xyn |
属性 (torch.Tensor ) |
归一化关键点列表,表示为张量。 |
xy |
属性 (torch.Tensor ) |
像素坐标表示的关键点列表,表示为张量。 |
conf |
属性 (torch.Tensor ) |
如果可用,则返回关键点的置信度值,否则返回 None。 |
更多详情请参阅 Keypoints
类文档。
Probs
Probs
对象可用于索引、获取分类的 top1
和 top5
索引及分数。
Probs
from ultralytics import YOLO
# Load a pretrained YOLOv8n-cls Classify model
model = YOLO("yolov8n-cls.pt")
# Run inference on an image
results = model("bus.jpg") # results list
# View results
for r in results:
print(r.probs) # print the Probs object containing the detected class probabilities
下面是总结 Probs
类方法和属性的表格:
名称 | 类型 | 描述 |
---|---|---|
cpu() |
方法 | 返回在 CPU 内存上的概率张量的副本。 |
numpy() |
方法 | 将概率张量的副本返回为 numpy 数组。 |
cuda() |
方法 | 返回在 GPU 内存上的概率张量的副本。 |
to() |
方法 | 返回指定设备和数据类型的概率张量的副本。 |
top1 |
属性 (int ) |
最高类别的索引。 |
top5 |
属性 (list[int] ) |
前五个类别的索引。 |
top1conf |
属性 (torch.Tensor ) |
最高类别的置信度。 |
top5conf |
属性 (torch.Tensor ) |
前五个类别的置信度。 |
要了解更多详情,请参阅Probs
类文档。
OBB
OBB
对象可用于索引、操作和将定向边界框转换为不同格式。
OBB
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n-obb.pt")
# Run inference on an image
results = model("bus.jpg") # results list
# View results
for r in results:
print(r.obb) # print the OBB object containing the oriented detection bounding boxes
这里是OBB
类的方法和属性表,包括它们的名称、类型和描述:
名称 | 类型 | 描述 |
---|---|---|
cpu() |
方法 | 将对象移动到 CPU 内存。 |
numpy() |
方法 | 将对象转换为 numpy 数组。 |
cuda() |
方法 | 将对象移动到 CUDA 内存。 |
to() |
方法 | 将对象移动到指定设备。 |
conf |
属性(torch.Tensor ) |
返回边界框的置信度值。 |
cls |
属性(torch.Tensor ) |
返回边界框的类别值。 |
id |
属性(torch.Tensor ) |
返回边界框的跟踪 ID(如果可用)。 |
xyxy |
属性(torch.Tensor ) |
返回 xyxy 格式的水平框。 |
xywhr |
属性(torch.Tensor ) |
返回 xywhr 格式的旋转框。 |
xyxyxyxy |
属性(torch.Tensor ) |
返回 xyxyxyxy 格式的旋转框。 |
xyxyxyxyn |
属性(torch.Tensor ) |
返回归一化为图像大小的 xyxyxyxy 格式的旋转框。 |
要了解更多详情,请参阅OBB
类文档。
绘制结果
Results
对象中的plot()
方法通过将检测到的对象(如边界框、掩码、关键点和概率)叠加到原始图像上,便于可视化预测。该方法将带注释的图像作为 NumPy 数组返回,方便显示或保存。
绘图
from PIL import Image
from ultralytics import YOLO
# Load a pretrained YOLOv8n model
model = YOLO("yolov8n.pt")
# Run inference on 'bus.jpg'
results = model(["bus.jpg", "zidane.jpg"]) # results list
# Visualize the results
for i, r in enumerate(results):
# Plot results image
im_bgr = r.plot() # BGR-order numpy array
im_rgb = Image.fromarray(im_bgr[..., ::-1]) # RGB-order PIL image
# Show results to screen (in supported environments)
r.show()
# Save results to disk
r.save(filename=f"results{i}.jpg")
plot()
方法参数
plot()
方法支持各种参数以自定义输出:
参数 | 类型 | 描述 | 默认值 |
---|---|---|---|
conf |
bool |
包括检测置信度分数。 | True |
line_width |
float |
边界框的线宽。如果为None ,则随着图像大小缩放。 |
None |
font_size |
float |
文本字体大小。如果为None ,则随着图像大小缩放。 |
None |
font |
str |
文本注释的字体名称。 | 'Arial.ttf' |
pil |
bool |
返回图像作为 PIL 图像对象。 | False |
img |
numpy.ndarray |
用于绘图的替代图像。如果为None ,则使用原始图像。 |
None |
im_gpu |
torch.Tensor |
GPU 加速的图像,用于更快的掩码绘制。形状:(1, 3, 640, 640)。 | None |
kpt_radius |
int |
绘制关键点的半径。 | 5 |
kpt_line |
bool |
使用线连接关键点。 | True |
labels |
bool |
在注释中包含类标签。 | True |
boxes |
bool |
在图像上叠加边界框。 | True |
masks |
bool |
在图像上叠加掩码。 | True |
probs |
bool |
包括分类概率。 | True |
show |
bool |
直接使用默认图像查看器显示带注释的图像。 | False |
save |
bool |
将带注释的图像保存到由filename 指定的文件中。 |
False |
filename |
str |
如果 save 为 True ,保存带注释图像的文件的路径和名称。 |
None |
线程安全推理
当您在不同线程上并行运行多个 YOLO 模型时,确保推理的线程安全性至关重要。线程安全推理确保每个线程的预测是隔离的,不会互相干扰,从而避免竞态条件,并确保输出一致和可靠。
当在多线程应用程序中使用 YOLO 模型时,重要的是为每个线程实例化单独的模型对象或使用线程本地存储来避免冲突:
线程安全推理
在每个线程内部实例化单个模型以实现线程安全推理:
from threading import Thread
from ultralytics import YOLO
def thread_safe_predict(image_path):
"""Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
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 模型的线程安全推理和逐步指南,请参阅我们的 YOLO 线程安全推理指南。该指南将为您提供避免常见问题并确保多线程推理顺利运行的所有必要信息。
流式源 for
循环
这是一个使用 OpenCV (cv2
) 和 YOLOv8 运行视频帧推理的 Python 脚本。该脚本假设您已经安装了必要的包 (opencv-python
和 ultralytics
)。
流式 for 循环
import cv2
from ultralytics import YOLO
# Load the YOLOv8 model
model = YOLO("yolov8n.pt")
# Open the video file
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)
# Loop through the video frames
while cap.isOpened():
# Read a frame from the video
success, frame = cap.read()
if success:
# Run YOLOv8 inference on the frame
results = model(frame)
# Visualize the results on the frame
annotated_frame = results[0].plot()
# Display the annotated frame
cv2.imshow("YOLOv8 Inference", annotated_frame)
# Break the loop if 'q' is pressed
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Break the loop if the end of the video is reached
break
# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()
该脚本将对视频的每一帧进行预测,可视化结果,并在窗口中显示。通过按下 'q' 键可以退出循环。
常见问题解答(FAQ)
Ultralytics YOLOv8 及其用于实时推理的预测模式是什么?
Ultralytics YOLOv8 是一种用于实时对象检测、分割和分类的先进模型。其预测模式允许用户在诸如图像、视频和实时流等多种数据源上进行高速推理。设计用于性能和多功能性,还提供批处理处理和流模式。有关其特性的更多详情,请查看 Ultralytics YOLOv8 预测模式。
如何在不同数据源上使用 Ultralytics YOLOv8 进行推理?
Ultralytics YOLOv8 可处理多种数据源,包括单个图像、视频、目录、URL 和流。您可以在 model.predict()
调用中指定数据源。例如,使用 'image.jpg'
表示本地图像,'https://ultralytics.com/images/bus.jpg'
表示 URL。请查看文档中有关各种推理源的详细示例。
如何优化 YOLOv8 推理速度和内存使用?
为了优化推理速度并有效管理内存,您可以在预测器的调用方法中设置 stream=True
来使用流模式。流模式生成一个内存高效的 Results
对象生成器,而不是将所有帧加载到内存中。对于处理长视频或大型数据集,流模式特别有用。了解更多关于流模式的信息。
Ultralytics YOLOv8 支持哪些推理参数?
YOLOv8 中的 model.predict()
方法支持各种参数,例如 conf
、iou
、imgsz
、device
等。这些参数允许您自定义推断过程,设置诸如置信阈值、图像大小和用于计算的设备等参数。关于这些参数的详细描述可以在推断参数部分找到。
如何可视化和保存 YOLOv8 预测结果?
在使用 YOLOv8 进行推断后,Results
对象包含用于显示和保存带注释图像的方法。您可以使用诸如 result.show()
和 result.save(filename="result.jpg")
的方法来可视化和保存结果。有关这些方法的详细列表,请参阅处理结果部分。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战