Ultralytics-中文文档-十二-

Ultralytics 中文文档（十二）

Ultralytics YOLO 超参数调整指南

原文：docs.ultralytics.com/guides/hyperparameter-tuning/

介绍

超参数调整不仅仅是一次性设置，而是一个迭代过程，旨在优化机器学习模型的性能指标，如准确率、精确率和召回率。在 Ultralytics YOLO 的背景下，这些超参数可以从学习率到架构细节，如层数或激活函数类型。

什么是超参数？

超参数是算法的高级结构设置。它们在训练阶段之前设置，并在其间保持不变。以下是 Ultralytics YOLO 中一些常调整的超参数：

学习率 lr0: 确定每次迭代中在损失函数中向最小值移动的步长大小。
批处理大小 batch: 在前向传递中同时处理的图像数量。
训练周期数 epochs: 一个周期是所有训练样本的完整前向和后向传递。
架构细节: 如通道数、层数、激活函数类型等。

超参数调整可视化

关于 YOLOv8 中使用的所有增强超参数的完整列表，请参阅配置页面。

遗传进化和突变

Ultralytics YOLO 使用遗传算法来优化超参数。遗传算法受自然选择和遗传机制的启发。

突变: 在 Ultralytics YOLO 的背景下，突变通过对现有超参数应用小的随机更改，在超参数空间中进行局部搜索，生成新的评估候选者。
交叉: 虽然交叉是一种流行的遗传算法技术，但它目前在 Ultralytics YOLO 中不用于超参数调整。主要关注通过变异生成新的超参数集。

准备超参数调整

在开始调整过程之前，重要的是：

确定评估模型性能的指标：这可能是 AP50、F1 分数或其他指标。
设定调整预算：定义你愿意分配的计算资源量。超参数调整可能需要大量计算资源。

涉及步骤

初始化超参数

从一组合理的初始超参数开始。这可以是由 Ultralytics YOLO 默认设置的超参数，也可以是基于您的领域知识或先前实验的某些内容。

变异超参数

使用_mutate方法基于现有集合生成新的超参数集。

训练模型

使用变异后的超参数集进行训练。然后评估训练性能。

评估模型

使用 AP50、F1 分数或自定义指标等指标评估模型性能。

记录结果

记录性能指标及相应超参数对于将来参考非常重要。

重复

这个过程重复进行，直到达到设定的迭代次数或性能指标令人满意为止。

用法示例

这里是如何使用model.tune()方法利用Tuner类对 YOLOv8n 在 COCO8 上进行 30 个 epoch 的超参数调整，使用 AdamW 优化器，并跳过绘图、检查点和仅在最后一个 epoch 上进行验证以加快调整速度。

示例

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolov8n.pt")

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

结果

在成功完成超参数调整过程之后，您将获得几个文件和目录，这些文件和目录概括了调整结果。以下是每个的描述：

文件结构

下面是结果目录结构的示例。像train1/这样的训练目录包含单独的调整迭代，即使用一组超参数训练的一个模型。tune/目录包含所有单独模型训练的调整结果：

runs/
└── detect/
    ├── train1/
    ├── train2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── best_fitness.png
        ├── tune_results.csv
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

文件描述

best_hyperparameters.yaml

此 YAML 文件包含调整过程中找到的表现最佳的超参数。您可以使用此文件使用这些优化设置初始化未来的训练。

格式: YAML
用法: 超参数结果

示例:

# 558/900 iterations complete ✅ (45536.81s)
# Results saved to /usr/src/ultralytics/runs/detect/tune
# Best fitness=0.64297 observed at iteration 498
# Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
# Best fitness model is /usr/src/ultralytics/runs/detect/train498
# Best fitness hyperparameters are printed below.

lr0:  0.00269
lrf:  0.00288
momentum:  0.73375
weight_decay:  0.00015
warmup_epochs:  1.22935
warmup_momentum:  0.1525
box:  18.27875
cls:  1.32899
dfl:  0.56016
hsv_h:  0.01148
hsv_s:  0.53554
hsv_v:  0.13636
degrees:  0.0
translate:  0.12431
scale:  0.07643
shear:  0.0
perspective:  0.0
flipud:  0.0
fliplr:  0.08631
mosaic:  0.42551
mixup:  0.0
copy_paste:  0.0

best_fitness.png

这是一个显示适应度（通常是像 AP50 这样的性能指标）随迭代次数变化的图表。它帮助您可视化遗传算法随时间的表现情况。

格式: PNG
用法: 性能可视化

超参数调整适应度 vs 迭代

tune_results.csv

CSV 文件包含调整过程中每次迭代的详细结果。文件中的每一行代表一次迭代，包括适应度分数、精确度、召回率以及所使用的超参数。

格式: CSV
用法: 追踪每次迭代的结果。

示例:

 fitness,lr0,lrf,momentum,weight_decay,warmup_epochs,warmup_momentum,box,cls,dfl,hsv_h,hsv_s,hsv_v,degrees,translate,scale,shear,perspective,flipud,fliplr,mosaic,mixup,copy_paste
  0.05021,0.01,0.01,0.937,0.0005,3.0,0.8,7.5,0.5,1.5,0.015,0.7,0.4,0.0,0.1,0.5,0.0,0.0,0.0,0.5,1.0,0.0,0.0
  0.07217,0.01003,0.00967,0.93897,0.00049,2.79757,0.81075,7.5,0.50746,1.44826,0.01503,0.72948,0.40658,0.0,0.0987,0.4922,0.0,0.0,0.0,0.49729,1.0,0.0,0.0
  0.06584,0.01003,0.00855,0.91009,0.00073,3.42176,0.95,8.64301,0.54594,1.72261,0.01503,0.59179,0.40658,0.0,0.0987,0.46955,0.0,0.0,0.0,0.49729,0.80187,0.0,0.0

tune_scatter_plots.png

此文件包含从tune_results.csv生成的散点图，帮助您可视化不同超参数与性能指标之间的关系。请注意，初始化为 0 的超参数将不会被调整，例如下面的degrees和shear。

格式: PNG
用法: 探索性数据分析

超参数调整散点图

weights/

此目录包含在超参数调整过程中最后和最佳迭代期间保存的 PyTorch 模型。

last.pt: last.pt是训练的最后一个 epoch 的权重。
best.pt: 达到最佳适应度分数的迭代的best.pt权重。

利用这些结果，您可以为未来的模型训练和分析做出更加明智的决策。随时参考这些工件，了解您的模型表现如何以及如何进一步改进它。

结论

Ultralytics YOLO 的超参数调优过程通过基于变异的遗传算法方法简化但功能强大。按照本指南中概述的步骤进行操作将帮助您系统地调整模型以实现更好的性能。

进一步阅读

维基百科中的超参数优化
YOLOv5 超参数演化指南
使用 Ray Tune 和 YOLOv8 进行高效的超参数调优

想要深入了解的话，你可以查看Tuner类的源代码和相关文档。如果你有任何问题、功能请求或需要进一步帮助，请随时通过GitHub或Discord联系我们。

常见问题

如何在 Ultralytics YOLO 的超参数调优过程中优化学习率？

要优化 Ultralytics YOLO 的学习率，请从设置初始学习率lr0参数开始。常见的初始值范围为0.001到0.01。在超参数调优过程中，此值将进行变异以找到最佳设置。您可以利用model.tune()方法来自动化此过程。例如：

示例

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolov8n.pt")

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

欲了解更多详情，请查看 Ultralytics YOLO 配置页面。

在 YOLOv8 中使用遗传算法进行超参数调优的好处是什么？

Ultralytics YOLOv8 中的遗传算法提供了一种探索超参数空间的强大方法，从而实现高度优化的模型性能。其主要优势包括：

高效搜索：像变异这样的遗传算法可以快速探索大量的超参数。
避免局部最小值：通过引入随机性，有助于避免局部最小值，确保更好的全局优化。
性能指标：它们根据 AP50 和 F1 分数等性能指标进行调整。

要了解遗传算法如何优化超参数，请查看超参数演化指南。

Ultralytics YOLO 的超参数调优过程需要多长时间？

使用 Ultralytics YOLO 进行超参数调优所需的时间在很大程度上取决于多个因素，如数据集大小、模型架构复杂性、迭代次数以及可用的计算资源。例如，对像 COCO8 这样的数据集进行 30 个 epochs 的 YOLOv8n 调优可能需要几小时到几天不等，具体取决于硬件配置。

为了有效管理调整时间，事先定义一个明确的调整预算（内部部分链接）。这有助于平衡资源分配和优化目标。

在 YOLO 超参数调优过程中应该使用哪些指标来评估模型性能？

在进行 YOLO 超参数调优时评估模型性能时，可以使用几个关键指标：

AP50：在 IoU 阈值为 0.50 时的平均精度。
F1 分数：精确率和召回率的调和平均数。
精确率和召回率：这些指标表明模型在识别真正例与假正例以及假负例方面的准确性。

这些指标帮助您理解模型性能的不同方面。请参考 Ultralytics YOLO 性能指标指南，获取全面的概述。

我可以使用 Ultralytics HUB 来调整 YOLO 模型的超参数吗？

是的，您可以使用 Ultralytics HUB 来调整 YOLO 模型的超参数。该 HUB 提供了一个无代码平台，可以轻松上传数据集、训练模型并高效进行超参数调整。它实时跟踪和可视化调整进展和结果。

在 Ultralytics HUB 云训练文档中深入了解如何使用 Ultralytics HUB 进行超参数调整。

Ultralytics 文档：如何在 SAHI 中使用 YOLOv8 进行切片推理

原文：docs.ultralytics.com/guides/sahi-tiled-inference/

欢迎来到 Ultralytics 文档，学习如何与 SAHI（切片辅助超推理）一起使用 YOLOv8。本详尽指南旨在为您提供所有必要的知识，以便您将 SAHI 与 YOLOv8 结合使用。我们将深入探讨 SAHI 的定义、切片推理在大规模应用中的重要性，以及如何将这些功能与 YOLOv8 整合，从而提升目标检测性能。

SAHI 切片推理概述

SAHI 简介

SAHI（切片辅助超推理）是一个创新的库，旨在优化大规模和高分辨率图像的目标检测算法。其核心功能在于将图像分割成可管理的切片，对每个切片进行目标检测，然后将结果拼合在一起。SAHI 兼容一系列目标检测模型，包括 YOLO 系列，从而在保证计算资源优化的同时提供灵活性。

www.youtube.com/embed/tq3FU_QczxE

