Ultralytics-中文文档-九-

Ultralytics 中文文档（九）

ImageNet10 数据集

原文：docs.ultralytics.com/datasets/classify/imagenet10/

ImageNet10 数据集是ImageNet 数据库的一个小规模子集，由Ultralytics 开发，旨在进行 CI 测试、健全性检查和快速训练流程测试。该数据集由 ImageNet 的前 10 个类别中的训练集第一张图像和验证集第一张图像组成。虽然规模显著较小，但保留了原始 ImageNet 数据集的结构和多样性。

主要特点

ImageNet10 是 ImageNet 的一个紧凑版本，包含原始数据集前 10 个类别的 20 张图像。
数据集按照 WordNet 层次结构进行组织，反映了完整 ImageNet 数据集的结构。
在计算机视觉任务中，它非常适合进行 CI 测试、健全性检查和训练流程的快速测试。
虽然不是为模型基准测试设计的，但可以快速指示模型的基本功能和正确性。

数据集结构

ImageNet10 数据集与原始 ImageNet 一样，采用 WordNet 层次结构进行组织。ImageNet10 的每个类别都由一个同义词集（synset）描述。ImageNet10 中的图像带有一个或多个同义词集的注释，为测试模型识别各种对象及其关系提供了紧凑的资源。

应用

ImageNet10 数据集非常适用于快速测试和调试计算机视觉模型和流程。其小规模允许快速迭代，非常适合连续集成测试和健全性检查。它还可用于新模型或现有模型更改的快速初步测试，然后再进行完整的 ImageNet 数据集测试。

使用

若要在 224x224 的图像大小上测试深度学习模型在 ImageNet10 数据集上的效果，可以使用以下代码片段。有关可用参数的详细列表，请参阅模型训练页面。

测试示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="imagenet10", epochs=5, imgsz=224)

# Start training from a pretrained *.pt model
yolo  classify  train  data=imagenet10  model=yolov8n-cls.pt  epochs=5  imgsz=224

样本图像和注释

ImageNet10 数据集包含原始 ImageNet 数据集中的一部分图像子集。这些图像被选为代表数据集中的前 10 个类别，为快速测试和评估提供了多样且紧凑的数据集。

数据集样本图像该示例展示了 ImageNet10 数据集中图像的多样性和复杂性，突显了它在健全性检查和快速测试计算机视觉模型时的实用性。

引用和致谢

如果您在研究或开发工作中使用 ImageNet10 数据集，请引用原始 ImageNet 论文：

@article{ILSVRC15,
  author  =  {Olga Russakovsky and Jia Deng and Hao Su and Jonathan Krause and Sanjeev Satheesh and Sean Ma and Zhiheng Huang and Andrej Karpathy and Aditya Khosla and Michael Bernstein and Alexander C. Berg and Li Fei-Fei},
  title={ImageNet Large Scale Visual Recognition Challenge},
  year={2015},
  journal={International Journal of Computer Vision (IJCV)},
  volume={115},
  number={3},
  pages={211-252}
}

我们要感谢由 Olga Russakovsky、Jia Deng 和 Li Fei-Fei 领导的 ImageNet 团队，他们创建并维护了 ImageNet 数据集。虽然 ImageNet10 数据集是一个紧凑的子集，但在机器学习和计算机视觉研究社区中，它是一个用于快速测试和调试的宝贵资源。关于 ImageNet 数据集及其创建者的更多信息，请访问ImageNet 网站。

常见问题

ImageNet10 数据集是什么，与完整的 ImageNet 数据集有何不同？

ImageNet10数据集是原始ImageNet数据库的紧凑子集，由 Ultralytics 创建，用于快速 CI 测试、健全性检查和训练流水线评估。ImageNet10 仅包括 20 张图像，代表 ImageNet 前 10 个类别的训练和验证集中的第一张图像。尽管规模小，但它保持了完整数据集的结构和多样性，非常适合快速测试，但不适用于模型基准测试。

如何使用 ImageNet10 数据集测试我的深度学习模型？

要在 224x224 的图像尺寸上使用 ImageNet10 数据集测试您的深度学习模型，请使用以下代码片段。

测试示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="imagenet10", epochs=5, imgsz=224)

# Start training from a pretrained *.pt model
yolo  classify  train  data=imagenet10  model=yolov8n-cls.pt  epochs=5  imgsz=224

请参阅培训页面以获取可用参数的全面列表。

为什么我应该在 CI 测试和健全性检查中使用 ImageNet10 数据集？

ImageNet10 数据集专为深度学习流水线中的 CI 测试、健全性检查和快速评估而设计。其小规模使得可以快速迭代和测试，非常适合速度至关重要的持续集成流程。通过保持原始 ImageNet 数据集的结构复杂性和多样性，ImageNet10 能够可靠地指示模型的基本功能和正确性，而无需处理大型数据集带来的额外开销。

ImageNet10 数据集的主要特点是什么？

ImageNet10 数据集具有以下几个关键特点：

紧凑大小：仅有 20 张图像，可进行快速测试和调试。
结构化组织：遵循 WordNet 层次结构，类似于完整的 ImageNet 数据集。
CI 和健全性检查：非常适合连续集成测试和健全性检查。
非基准测试：虽然用于快速模型评估很有用，但不适用于广泛的基准测试。

我从哪里可以下载 ImageNet10 数据集？

您可以从Ultralytics GitHub 发布页面下载 ImageNet10 数据集。有关其结构和应用的更详细信息，请参阅 ImageNet10 数据集页面。

ImageNette 数据集

原文：docs.ultralytics.com/datasets/classify/imagenette/

ImageNette 数据集是较大的 Imagenet 数据集的子集，但仅包括 10 个易于区分的类别。它被创建为 Imagenet 的更快、更易于使用的版本，用于软件开发和教育。

主要特点

ImageNette 包含来自十个不同类别的图像，例如 tench（鲑鱼）、English springer（英国斯普林格犬）、cassette player（卡带播放器）、chain saw（链锯）、church（教堂）、French horn（法国号）、garbage truck（垃圾车）、gas pump（加油泵）、golf ball（高尔夫球）、parachute（降落伞）。
该数据集包含尺寸不同的彩色图像。
ImageNette 在机器学习领域广泛用于训练和测试，特别是图像分类任务。

数据集结构

ImageNette 数据集分为两个子集：

训练集：该子集包含数千张用于训练机器学习模型的图像。每个类别的确切数量会有所变化。
验证集：该子集包含数百张图像，用于验证和评估训练模型。同样，每个类别的确切数量会有所变化。

应用

ImageNette 数据集在图像分类任务中广泛用于训练和评估深度学习模型，如卷积神经网络（CNNs）和其他各种机器学习算法。该数据集直观的格式和精心选择的类别，使其成为机器学习和计算机视觉领域的初学者和经验丰富从业者的便捷资源。

用法

要在 ImageNette 数据集上使用标准的图像大小为 224x224，训练模型 100 个 epoch，可以使用以下代码片段。有关可用参数的详细列表，请参阅模型训练页面。

训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="imagenette", epochs=100, imgsz=224)

# Start training from a pretrained *.pt model
yolo  classify  train  data=imagenette  model=yolov8n-cls.pt  epochs=100  imgsz=224

样本图像和注释

ImageNette 数据集包含各种对象和场景的彩色图像，为图像分类任务提供了多样化的数据集。以下是数据集中的一些示例图像：

数据集示例图像

该示例展示了 ImageNette 数据集中图像的多样性和复杂性，突显了多样化数据集对训练健壮图像分类模型的重要性。

ImageNette160 和 ImageNette320

为了更快的原型设计和训练，ImageNette 数据集还提供了两个缩减版本：ImageNette160 和 ImageNette320。这些数据集与完整的 ImageNette 数据集具有相同的类别和结构，但图像被调整到较小的尺寸。因此，这些数据集版本特别适用于初步模型测试，或者在计算资源有限时使用。

要使用这些数据集，只需在训练命令中用 'imagenette160' 或 'imagenette320' 替换 'imagenette'。以下代码片段说明了这一点：

使用 ImageNette160 的训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model with ImageNette160
results = model.train(data="imagenette160", epochs=100, imgsz=160)

# Start training from a pretrained *.pt model with ImageNette160
yolo  classify  train  data=imagenette160  model=yolov8n-cls.pt  epochs=100  imgsz=160

使用 ImageNette320 进行训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model with ImageNette320
results = model.train(data="imagenette320", epochs=100, imgsz=320)

# Start training from a pretrained *.pt model with ImageNette320
yolo  classify  train  data=imagenette320  model=yolov8n-cls.pt  epochs=100  imgsz=320