观看： 使用 Ultralytics YOLOv8 进行 SAHI 推理（切片辅助超推理）

SAHI 的关键特性

无缝集成：SAHI 与 YOLO 模型无缝集成，意味着您可以在不需要大量代码修改的情况下开始切片和检测。
资源效率：通过将大图像分解成较小的部分，SAHI 优化了内存使用，使您可以在资源有限的硬件上运行高质量的检测。
高准确性：SAHI 在拼合过程中采用智能算法合并重叠的检测框，从而保持检测的准确性。

什么是切片推理？

切片推理指的是将大尺寸或高分辨率图像细分为较小的段（切片），在这些切片上进行目标检测，然后重新组合这些切片，以重建原始图像上的对象位置。在计算资源有限或者处理极高分辨率图像可能导致内存问题的情况下，这种技术非常宝贵。

切片推理的优势

减少计算负担：较小的图像切片处理速度更快，内存消耗更少，使其能够在低端硬件上更加流畅运行。
保持检测质量：由于每个切片都是独立处理的，只要切片足够大以捕捉感兴趣的对象，就不会降低目标检测的质量。
增强可扩展性：该技术允许更轻松地在不同尺寸和分辨率的图像上进行目标检测，适用于从卫星图像到医学诊断等各种应用。

YOLOv8 无 SAHI	YOLOv8 有 SAHI

安装与准备

安装

要开始，请安装 SAHI 和 Ultralytics 的最新版本：

pip  install  -U  ultralytics  sahi

导入模块并下载资源

这是如何导入必要模块、下载 YOLOv8 模型和一些测试图像的方法：

from sahi.utils.file import download_from_url
from sahi.utils.yolov8 import download_yolov8s_model

# Download YOLOv8 model
yolov8_model_path = "models/yolov8s.pt"
download_yolov8s_model(yolov8_model_path)

# Download test images
download_from_url(
    "https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/small-vehicles1.jpeg",
    "demo_data/small-vehicles1.jpeg",
)
download_from_url(
    "https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/terrain2.png",
    "demo_data/terrain2.png",
)

使用 YOLOv8 进行标准推断

实例化模型

您可以像这样实例化 YOLOv8 模型进行目标检测：

from sahi import AutoDetectionModel

detection_model = AutoDetectionModel.from_pretrained(
    model_type="yolov8",
    model_path=yolov8_model_path,
    confidence_threshold=0.3,
    device="cpu",  # or 'cuda:0'
)

执行标准预测

使用图像路径或 numpy 图像执行标准推断。

from sahi.predict import get_prediction

# With an image path
result = get_prediction("demo_data/small-vehicles1.jpeg", detection_model)

# With a numpy image
result = get_prediction(read_image("demo_data/small-vehicles1.jpeg"), detection_model)

可视化结果

导出并可视化预测的边界框和掩模：

result.export_visuals(export_dir="demo_data/")
Image("demo_data/prediction_visual.png")

使用 YOLOv8 进行切片推断

指定切片尺寸和重叠比率执行切片推断：

from sahi.predict import get_sliced_prediction

result = get_sliced_prediction(
    "demo_data/small-vehicles1.jpeg",
    detection_model,
    slice_height=256,
    slice_width=256,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
)

处理预测结果

SAHI 提供 PredictionResult 对象，可转换为各种注释格式：

# Access the object prediction list
object_prediction_list = result.object_prediction_list

# Convert to COCO annotation, COCO prediction, imantics, and fiftyone formats
result.to_coco_annotations()[:3]
result.to_coco_predictions(image_id=1)[:3]
result.to_imantics_annotations()[:3]
result.to_fiftyone_detections()[:3]

批量预测

对目录中的图像进行批量预测：

from sahi.predict import predict

predict(
    model_type="yolov8",
    model_path="path/to/yolov8n.pt",
    model_device="cpu",  # or 'cuda:0'
    model_confidence_threshold=0.4,
    source="path/to/dir",
    slice_height=256,
    slice_width=256,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
)

就这样！现在您已准备好使用 YOLOv8 和 SAHI 进行标准和切片推断了。

引用与致谢

如果您在研究或开发工作中使用 SAHI，请引用原始的 SAHI 论文并致谢作者：

@article{akyon2022sahi,
  title={Slicing Aided Hyper Inference and Fine-tuning for Small Object Detection},
  author={Akyon, Fatih Cagatay and Altinuc, Sinan Onur and Temizel, Alptekin},
  journal={2022 IEEE International Conference on Image Processing (ICIP)},
  doi={10.1109/ICIP46576.2022.9897990},
  pages={966-970},
  year={2022}
}

我们衷心感谢 SAHI 研究组为计算机视觉社区创建和维护这一宝贵资源。有关 SAHI 及其作者的更多信息，请访问 SAHI GitHub 仓库。

常见问题解答

如何集成 YOLOv8 和 SAHI 以在目标检测中进行切片推断？

将 Ultralytics YOLOv8 与 SAHI 集成（切片辅助超推断）用于在高分辨率图像上优化切片推断，通过将图像分割成可管理的切片来改善内存使用和确保高检测精度。要开始使用，您需要安装 ultralytics 和 sahi 库：

pip  install  -U  ultralytics  sahi

然后，下载 YOLOv8 模型和测试图像：

from sahi.utils.file import download_from_url
from sahi.utils.yolov8 import download_yolov8s_model

# Download YOLOv8 model
yolov8_model_path = "models/yolov8s.pt"
download_yolov8s_model(yolov8_model_path)

# Download test images
download_from_url(
    "https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/small-vehicles1.jpeg",
    "demo_data/small-vehicles1.jpeg",
)

欲了解更详细的说明，请参阅我们的切片推断指南。

我为什么要在大图像上使用 YOLOv8 和 SAHI 进行目标检测？

使用 SAHI 和 Ultralytics YOLOv8 在大图像上进行目标检测提供了几个好处：

减少计算负担：更小的切片处理速度更快，消耗更少内存，使得在资源有限的硬件上运行高质量检测成为可能。
保持检测精度：SAHI 使用智能算法合并重叠框，保持检测质量。
增强可扩展性：通过在不同图像尺寸和分辨率上扩展目标检测任务，SAHI 成为各种应用的理想选择，如卫星图像分析和医学诊断。

在我们的文档中了解更多关于切片推理的好处。

当使用 YOLOv8 和 SAHI 时，我可以可视化预测结果吗？

是的，当使用 YOLOv8 和 SAHI 时，您可以可视化预测结果。以下是导出和可视化结果的方法：

result.export_visuals(export_dir="demo_data/")
from IPython.display import Image

Image("demo_data/prediction_visual.png")

此命令将预测结果保存到指定目录，并且您可以加载图像在您的笔记本或应用程序中查看它。查看标准推理部分以获取详细指南。

SAHI 提供了哪些功能来改进 YOLOv8 的目标检测？

SAHI（切片辅助超推理）提供了几个功能，可以补充 Ultralytics YOLOv8 进行目标检测：

无缝集成：SAHI 轻松集成到 YOLO 模型中，只需进行最少的代码调整。
资源效率：它将大图像分割成较小的切片，优化内存使用和速度。
高准确性：通过在拼接过程中有效合并重叠的检测框，SAHI 保持高检测准确性。

深入了解，请阅读关于 SAHI 的关键特性。

如何处理使用 YOLOv8 和 SAHI 的大规模推理项目？

要处理使用 YOLOv8 和 SAHI 的大规模推理项目，请遵循以下最佳实践：

安装所需的库：确保您拥有最新版本的 ultralytics 和 sahi。
配置切片推理：确定适合您特定项目的最佳切片尺寸和重叠比率。
运行批量预测：利用 SAHI 的能力对图像目录进行批量预测，从而提高效率。

批量预测示例：

from sahi.predict import predict

predict(
    model_type="yolov8",
    model_path="path/to/yolov8n.pt",
    model_device="cpu",  # or 'cuda:0'
    model_confidence_threshold=0.4,
    source="path/to/dir",
    slice_height=256,
    slice_width=256,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
)

要获取更详细的步骤，请访问我们的批量预测部分。

YOLOv8 🚀 在 AzureML 上

原文：docs.ultralytics.com/guides/azureml-quickstart/

什么是 Azure？

Azure 是微软的云计算平台，旨在帮助组织将其工作负载从本地数据中心转移到云上。凭借包括计算、数据库、分析、机器学习和网络在内的全方位云服务，用户可以根据需要选择这些服务来开发和扩展新应用程序或运行现有应用程序。

什么是 Azure 机器学习（AzureML）？

Azure 机器学习，通常称为 AzureML，是一种完全托管的云服务，使数据科学家和开发人员能够有效地将预测性分析嵌入其应用程序中，帮助组织利用大规模数据集，并将云的所有优势带入机器学习中。AzureML 提供了各种服务和功能，旨在使机器学习易于访问、易于使用且易于扩展。它提供了自动化机器学习、拖放式模型训练以及强大的 Python SDK，使开发人员能够充分利用其机器学习模型。

AzureML 如何使 YOLO 用户受益？

对于 YOLO（You Only Look Once）的用户，AzureML 提供了一个强大、可扩展和高效的平台，用于训练和部署机器学习模型。无论您是想运行快速原型还是扩展以处理更广泛的数据，AzureML 灵活且用户友好的环境提供了各种工具和服务来满足您的需求。您可以利用 AzureML 来：

轻松管理大型数据集和计算资源以进行训练。
利用内置工具进行数据预处理、特征选择和模型训练。
通过支持 MLOps（机器学习运营）的能力更有效地进行协作，包括但不限于对模型和数据的监视、审计和版本控制。

在接下来的几节中，您将找到一个快速入门指南，详细介绍如何在 AzureML 上运行 YOLOv8 目标检测模型，无论是从计算终端还是笔记本电脑。

先决条件

在开始之前，请确保您可以访问 AzureML 工作区。如果没有，请按照 Azure 的官方文档创建一个新的 AzureML 工作区。这个工作区作为管理所有 AzureML 资源的集中地。

创建计算实例

从您的 AzureML 工作区中，选择 Compute > Compute instances > New，选择具有所需资源的实例。

创建 Azure 计算实例

从终端快速入门

启动您的计算机并打开终端：

打开终端

创建虚拟环境

创建您的 conda 虚拟环境并在其中安装 pip：

conda  create  --name  yolov8env  -y
conda  activate  yolov8env
conda  install  pip  -y

安装所需的依赖项：

cd  ultralytics
pip  install  -r  requirements.txt
pip  install  ultralytics
pip  install  onnx>=1.12.0

执行 YOLOv8 任务

预测：

yolo  predict  model=yolov8n.pt  source='https://ultralytics.com/images/bus.jpg'

使用初始学习率为 0.01 训练一个检测模型，进行 10 个 epochs：

yolo  train  data=coco8.yaml  model=yolov8n.pt  epochs=10  lr0=0.01

您可以在这里找到更多使用 Ultralytics CLI 的指令。

从笔记本快速入门

创建一个新的 IPython 内核

打开计算终端。

打开终端

从计算终端开始，您需要创建一个新的 ipykernel，该内核将由您的笔记本用于管理依赖项：

conda  create  --name  yolov8env  -y
conda  activate  yolov8env
conda  install  pip  -y
conda  install  ipykernel  -y
python  -m  ipykernel  install  --user  --name  yolov8env  --display-name  "yolov8env"

关闭您的终端并创建一个新的笔记本。从您的笔记本中，您可以选择新的内核。

然后，您可以打开一个笔记本单元格并安装所需的依赖项：

%%bash
source  activate  yolov8env
cd  ultralytics
pip  install  -r  requirements.txt
pip  install  ultralytics
pip  install  onnx>=1.12.0

请注意，我们需要对所有 %%bash 单元格使用 source activate yolov8env，以确保 %%bash 单元格使用我们想要的环境。

使用 Ultralytics CLI 运行一些预测：

%%bash
source  activate  yolov8env
yolo  predict  model=yolov8n.pt  source='https://ultralytics.com/images/bus.jpg'

或者使用 Ultralytics Python 接口，例如训练模型：

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # load an official YOLOv8n model

# Use the model
model.train(data="coco8.yaml", epochs=3)  # train the model
metrics = model.val()  # evaluate model performance on the validation set
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image
path = model.export(format="onnx")  # export the model to ONNX format

您可以使用 Ultralytics CLI 或 Python 接口来运行 YOLOv8 任务，如上面终端部分所述。

通过按照这些步骤操作，您应该能够快速在 AzureML 上运行 YOLOv8 进行快速试验。对于更高级的用途，您可以参考本指南开头链接的完整 AzureML 文档。

探索更多 AzureML 功能

本指南旨在为您介绍如何在 AzureML 上快速运行 YOLOv8。但它仅揭示了 AzureML 可以提供的一小部分。要深入了解并释放 AzureML 在您的机器学习项目中的全部潜力，请考虑探索本指南开头链接的相关资源。

创建数据资产: 学习如何在 AzureML 环境中有效地设置和管理数据资产。
启动 AzureML 作业: 全面了解如何在 AzureML 上启动您的机器学习训练作业。
注册模型: 熟悉模型管理实践，包括注册、版本控制和部署。
使用 AzureML Python SDK 训练 YOLOv8: 探索使用 AzureML Python SDK 训练 YOLOv8 模型的逐步指南。
使用 AzureML CLI 训练 YOLOv8: 发现如何利用命令行界面简化在 AzureML 上训练和管理 YOLOv8 模型。

常见问题解答

如何在 AzureML 上运行 YOLOv8 进行模型训练？

在 AzureML 上运行 YOLOv8 进行模型训练涉及几个步骤：

创建计算实例: 从您的 AzureML 工作区导航到计算 > 计算实例 > 新建，并选择所需的实例。

设置环境: 启动您的计算实例，打开终端，并创建一个 conda 环境：

conda  create  --name  yolov8env  -y
conda  activate  yolov8env
conda  install  pip  -y
pip  install  ultralytics  onnx>=1.12.0

运行 YOLOv8 任务：使用 Ultralytics CLI 训练您的模型：

yolo  train  data=coco8.yaml  model=yolov8n.pt  epochs=10  lr0=0.01

欲了解更多详细信息，请参阅使用 Ultralytics CLI 的说明。

使用 AzureML 进行 YOLOv8 训练的好处是什么？

AzureML 提供了一个强大而高效的生态系统，用于训练 YOLOv8 模型：

可扩展性：随着数据和模型复杂性的增长，轻松扩展您的计算资源。
MLOps 集成：利用版本控制、监控和审计等功能来优化 ML 运营。
协作：在团队内共享和管理资源，增强协作工作流程。

这些优势使得 AzureML 成为从快速原型到大规模部署项目的理想平台。欲获取更多提示，请查看 AzureML Jobs。

在 AzureML 上运行 YOLOv8 时如何排除常见问题？

在 AzureML 上排除 YOLOv8 的常见问题可能涉及以下步骤：

依赖问题：确保所有必需的包已安装。请参考 requirements.txt 文件的依赖关系。
环境设置：在运行命令之前，请确认您的 conda 环境已正确激活。
资源分配：确保您的计算实例具有足够的资源来处理训练工作负载。

欲获得更多指导，请查看我们的 YOLO 常见问题文档。

我可以在 AzureML 上同时使用 Ultralytics CLI 和 Python 接口吗？

是的，AzureML 允许您无缝使用 Ultralytics CLI 和 Python 接口：

CLI：适用于快速任务和直接从终端运行标准脚本。

yolo  predict  model=yolov8n.pt  source='https://ultralytics.com/images/bus.jpg'

Python 接口：用于需要自定义编码和在笔记本内部集成的更复杂任务。

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.train(data="coco8.yaml", epochs=3)

请参阅这里和这里以获取更详细的快速入门指南。

使用 Ultralytics YOLOv8 而非其他目标检测模型的优势是什么？

Ultralytics YOLOv8 提供了与竞争对手的几种目标检测模型相比的几个独特优势：

速度：相比 Faster R-CNN 和 SSD 等模型，推理和训练时间更快。
准确性：在检测任务中具有高准确性，具备无锚设计和增强的增强策略等特性。
易用性：直观的 API 和 CLI，便于快速设置，使其既适用于初学者又适用于专家。

要了解更多关于 YOLOv8 的功能，请访问 Ultralytics YOLO 页面以获取详细的见解。

Ultralytics 快速入门指南

原文：docs.ultralytics.com/guides/conda-quickstart/

Ultralytics Conda 包视觉

本指南全面介绍了为 Ultralytics 项目设置 Conda 环境的方法。Conda 是一个开源的软件包和环境管理系统，提供了安装软件包和依赖项的优秀替代方法，特别适合数据科学和机器学习。要了解更多详情，请访问 Anaconda 上的 Ultralytics Conda 包，并查看 GitHub 上的 Ultralytics feedstock 仓库以获取软件包更新。

Conda 版本 Conda 下载量 Conda 配方 Conda 平台

您将学到什么

设置 Conda 环境
通过 Conda 安装 Ultralytics
在您的环境中初始化 Ultralytics
使用 Ultralytics Docker 镜像与 Conda

先决条件

您的系统上应安装 Anaconda 或 Miniconda。如果没有，请从 Anaconda 或 Miniconda 下载并安装。

设置 Conda 环境

首先，让我们创建一个新的 Conda 环境。打开终端并运行以下命令：

conda  create  --name  ultralytics-env  python=3.8  -y

激活新环境：

conda  activate  ultralytics-env

安装 Ultralytics

您可以从 conda-forge 频道安装 Ultralytics 软件包。执行以下命令：

conda  install  -c  conda-forge  ultralytics

CUDA 环境注意事项

如果您在支持 CUDA 的环境中工作，建议一起安装 ultralytics、pytorch 和 pytorch-cuda 以解决任何冲突：

conda  install  -c  pytorch  -c  nvidia  -c  conda-forge  pytorch  torchvision  pytorch-cuda=11.8  ultralytics

使用 Ultralytics

安装了 Ultralytics 后，您现在可以开始使用其强大的功能进行对象检测、实例分割等。例如，要预测一张图像，您可以运行：

from ultralytics import YOLO

model = YOLO("yolov8n.pt")  # initialize model
results = model("path/to/image.jpg")  # perform inference
results[0].show()  # display results for the first image

Ultralytics Conda Docker 镜像

如果您喜欢使用 Docker，Ultralytics 提供了包含 Conda 环境的 Docker 镜像。您可以从 DockerHub 拉取这些镜像。

拉取最新的 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

使用 Libmamba 加速安装

如果您希望加快 Conda 中的软件包安装速度，可以选择使用 libmamba，这是一个快速、跨平台和依赖感知的软件包管理器，作为 Conda 默认求解器的替代品。

如何启用 Libmamba

要将 libmamba 作为 Conda 的求解器启用，您可以执行以下步骤：

首先，安装conda-libmamba-solver包。如果您的 Conda 版本为 4.11 或更高，则可以跳过此步骤，因为libmamba已默认包含。
```
conda  install  conda-libmamba-solver 
```
接下来，配置 Conda 使用libmamba作为求解器：
```
conda  config  --set  solver  libmamba 
```

就是这样！现在您的 Conda 安装将使用libmamba作为求解器，这应该会使包安装过程更快。

恭喜！您已成功设置了 Conda 环境，安装了 Ultralytics 包，并且现在可以探索其丰富的功能。请随时深入了解 Ultralytics 文档，以获取更高级的教程和示例。

常见问题解答

为 Ultralytics 项目设置 Conda 环境的过程是什么？

为 Ultralytics 项目设置 Conda 环境非常简单，并确保平稳的包管理。首先，使用以下命令创建一个新的 Conda 环境：

conda  create  --name  ultralytics-env  python=3.8  -y

然后，使用以下命令激活新环境：

conda  activate  ultralytics-env

最后，从 conda-forge 渠道安装 Ultralytics：

conda  install  -c  conda-forge  ultralytics

为什么在 Ultralytics 项目中管理依赖项时应该使用 Conda 而不是 pip？

Conda 是一个强大的包和环境管理系统，相比于 pip 有几个优点。它高效地管理依赖关系，并确保所有必要的库是兼容的。Conda 的隔离环境可以防止包之间的冲突，在数据科学和机器学习项目中至关重要。此外，Conda 支持二进制包分发，加快安装过程。

我可以在支持 CUDA 的环境中使用 Ultralytics YOLO 以获得更快的性能吗？

是的，您可以通过使用支持 CUDA 的环境来增强性能。确保同时安装ultralytics，pytorch和pytorch-cuda以避免冲突：

conda  install  -c  pytorch  -c  nvidia  -c  conda-forge  pytorch  torchvision  pytorch-cuda=11.8  ultralytics