这些数据集的较小版本允许在开发过程中快速迭代，同时仍提供有价值和现实的图像分类任务。

引用和致谢

如果您在研究或开发工作中使用 ImageNette 数据集，请适当地加以确认。有关 ImageNette 数据集的更多信息，请访问ImageNette 数据集 GitHub 页面。

常见问题解答

什么是 ImageNette 数据集？

ImageNette 数据集是较大的ImageNet 数据集的简化子集，仅包含 10 个易于区分的类别，例如 tench、English springer 和 French horn。它旨在为高效的训练和评估图像分类模型提供更可管理的数据集。该数据集特别适用于快速软件开发以及机器学习和计算机视觉的教育目的。

我如何使用 ImageNette 数据集训练 YOLO 模型？

要在 ImageNette 数据集上为 YOLO 模型训练 100 个时期，您可以使用以下命令。确保已设置好 Ultralytics YOLO 环境。

训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="imagenette", epochs=100, imgsz=224)

# Start training from a pretrained *.pt model
yolo  classify  train  data=imagenette  model=yolov8n-cls.pt  epochs=100  imgsz=224

欲了解更多详细信息，请参阅训练文档页面。

我为什么要在图像分类任务中使用 ImageNette？

ImageNette 数据集有几个优点：

快速简便：仅包含 10 个类别，比大型数据集更简单和节省时间。
教育用途：适合学习和教授图像分类基础知识，因为它需要较少的计算资源和时间。
多功能性：广泛用于训练和基准测试各种机器学习模型，尤其是在图像分类中。

欲了解有关模型训练和数据集管理的详细信息，请探索数据集结构部分。

ImageNette 数据集可以用不同的图像尺寸吗？

是的，ImageNette 数据集也有两个调整大小的版本：ImageNette160 和 ImageNette320。这些版本有助于更快地进行原型设计，并在计算资源有限时特别有用。

使用 ImageNette160 进行训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")

# Train the model with ImageNette160
results = model.train(data="imagenette160", epochs=100, imgsz=160)

# Start training from a pretrained *.pt model with ImageNette160
yolo  detect  train  data=imagenette160  model=yolov8n-cls.pt  epochs=100  imgsz=160

欲了解更多信息，请参阅使用 ImageNette160 和 ImageNette320 进行训练。

ImageNette 数据集的一些实际应用是什么？

ImageNette 数据集被广泛用于：

教育设置：用于教授机器学习和计算机视觉初学者。
软件开发：用于快速原型设计和图像分类模型开发。
深度学习研究：评估和基准测试各种深度学习模型的性能，尤其是卷积神经网络（CNN）。

探索应用程序部分以获取详细的使用案例。

ImageWoof 数据集

原文：docs.ultralytics.com/datasets/classify/imagewoof/

ImageWoof 数据集是 ImageNet 的一个子集，包含 10 个具有挑战性的狗类别。这些类别很难分类，旨在鼓励开发更先进的模型。

主要特点

ImageWoof 包含 10 种不同的狗类：澳大利亚梗、边境梗、萨摩耶、比格犬、狮子狗、英国猎狐犬、罗得西亚脊背犬、澳大利亚野狗、金毛寻回犬和英国牧羊犬。
该数据集提供各种分辨率的图像（全尺寸、320px、160px），以适应不同的计算能力和研究需求。
还包括一个带有嘈杂标签的版本，提供一个更真实的场景，其中标签可能并不总是可靠的。

数据集结构

ImageWoof 数据集的结构基于狗种类，每个品种都有自己的图像目录。

应用

ImageWoof 数据集广泛用于训练和评估图像分类任务中的深度学习模型，特别是在处理更复杂和相似类别时。该数据集的挑战在于狗品种之间的微妙差异，推动模型性能和泛化能力的极限。

使用

要在 ImageWoof 数据集上使用 CNN 模型进行 100 个 epochs 的训练，图像尺寸为 224x224，可以使用以下代码片段。有关可用参数的全面列表，请参阅模型训练页面。

训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="imagewoof", epochs=100, imgsz=224)

# Start training from a pretrained *.pt model
yolo  classify  train  data=imagewoof  model=yolov8n-cls.pt  epochs=100  imgsz=224

数据集变种

ImageWoof 数据集提供三种不同尺寸，以适应各种研究需求和计算能力：

全尺寸（imagewoof）：这是 ImageWoof 数据集的原始版本。它包含全尺寸图像，非常适合最终训练和性能基准测试。
中等尺寸（imagewoof320）：此版本包含将图像调整大小至最大边长为 320 像素的图像。它适用于更快的训练，而不会显著牺牲模型性能。
小尺寸（imagewoof160）：此版本包含将图像调整大小至最大边长为 160 像素的图像。它专为快速原型设计和实验而设计，其中训练速度是优先考虑的。

要在训练中使用这些变体，只需将数据集参数中的 'imagewoof' 替换为 'imagewoof320' 或 'imagewoof160'。例如：

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# For medium-sized dataset
model.train(data="imagewoof320", epochs=100, imgsz=224)

# For small-sized dataset
model.train(data="imagewoof160", epochs=100, imgsz=224)

重要提示：使用较小的图像可能会降低分类准确性的性能。然而，在模型开发和原型设计的早期阶段，这是迭代快速的绝佳方式。

样本图像和注释

ImageWoof 数据集包含各种狗类的彩色图像，为图像分类任务提供了具有挑战性的数据集。以下是数据集中的一些示例图像：

数据集示例图像

该示例展示了 ImageWoof 数据集中不同狗品种之间的细微差别和相似之处，突显了分类任务的复杂性和困难。

引用和致谢

如果您在研究或开发工作中使用 ImageWoof 数据集，请务必通过链接到官方数据集存储库来致谢数据集的创建者。

我们要感谢 FastAI 团队为机器学习和计算机视觉研究社区创建和维护了 ImageWoof 数据集，作为宝贵的资源。有关 ImageWoof 数据集的更多信息，请访问ImageWoof 数据集存储库。

常见问题

ImageWoof 数据集在 Ultralytics 中是什么？

ImageWoof数据集是 ImageNet 的一个具有挑战性的子集，专注于 10 种特定的狗品种。旨在推动图像分类模型的极限，包括比格犬、狮子狗和金毛寻回犬等品种。该数据集包括不同分辨率（全尺寸、320px、160px）的图像，甚至包含用于更真实训练场景的噪声标签。这种复杂性使得 ImageWoof 非常适合开发更先进的深度学习模型。

如何使用 Ultralytics YOLO 训练 ImageWoof 数据集的模型？

要在图像大小为 224x224 的情况下使用 Ultralytics YOLO 在 ImageWoof 数据集上训练一个卷积神经网络（CNN）模型进行 100 个 epochs，可以使用以下代码：

训练示例

from ultralytics import YOLO

model = YOLO("yolov8n-cls.pt")  # Load a pretrained model
results = model.train(data="imagewoof", epochs=100, imgsz=224)

yolo  classify  train  data=imagewoof  model=yolov8n-cls.pt  epochs=100  imgsz=224

要获取关于可用训练参数的更多详细信息，请参考训练页面。

ImageWoof 数据集有哪些版本可用？

ImageWoof 数据集有三种尺寸：

全尺寸（imagewoof）：适合最终训练和基准测试，包含全尺寸图像。
中等尺寸（imagewoof320）：调整大小后的图像，最大边长为 320 像素，适合更快的训练速度。
小尺寸（imagewoof160）：调整大小后的图像，最大边长为 160 像素，非常适合快速原型设计。

通过相应替换数据集参数中的'imagewoof'来使用这些版本。然而，较小的图像可能会导致较低的分类准确性，但对于快速迭代可能会更有用。

ImageWoof 数据集中的噪声标签如何有益于训练？

ImageWoof 数据集中的噪声标签模拟了现实世界中可能不准确的标签条件。使用这些数据训练模型有助于开发图像分类任务中的鲁棒性和泛化能力。这使得模型能够有效处理模糊或误标记的数据，在实际应用中经常遇到这种情况。

使用 ImageWoof 数据集的主要挑战是什么？

ImageWoof 数据集的主要挑战在于其中包含的犬种之间的细微差异。由于它集中于 10 个密切相关的品种，区分它们需要更高级和精细调整的图像分类模型。这使得 ImageWoof 成为测试深度学习模型能力和改进的优秀基准。

MNIST 数据集

原文：docs.ultralytics.com/datasets/classify/mnist/