此设置使 GPU 加速成为可能，对于深度学习模型训练和推断等密集任务至关重要。更多信息，请访问 Ultralytics 安装指南。

使用 Ultralytics Docker 镜像与 Conda 环境的好处是什么？

使用 Ultralytics Docker 镜像可以确保一个一致和可重现的环境，消除了“在我的机器上可以运行”的问题。这些镜像包括预配置的 Conda 环境，简化了设置过程。您可以使用以下命令拉取并运行最新的 Ultralytics Docker 镜像：

sudo  docker  pull  ultralytics/ultralytics:latest-conda
sudo  docker  run  -it  --ipc=host  --gpus  all  ultralytics/ultralytics:latest-conda

这种方法非常适合在生产中部署应用程序或运行复杂的工作流程而无需手动配置。了解更多关于 Ultralytics Conda Docker 镜像的信息。

如何加快在我的 Ultralytics 环境中安装 Conda 包的速度？

您可以通过使用libmamba，Conda 的快速依赖求解器来加速包安装过程。首先，安装conda-libmamba-solver包：

conda  install  conda-libmamba-solver

然后配置 Conda 使用libmamba作为求解器：

conda  config  --set  solver  libmamba

这种设置提供了更快和更高效的包管理。有关优化您的环境的更多提示，请阅读关于 libmamba 安装的内容。

Ultralytics 的 Docker 快速入门指南

原文：docs.ultralytics.com/guides/docker-quickstart/

Ultralytics Docker Package Visual

本指南旨在全面介绍为您的 Ultralytics 项目设置 Docker 环境。Docker 是一个用于开发、交付和运行容器化应用程序的平台。它特别有助于确保软件在部署的任何地方始终运行相同。有关更多详细信息，请访问Docker Hub 上的 Ultralytics Docker 仓库。

Docker 镜像版本 Docker 拉取次数

您将学到什么

使用带 NVIDIA 支持的 Docker 设置
安装 Ultralytics Docker 映像
在支持 CPU 或 GPU 的 Docker 容器中运行 Ultralytics
使用显示服务器在 Docker 中显示 Ultralytics 检测结果
将本地目录挂载到容器中

先决条件

确保您的系统已安装 Docker。如果没有，请从Docker 的网站下载并安装它。
确保您的系统具有 NVIDIA GPU 并安装了 NVIDIA 驱动程序。

使用带 NVIDIA 支持的 Docker 设置

首先通过运行以下命令验证 NVIDIA 驱动程序是否正确安装：

nvidia-smi

安装 NVIDIA Docker 运行时

现在，让我们安装 NVIDIA Docker 运行时，以在 Docker 容器中启用 GPU 支持：

# Add NVIDIA package repositories
curl  -s  -L  https://nvidia.github.io/nvidia-docker/gpgkey  |  sudo  apt-key  add  -
distribution=$(lsb_release  -cs)
curl  -s  -L  https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list  |  sudo  tee  /etc/apt/sources.list.d/nvidia-docker.list

# Install NVIDIA Docker runtime
sudo  apt-get  update
sudo  apt-get  install  -y  nvidia-docker2

# Restart Docker service to apply changes
sudo  systemctl  restart  docker

使用 Docker 验证 NVIDIA 运行时

运行 docker info | grep -i runtime 来确保 nvidia 出现在运行时列表中：

docker  info  |  grep  -i  runtime

安装 Ultralytics Docker 映像

Ultralytics 提供了多个针对各种平台和用例优化的 Docker 映像：

Dockerfile: GPU 映像，用于训练。
Dockerfile-arm64: 适用于 ARM64 架构，适合树莓派等设备。
Dockerfile-cpu: 仅用于推断和非 GPU 环境。
Dockerfile-jetson: 专为 NVIDIA Jetson 设备优化。
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

在 Docker 容器中运行 Ultralytics

下面是如何执行 Ultralytics Docker 容器的方法：

仅使用 CPU

# Run with all GPUs
sudo  docker  run  -it  --ipc=host  $t

使用 GPU

# Run with all GPUs
sudo  docker  run  -it  --ipc=host  --gpus  all  $t

# Run specifying which GPUs to use
sudo  docker  run  -it  --ipc=host  --gpus  '"device=2,3"'  $t

-it标志分配一个伪 TTY 并保持 stdin 打开，允许您与容器交互。--ipc=host标志启用共享主机的 IPC 命名空间，对于进程间共享内存是必需的。--gpus标志允许容器访问主机的 GPU。

在 Docker 容器中运行 Ultralytics

下面是如何执行 Ultralytics Docker 容器的方法：

仅使用 CPU

# Run with all GPUs
sudo  docker  run  -it  --ipc=host  $t

使用 GPU

# Run with all GPUs
sudo  docker  run  -it  --ipc=host  --gpus  all  $t

# Run specifying which GPUs to use
sudo  docker  run  -it  --ipc=host  --gpus  '"device=2,3"'  $t

-it 标志分配一个伪 TTY 并保持 stdin 打开，允许你与容器交互。--ipc=host 标志启用主机 IPC 命名空间的共享，这对于进程之间的内存共享至关重要。--gpus 标志允许容器访问主机的 GPU。

文件可访问性说明

要在容器内处理本地计算机上的文件，你可以使用 Docker 卷：

# Mount a local directory into the container
sudo  docker  run  -it  --ipc=host  --gpus  all  -v  /path/on/host:/path/in/container  $t

将 /path/on/host 替换为你本地计算机上的目录路径，将 /path/in/container 替换为 Docker 容器内的所需路径。

在 Docker 容器中运行图形用户界面（GUI）应用程序

高度实验性 - 用户承担所有风险

以下说明是实验性的。与 Docker 容器共享 X11 套接字存在潜在的安全风险。因此，建议仅在受控环境中测试此解决方案。有关如何使用 xhost 的更多信息，请参考这些资源^((1)(2))。

Docker 主要用于将后台应用程序和 CLI 程序容器化，但它也可以运行图形程序。在 Linux 世界中，有两个主要的图形服务器处理图形显示：X11（也称为 X 窗口系统）和 Wayland。在开始之前，确定你当前使用的图形服务器是至关重要的。运行此命令以找出：

env  |  grep  -E  -i  'x11|xorg|wayland'

X11 或 Wayland 显示服务器的设置和配置超出了本指南的范围。如果上述命令没有返回任何内容，那么你需要先确保你的系统上有一个可用的服务器，然后再继续。

在 Docker 容器中运行带 GUI 的 Docker 容器

示例

使用 GPU

If you're using [GPUs](#using-gpus), you can add the `--gpus all` flag to the command. 
```</details>

如果你使用的是 X11，你可以运行以下命令以允许 Docker 容器访问 X11 套接字：

```py
xhost  +local:docker  &&  docker  run  -e  DISPLAY=$DISPLAY  \
-v  /tmp/.X11-unix:/tmp/.X11-unix  \
-v  ~/.Xauthority:/root/.Xauthority  \
-it  --ipc=host  $t

此命令将 DISPLAY 环境变量设置为主机的显示，挂载 X11 套接字，并将 .Xauthority 文件映射到容器。xhost +local:docker 命令允许 Docker 容器访问 X11 服务器。

对于 Wayland，使用以下命令：

xhost  +local:docker  &&  docker  run  -e  DISPLAY=$DISPLAY  \
-v  $XDG_RUNTIME_DIR/$WAYLAND_DISPLAY:/tmp/$WAYLAND_DISPLAY  \
--net=host  -it  --ipc=host  $t

此命令将 DISPLAY 环境变量设置为主机的显示，挂载 Wayland 套接字，并允许 Docker 容器访问 Wayland 服务器。

使用带 GUI 的 Docker

现在你可以在 Docker 容器内显示图形应用程序。例如，你可以运行以下 CLI 命令来可视化 YOLOv8 模型的预测：

yolo  predict  model=yolov8n.pt  show=True

测试

要验证 Docker 组是否可以访问 X11 服务器的简单方法是运行包含 GUI 程序如xclock或xeyes的容器。或者，您也可以在 Ultralytics Docker 容器中安装这些程序，以测试您的 GNU-Linux 显示服务器对 X11 服务器的访问权限。如果遇到任何问题，请考虑设置环境变量-e QT_DEBUG_PLUGINS=1。设置此环境变量会启用调试信息输出，有助于故障排除过程。

完成 Docker GUI 后

撤销访问

在两种情况下，完成后不要忘记从 Docker 组中撤销访问权限。

xhost  -local:docker

想直接在终端中查看图像结果吗？

请参阅以下指南以在终端中查看图像结果

恭喜！您现在已经设置好了使用 Ultralytics 与 Docker，并准备利用其强大功能。如需备用安装方法，请随时查阅 Ultralytics 快速入门文档。

常见问题

如何设置 Ultralytics 与 Docker？

要在 Docker 中设置 Ultralytics，请确保系统已安装 Docker。如果您有 NVIDIA GPU，请安装 NVIDIA Docker 运行时以启用 GPU 支持。然后，使用以下命令从 Docker Hub 拉取最新的 Ultralytics Docker 镜像：

sudo  docker  pull  ultralytics/ultralytics:latest

有关详细步骤，请参阅我们的 Docker 快速入门指南。

使用 Ultralytics Docker 镜像用于机器学习项目有哪些好处？

使用 Ultralytics Docker 镜像可确保跨不同机器的一致环境，复制相同的软件和依赖关系。这对于团队协作、在各种硬件上运行模型和保持可重现性特别有用。对于基于 GPU 的训练，Ultralytics 提供了优化的 Docker 镜像，如用于一般 GPU 使用的 Dockerfile 和用于 NVIDIA Jetson 设备的 Dockerfile-jetson。请访问Ultralytics Docker Hub了解更多详情。

如何在带 GPU 支持的 Docker 容器中运行 Ultralytics YOLO？

首先确保安装和配置 NVIDIA Docker 运行时。然后，使用以下命令以 GPU 支持运行 Ultralytics YOLO：

sudo  docker  run  -it  --ipc=host  --gpus  all  ultralytics/ultralytics:latest

此命令设置具有 GPU 访问权限的 Docker 容器。有关更多详细信息，请参阅 Docker 快速入门指南。

如何在 Docker 容器中使用显示服务器可视化 YOLO 预测结果？

要在 Docker 容器中使用 GUI 可视化 YOLO 预测结果，您需要允许 Docker 访问您的显示服务器。对于运行 X11 的系统，命令如下：

xhost  +local:docker  &&  docker  run  -e  DISPLAY=$DISPLAY  \
-v  /tmp/.X11-unix:/tmp/.X11-unix  \
-v  ~/.Xauthority:/root/.Xauthority  \
-it  --ipc=host  ultralytics/ultralytics:latest

对于运行 Wayland 的系统，请使用：

xhost  +local:docker  &&  docker  run  -e  DISPLAY=$DISPLAY  \
-v  $XDG_RUNTIME_DIR/$WAYLAND_DISPLAY:/tmp/$WAYLAND_DISPLAY  \
--net=host  -it  --ipc=host  ultralytics/ultralytics:latest

更多信息请参阅在 Docker 容器中运行图形用户界面（GUI）应用程序部分。

我可以将本地目录挂载到 Ultralytics Docker 容器中吗？

是的，你可以使用 -v 标志将本地目录挂载到 Ultralytics Docker 容器中：

sudo  docker  run  -it  --ipc=host  --gpus  all  -v  /path/on/host:/path/in/container  ultralytics/ultralytics:latest

将 /path/on/host 替换为本地机器上的目录，将 /path/in/container 替换为容器内的所需路径。这样设置可以让你在容器内处理本地文件。有关挂载本地目录的更多信息，请参阅相关章节。

快速入门指南：树莓派与 Ultralytics YOLOv8

原文：docs.ultralytics.com/guides/raspberry-pi/

这份全面的指南提供了在树莓派设备上部署 Ultralytics YOLOv8 的详细步骤。此外，它展示了性能基准，以展示 YOLOv8 在这些小型而强大的设备上的能力。

www.youtube.com/embed/yul4gq_LrOI

Watch: 树莓派 5 的更新和改进。

Note

本指南已在运行最新的树莓派 OS Bookworm (Debian 12)的树莓派 4 和树莓派 5 上进行了测试。只要安装了相同的树莓派 OS Bookworm，预计可以在旧版树莓派设备（如树莓派 3）上使用此指南。

什么是树莓派？

树莓派是一款小巧、价格实惠的单板计算机。它已经在从业余家庭自动化到工业应用的广泛项目和应用中变得流行起来。树莓派板可以运行多种操作系统，并且提供 GPIO（通用输入/输出）引脚，便于与传感器、执行器和其他硬件组件进行集成。它们有不同的型号和规格，但它们都共享相同的基本设计理念：低成本、紧凑和多功能。

树莓派系列比较

	树莓派 3	树莓派 4	树莓派 5
CPU	Broadcom BCM2837, Cortex-A53 64Bit SoC	Broadcom BCM2711, Cortex-A72 64Bit SoC	Broadcom BCM2712, Cortex-A76 64Bit SoC
CPU 最大频率	1.4GHz	1.8GHz	2.4GHz
GPU	Videocore IV	Videocore VI	VideoCore VII
GPU 最大频率	400Mhz	500Mhz	800Mhz
内存	1GB LPDDR2 SDRAM	1GB, 2GB, 4GB, 8GB LPDDR4-3200 SDRAM	4GB, 8GB LPDDR4X-4267 SDRAM
PCIe	N/A	N/A	1xPCIe 2.0 接口
最大功耗	2.5A@5V	3A@5V	5A@5V (PD enabled)

什么是树莓派操作系统？

树莓派操作系统（之前称为 Raspbian）是一款基于 Debian GNU/Linux 发行版的类 Unix 操作系统，专为由树莓派基金会分发的紧凑型单板计算机家族而优化。树莓派操作系统使用 ARM CPU，并采用修改版的 LXDE 桌面环境和 Openbox 堆叠窗口管理器。树莓派操作系统正在积极开发中，重点是尽可能提高尽可能多的 Debian 软件包在树莓派上的稳定性和性能。

将树莓派操作系统刷入树莓派

在获得树莓派后的第一件事是用树莓派 OS 刷一张 micro-SD 卡，插入设备并引导至操作系统。详细遵循由树莓派提供的开始使用文档准备设备首次使用。

设置 Ultralytics

有两种在树莓派上设置 Ultralytics 包以构建下一个计算机视觉项目的方法。您可以选择使用其中任何一种。

使用 Docker 开始
开始时不使用 Docker

使用 Docker 开始

在树莓派上使用预构建的 docker 镜像是快速开始 Ultralytics YOLOv8 的最快方法。

执行以下命令以拉取 Docker 容器并在树莓派上运行。这基于包含 Debian 12（Bookworm）的arm64v8/debian docker 镜像，处于 Python3 环境中。

t=ultralytics/ultralytics:latest-arm64  &&  sudo  docker  pull  $t  &&  sudo  docker  run  -it  --ipc=host  $t

在完成此操作后，请跳至使用树莓派上的 NCNN 部分。

开始时不使用 Docker

安装 Ultralytics 包

在这里，我们将在树莓派上安装 Ultralytics 包及其可选依赖项，以便我们可以将 PyTorch 模型导出为其他不同的格式。

更新包列表，安装 pip 并升级到最新版本

sudo  apt  update
sudo  apt  install  python3-pip  -y
pip  install  -U  pip

使用可选依赖项安装ultralytics pip 包
```
pip  install  ultralytics[export] 
```
重新启动设备
```
sudo  reboot 
```

在树莓派上使用 NCNN

在所有 Ultralytics 支持的模型导出格式中，NCNN在与树莓派设备一起工作时提供了最佳推理性能，因为 NCNN 在移动/嵌入式平台（如 ARM 架构）上进行了高度优化。因此，我们建议在树莓派上使用 NCNN。

将模型转换为 NCNN 并运行推理

将 PyTorch 格式中的 YOLOv8n 模型转换为 NCNN，以便使用导出模型进行推理。

示例

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Export the model to NCNN format
model.export(format="ncnn")  # creates 'yolov8n_ncnn_model'

# Load the exported NCNN model
ncnn_model = YOLO("yolov8n_ncnn_model")

# Run inference
results = ncnn_model("https://ultralytics.com/images/bus.jpg")

# Export a YOLOv8n PyTorch model to NCNN format
yolo  export  model=yolov8n.pt  format=ncnn  # creates 'yolov8n_ncnn_model'

# Run inference with the exported model
yolo  predict  model='yolov8n_ncnn_model'  source='https://ultralytics.com/images/bus.jpg'

提示

要了解有关支持的导出选项的更多详细信息，请访问Ultralytics 文档页关于部署选项。

树莓派 5 与树莓派 4 YOLOv8 性能基准测试

Ultralytics 团队在九种不同的模型格式上运行了 YOLOv8 基准测试，测量速度和准确性：PyTorch，TorchScript，ONNX，OpenVINO，TF SavedModel，TF GraphDef，TF Lite，PaddlePaddle，NCNN。基准测试在树莓派 5 和树莓派 4 上以 FP32 精度进行，使用默认输入图像尺寸为 640。

注意

我们仅包含 YOLOv8n 和 YOLOv8s 模型的基准测试，因为其他模型尺寸过大，在树莓派上运行性能不佳。

比较图表

性能

NVIDIA Jetson 生态系统

详细比较表

下表显示了两种不同模型（YOLOv8n、YOLOv8s）在九种不同格式（PyTorch、TorchScript、ONNX、OpenVINO、TF SavedModel、TF GraphDef、TF Lite、PaddlePaddle、NCNN）上在树莓派 4 和树莓派 5 上的基准测试结果，给出了每种组合的状态、大小、mAP50-95(B)指标和推理时间。

性能

格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（ms/im）
PyTorch	✅	6.2	0.6381	508.61
TorchScript	✅	12.4	0.6092	558.38
ONNX	✅	12.2	0.6092	198.69
OpenVINO	✅	12.3	0.6092	704.70
TF SavedModel	✅	30.6	0.6092	367.64
TF GraphDef	✅	12.3	0.6092	473.22
TF Lite	✅	12.3	0.6092	380.67
PaddlePaddle	✅	24.4	0.6092	703.51
NCNN	✅	12.2	0.6034	94.28
格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（ms/im）
---	---	---	---	---
PyTorch	✅	21.5	0.6967	969.49
TorchScript	✅	43.0	0.7136	1110.04
ONNX	✅	42.8	0.7136	451.37
OpenVINO	✅	42.9	0.7136	873.51
TF SavedModel	✅	107.0	0.7136	658.15
TF GraphDef	✅	42.8	0.7136	946.01
TF Lite	✅	42.8	0.7136	1013.27
PaddlePaddle	✅	85.5	0.7136	1560.23
NCNN	✅	42.7	0.7204	211.26
格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（ms/im）
---	---	---	---	---
PyTorch	✅	6.2	0.6381	1068.42
TorchScript	✅	12.4	0.6092	1248.01
ONNX	✅	12.2	0.6092	560.04
OpenVINO	✅	12.3	0.6092	534.93
TF SavedModel	✅	30.6	0.6092	816.50
TF GraphDef	✅	12.3	0.6092	1007.57
TF Lite	✅	12.3	0.6092	950.29
PaddlePaddle	✅	24.4	0.6092	1507.75
NCNN	✅	12.2	0.6092	414.73
格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（ms/im）
---	---	---	---	---
PyTorch	✅	21.5	0.6967	2589.58
TorchScript	✅	43.0	0.7136	2901.33
ONNX	✅	42.8	0.7136	1436.33
OpenVINO	✅	42.9	0.7136	1225.19
TF SavedModel	✅	107.0	0.7136	1770.95
TF GraphDef	✅	42.8	0.7136	2146.66
TF Lite	✅	42.8	0.7136	2945.03
PaddlePaddle	✅	85.5	0.7136	3962.62
NCNN	✅	42.7	0.7136	1042.39

复现我们的结果

要在所有导出格式上复现上述 Ultralytics 基准测试结果，请运行此代码：

示例

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
results = model.benchmarks(data="coco8.yaml", imgsz=640)

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
yolo  benchmark  model=yolov8n.pt  data=coco8.yaml  imgsz=640

请注意，基准测试结果可能会根据系统的确切硬件和软件配置以及系统在进行基准测试时的当前工作负载而有所不同。要获得最可靠的结果，请使用一个包含大量图像的数据集，即data='coco8.yaml' (4 val images)，或者data='coco.yaml'（5000 val images）。

使用树莓派摄像头

在进行计算机视觉项目时使用树莓派，抓取实时视频流进行推理非常重要。树莓派上的 MIPI CSI 连接器允许连接官方树莓派摄像头模块。在本指南中，我们使用了 Raspberry Pi Camera Module 3 抓取视频流，并使用 YOLOv8 模型进行推理。