MNIST（修改过的国家标准与技术研究所数据集）数据集是一个包含手写数字的大型数据库，通常用于训练各种图像处理系统和机器学习模型。它通过“重新混合”NIST 原始数据集中的样本而创建，并已成为评估图像分类算法性能的基准。

关键特点

MNIST 包含 60,000 张训练图像和 10,000 张测试图像的手写数字。
数据集包含尺寸为 28x28 像素的灰度图像。
图像被归一化以适应 28x28 像素的边界框，并进行了抗锯齿处理，引入了灰度级别。
MNIST 在机器学习领域特别是图像分类任务中被广泛用于训练和测试。

数据集结构

MNIST 数据集分为两个子集：

训练集：这个子集包含用于训练机器学习模型的 60,000 张手写数字图像。
测试集：这个子集包含用于测试和基准测试训练模型的 10,000 张图像。

扩展 MNIST（EMNIST）

扩展 MNIST（EMNIST）是 NIST 开发和发布的新数据集，旨在取代 MNIST。虽然 MNIST 仅包括手写数字的图像，但 EMNIST 包括 NIST 特殊数据库 19 中所有大写和小写字母以及数字的图像。EMNIST 的图像经过与 MNIST 相同的过程转换为相同的 28x28 像素格式。因此，与旧的、较小的 MNIST 数据集兼容的工具可能会不经修改地与 EMNIST 一起使用。

应用程序

MNIST 数据集在深度学习模型，如卷积神经网络（CNNs），支持向量机（SVMs）和各种其他机器学习算法的训练和评估中广泛使用。该数据集简单且结构良好，是机器学习和计算机视觉领域研究人员和从业者的重要资源。

用途

要在 MNIST 数据集上使用图像大小为 32x32 训练 CNN 模型 100 个 epochs，可以使用以下代码片段。有关可用参数的详细列表，请参阅模型训练页面。

训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="mnist", epochs=100, imgsz=32)

# Start training from a pretrained *.pt model
yolo  classify  train  data=mnist  model=yolov8n-cls.pt  epochs=100  imgsz=28

示例图像和注释

MNIST 数据集包含手写数字的灰度图像，为图像分类任务提供了一个结构良好的数据集。以下是数据集中的一些图像示例：

数据集示例图像

该示例展示了 MNIST 数据集中手写数字的多样性和复杂性，突显了多样化数据集对训练鲁棒图像分类模型的重要性。

引用和致谢

如果您在您的工作中使用 MNIST 数据集

研究或开发工作，请引用以下论文：

@article{lecun2010mnist,
  title={MNIST handwritten digit database},
  author={LeCun, Yann and Cortes, Corinna and Burges, CJ},
  journal={ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist},
  volume={2},
  year={2010}
}

我们要感谢 Yann LeCun、Corinna Cortes 和 Christopher J.C. Burges 创建和维护 MNIST 数据集，作为机器学习和计算机视觉研究社区的宝贵资源。有关 MNIST 数据集及其创建者的更多信息，请访问MNIST 数据集网站。

常见问题解答

MNIST 数据集是什么，以及它在机器学习中的重要性是什么？

MNIST数据集，或者修改过的国家标准技术研究所数据集，是一个广泛使用的手写数字集合，专为训练和测试图像分类系统而设计。它包含 60,000 张训练图像和 10,000 张测试图像，全部为灰度图像，大小为 28x28 像素。该数据集的重要性在于其作为评估图像分类算法的标准基准角色，帮助研究人员和工程师比较方法并追踪领域进展。

如何使用 Ultralytics YOLO 来训练 MNIST 数据集上的模型？

要在 MNIST 数据集上使用 Ultralytics YOLO 训练模型，您可以按照以下步骤进行：

训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="mnist", epochs=100, imgsz=32)

# Start training from a pretrained *.pt model
yolo  classify  train  data=mnist  model=yolov8n-cls.pt  epochs=100  imgsz=28

对于可用训练参数的详细列表，请参阅训练页面。

MNIST 数据集和 EMNIST 数据集之间有什么区别？

MNIST 数据集仅包含手写数字，而扩展的 MNIST（EMNIST）数据集包括数字、大写和小写字母。EMNIST 作为 MNIST 的后继者开发，并使用相同的 28x28 像素图像格式，与设计用于原始 MNIST 数据集的工具和模型兼容。EMNIST 中更广泛的字符范围使其在更多种机器学习应用中变得有用。

我可以使用 Ultralytics HUB 来训练类似 MNIST 这样的自定义数据集吗？

是的，您可以使用 Ultralytics HUB 来训练类似 MNIST 这样的自定义数据集。Ultralytics HUB 提供了一个用户友好的界面，用于上传数据集、训练模型和管理项目，无需广泛的编码知识。有关如何入门的更多详细信息，请查看Ultralytics HUB 快速入门页面。

定向边界框（OBB）数据集概述

原文：docs.ultralytics.com/datasets/obb/

使用定向边界框（OBB）训练精确的目标检测模型需要一个完整的数据集。本指南介绍了与 Ultralytics YOLO 模型兼容的各种 OBB 数据集格式，提供了关于它们的结构、应用和格式转换方法的见解。

支持的 OBB 数据集格式

YOLO OBB 格式

YOLO OBB 格式通过其在 0 到 1 之间标准化的四个角点坐标指定边界框。它遵循以下格式：

class_index  x1  y1  x2  y2  x3  y3  x4  y4

在内部，YOLO 使用 xywhr 格式处理损失和输出，表示边界框的中心点（xy）、宽度、高度和旋转。

OBB 格式示例

上述图像的 *.txt 标签文件示例，其中包含了类别 0 的 OBB 格式对象，可能如下所示：

0  0.780811  0.743961  0.782371  0.74686  0.777691  0.752174  0.776131  0.749758

使用方法

使用这些 OBB 格式训练模型：

示例

from ultralytics import YOLO

# Create a new YOLOv8n-OBB model from scratch
model = YOLO("yolov8n-obb.yaml")

# Train the model on the DOTAv2 dataset
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=640)

# Train a new YOLOv8n-OBB model on the DOTAv2 dataset
yolo  obb  train  data=DOTAv1.yaml  model=yolov8n-obb.pt  epochs=100  imgsz=640

支持的数据集

目前支持以下带有定向边界框的数据集：

DOTA-v2：DOTA（用于航空图像中目标检测的大规模数据集）第二版，重点是从航空视角进行检测，包含了 1.7 百万个实例和 11,268 张图像的定向边界框。
DOTA8：DOTA 数据集的小型 8 张图像子集，适合测试在 ultralytics 仓库中进行的 OBB 训练工作流程和持续集成（CI）检查。

合并您自己的 OBB 数据集

对于希望引入自己的定向边界框数据集的用户，请确保其与上述“YOLO OBB 格式”兼容。将您的注释转换为此所需格式，并在相应的 YAML 配置文件中详细说明路径、类别和类名。

转换标签格式

DOTA 数据集格式转换为 YOLO OBB 格式

可以使用此脚本将标签从 DOTA 数据集格式转换为 YOLO OBB 格式：

示例

from ultralytics.data.converter import convert_dota_to_yolo_obb

convert_dota_to_yolo_obb("path/to/DOTA")

这种转换机制对于 DOTA 格式的数据集至关重要，确保与 Ultralytics YOLO OBB 格式的对齐。

验证数据集与模型的兼容性并遵循必要的格式约定至关重要。结构良好的数据集对于使用定向边界框训练高效的目标检测模型至关重要。

常见问题

定向边界框（OBB）是什么，它们在 Ultralytics YOLO 模型中如何使用？

定向边界框（OBB）是一种边界框注释类型，其中框可以旋转以更紧密地与要检测的对象对齐，而不仅仅是轴对齐。这在航空或卫星图像中特别有用，因为对象可能与图像轴不对齐。在 Ultralytics YOLO 模型中，OBB 通过其在 YOLO OBB 格式中的四个角点表示。这样做可以更准确地检测对象，因为边界框可以旋转以更好地适应对象。

如何将我现有的 DOTA 数据集标签转换为 YOLO OBB 格式，以便与 Ultralytics YOLOv8 使用？

您可以使用 Ultralytics 的 convert_dota_to_yolo_obb 函数将 DOTA 数据集标签转换为 YOLO OBB 格式。此转换确保与 Ultralytics YOLO 模型兼容，使您能够利用 OBB 功能来增强对象检测。以下是一个快速示例：

from ultralytics.data.converter import convert_dota_to_yolo_obb

convert_dota_to_yolo_obb("path/to/DOTA")

此脚本将重新格式化您的 DOTA 注释以符合 YOLO 兼容格式。