提示

查看关于树莓派提供的不同摄像头模块以及如何开始使用树莓派摄像头模块的信息的文档。

注意

树莓派 5 使用比树莓派 4 更小的 CSI 连接器（15 引脚 vs 22 引脚），因此您需要一根 15 引脚到 22 引脚适配器电缆来连接树莓派摄像头。

测试摄像头

在连接摄像头到树莓派后执行以下命令。您应该能看到来自摄像头的实时视频流，持续约 5 秒钟。

rpicam-hello

提示

查看官方树莓派文档中关于 rpicam-hello 的使用说明。

使用摄像头进行推理

有两种使用树莓派摄像头进行 YOLOv8 模型推理的方法。

使用方法

我们可以使用预装在树莓派 OS 上的 picamera2 来访问摄像头并推理 YOLOv8 模型。

示例

import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

# Initialize the Picamera2
picam2 = Picamera2()
picam2.preview_configuration.main.size = (1280, 720)
picam2.preview_configuration.main.format = "RGB888"
picam2.preview_configuration.align()
picam2.configure("preview")
picam2.start()

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

while True:
    # Capture frame-by-frame
    frame = picam2.capture_array()

    # Run YOLOv8 inference on the frame
    results = model(frame)

    # Visualize the results on the frame
    annotated_frame = results[0].plot()

    # Display the resulting frame
    cv2.imshow("Camera", annotated_frame)

    # Break the loop if 'q' is pressed
    if cv2.waitKey(1) == ord("q"):
        break

# Release resources and close windows
cv2.destroyAllWindows()

我们需要通过连接的摄像头与 rpicam-vid 建立一个 TCP 流，以便在后续推理时将此流 URL 作为输入。执行以下命令来启动 TCP 流。

rpicam-vid  -n  -t  0  --inline  --listen  -o  tcp://127.0.0.1:8888

查看官方树莓派文档中关于 rpicam-vid 的使用说明。

示例

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Run inference
results = model("tcp://127.0.0.1:8888")

yolo  predict  model=yolov8n.pt  source="tcp://127.0.0.1:8888"

提示

查看我们的文档关于推理来源，如果您想更改图像/视频输入类型。

在使用树莓派时的最佳实践

有几项最佳实践需要遵循，以在运行 YOLOv8 的树莓派上实现最大性能。

使用 SSD

在持续使用树莓派进行 24x7 使用时，建议使用 SSD 作为系统，因为 SD 卡无法承受连续写入并可能损坏。现在，通过树莓派 5 上的内置 PCIe 连接器，您可以使用适配器如 NVMe Base for Raspberry Pi 5 连接 SSD。
无 GUI 刷写

在刷写树莓派 OS 时，您可以选择不安装桌面环境（树莓派 OS Lite），这样可以节省设备上的一些 RAM，为计算机视觉处理留下更多空间。

下一步

恭喜您成功在树莓派上设置 YOLO！如需进一步学习和支持，请访问 Ultralytics YOLOv8 文档和Kashmir World Foundation。

致谢与引用

本指南最初由 Daan Eeltink 为 Kashmir World Foundation 创建，这是一个致力于利用 YOLO 保护濒危物种的组织。我们承认他们在物体检测技术领域的开创性工作和教育重点。

欲了解更多关于 Kashmir World Foundation 活动的信息，请访问他们的网站。

常见问题解答

如何在树莓派上不使用 Docker 设置 Ultralytics YOLOv8？

要在树莓派上设置 Ultralytics YOLOv8 而不使用 Docker，请按照以下步骤操作：

更新软件包列表并安装pip：

sudo  apt  update
sudo  apt  install  python3-pip  -y
pip  install  -U  pip

使用可选依赖项安装 Ultralytics 包：
```
pip  install  ultralytics[export] 
```
重新启动设备以应用更改：
```
sudo  reboot 
```

有关详细说明，请参阅无 Docker 启动部分。

为什么我应该在树莓派上使用 Ultralytics YOLOv8 的 NCNN 格式进行 AI 任务？

Ultralytics YOLOv8 的 NCNN 格式经过高度优化，非常适合移动和嵌入式平台，非常适合在树莓派设备上运行 AI 任务。NCNN 通过利用 ARM 架构提供更快速和更高效的处理，最大化推断性能，比其他格式更优。有关支持的导出选项的详细信息，请访问 Ultralytics 部署选项文档页面。

如何将 YOLOv8 模型转换为 NCNN 格式以在树莓派上使用？

您可以使用 Python 或 CLI 命令将 PyTorch YOLOv8 模型转换为 NCNN 格式：

示例

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Export the model to NCNN format
model.export(format="ncnn")  # creates 'yolov8n_ncnn_model'

# Load the exported NCNN model
ncnn_model = YOLO("yolov8n_ncnn_model")

# Run inference
results = ncnn_model("https://ultralytics.com/images/bus.jpg")

# Export a YOLOv8n PyTorch model to NCNN format
yolo  export  model=yolov8n.pt  format=ncnn  # creates 'yolov8n_ncnn_model'

# Run inference with the exported model
yolo  predict  model='yolov8n_ncnn_model'  source='https://ultralytics.com/images/bus.jpg'

更多详情，请参阅在树莓派上使用 NCNN 部分。

树莓派 4 和树莓派 5 在运行 YOLOv8 时的硬件差异是什么？

关键差异包括：

CPU：树莓派 4 使用 Broadcom BCM2711，Cortex-A72 64 位 SoC，而树莓派 5 使用 Broadcom BCM2712，Cortex-A76 64 位 SoC。
最大 CPU 频率：树莓派 4 的最大频率为 1.8GHz，而树莓派 5 可达到 2.4GHz。
内存：树莓派 4 提供高达 8GB 的 LPDDR4-3200 SDRAM，而树莓派 5 采用 LPDDR4X-4267 SDRAM，有 4GB 和 8GB 两种变体。

这些增强措施使 YOLOv8 模型在树莓派 5 上的性能基准比树莓派 4 更好。有关更多详细信息，请参阅树莓派系列比较表。

如何设置树莓派摄像头模块以与 Ultralytics YOLOv8 配合使用？

设置树莓派摄像头进行 YOLOv8 推断有两种方法：

使用picamera2：

import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

picam2 = Picamera2()
picam2.preview_configuration.main.size = (1280, 720)
picam2.preview_configuration.main.format = "RGB888"
picam2.preview_configuration.align()
picam2.configure("preview")
picam2.start()

model = YOLO("yolov8n.pt")

while True:
    frame = picam2.capture_array()
    results = model(frame)
    annotated_frame = results[0].plot()
    cv2.imshow("Camera", annotated_frame)

    if cv2.waitKey(1) == ord("q"):
        break

cv2.destroyAllWindows()

使用 TCP 流：

rpicam-vid  -n  -t  0  --inline  --listen  -o  tcp://127.0.0.1:8888

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
results = model("tcp://127.0.0.1:8888")

有关详细设置说明，请访问使用摄像头推断部分。

快速入门指南：NVIDIA Jetson 与 Ultralytics YOLOv8

原文：docs.ultralytics.com/guides/nvidia-jetson/

本详细指南提供了在NVIDIA Jetson设备上部署 Ultralytics YOLOv8 的详细步骤。此外，它展示了性能基准，以展示 YOLOv8 在这些小巧且强大的设备上的能力。

www.youtube.com/embed/mUybgOlSxxA

注意： 如何设置 NVIDIA Jetson 与 Ultralytics YOLOv8

NVIDIA Jetson 生态系统

注意

此指南已在基于 NVIDIA Jetson Orin NX 16GB 的Seeed Studio reComputer J4012（运行最新稳定的 JetPack 版本JP6.0）、基于 NVIDIA Jetson Nano 4GB 的Seeed Studio reComputer J1020 v2（运行 JetPack 版本JP4.6.1）上经过测试。预计可以在包括最新和传统硬件在内的所有 NVIDIA Jetson 硬件系列上运行。

什么是 NVIDIA Jetson？

NVIDIA Jetson 是一系列嵌入式计算板，旨在将加速 AI（人工智能）计算引入边缘设备。这些小巧而强大的设备围绕 NVIDIA 的 GPU 架构构建，并能够在设备上直接运行复杂的 AI 算法和深度学习模型，无需依赖云计算资源。Jetson 板常用于机器人技术、自动驾驶车辆、工业自动化及其他需要在本地进行低延迟和高效率 AI 推理的应用。此外，这些板基于 ARM64 架构，与传统的 GPU 计算设备相比，功耗更低。

NVIDIA Jetson 系列比较

Jetson Orin是基于 NVIDIA Ampere 架构的 NVIDIA Jetson 系列的最新版本，与前几代相比，显著提升了 AI 性能。下表比较了生态系统中几款 Jetson 设备。

	Jetson AGX Orin 64GB	Jetson Orin NX 16GB	Jetson Orin Nano 8GB	Jetson AGX Xavier	Jetson Xavier NX	Jetson Nano
AI Performance	275 TOPS	100 TOPS	40 TOPs	32 TOPS	21 TOPS	472 GFLOPS
GPU	2048 核 NVIDIA 安培架构 GPU，带有 64 个张量核心	1024 核 NVIDIA 安培架构 GPU，带有 32 个张量核心	1024 核 NVIDIA 安培架构 GPU，带有 32 个张量核心	512 核 NVIDIA 伏特架构 GPU，带有 64 个张量核心	384 核 NVIDIA 伏特架构 GPU，带有 48 个张量核心	128 核 NVIDIA 麦克斯韦架构 GPU
GPU 最大频率	1.3 GHz	918 MHz	625 MHz	1377 MHz	1100 MHz	921MHz
CPU	12 核 NVIDIA Arm® Cortex A78AE v8.2 64 位 CPU，3MB L2 + 6MB L3	8 核 NVIDIA Arm® Cortex A78AE v8.2 64 位 CPU，2MB L2 + 4MB L3	6 核 Arm® Cortex®-A78AE v8.2 64 位 CPU，1.5MB L2 + 4MB L3	8 核 NVIDIA Carmel Arm®v8.2 64 位 CPU，8MB L2 + 4MB L3	6 核 NVIDIA Carmel Arm®v8.2 64 位 CPU，6MB L2 + 4MB L3	四核 Arm® Cortex®-A57 MPCore 处理器
CPU 最大频率	2.2 GHz	2.0 GHz	1.5 GHz	2.2 GHz	1.9 GHz	1.43GHz
内存	64GB 256 位 LPDDR5，204.8GB/s	16GB 128 位 LPDDR5，102.4GB/s	8GB 128 位 LPDDR5，68 GB/s	32GB 256 位 LPDDR4x，136.5GB/s	8GB 128 位 LPDDR4x，59.7GB/s	4GB 64 位 LPDDR4，25.6GB/s"

欲查看更详细的比较表，请访问官方 NVIDIA Jetson 页面的技术规格部分。

NVIDIA JetPack 是什么？

NVIDIA JetPack SDK，为 Jetson 模块提供动力的最全面解决方案，为构建端到端加速 AI 应用提供完整的开发环境，并缩短上市时间。JetPack 包括 Jetson Linux 与引导加载程序、Linux 内核、Ubuntu 桌面环境，以及一整套用于加速 GPU 计算、多媒体、图形和计算机视觉的库。它还包括样本、文档和主机计算机及开发套件的开发工具，并支持更高级别的 SDK，如用于流媒体视频分析的 DeepStream、用于机器人技术的 Isaac 和用于对话 AI 的 Riva。

将 JetPack 刷写到 NVIDIA Jetson

获得 NVIDIA Jetson 设备后的第一步是将 NVIDIA JetPack 刷写到设备上。有多种不同的刷写 NVIDIA Jetson 设备的方法。

如果您拥有官方的 NVIDIA 开发套件，如 Jetson Orin Nano 开发套件，可以下载映像并准备一张 JetPack 启动设备的 SD 卡。
如果您拥有其他任何 NVIDIA 开发套件，可以使用 SDK 管理器将 JetPack 刷写到设备上。
如果您拥有 Seeed Studio reComputer J4012 设备，可以将 JetPack 刷写到包含的 SSD 上，如果您拥有 Seeed Studio reComputer J1020 v2 设备，可以将 JetPack 刷写到 eMMC/ SSD 上。
如果您拥有其他由 NVIDIA Jetson 模块驱动的第三方设备，建议按照命令行刷写进行操作。

注意

对于上述方法 3 和 4，在刷写系统并启动设备后，请在设备终端上输入 "sudo apt update && sudo apt install nvidia-jetpack -y" 来安装所有剩余的 JetPack 组件。

基于 Jetson 设备的 JetPack 支持

下表突出显示了不同 NVIDIA Jetson 设备支持的 NVIDIA JetPack 版本。

	JetPack 4	JetPack 5	JetPack 6
Jetson Nano	✅	❌	❌
Jetson TX2	✅	❌	❌
Jetson Xavier NX	✅	✅	❌
Jetson AGX Xavier	✅	✅	❌
Jetson AGX Orin	❌	✅	✅
Jetson Orin NX	❌	✅	✅
Jetson Orin Nano	❌	✅	✅

使用 Docker 快速入门

在 NVIDIA Jetson 上快速开始 Ultralytics YOLOv8 的最快方式是使用为 Jetson 预构建的 Docker 镜像。请根据上表选择适合您拥有的 Jetson 设备的 JetPack 版本。

t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo  docker  pull  $t  &&  sudo  docker  run  -it  --ipc=host  --runtime=nvidia  $t

t=ultralytics/ultralytics:latest-jetson-jetpack5
sudo  docker  pull  $t  &&  sudo  docker  run  -it  --ipc=host  --runtime=nvidia  $t

t=ultralytics/ultralytics:latest-jetson-jetpack6
sudo  docker  pull  $t  &&  sudo  docker  run  -it  --ipc=host  --runtime=nvidia  $t

完成后，跳转到在 NVIDIA Jetson 上使用 TensorRT 部分。

从本地安装开始

如果要进行无 Docker 的本地安装，请参考以下步骤。

在 JetPack 6.x 上运行

安装 Ultralytics 包

在 Jetson 上安装 Ultralytics 包及其可选依赖项，以便我们可以将 PyTorch 模型导出为其他不同的格式。我们将主要关注 NVIDIA TensorRT 导出，因为 TensorRT 将确保我们可以在 Jetson 设备上获得最大的性能。

更新软件包列表，安装 pip 并升级到最新版本

sudo  apt  update
sudo  apt  install  python3-pip  -y
pip  install  -U  pip

安装 ultralytics pip 包及其可选依赖项
```
pip  install  ultralytics[export] 
```
重启设备
```
sudo  reboot 
```

安装 PyTorch 和 Torchvision

上述的 Ultralytics 安装将安装 Torch 和 Torchvision。然而，通过 pip 安装的这两个包不兼容基于 ARM64 架构的 Jetson 平台。因此，我们需要手动安装预构建的 PyTorch pip wheel 并从源代码编译/安装 Torchvision。

根据 JP6.0 安装 torch 2.3.0 和 torchvision 0.18

sudo  apt-get  install  libopenmpi-dev  libopenblas-base  libomp-dev  -y
pip  install  https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.3.0-cp310-cp310-linux_aarch64.whl
pip  install  https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.18.0a0+6043bc2-cp310-cp310-linux_aarch64.whl

访问 PyTorch for Jetson 页面获取不同 JetPack 版本的所有不同 PyTorch 版本。有关 PyTorch 和 Torchvision 的兼容性更详细的列表，请访问 PyTorch 和 Torchvision 兼容性页面。

安装 `onnxruntime-gpu`

onnxruntime-gpu 包在 PyPI 上托管的版本没有适用于 Jetson 的 aarch64 二进制文件。因此我们需要手动安装此包。这个包在某些导出过程中是必需的。

所有不同 JetPack 和 Python 版本对应的 onnxruntime-gpu 包都列在这里。然而，在这里我们将下载并安装支持 Python3.10 的 onnxruntime-gpu 1.18.0。

wget  https://nvidia.box.com/shared/static/48dtuob7meiw6ebgfsfqakc9vse62sg4.whl  -O  onnxruntime_gpu-1.18.0-cp310-cp310-linux_aarch64.whl
pip  install  onnxruntime_gpu-1.18.0-cp310-cp310-linux_aarch64.whl

注意

onnxruntime-gpu 将自动将 numpy 版本恢复到最新版本。因此，我们需要重新安装 numpy 到 1.23.5 以修复一个问题，执行以下命令：

pip install numpy==1.23.5

在 JetPack 5.x 上运行

安装 Ultralytics 包

在 Jetson 上安装 Ultralytics 包及其可选依赖项，以便我们可以将 PyTorch 模型导出到其他不同的格式。我们将主要关注 NVIDIA TensorRT 的导出，因为 TensorRT 能确保我们从 Jetson 设备中获得最佳性能。

更新软件包列表，安装 pip 并升级到最新版本

sudo  apt  update
sudo  apt  install  python3-pip  -y
pip  install  -U  pip

安装带有可选依赖项的 ultralytics pip 包
```
pip  install  ultralytics[export] 
```
重启设备
```
sudo  reboot 
```

安装 PyTorch 和 Torchvision

上述 Ultralytics 安装将安装 Torch 和 Torchvision。然而，通过 pip 安装的这两个包不兼容运行在基于 ARM64 架构的 Jetson 平台上。因此，我们需要手动安装预构建的 PyTorch pip wheel，并从源代码编译/安装 Torchvision。

卸载当前安装的 PyTorch 和 Torchvision
```
pip  uninstall  torch  torchvision 
```

根据 JP5.1.3 安装 PyTorch 2.1.0

sudo  apt-get  install  -y  libopenblas-base  libopenmpi-dev
wget  https://developer.download.nvidia.com/compute/redist/jp/v512/pytorch/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl  -O  torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
pip  install  torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl

根据 PyTorch v2.1.0 安装 Torchvision v0.16.2

sudo  apt  install  -y  libjpeg-dev  zlib1g-dev
git  clone  https://github.com/pytorch/vision  torchvision
cd  torchvision
git  checkout  v0.16.2
python3  setup.py  install  --user

访问 Jetson 上的 PyTorch 页面以访问不同 JetPack 版本的所有 PyTorch 不同版本。有关 PyTorch 和 Torchvision 兼容性的更详细列表，请访问 PyTorch 和 Torchvision 兼容性页面。

安装 `onnxruntime-gpu`

托管在 PyPI 上的 onnxruntime-gpu 包没有适用于 Jetson 的 aarch64 二进制文件。因此，我们需要手动安装此包。此包在某些导出中是必需的。

所有不同 JetPack 和 Python 版本对应的 onnxruntime-gpu 包都列在这里。然而，在这里我们将下载并安装支持 Python3.8 的 onnxruntime-gpu 1.17.0。

wget  https://nvidia.box.com/shared/static/zostg6agm00fb6t5uisw51qi6kpcuwzd.whl  -O  onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
pip  install  onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl

注意

onnxruntime-gpu 将自动将 numpy 版本恢复到最新版本。因此，我们需要重新安装 numpy 到 1.23.5 以修复一个问题，执行以下命令：

pip install numpy==1.23.5

在 NVIDIA Jetson 上使用 TensorRT

在 Ultralytics 支持的所有模型导出格式中，TensorRT 在与 NVIDIA Jetson 设备一起使用时提供了最佳推断性能。我们建议在 Jetson 上使用 TensorRT。我们还有一个关于 TensorRT 的详细文档 here。

将模型转换为 TensorRT 并运行推断

将 PyTorch 格式中的 YOLOv8n 模型转换为 TensorRT，以便使用导出模型进行推断。

示例

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Export the model
model.export(format="engine")  # creates 'yolov8n.engine'

# Load the exported TensorRT model
trt_model = YOLO("yolov8n.engine")

# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")

# Export a YOLOv8n PyTorch model to TensorRT format
yolo  export  model=yolov8n.pt  format=engine  # creates 'yolov8n.engine'

# Run inference with the exported model
yolo  predict  model=yolov8n.engine  source='https://ultralytics.com/images/bus.jpg'

注意

访问导出页面以获取导出模型到不同模型格式时的额外参数

NVIDIA Jetson Orin YOLOv8 基准测试

Ultralytics 团队在由 Jetson Orin NX 16GB 设备提供动力的 Seeed Studio reComputer J4012 上，使用 FP32 精度和默认输入图像大小为 640，对 10 种不同的模型格式（PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, PaddlePaddle, NCNN）进行了 YOLOv8 基准测试，测量了速度和准确性。

比较图表