如何在我的数据集上使用定向边界框（OBB）训练 YOLOv8 模型？

使用 OBB 训练 YOLOv8 模型涉及确保您的数据集采用 YOLO OBB 格式，然后使用 Ultralytics API 训练模型。以下是 Python 和 CLI 的示例：

示例

from ultralytics import YOLO

# Create a new YOLOv8n-OBB model from scratch
model = YOLO("yolov8n-obb.yaml")

# Train the model on the custom dataset
results = model.train(data="your_dataset.yaml", epochs=100, imgsz=640)

# Train a new YOLOv8n-OBB model on the custom dataset
yolo  obb  train  data=your_dataset.yaml  model=yolov8n-obb.yaml  epochs=100  imgsz=640

这确保您的模型利用详细的 OBB 注释以提高检测精度。

Ultralytics YOLO 模型当前支持哪些用于 OBB 训练的数据集？

目前，Ultralytics 支持以下数据集进行 OBB 训练：

DOTA-v2：该数据集包含 170 万个带有定向边界框的实例和 11,268 张图像，主要专注于航空物体检测。
DOTA8：DOTA 数据集的一个较小的子集，包含 8 张图像，用于测试和持续集成（CI）检查。

这些数据集专为 OBB 在航空和卫星图像分析等场景中提供显著优势而设计。

我可以使用带有定向边界框的自定义数据集进行 YOLOv8 训练吗？如果可以，如何操作？

是的，您可以使用带有定向边界框的自定义数据集进行 YOLOv8 训练。确保您的数据集注释已转换为 YOLO OBB 格式，这涉及通过四个角点定义边界框。然后，您可以创建一个 YAML 配置文件，指定数据集路径、类别和其他必要细节。有关创建和配置数据集的更多信息，请参阅支持的数据集部分。

带 OBB 的 DOTA 数据集

原文：docs.ultralytics.com/datasets/obb/dota-v2/

DOTA是一个专门的数据集，强调空中图像中的目标检测。源自 DOTA 系列数据集，提供了带有定向边界框（OBB）的标注图像，捕捉了多样的空中场景。

DOTA 类别视觉化

主要特点

收集自各种传感器和平台，图像尺寸从 800 × 800 到 20,000 × 20,000 像素不等。
跨 18 个类别具有超过 170 万个定向边界框。
包括多尺度目标检测。
实例由专家使用任意（8 自由度）的四边形进行标注，捕捉不同尺度、方向和形状的对象。

数据集版本

DOTA-v1.0

包含 15 个常见类别。
包括 2,806 张图像，包含 188,282 个实例。
分割比例：1/2 用于训练，1/6 用于验证，1/3 用于测试。

DOTA-v1.5

包含与 DOTA-v1.0 相同的图像。
非常小的实例（小于 10 像素）也被标注了。
新类别的增加："集装箱起重机"。
总共有 403,318 个实例。
发布于 2019 年 DOAI 挑战赛上，专注于空中图像目标检测。

DOTA-v2.0

收集自谷歌地球、GF-2 卫星和其他空中图像。
包含 18 个常见类别。
包括 11,268 张图像，具有令人惊叹的 1,793,658 个实例。
新引入的类别包括："机场" 和 "直升机停机坪"。
图像分割：
- 训练集：1,830 张图像，包含 268,627 个实例。
- 验证：593 张图像，包含 81,048 个实例。
- 测试开发集：2,792 张图像，包含 353,346 个实例。
- 测试挑战：6,053 张图像，包含 1,090,637 个实例。

数据集结构

DOTA 展示了专门针对 OBB 目标检测挑战的结构化布局：

图像：包括多样的地形和结构的高分辨率空中图像的大量收集。
定向边界框：以旋转矩形的形式进行标注，适合捕捉飞机、船只和建筑物等不同方向的对象。

应用

DOTA 作为专门针对空中图像分析的模型训练和评估的基准。通过 OBB 标注的加入，提供了一个独特的挑战，促进了专门针对空中图像的目标检测模型的发展。

数据集 YAML

通常，数据集包括一个 YAML（Yet Another Markup Language）文件，详细说明数据集的配置。对于 DOTA v1 和 DOTA v1.5，Ultralytics 提供了DOTAv1.yaml和DOTAv1.5.yaml文件。有关这些文件以及 DOTA v2 的更多详细信息，请参阅 DOTA 的官方存储库和文档。

DOTAv1.yaml

# Ultralytics YOLO 🚀, AGPL-3.0 license
# DOTA 1.0 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── dota1  ← downloads here (2GB)

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path:  ../datasets/DOTAv1  # dataset root dir
train:  images/train  # train images (relative to 'path') 1411 images
val:  images/val  # val images (relative to 'path') 458 images
test:  images/test  # test images (optional) 937 images

# Classes for DOTA 1.0
names:
  0:  plane
  1:  ship
  2:  storage tank
  3:  baseball diamond
  4:  tennis court
  5:  basketball court
  6:  ground track field
  7:  harbor
  8:  bridge
  9:  large vehicle
  10:  small vehicle
  11:  helicopter
  12:  roundabout
  13:  soccer ball field
  14:  swimming pool

# Download script/URL (optional)
download:  https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.zip

拆分 DOTA 图像

为了训练 DOTA 数据集，我们将原始的高分辨率 DOTA 图像以多尺度方式拆分成 1024x1024 分辨率的图像。

图像分割

from ultralytics.data.split_dota import split_test, split_trainval

# split train and val set, with labels.
split_trainval(
    data_root="path/to/DOTAv1.0/",
    save_dir="path/to/DOTAv1.0-split/",
    rates=[0.5, 1.0, 1.5],  # multiscale
    gap=500,
)
# split test set, without labels.
split_test(
    data_root="path/to/DOTAv1.0/",
    save_dir="path/to/DOTAv1.0-split/",
    rates=[0.5, 1.0, 1.5],  # multiscale
    gap=500,
)

使用方法

要在 DOTA v1 数据集上训练模型，您可以使用以下代码片段。始终参考您模型的文档以获取可用参数的详尽列表。

警告

请注意，DOTAv1 数据集中的所有图像和相关注释可用于学术目的，但商业用途被禁止。非常感谢您理解和尊重数据集创建者的愿望！

Train 示例

from ultralytics import YOLO

# Create a new YOLOv8n-OBB model from scratch
model = YOLO("yolov8n-obb.yaml")

# Train the model on the DOTAv2 dataset
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=640)

# Train a new YOLOv8n-OBB model on the DOTAv2 dataset
yolo  obb  train  data=DOTAv1.yaml  model=yolov8n-obb.pt  epochs=100  imgsz=640

样本数据和注释

浏览数据集可见其深度：

数据集示例图像

DOTA 示例：此快照突显了航空场景的复杂性和面向对象的边界框注释的重要性，捕捉了对象的自然方向。

数据集的丰富性提供了关于专属于航空影像的目标检测挑战的宝贵见解。

引用和致谢

对于那些在努力中利用 DOTA 的人，引用相关研究论文是非常重要的。

@article{9560031,
  author={Ding, Jian and Xue, Nan and Xia, Gui-Song and Bai, Xiang and Yang, Wen and Yang, Michael and Belongie, Serge and Luo, Jiebo and Datcu, Mihai and Pelillo, Marcello and Zhang, Liangpei},
  journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
  title={Object Detection in Aerial Images: A Large-Scale Benchmark and Challenges},
  year={2021},
  volume={},
  number={},
  pages={1-1},
  doi={10.1109/TPAMI.2021.3117983}
}

特别感谢 DOTA 数据集背后的团队，他们在策划这个数据集方面做出了值得称赞的努力。要全面了解数据集及其细微差别，请访问官方 DOTA 网站。

常见问题

DOTA 数据集是什么，以及它在航空影像目标检测中的重要性是什么？

DOTA 数据集是一个专注于航空影像目标检测的专业数据集。它采用了面向对象的边界框（OBB），提供了来自多样航空场景的注释图像。DOTA 在其 1.7M 注释和 18 个类别中展示了对象方向、尺度和形状的多样性，非常适合开发和评估专门用于航空影像分析的模型，例如用于监控、环境监测和灾害管理的模型。

DOTA 数据集如何处理图像中的不同尺度和方向？

DOTA 使用面向对象的边界框（OBB）进行注释，这些由旋转矩形表示，无论其方向如何，都能准确地捕捉对象。数据集的多尺度图像范围从 800 × 800 到 20,000 × 20,000 像素，进一步允许有效检测小型和大型对象。

如何使用 DOTA 数据集训练模型？

要在 DOTA 数据集上训练模型，您可以使用以下示例与 Ultralytics YOLO：

Train 示例

from ultralytics import YOLO

# Create a new YOLOv8n-OBB model from scratch
model = YOLO("yolov8n-obb.yaml")

# Train the model on the DOTAv1 dataset
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=640)

# Train a new YOLOv8n-OBB model on the DOTAv1 dataset
yolo  obb  train  data=DOTAv1.yaml  model=yolov8n-obb.pt  epochs=100  imgsz=640

关于如何拆分和预处理 DOTA 图像的详细信息，请参考拆分 DOTA 图像部分。

DOTA-v1.0、DOTA-v1.5 和 DOTA-v2.0 之间有什么区别？

DOTA-v1.0：包括 15 个常见类别，在 2,806 张图像中有 188,282 个实例。数据集被分为训练、验证和测试集。
DOTA-v1.5：在 DOTA-v1.0 的基础上，通过标注非常小的实例（小于 10 像素），并添加了一个新的类别，“集装箱起重机”，总计 403,318 个实例。
DOTA-v2.0：通过 Google Earth 和 GF-2 卫星的标注进一步扩展，包括 11,268 张图像和 1,793,658 个实例。它包含了新的类别如“机场”和“直升机停机坪”。

欲进行详细比较和额外的具体信息，请查看数据集版本部分。

如何为训练准备高分辨率的 DOTA 图像？

DOTA 图像可能非常大，因此会将其分割为更小的分辨率以便于管理的训练。以下是一个 Python 代码片段用于分割图像：

示例

from ultralytics.data.split_dota import split_test, split_trainval

# split train and val set, with labels.
split_trainval(
    data_root="path/to/DOTAv1.0/",
    save_dir="path/to/DOTAv1.0-split/",
    rates=[0.5, 1.0, 1.5],  # multiscale
    gap=500,
)
# split test set, without labels.
split_test(
    data_root="path/to/DOTAv1.0/",
    save_dir="path/to/DOTAv1.0-split/",
    rates=[0.5, 1.0, 1.5],  # multiscale
    gap=500,
)

这一过程有助于提高训练效率和模型性能。欲获取详细说明，请访问分割 DOTA 图像部分。

DOTA8 数据集

原文：docs.ultralytics.com/datasets/obb/dota8/

介绍

Ultralytics DOTA8 是一个小型但多功能的有向目标检测数据集，由 DOTAv1 集的前 8 张图像中的第一 8 张图像组成，用于训练 4 张和验证 4 张。该数据集非常适合测试和调试对象检测模型，或者尝试新的检测方法。有了 8 张图像，它足够小，可以轻松管理，但又足够多样，以测试训练管道中的错误并作为在训练更大数据集之前的合理性检查。

该数据集适用于 Ultralytics 的HUB和YOLOv8。

数据集 YAML

一个 YAML（Yet Another Markup Language）文件用于定义数据集配置。它包含有关数据集路径、类别和其他相关信息的信息。在 DOTA8 数据集的情况下，dota8.yaml文件维护在github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dota8.yaml。

ultralytics/cfg/datasets/dota8.yaml

# Ultralytics YOLO 🚀, AGPL-3.0 license
# DOTA8 dataset 8 images from split DOTAv1 dataset by Ultralytics
# Documentation: https://docs.ultralytics.com/datasets/obb/dota8/
# Example usage: yolo train model=yolov8n-obb.pt data=dota8.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── dota8  ← downloads here (1MB)

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path:  ../datasets/dota8  # dataset root dir
train:  images/train  # train images (relative to 'path') 4 images
val:  images/val  # val images (relative to 'path') 4 images

# Classes for DOTA 1.0
names:
  0:  plane
  1:  ship
  2:  storage tank
  3:  baseball diamond
  4:  tennis court
  5:  basketball court
  6:  ground track field
  7:  harbor
  8:  bridge
  9:  large vehicle
  10:  small vehicle
  11:  helicopter
  12:  roundabout
  13:  soccer ball field
  14:  swimming pool

# Download script/URL (optional)
download:  https://github.com/ultralytics/assets/releases/download/v0.0.0/dota8.zip

使用方法

要在 DOTA8 数据集上使用 640 像素的图像大小训练 YOLOv8n-obb 模型 100 个 epochs，您可以使用以下代码片段。有关可用参数的详细列表，请参阅模型训练页面。

训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-obb.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)

# Start training from a pretrained *.pt model
yolo  obb  train  data=dota8.yaml  model=yolov8n-obb.pt  epochs=100  imgsz=640

样本图像和注释

以下是 DOTA8 数据集中图像的一些示例及其相应的注释：

数据集示例图像

拼接图像：此图展示了由拼接数据集图像组成的训练批次。拼接是一种在训练过程中将多个图像合并成单个图像的技术，以增加每个训练批次中对象和场景的多样性。这有助于提高模型对不同对象大小、长宽比和上下文的泛化能力。

该示例展示了 DOTA8 数据集中图像的多样性和复杂性，以及在训练过程中使用拼接的好处。

引用和致谢

如果您在研究或开发工作中使用 DOTA 数据集，请引用以下论文：

@article{9560031,
  author={Ding, Jian and Xue, Nan and Xia, Gui-Song and Bai, Xiang and Yang, Wen and Yang, Michael and Belongie, Serge and Luo, Jiebo and Datcu, Mihai and Pelillo, Marcello and Zhang, Liangpei},
  journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
  title={Object Detection in Aerial Images: A Large-Scale Benchmark and Challenges},
  year={2021},
  volume={},
  number={},
  pages={1-1},
  doi={10.1109/TPAMI.2021.3117983}
}

特别感谢 DOTA 数据集团队为策划此数据集所作的值得称赞的努力。要全面了解数据集及其细微差别，请访问官方 DOTA 网站。

常见问题

DOTA8 数据集是什么以及如何使用它？

DOTA8 数据集是一个小型、多用途的面向对象检测数据集，由 DOTAv1 拆分集中的前 8 个图像组成，其中 4 个用于训练，4 个用于验证。它非常适合测试和调试像 Ultralytics YOLOv8 这样的物体检测模型。由于其可管理的大小和多样性，它有助于识别管道错误并在部署更大数据集之前进行健全性检查。了解更多关于使用Ultralytics YOLOv8 进行物体检测的信息。

如何使用 DOTA8 数据集训练 YOLOv8 模型？

要在 DOTA8 数据集上训练一个 100 个 epochs、图像尺寸为 640 的 YOLOv8n-obb 模型，您可以使用以下代码片段。有关详细的参数选项，请参考模型训练页面。

训练示例

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n-obb.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)

# Start training from a pretrained *.pt model
yolo  obb  train  data=dota8.yaml  model=yolov8n-obb.pt  epochs=100  imgsz=640

DOTA 数据集的关键特性是什么，我可以在哪里获取 YAML 文件？

DOTA 数据集以其大规模基准和在航空图像中物体检测中所提出的挑战而闻名。DOTA8 子集是一个较小、可管理的数据集，非常适合进行初步测试。您可以在这个GitHub 链接上访问dota8.yaml文件，其中包含路径、类别和配置细节。

拼接如何增强使用 DOTA8 数据集进行模型训练？

在训练期间，拼接技术将多个图像组合成一个图像，增加了每个批次中对象和场景的多样性。这有助于模型更好地泛化到不同的对象大小、长宽比和场景中。通过由拼接的 DOTA8 数据集图像组成的训练批次，可以直观展示这一技术，有助于稳健的模型开发。在我们的训练页面上进一步了解更多关于拼接和训练技术的信息。

为什么我应该在物体检测任务中使用 Ultralytics YOLOv8？

Ultralytics YOLOv8 提供了最先进的实时物体检测能力，包括面向边界框（OBB）、实例分割和高度灵活的训练流程。它适用于各种应用，并提供了预训练模型以进行高效的微调。进一步了解优势和使用方法，请参阅Ultralytics YOLOv8 文档。

多物体跟踪数据集概述

原文：docs.ultralytics.com/datasets/track/

数据集格式（即将推出）

多物体检测器无需独立训练，直接支持预训练的检测、分割或姿态模型。独立跟踪器训练的支持即将推出。

用法

示例

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)

yolo  track  model=yolov8n.pt  source="https://youtu.be/LNwODJXcvt4"  conf=0.3,  iou=0.5  show

FAQ

我如何使用 Ultralytics YOLO 进行多物体跟踪？

要使用 Ultralytics YOLO 进行多物体跟踪，您可以从提供的 Python 或 CLI 示例开始。以下是如何开始的方法：

示例