即使所有的模型输出都能在 NVIDIA Jetson 上正常工作，我们在下面的比较图表中仅包括PyTorch, TorchScript, TensorRT，因为它们利用 Jetson 上的 GPU，保证能够产生最佳结果。所有其他的输出只利用 CPU，性能不如以上三者。您可以在此图表后的部分找到所有输出的基准测试结果。

NVIDIA Jetson 生态系统

详细比较表

下表显示了五种不同模型（YOLOv8n, YOLOv8s, YOLOv8m, YOLOv8l, YOLOv8x）在十种不同格式（PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, PaddlePaddle, NCNN）下的基准测试结果，提供了每种组合的状态、大小、mAP50-95(B)指标和推理时间。

性能

格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（毫秒/图像）
PyTorch	✅	6.2	0.6381	14.3
TorchScript	✅	12.4	0.6117	13.3
ONNX	✅	12.2	0.6092	70.6
OpenVINO	✅	12.3	0.6092	104.2
TensorRT	✅	13.6	0.6117	8.9
TF SavedModel	✅	30.6	0.6092	141.74
TF GraphDef	✅	12.3	0.6092	199.93
TF Lite	✅	12.3	0.6092	349.18
PaddlePaddle	✅	24.4	0.6030	555
NCNN	✅	12.2	0.6092	32
格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（毫秒/图像）
---	---	---	---	---
PyTorch	✅	21.5	0.6967	18
TorchScript	✅	43.0	0.7136	23.81
ONNX	✅	42.8	0.7136	185.55
OpenVINO	✅	42.9	0.7136	243.97
TensorRT	✅	44.0	0.7136	14.82
TF SavedModel	✅	107	0.7136	260.03
TF GraphDef	✅	42.8	0.7136	423.4
TF Lite	✅	42.8	0.7136	1046.64
PaddlePaddle	✅	85.5	0.7140	1464
NCNN	✅	42.7	0.7200	63
格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（毫秒/图像）
---	---	---	---	---
PyTorch	✅	49.7	0.7370	36.4
TorchScript	✅	99.2	0.7285	53.58
ONNX	✅	99	0.7280	452.09
OpenVINO	✅	99.1	0.7280	544.36
TensorRT	✅	100.3	0.7285	33.21
TF SavedModel	✅	247.5	0.7280	543.65
TF GraphDef	✅	99	0.7280	906.63
TF Lite	✅	99	0.7280	2758.08
PaddlePaddle	✅	197.9	0.7280	3678
NCNN	✅	98.9	0.7260	135
格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（毫秒/图像）
---	---	---	---	---
PyTorch	✅	83.7	0.7768	61.3
TorchScript	✅	167.2	0.7554	87.9
ONNX	✅	166.8	0.7551	852.29
OpenVINO	✅	167	0.7551	1012.6
TensorRT	✅	168.4	0.7554	51.23
TF SavedModel	✅	417.2	0.7551	990.45
TF GraphDef	✅	166.9	0.7551	1649.86
TF Lite	✅	166.9	0.7551	5652.37
PaddlePaddle	✅	333.6	0.7551	7114.67
NCNN	✅	166.8	0.7685	231.9
格式	状态	磁盘大小（MB）	mAP50-95(B)	推理时间（ms/图像）
---	---	---	---	---
PyTorch	✅	130.5	0.7759	93
TorchScript	✅	260.7	0.7472	135.1
ONNX	✅	260.4	0.7479	1296.13
OpenVINO	✅	260.6	0.7479	1502.15
TensorRT	✅	261.8	0.7469	84.53
TF SavedModel	✅	651.1	0.7479	1451.76
TF GraphDef	✅	260.5	0.7479	4029.36
TF Lite	✅	260.4	0.7479	8772.86
PaddlePaddle	✅	520.8	0.7479	10619.53
NCNN	✅	260.4	0.7646	376.38

查看由 Seeed Studio 进行的更多基准测试工作，适用于不同版本的 NVIDIA Jetson 硬件。

复现我们的结果

要在所有导出格式上复现以上 Ultralytics 基准，请运行此代码：

示例

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
results = model.benchmarks(data="coco8.yaml", imgsz=640)

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
yolo  benchmark  model=yolov8n.pt  data=coco8.yaml  imgsz=640

请注意，基准测试结果可能会因系统的精确硬件和软件配置以及进行基准测试时系统当前工作负载的不同而有所变化。要获得最可靠的结果，请使用具有大量图像的数据集，例如data='coco8.yaml'（4 个 val 图像）或data='coco.yaml'（5000 个 val 图像）。

使用 NVIDIA Jetson 时的最佳实践

使用 NVIDIA Jetson 时，有几个最佳实践需要遵循，以确保在运行 YOLOv8 的 NVIDIA Jetson 上实现最佳性能。

启用 MAX 功率模式

在 Jetson 上启用 MAX 功率模式将确保所有 CPU 和 GPU 核心都处于启动状态。
```
sudo  nvpmodel  -m  0 
```
启用 Jetson 时钟

启用 Jetson 时钟将确保所有 CPU 和 GPU 核心以其最大频率时钟运行。
```
sudo  jetson_clocks 
```
安装 Jetson Stats 应用程序

我们可以使用 Jetson Stats 应用程序监视系统组件的温度并检查其他系统详细信息，例如查看 CPU、GPU、RAM 利用率，更改功率模式，设置为最大时钟，检查 JetPack 信息。
```
sudo  apt  update
sudo  pip  install  jetson-stats
sudo  reboot
jtop 
```

Jetson Stats

后续步骤

祝贺您成功在 NVIDIA Jetson 上设置了 YOLOv8！如需进一步了解和支持，请访问 Ultralytics YOLOv8 文档的更多指南！

常见问题解答

如何在 NVIDIA Jetson 设备上部署 Ultralytics YOLOv8？

在 NVIDIA Jetson 上部署 Ultralytics YOLOv8 是一个简单直接的过程。首先，使用 NVIDIA JetPack SDK 刷新您的 Jetson 设备。然后，可以使用预构建的 Docker 镜像进行快速设置，或者手动安装所需的软件包。每种方法的详细步骤可以在“使用 Docker 快速入门”和“开始本地安装”部分找到。

我可以在 NVIDIA Jetson 设备上的 YOLOv8 模型中期望什么性能基准？

YOLOv8 模型在各种 NVIDIA Jetson 设备上进行了基准测试，显示出显著的性能改进。例如，TensorRT 格式提供了最佳的推理性能。详细比较表部分的表格提供了跨不同模型格式的 mAP50-95 和推理时间等性能指标的全面视图。

在 NVIDIA Jetson 上部署 YOLOv8 时，为什么应该使用 TensorRT？

由于其优化的性能，强烈推荐在 NVIDIA Jetson 上部署 YOLOv8 模型使用 TensorRT。它通过利用 Jetson 的 GPU 能力加速推理，确保最大的效率和速度。了解更多有关如何转换为 TensorRT 并在 NVIDIA Jetson 上运行推理的信息，请参阅在 NVIDIA Jetson 上使用 TensorRT 部分。

我如何在 NVIDIA Jetson 上安装 PyTorch 和 Torchvision？

要在 NVIDIA Jetson 上安装 PyTorch 和 Torchvision，首先卸载可能通过 pip 安装的任何现有版本。然后，为 Jetson 的 ARM64 架构手动安装兼容的 PyTorch 和 Torchvision 版本。有关此过程的详细说明，请参阅安装 PyTorch 和 Torchvision 部分。

在使用 YOLOv8 时，如何最大化 NVIDIA Jetson 的性能的最佳实践是什么？

为了在 NVIDIA Jetson 上最大化 YOLOv8 的性能，请遵循以下最佳实践：

启用最大功率模式以利用所有 CPU 和 GPU 核心。
启用 Jetson Clocks，以使所有核心运行在其最大频率。
安装 Jetson Stats 应用程序以监视系统指标。

对于命令和额外的细节，请参考使用 NVIDIA Jetson 时的最佳实践部分。

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

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Ultralytics-中文文档-十二-

Ultralytics 中文文档（十二）

Ultralytics YOLO 超参数调整指南

介绍

什么是超参数？

遗传进化和突变

准备超参数调整

涉及步骤

初始化超参数

变异超参数

训练模型

评估模型

记录结果

重复

用法示例

结果

文件结构

文件描述

best_hyperparameters.yaml

best_fitness.png

tune_results.csv

tune_scatter_plots.png

weights/

结论

进一步阅读

常见问题

如何在 Ultralytics YOLO 的超参数调优过程中优化学习率？

在 YOLOv8 中使用遗传算法进行超参数调优的好处是什么？

Ultralytics YOLO 的超参数调优过程需要多长时间？

在 YOLO 超参数调优过程中应该使用哪些指标来评估模型性能？

我可以使用 Ultralytics HUB 来调整 YOLO 模型的超参数吗？

Ultralytics 文档：如何在 SAHI 中使用 YOLOv8 进行切片推理

SAHI 简介

SAHI 的关键特性

什么是切片推理？

切片推理的优势

安装与准备

安装

导入模块并下载资源

使用 YOLOv8 进行标准推断

实例化模型

执行标准预测

可视化结果

使用 YOLOv8 进行切片推断

处理预测结果

批量预测

引用与致谢

常见问题解答

如何集成 YOLOv8 和 SAHI 以在目标检测中进行切片推断？

我为什么要在大图像上使用 YOLOv8 和 SAHI 进行目标检测？

当使用 YOLOv8 和 SAHI 时，我可以可视化预测结果吗？

SAHI 提供了哪些功能来改进 YOLOv8 的目标检测？

如何处理使用 YOLOv8 和 SAHI 的大规模推理项目？

YOLOv8 🚀 在 AzureML 上

什么是 Azure？

什么是 Azure 机器学习（AzureML）？

AzureML 如何使 YOLO 用户受益？

先决条件

创建计算实例

从终端快速入门

创建虚拟环境

执行 YOLOv8 任务

从笔记本快速入门

创建一个新的 IPython 内核

探索更多 AzureML 功能

常见问题解答

如何在 AzureML 上运行 YOLOv8 进行模型训练？

使用 AzureML 进行 YOLOv8 训练的好处是什么？

在 AzureML 上运行 YOLOv8 时如何排除常见问题？

我可以在 AzureML 上同时使用 Ultralytics CLI 和 Python 接口吗？

使用 Ultralytics YOLOv8 而非其他目标检测模型的优势是什么？

Ultralytics 快速入门指南

您将学到什么

先决条件

设置 Conda 环境

安装 Ultralytics

CUDA 环境注意事项

使用 Ultralytics