from ultralytics import YOLO

model = YOLO("yolov8n.pt")  # Load the YOLOv8 model
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)

yolo  track  model=yolov8n.pt  source="https://youtu.be/LNwODJXcvt4"  conf=0.3  iou=0.5  show

这些命令加载了 YOLOv8 模型，并使用特定置信度（conf）和 IoU（Intersection over Union，iou）阈值跟踪给定视频源中的物体。有关更多详细信息，请参阅跟踪模式文档。

Ultralytics 用于训练跟踪器的即将推出的功能有哪些？

Ultralytics 正在不断增强其 AI 模型。即将推出的功能将支持独立跟踪器的训练。在此之前，多物体检测器利用预训练的检测、分割或姿态模型进行跟踪，无需独立训练。通过关注我们的博客或查看即将推出的功能，保持更新。

为什么我应该使用 Ultralytics YOLO 进行多物体跟踪？

Ultralytics YOLO 是一种以其实时性能和高准确性而闻名的最先进的目标检测模型。使用 YOLO 进行多物体跟踪具有多个优势：

实时跟踪： 实现高效率和高速度的跟踪，非常适合动态环境。
使用预训练模型的灵活性： 无需从头开始训练；直接使用预训练的检测、分割或姿态模型。
易于使用： 简单的 Python 和 CLI API 集成使得设置跟踪流水线变得简单直接。
广泛的文档和社区支持： Ultralytics 提供了全面的文档和一个活跃的社区论坛，以解决问题并增强您的跟踪模型。

有关设置和使用 YOLO 进行跟踪的更多详细信息，请访问我们的跟踪使用指南。

我可以使用自定义数据集来进行 Ultralytics YOLO 的多物体跟踪吗？

是的，您可以使用自定义数据集来进行 Ultralytics YOLO 的多物体跟踪。虽然独立跟踪器训练的支持即将推出，但您已经可以在自定义数据集上使用预训练模型。准备符合 YOLO 兼容的适当格式的数据集，并按照文档集成它们。

我如何解释 Ultralytics YOLO 跟踪模型的结果？

在使用 Ultralytics YOLO 运行跟踪作业后，结果包括跟踪对象的各种数据点，如跟踪的物体 ID、它们的边界框和置信度分数。这里是如何解释这些结果的简要概述：

跟踪的 ID： 每个物体都被分配了一个唯一的 ID，这有助于在帧间进行跟踪。
边界框： 这些指示了帧内跟踪对象的位置。
置信度分数： 这些反映了模型对检测到的跟踪对象的信心。

对于详细的解释和可视化这些结果的指导，请参考结果处理指南。

Ultralytics 解决方案：利用 YOLOv8 解决现实世界的问题

原文：docs.ultralytics.com/solutions/

Ultralytics 解决方案提供 YOLO 模型的前沿应用，包括对象计数、模糊处理和安全系统，提高各行业的效率和准确性。探索 YOLOv8 在实际中的实施力量。

Ultralytics 解决方案缩略图

解决方案

这是我们精心策划的 Ultralytics 解决方案列表，可用于创建令人印象深刻的计算机视觉项目。

对象计数 🚀 新功能：学习使用 YOLOv8 进行实时对象计数。掌握在实时视频流中准确计数对象的技能。
对象裁剪 🚀 新功能：使用 YOLOv8 精确裁剪图像和视频中的对象，实现精准提取。
对象模糊处理 🚀 新功能：使用 YOLOv8 对象模糊处理，保护图像和视频的隐私。
运动监测 🚀 新功能：探索如何使用 YOLOv8 监测运动。学习实时跟踪和分析各种健身活动。
区域内的对象计数 🚀 新功能：使用 YOLOv8 在特定区域内计数对象，实现精准检测。
安全警报系统 🚀 新功能：使用 YOLOv8 创建安全警报系统，在检测到新对象时触发警报。根据特定需求定制系统。
热图 🚀 新功能：利用检测热图可视化矩阵内数据强度，为计算机视觉任务提供清晰的洞察。
实例分割与对象追踪 🚀 新功能：使用 YOLOv8 实现实例分割和对象追踪，精确获取对象边界并进行持续监控。
VisionEye 视觉对象映射 🚀 新功能：开发系统，模仿人眼对特定对象的聚焦，增强计算机辨别和优先处理细节的能力。
速度估算 🚀 新功能：利用 YOLOv8 和对象追踪技术估算对象的速度，对自动驾驶车辆和交通监测等应用至关重要。
距离计算 🚀 新功能：使用 YOLOv8 中的边界框质心计算对象之间的距离，对空间分析至关重要。
排队管理 🚀 新功能：使用 YOLOv8 实现高效的排队管理系统，减少等待时间，提高生产效率。
停车管理 🚀 新功能：使用 YOLOv8 在停车区域组织和引导车辆流，优化空间利用和用户体验。
分析 📊 新功能：进行全面的数据分析，发现模式并做出知情决策，利用 YOLOv8 进行描述性、预测性和指导性分析。
Streamlit 实时推理 🚀 新功能：通过用户友好的 Streamlit 界面直接在网页浏览器中利用 YOLOv8 进行实时对象检测。

为我们的解决方案做出贡献

我们欢迎社区贡献！如果您精通超派科技 YOLO 的某一方面，而我们的解决方案尚未涵盖，请分享您的专业知识。撰写指南是回馈社区并帮助我们使文档更加全面和用户友好的好方法。

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

让我们共同努力，使超派科技 YOLO 生态系统更加强大和多样化 🙏！

常见问题

如何使用超派科技 YOLO 进行实时物体计数？

超派科技 YOLOv8 可以通过其先进的物体检测能力进行实时物体计数。您可以按照我们的物体计数详细指南设置 YOLOv8 以进行实时视频流分析。只需安装 YOLOv8，加载模型，处理视频帧以动态计数物体。

使用超派科技 YOLO 的安全系统有哪些好处？

超派科技 YOLOv8 通过提供实时物体检测和警报机制来增强安全系统。通过使用 YOLOv8，您可以创建一个安全警报系统，当监控区域检测到新对象时触发警报。了解如何设置使用 YOLOv8 进行强大安全监控的安全警报系统。

超派科技 YOLO 如何改善排队管理系统？

超派科技 YOLOv8 可以通过准确计数和跟踪排队中的人员显著改善排队管理系统，从而帮助减少等待时间并优化服务效率。请按照我们的排队管理详细指南学习如何实现使用 YOLOv8 进行有效排队监控和分析。

超派科技的 YOLO 可以用于监控健身训练吗？

是的，超派科技 YOLOv8 可以通过跟踪和分析实时的健身例程有效地用于监控健身训练。这允许精确评估锻炼形式和表现。探索我们的健身监控指南，了解如何使用 YOLOv8 设置基于 AI 的健身监控系统。

超派科技 YOLO 如何帮助创建数据可视化的热图？

超派科技 YOLOv8 可以生成热图，可视化给定区域内的数据强度，突出显示高活动或感兴趣的区域。此功能在理解各种计算机视觉任务中的模式和趋势方面尤为有用。了解如何使用 YOLOv8 创建和使用热图进行全面的数据分析和可视化。

Analytics using Ultralytics YOLOv8

原文：docs.ultralytics.com/guides/analytics/

Introduction

本指南全面介绍了三种基本数据可视化类型：线图、条形图和饼图。每个部分都包括使用 Python 创建这些可视化的逐步说明和代码片段。

Visual Samples

Line Graph	Bar Plot	Pie Chart

Why Graphs are Important

线图适合追踪短期和长期的变化，并比较同一时期多个组的变化。
另一方面，条形图适合比较不同类别的数量，并展示类别与其数值之间的关系。
最后，饼图适合用于说明各类别之间的比例及展示整体中的各部分。

Analytics Examples

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.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))

out = cv2.VideoWriter("line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="line",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)
total_counts = 0
frame_count = 0

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

    if success:
        frame_count += 1
        results = model.track(frame, persist=True, verbose=True)

        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            for box in boxes:
                total_counts += 1

        analytics.update_line(frame_count, total_counts)

        total_counts = 0
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.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))
out = cv2.VideoWriter("multiple_line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="line",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
    max_points=200,
)

frame_count = 0
data = {}
labels = []

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

    if success:
        frame_count += 1

        results = model.track(frame, persist=True)

        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            track_ids = results[0].boxes.id.int().cpu().tolist()
            clss = results[0].boxes.cls.cpu().tolist()

            for box, track_id, cls in zip(boxes, track_ids, clss):
                # Store each class label
                if model.names[int(cls)] not in labels:
                    labels.append(model.names[int(cls)])

                # Store each class count
                if model.names[int(cls)] in data:
                    data[model.names[int(cls)]] += 1
                else:
                    data[model.names[int(cls)]] = 0

        # update lines every frame
        analytics.update_multiple_lines(data, labels, frame_count)
        data = {}  # clear the data list for next frame
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.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))

out = cv2.VideoWriter("pie_chart.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="pie",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)

clswise_count = {}

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True, verbose=True)
        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            clss = results[0].boxes.cls.cpu().tolist()
            for box, cls in zip(boxes, clss):
                if model.names[int(cls)] in clswise_count:
                    clswise_count[model.names[int(cls)]] += 1
                else:
                    clswise_count[model.names[int(cls)]] = 1

            analytics.update_pie(clswise_count)
            clswise_count = {}

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.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))

out = cv2.VideoWriter("bar_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="bar",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)

clswise_count = {}

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True, verbose=True)
        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xyxy.cpu()
            clss = results[0].boxes.cls.cpu().tolist()
            for box, cls in zip(boxes, clss):
                if model.names[int(cls)] in clswise_count:
                    clswise_count[model.names[int(cls)]] += 1
                else:
                    clswise_count[model.names[int(cls)]] = 1

            analytics.update_bar(clswise_count)
            clswise_count = {}

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.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))

out = cv2.VideoWriter("area_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(
    type="area",
    writer=out,
    im0_shape=(w, h),
    view_img=True,
)

clswise_count = {}
frame_count = 0

while cap.isOpened():
    success, frame = cap.read()
    if success:
        frame_count += 1
        results = model.track(frame, persist=True, verbose=True)

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

            for box, cls in zip(boxes, clss):
                if model.names[int(cls)] in clswise_count:
                    clswise_count[model.names[int(cls)]] += 1
                else:
                    clswise_count[model.names[int(cls)]] = 1

        analytics.update_area(frame_count, clswise_count)
        clswise_count = {}
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Argument `Analytics`

这里有一个包含Analytics参数的表格：

Name	Type	Default	Description
`type`	`str`	`None`	Type of data or object.
`im0_shape`	`tuple`	`None`	Shape of the initial image.
`writer`	`cv2.VideoWriter`	`None`	Object for writing video files.
`title`	`str`	`ultralytics`	Title for the visualization.
`x_label`	`str`	`x`	Label for the x-axis.
`y_label`	`str`	`y`	Label for the y-axis.
`bg_color`	`str`	`white`	Background color.
`fg_color`	`str`	`black`	Foreground color.
`line_color`	`str`	`yellow`	Color of the lines.
`line_width`	`int`	`2`	Width of the lines.
`fontsize`	`int`	`13`	Font size for text.
`view_img`	`bool`	`False`	Flag to display the image or video.
`save_img`	`bool`	`True`	Flag to save the image or video.
`max_points`	`int`	`50`	For multiple lines, total points drawn on frame, before deleting initial points.
`points_width`	`int`	`15`	Width of line points highlighter.

Arguments `model.track`

Name	Type	Default	Description
`source`	`im0`	`None`	source directory for images or videos
`persist`	`bool`	`False`	persisting tracks between frames
`tracker`	`str`	`botsort.yaml`	Tracking method 'bytetrack' or 'botsort'
`conf`	`float`	`0.3`	Confidence Threshold
`iou`	`float`	`0.5`	IOU Threshold
`classes`	`list`	`None`	filter results by class, i.e. classes=0, or classes=[0,2,3]
`verbose`	`bool`	`True`	Display the object tracking results

Conclusion

理解何时以及如何使用不同类型的可视化对于有效的数据分析至关重要。折线图、条形图和饼图是可以帮助您更清晰和更有效地传达数据故事的基本工具。

常见问题解答

如何使用 Ultralytics YOLOv8 Analytics 创建折线图？

要使用 Ultralytics YOLOv8 Analytics 创建折线图，请按照以下步骤操作：

加载 YOLOv8 模型并打开您的视频文件。
使用类型设置为“线”的Analytics类进行初始化。
迭代视频帧，更新包含每帧对象计数等相关数据的折线图。
保存显示折线图的输出视频。

示例：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="line", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        total_counts = sum([1 for box in results[0].boxes.xyxy])
        analytics.update_line(frame_count, total_counts)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

要进一步了解如何配置Analytics类，请访问使用 Ultralytics YOLOv8 📊部分。

使用 Ultralytics YOLOv8 创建条形图的好处是什么？

使用 Ultralytics YOLOv8 创建条形图具有多个优点：

实时数据可视化：无缝集成对象检测结果到条形图中进行动态更新。
易用性：简单的 API 和功能使得实现和可视化数据变得直接。
定制化：根据您的特定需求自定义标题、标签、颜色等。
高效性：高效处理大量数据，并在视频处理期间实时更新绘图。

使用以下示例生成条形图：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("bar_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="bar", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        clswise_count = {
            model.names[int(cls)]: boxes.size(0)
            for cls, boxes in zip(results[0].boxes.cls.tolist(), results[0].boxes.xyxy)
        }
        analytics.update_bar(clswise_count)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

要了解更多，请访问指南中的条形图部分。

为什么我应该在我的数据可视化项目中使用 Ultralytics YOLOv8 来创建饼图？

Ultralytics YOLOv8 是创建饼图的优秀选择，因为：

与对象检测集成：直接将对象检测结果集成到饼图中，以获得即时洞察。
用户友好的 API：通过最少的代码简单设置和使用。
可定制性：多种颜色、标签等的定制选项。
实时更新：处理和实时可视化数据，非常适合视频分析项目。

这是一个快速示例：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("pie_chart.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="pie", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        clswise_count = {
            model.names[int(cls)]: boxes.size(0)
            for cls, boxes in zip(results[0].boxes.cls.tolist(), results[0].boxes.xyxy)
        }
        analytics.update_pie(clswise_count)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

要获取更多信息，请参考指南中的饼图部分。

可以使用 Ultralytics YOLOv8 来跟踪对象并动态更新可视化吗？

是的，Ultralytics YOLOv8 可以用于跟踪对象并动态更新可视化。它支持实时跟踪多个对象，并根据跟踪对象的数据更新各种可视化，如折线图、条形图和饼图。

用于跟踪和更新折线图的示例：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
out = cv2.VideoWriter("line_plot.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

analytics = solutions.Analytics(type="line", writer=out, im0_shape=(w, h), view_img=True)

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        total_counts = sum([1 for box in results[0].boxes.xyxy])
        analytics.update_line(frame_count, total_counts)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

要了解完整功能，请参阅跟踪部分。

Ultralytics YOLOv8 与其他对象检测解决方案（如 OpenCV 和 TensorFlow）有何不同之处？

Ultralytics YOLOv8 在多个方面与其他对象检测解决方案（如 OpenCV 和 TensorFlow）不同：

最先进的准确性：YOLOv8 在对象检测、分割和分类任务中提供卓越的准确性。
易于使用: 用户友好的 API，允许快速实现和集成，无需深奥的编程。
实时性能: 优化以进行高速推理，适用于实时应用。
多样化应用: 支持多种任务，包括多对象跟踪、自定义模型训练，并支持导出到 ONNX、TensorRT 和 CoreML 等不同格式。
全面的文档: 广泛的文档和博客资源，指导用户每一步。

若要详细比较和使用案例，请查看我们的Ultralytics 博客。

使用 Ultralytics YOLOv8 进行对象计数

原文：docs.ultralytics.com/guides/object-counting/

什么是对象计数？

使用Ultralytics YOLOv8进行对象计数涉及对视频和摄像头流中特定对象的准确识别和计数。YOLOv8 在实时应用中表现出色，通过其先进的算法和深度学习能力为各种场景（如人群分析和监视）提供高效精确的对象计数。

www.youtube.com/embed/Ag2e-5_NpS0

观看： 使用 Ultralytics YOLOv8 进行对象计数 |

www.youtube.com/embed/Fj9TStNBVoY

观看： 使用 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))

# Define region points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

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

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=region_points,
    names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False)

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.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))

# Define region points as a polygon with 5 points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360), (20, 400)]

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

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=region_points,
    names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False)

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.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))

# Define line points
line_points = [(20, 400), (1080, 400)]

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

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False)

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.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))

line_points = [(20, 400), (1080, 400)]  # line or region points
classes_to_count = [0, 2]  # person and car classes for count

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

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False, classes=classes_to_count)

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

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

区域可移动

通过点击其边缘，您可以将区域移动到帧的任何位置

参数`ObjectCounter`

下表列出了ObjectCounter的参数：

名称	类型	默认	描述
`names`	`dict`	`None`	类名字典。
`reg_pts`	`list`	`[(20, 400), (1260, 400)]`	定义计数区域的点列表。
`count_reg_color`	`tuple`	`(255, 0, 255)`	计数区域的 RGB 颜色。
`count_txt_color`	`tuple`	`(0, 0, 0)`	计数文本的 RGB 颜色。
`count_bg_color`	`tuple`	`(255, 255, 255)`	计数文本的背景颜色的 RGB 值。
`line_thickness`	`int`	`2`	边界框的线条厚度。
`track_thickness`	`int`	`2`	轨道线的厚度。
`view_img`	`bool`	`False`	控制是否显示视频流。
`view_in_counts`	`bool`	`True`	控制是否在视频流中显示计数。
`view_out_counts`	`bool`	`True`	控制是否在视频流中显示计数。
`draw_tracks`	`bool`	`False`	控制是否绘制对象轨迹的标志。
`track_color`	`tuple`	`None`	轨迹的 RGB 颜色。
`region_thickness`	`int`	`5`	对象计数区域的厚度。
`line_dist_thresh`	`int`	`15`	线计数器的欧几里得距离阈值。
`cls_txtdisplay_gap`	`int`	`50`	每个类别计数之间的显示间隙。

参数`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 在视频中计数对象，您可以按照以下步骤操作：

导入必要的库（cv2，ultralytics）。
加载预训练的 YOLOv8 模型。
定义计数区域（例如多边形、线条等）。
设置视频捕获并初始化对象计数器。
处理每一帧以跟踪对象并在定义的区域内进行计数。

下面是在区域内进行计数的简单示例：

import cv2

from ultralytics import YOLO, solutions

def count_objects_in_region(video_path, output_video_path, model_path):
  """Count objects in a specific region within a video."""
    model = YOLO(model_path)
    cap = cv2.VideoCapture(video_path)
    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))
    region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
    video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
    counter = solutions.ObjectCounter(
        view_img=True, reg_pts=region_points, names=model.names, draw_tracks=True, line_thickness=2
    )

    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            print("Video frame is empty or video processing has been successfully completed.")
            break
        tracks = model.track(im0, persist=True, show=False)
        im0 = counter.start_counting(im0, tracks)
        video_writer.write(im0)

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

count_objects_in_region("path/to/video.mp4", "output_video.avi", "yolov8n.pt")

在对象计数部分探索更多配置和选项。

使用 Ultralytics YOLOv8 进行对象计数的优势是什么？

使用 Ultralytics YOLOv8 进行对象计数提供了几个优势：

资源优化： 它通过提供准确的计数帮助优化资源分配，有效管理资源，适用于库存管理等行业。
增强安全性： 它通过准确跟踪和计数实体增强安全和监控，有助于主动威胁检测。
支持决策： 它为决策提供宝贵的洞察力，优化零售、交通管理等领域的流程。

对于实际应用和代码示例，请访问对象计数部分的优势。

如何使用 Ultralytics YOLOv8 计数特定类别的对象？

要使用 Ultralytics YOLOv8 计数特定类别的对象，您需要在跟踪阶段指定感兴趣的类别。以下是一个 Python 示例：

import cv2

from ultralytics import YOLO, solutions

def count_specific_classes(video_path, output_video_path, model_path, classes_to_count):
  """Count specific classes of objects in a video."""
    model = YOLO(model_path)
    cap = cv2.VideoCapture(video_path)
    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))
    line_points = [(20, 400), (1080, 400)]
    video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
    counter = solutions.ObjectCounter(
        view_img=True, reg_pts=line_points, names=model.names, draw_tracks=True, line_thickness=2
    )

    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            print("Video frame is empty or video processing has been successfully completed.")
            break
        tracks = model.track(im0, persist=True, show=False, classes=classes_to_count)
        im0 = counter.start_counting(im0, tracks)
        video_writer.write(im0)

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

count_specific_classes("path/to/video.mp4", "output_specific_classes.avi", "yolov8n.pt", [0, 2])

在这个例子中，classes_to_count=[0, 2]，意味着它计数类别为0和2的对象（例如，人和车）。

为什么应该在实时应用中使用 YOLOv8 而不是其他对象检测模型？

Ultralytics YOLOv8 相对于其他对象检测模型（如 Faster R-CNN、SSD 和之前的 YOLO 版本）提供了几个优势：

速度与效率： YOLOv8 提供实时处理能力，非常适合需要高速推理的应用，例如监控和自动驾驶。
准确性： 它为目标检测和跟踪任务提供了最先进的准确性，减少了误报数量，提高了整体系统的可靠性。
集成便利性： YOLOv8 能够与各种平台和设备（包括移动和边缘设备）无缝集成，这对现代 AI 应用至关重要。
灵活性： 支持对象检测、分割和跟踪等各种任务，可配置的模型能够满足特定的用例需求。

查看 Ultralytics YOLOv8 文档以深入了解其功能和性能比较。

我可以将 YOLOv8 用于像人群分析和交通管理这样的高级应用吗？

是的，Ultralytics 的 YOLOv8 非常适合像人群分析和交通管理这样的高级应用，因为它具有实时检测能力、可扩展性和集成灵活性。其先进的功能允许在动态环境中进行高精度的对象跟踪、计数和分类。示例用例包括：

人群分析： 监控和管理大型聚会，确保安全和优化人群流动。
交通管理： 实时跟踪和计数车辆，分析交通模式，管理拥堵。

欲了解更多信息和实施细节，请参阅有关使用 YOLOv8 进行对象计数的实际应用指南。

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

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Ultralytics-中文文档-九-

Ultralytics 中文文档（九）

ImageNet10 数据集

主要特点

数据集结构

应用

使用

样本图像和注释

引用和致谢

常见问题

ImageNet10 数据集是什么，与完整的 ImageNet 数据集有何不同？

如何使用 ImageNet10 数据集测试我的深度学习模型？

为什么我应该在 CI 测试和健全性检查中使用 ImageNet10 数据集？

ImageNet10 数据集的主要特点是什么？

我从哪里可以下载 ImageNet10 数据集？

ImageNette 数据集

主要特点

数据集结构

应用

用法

样本图像和注释

ImageNette160 和 ImageNette320

引用和致谢

常见问题解答

什么是 ImageNette 数据集？

我如何使用 ImageNette 数据集训练 YOLO 模型？

我为什么要在图像分类任务中使用 ImageNette？

ImageNette 数据集可以用不同的图像尺寸吗？

ImageNette 数据集的一些实际应用是什么？

ImageWoof 数据集

主要特点

数据集结构

应用

使用

数据集变种

样本图像和注释

引用和致谢

常见问题

ImageWoof 数据集在 Ultralytics 中是什么？

如何使用 Ultralytics YOLO 训练 ImageWoof 数据集的模型？

ImageWoof 数据集有哪些版本可用？

ImageWoof 数据集中的噪声标签如何有益于训练？

使用 ImageWoof 数据集的主要挑战是什么？

MNIST 数据集

关键特点

数据集结构

扩展 MNIST（EMNIST）

应用程序

用途

示例图像和注释

引用和致谢

常见问题解答

MNIST 数据集是什么，以及它在机器学习中的重要性是什么？

如何使用 Ultralytics YOLO 来训练 MNIST 数据集上的模型？

MNIST 数据集和 EMNIST 数据集之间有什么区别？

我可以使用 Ultralytics HUB 来训练类似 MNIST 这样的自定义数据集吗？

定向边界框（OBB）数据集概述

支持的 OBB 数据集格式

YOLO OBB 格式

使用方法

支持的数据集

合并您自己的 OBB 数据集

转换标签格式

DOTA 数据集格式转换为 YOLO OBB 格式

常见问题

定向边界框（OBB）是什么，它们在 Ultralytics YOLO 模型中如何使用？

如何将我现有的 DOTA 数据集标签转换为 YOLO OBB 格式，以便与 Ultralytics YOLOv8 使用？

如何在我的数据集上使用定向边界框（OBB）训练 YOLOv8 模型？

Ultralytics YOLO 模型当前支持哪些用于 OBB 训练的数据集？

我可以使用带有定向边界框的自定义数据集进行 YOLOv8 训练吗？如果可以，如何操作？

带 OBB 的 DOTA 数据集

主要特点

数据集版本

DOTA-v1.0

DOTA-v1.5

DOTA-v2.0

数据集结构

应用

Argument `Analytics`

Arguments `model.track`

参数`ObjectCounter`

参数`model.track`