Ultralytics 中文文档（十三）

使用 DeepStream SDK 和 TensorRT 在 NVIDIA Jetson 上的 Ultralytics YOLOv8

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

这份详尽的指南提供了在NVIDIA Jetson设备上使用 DeepStream SDK 和 TensorRT 部署 Ultralytics YOLOv8 的详细步骤。在这里，我们使用 TensorRT 来最大化 Jetson 平台上的推理性能。

注意

本指南已在基于 NVIDIA Jetson Orin NX 16GB 运行 JetPack 版本JP5.1.3的Seeed Studio reComputer J4012和基于 NVIDIA Jetson Nano 4GB 运行 JetPack 版本JP4.6.4的Seeed Studio reComputer J1020 v2上进行了测试。它预计可以在包括最新和传统的所有 NVIDIA Jetson 硬件中使用。

什么是 NVIDIA DeepStream？

NVIDIA 的 DeepStream SDK是基于 GStreamer 的完整流分析工具包，用于基于 AI 的多传感器处理、视频、音频和图像理解。它非常适合视觉 AI 开发人员、软件合作伙伴、初创公司和 OEM 构建 IVA（智能视频分析）应用和服务。您现在可以创建包含神经网络和其他复杂处理任务（如跟踪、视频编码/解码和视频渲染）的流处理管道。这些管道实现了对视频、图像和传感器数据的实时分析。DeepStream 的多平台支持为您在本地、边缘和云端开发视觉 AI 应用和服务提供了更快、更简单的方法。

先决条件

在开始遵循本指南之前：

• 访问我们的文档，快速入门指南：NVIDIA Jetson 与 Ultralytics YOLOv8，为您的 NVIDIA Jetson 设备设置 Ultralytics YOLOv8

• 根据 JetPack 版本安装DeepStream SDK

  • 对于 JetPack 4.6.4，请安装DeepStream 6.0.1

  • 对于 JetPack 5.1.3，请安装DeepStream 6.3

提示

在本指南中，我们使用了将 DeepStream SDK 安装到 Jetson 设备的 Debian 软件包方法。您也可以访问Jetson 上的 DeepStream SDK（存档）来获取 DeepStream 的旧版本。

YOLOv8 在 DeepStream 上的配置

我们使用的是marcoslucianops/DeepStream-Yolo GitHub 存储库，该存储库包含 NVIDIA DeepStream SDK 对 YOLO 模型的支持。我们感谢 marcoslucianops 为其贡献所做的努力！

1. 安装依赖项

   pip  install  cmake
   pip  install  onnxsim 
   

2. 克隆以下存储库

   git  clone  https://github.com/marcoslucianops/DeepStream-Yolo
   cd  DeepStream-Yolo 
   

3. 从YOLOv8 releases下载您选择的 Ultralytics YOLOv8 检测模型（.pt）。这里我们使用yolov8s.pt。

   wget  https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt 
   

   注意

   您还可以使用自定义训练的 YOLOv8 模型。

4. 将模型转换为 ONNX

   python3  utils/export_yoloV8.py  -w  yolov8s.pt 
   

   将以下参数传递给上述命令

   对于 DeepStream 6.0.1，请使用 opset 12 或更低版本。默认 opset 为 16。

   --opset  12 
   

   更改推理尺寸（默认值：640）

   -s  SIZE
   --size  SIZE
   -s  HEIGHT  WIDTH
   --size  HEIGHT  WIDTH 
   

   例如 1280 的示例：

   -s  1280
   or
   -s  1280  1280 
   

   要简化 ONNX 模型（DeepStream >= 6.0）

   --simplify 
   

   要使用动态批量大小（DeepStream >= 6.1）

   --dynamic 
   

   若要使用静态批量大小（例如批量大小为 4）

   --batch  4 
   

5. 根据安装的 JetPack 版本设置 CUDA 版本

   对于 JetPack 4.6.4：

   export  CUDA_VER=10.2 
   

   对于 JetPack 5.1.3：

   export  CUDA_VER=11.4 
   

6. 编译库

   make  -C  nvdsinfer_custom_impl_Yolo  clean  &&  make  -C  nvdsinfer_custom_impl_Yolo 
   

7. 根据您的模型编辑config_infer_primary_yoloV8.txt文件（适用于具有 80 个类别的 YOLOv8s）

   [property]
   ...
   onnx-file=yolov8s.onnx
   ...
   num-detected-classes=80
   ... 
   

8. 编辑deepstream_app_config文件

   ...
   [primary-gie]
   ...
   config-file=config_infer_primary_yoloV8.txt 
   

9. 您还可以在deepstream_app_config文件中更改视频源。这里加载了一个默认视频文件

   ...
   [source0]
   ...
   uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4 
   

运行推理

deepstream-app  -c  deepstream_app_config.txt 

注意

在开始推理之前生成 TensorRT 引擎文件可能需要很长时间，请耐心等待。

提示

如果要将模型转换为 FP16 精度，只需在config_infer_primary_yoloV8.txt内设置model-engine-file=model_b1_gpu0_fp16.engine和network-mode=2。

INT8 校准

如果要进行推理的 INT8 精度，您需要按照以下步骤操作

1. 设置OPENCV环境变量

   export  OPENCV=1 
   

2. 编译库

   make  -C  nvdsinfer_custom_impl_Yolo  clean  &&  make  -C  nvdsinfer_custom_impl_Yolo 
   

3. 对于 COCO 数据集，请下载val2017，解压并移动到DeepStream-Yolo文件夹

4. 创建一个用于校准图像的新目录

   mkdir  calibration 
   

5. 运行以下命令从 COCO 数据集中选择 1000 张随机图像以进行校准

   for  jpg  in  $(ls  -1  val2017/*.jpg  |  sort  -R  |  head  -1000);  do  \
     cp  ${jpg}  calibration/;  \
   done 
   

   注意

   NVIDIA 建议至少使用 500 张图像以获得良好的准确性。在此示例中，选择 1000 张图像以获得更高的准确性（更多图像=更高的准确性）。您可以设置为head -1000。例如，对于 2000 张图像，设置为head -2000。此过程可能需要很长时间。

6. 创建包含所有选定图像的calibration.txt文件

   realpath  calibration/*jpg  >  calibration.txt 
   

7. 设置环境变量

   export  INT8_CALIB_IMG_PATH=calibration.txt
   export  INT8_CALIB_BATCH_SIZE=1 
   

   注意

   较高的 INT8_CALIB_BATCH_SIZE 值将导致更高的准确性和更快的校准速度。根据您的 GPU 内存设置它。

8. 更新config_infer_primary_yoloV8.txt文件

   来自

   ...
   model-engine-file=model_b1_gpu0_fp32.engine
   #int8-calib-file=calib.table
   ...
   network-mode=0
   ... 
   

   为了

   ...
   model-engine-file=model_b1_gpu0_int8.engine
   int8-calib-file=calib.table
   ...
   network-mode=1
   ... 
   

运行推理

deepstream-app  -c  deepstream_app_config.txt 

多流设置

要在单个 DeepStream 应用程序下设置多个流，您可以对deepstream_app_config.txt文件进行以下更改

1. 根据所需的流数量更改行和列以构建网格显示。例如，对于 4 个流，我们可以添加 2 行和 2 列。

   [tiled-display]
   rows=2
   columns=2 
   

2. 设置 num-sources=4 并添加所有 4 个流的 uri

   [source0]
   enable=1
   type=3
   uri=<path_to_video>
   uri=<path_to_video>
   uri=<path_to_video>
   uri=<path_to_video>
   num-sources=4 
   

运行推理

deepstream-app  -c  deepstream_app_config.txt 

基准结果

以下表格总结了在 NVIDIA Jetson Orin NX 16GB 上，YOLOv8s 模型在不同 TensorRT 精度级别（输入尺寸为 640x640）下的性能表现。

致谢

此指南最初由我们的朋友 Seeed Studio 的 Lakshantha 和 Elaine 创建。

常见问题解答

如何在 NVIDIA Jetson 设备上设置 Ultralytics YOLOv8？

要在 NVIDIA Jetson 设备上设置 Ultralytics YOLOv8，首先需要安装与你的 JetPack 版本兼容的 DeepStream SDK。按照我们的快速入门指南逐步配置你的 NVIDIA Jetson，以便部署 YOLOv8。

在 NVIDIA Jetson 上使用 TensorRT 与 YOLOv8 的好处是什么？

使用 TensorRT 优化 YOLOv8 模型，显著降低 NVIDIA Jetson 设备上的延迟，并提高吞吐量。TensorRT 通过层融合、精度校准和内核自动调整提供高性能、低延迟的深度学习推理。这导致更快更高效的执行，特别适用于视频分析和自动化机器等实时应用。

能否在不同的 NVIDIA Jetson 硬件上运行 Ultralytics YOLOv8 与 DeepStream SDK？

是的，部署 Ultralytics YOLOv8 与 DeepStream SDK 和 TensorRT 的指南适用于整个 NVIDIA Jetson 系列。这包括 Jetson Orin NX 16GB（使用 JetPack 5.1.3）和 Jetson Nano 4GB（使用 JetPack 4.6.4）。详细步骤请参阅 YOLOv8 的 DeepStream 配置部分。

如何将 YOLOv8 模型转换为 DeepStream 的 ONNX 格式？

要将 YOLOv8 模型转换为 ONNX 格式以在 DeepStream 中部署，请使用来自 DeepStream-Yolo 仓库的 utils/export_yoloV8.py 脚本。

这是一个示例命令：

python3  utils/export_yoloV8.py  -w  yolov8s.pt  --opset  12  --simplify 

要了解更多有关模型转换的详细信息，请查看我们的模型导出部分。

NVIDIA Jetson Orin NX 上 YOLOv8 的性能基准是多少？

NVIDIA Jetson Orin NX 16GB 上 YOLOv8 模型的性能因 TensorRT 精度级别而异。例如，YOLOv8s 模型达到：

• FP32 精度: 15.63 ms/im, 64 FPS

• FP16 精度: 7.94 ms/im, 126 FPS

• INT8 精度: 5.53 ms/im, 181 FPS

这些基准测试突显了在 NVIDIA Jetson 硬件上使用 TensorRT 优化的 YOLOv8 模型的效率和能力。详细信息请参见我们的基准测试结果部分。

Triton 推理服务器与 Ultralytics YOLOv8。

原文：docs.ultralytics.com/guides/triton-inference-server/

Triton 推理服务器（以前称为 TensorRT 推理服务器）是 NVIDIA 开发的开源软件解决方案。它提供了一个针对 NVIDIA GPU 优化的云推理解决方案。Triton 简化了生产环境中大规模部署 AI 模型的过程。将 Ultralytics YOLOv8 与 Triton 推理服务器集成，可以部署可扩展、高性能的深度学习推理工作负载。本指南提供了设置和测试集成的步骤。

www.youtube.com/embed/NQDtfSi5QF4

观看：开始使用 NVIDIA Triton 推理服务器。

什么是 Triton 推理服务器？

Triton 推理服务器旨在生产部署各种 AI 模型，支持 TensorFlow、PyTorch、ONNX Runtime 等广泛的深度学习和机器学习框架。其主要用例包括：

• 从单个服务器实例中服务多个模型。

• 动态模型加载和卸载，无需服务器重启。

• 集成推理，允许多个模型一起使用以实现结果。

• 为 A/B 测试和滚动更新进行模型版本控制。

先决条件

在继续之前，请确保具备以下先决条件：

• 您的机器上安装了 Docker。

• 安装tritonclient：

  pip  install  tritonclient[all] 
  

将 YOLOv8 导出为 ONNX 格式

在将模型部署到 Triton 之前，必须将其导出为 ONNX 格式。ONNX（开放神经网络交换）是一种允许在不同深度学习框架之间转移模型的格式。使用YOLO类的export功能：

from ultralytics import YOLO

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

# Export the model
onnx_file = model.export(format="onnx", dynamic=True) 

设置 Triton 模型仓库

Triton 模型仓库是 Triton 可以访问和加载模型的存储位置。

1. 创建必要的目录结构：

   from pathlib import Path
   
   # Define paths
   model_name = "yolo"
   triton_repo_path = Path("tmp") / "triton_repo"
   triton_model_path = triton_repo_path / model_name
   
   # Create directories
   (triton_model_path / "1").mkdir(parents=True, exist_ok=True) 
   

2. 将导出的 ONNX 模型移至 Triton 仓库：

   from pathlib import Path
   
   # Move ONNX model to Triton Model path
   Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")
   
   # Create config file
   (triton_model_path / "config.pbtxt").touch() 
   

运行 Triton 推理服务器

使用 Docker 运行 Triton 推理服务器：

import contextlib
import subprocess
import time

from tritonclient.http import InferenceServerClient

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:23.09-py3"  # 6.4 GB

# Pull the image
subprocess.call(f"docker pull {tag}", shell=True)

# Run the Triton server and capture the container ID
container_id = (
    subprocess.check_output(
        f"docker run -d --rm -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
        shell=True,
    )
    .decode("utf-8")
    .strip()
)

# Wait for the Triton server to start
triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)

# Wait until model is ready
for _ in range(10):
    with contextlib.suppress(Exception):
        assert triton_client.is_model_ready(model_name)
        break
    time.sleep(1) 

然后使用 Triton 服务器模型进行推理：

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg") 

清理容器：

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True) 

遵循以上步骤，您可以在 Triton 推理服务器上高效部署和运行 Ultralytics YOLOv8 模型，为深度学习推理任务提供可扩展和高性能的解决方案。如果遇到任何问题或有进一步的疑问，请参阅官方 Triton 文档或联系 Ultralytics 社区获取支持。

常见问题

如何设置 Ultralytics YOLOv8 与 NVIDIA Triton 推理服务器？

使用NVIDIA Triton 推理服务器设置Ultralytics YOLOv8涉及几个关键步骤：

1. 将 YOLOv8 导出为 ONNX 格式：

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov8n.pt")  # load an official model
   
   # Export the model to ONNX format
   onnx_file = model.export(format="onnx", dynamic=True) 
   

2. 设置 Triton 模型仓库：

   from pathlib import Path
   
   # Define paths
   model_name = "yolo"
   triton_repo_path = Path("tmp") / "triton_repo"
   triton_model_path = triton_repo_path / model_name
   
   # Create directories
   (triton_model_path / "1").mkdir(parents=True, exist_ok=True)
   Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")
   (triton_model_path / "config.pbtxt").touch() 
   

3. 运行 Triton 服务器：

   import contextlib
   import subprocess
   import time
   
   from tritonclient.http import InferenceServerClient
   
   # Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
   tag = "nvcr.io/nvidia/tritonserver:23.09-py3"
   
   subprocess.call(f"docker pull {tag}", shell=True)
   
   container_id = (
       subprocess.check_output(
           f"docker run -d --rm -v {triton_repo_path}/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
           shell=True,
       )
       .decode("utf-8")
       .strip()
   )
   
   triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)
   
   for _ in range(10):
       with contextlib.suppress(Exception):
           assert triton_client.is_model_ready(model_name)
           break
       time.sleep(1) 
   

此设置可帮助您高效地在 Triton 推断服务器上部署 YOLOv8 模型，用于高性能 AI 模型推断。

使用 Ultralytics YOLOv8 与 NVIDIA Triton 推断服务器有什么好处？

将Ultralytics YOLOv8与NVIDIA Triton Inference Server集成，具有多个优势：

• 可扩展的 AI 推断：Triton 允许从单个服务器实例中服务多个模型，支持动态模型的加载和卸载，因此对各种 AI 工作负载具有高度可扩展性。

• 高性能：针对 NVIDIA GPU 进行优化，Triton 推断服务器确保高速推断操作，非常适合实时目标检测等实时应用。

• 集成和模型版本控制：Triton 的集成模式允许组合多个模型以提高结果，其模型版本控制支持 A/B 测试和滚动更新。

有关设置和运行 YOLOv8 与 Triton 的详细说明，请参考设置指南。

为什么在使用 Triton 推断服务器之前需要将 YOLOv8 模型导出为 ONNX 格式？

在部署在NVIDIA Triton Inference Server上之前，为您的 Ultralytics YOLOv8 模型使用 ONNX（开放神经网络交换格式）提供了几个关键的好处：

• 互操作性：ONNX 格式支持不同深度学习框架（如 PyTorch、TensorFlow）之间的转换，确保更广泛的兼容性。

• 优化：包括 Triton 在内的许多部署环境都为 ONNX 进行了优化，实现更快的推断和更好的性能。

• 部署简便性：ONNX 在各种操作系统和硬件配置中广泛支持，简化了部署过程。

要导出您的模型，请使用：

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
onnx_file = model.export(format="onnx", dynamic=True) 

您可以按照导出指南中的步骤完成该过程。

我可以在 Triton 推断服务器上使用 Ultralytics YOLOv8 模型进行推断吗？

是的，您可以在NVIDIA Triton Inference Server上运行 Ultralytics YOLOv8 模型进行推断。一旦您的模型设置在 Triton 模型存储库中并且服务器正在运行，您可以加载并运行推断模型如下：

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg") 

有关设置和运行 Triton 服务器与 YOLOv8 的深入指南，请参考运行 Triton 推断服务器部分。

Ultralytics YOLOv8 在部署时与 TensorFlow 和 PyTorch 模型有何区别？

Ultralytics YOLOv8相比于 TensorFlow 和 PyTorch 模型，在部署时提供了几个独特的优势：

• 实时性能：优化用于实时目标检测任务，YOLOv8 提供了最先进的精度和速度，非常适合需要实时视频分析的应用。

• 易用性：YOLOv8 与 Triton 推理服务器无缝集成，并支持多种导出格式（ONNX、TensorRT、CoreML），使其在各种部署场景下具备灵活性。

• 高级功能：YOLOv8 包括动态模型加载、模型版本管理和集成推理等功能，对于可扩展和可靠的 AI 部署至关重要。

有关更多详细信息，请比较模型部署指南中的部署选项。

隔离分割对象

原文：docs.ultralytics.com/guides/isolating-segmentation-objects/

执行分割任务后，有时希望从推断结果中提取出隔离的对象。本指南提供了使用 Ultralytics 预测模式完成此操作的通用方法。

步骤详解

1. 请查看 Ultralytics 快速入门安装部分，了解所需库的快速设置步骤。

   ---

2. 加载模型并在源上运行 predict() 方法。

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov8n-seg.pt")
   
   # Run inference
   results = model.predict() 
   

   没有预测参数？

   如果没有指定来源，将使用库中的示例图像：

   'ultralytics/assets/bus.jpg'
   'ultralytics/assets/zidane.jpg' 
   

   这对于使用 predict() 方法进行快速测试非常有帮助。

   如需了解有关分割模型的更多信息，请访问分割任务页面。要了解更多关于 predict() 方法的信息，请参阅文档中的预测模式部分。

   ---

3. 现在迭代结果和轮廓。对于希望将图像保存到文件的工作流程，会提取源图像 base-name 和检测到的 class-label 以供后续使用（可选）。

   from pathlib import Path
   
   import numpy as np
   
   # (2) Iterate detection results (helpful for multiple images)
   for r in res:
       img = np.copy(r.orig_img)
       img_name = Path(r.path).stem  # source image base-name
   
       # Iterate each object contour (multiple detections)
       for ci, c in enumerate(r):
           # (1) Get detection class name
           label = c.names[c.boxes.cls.tolist().pop()] 
   

   1. 要了解更多关于处理检测结果的信息，请参阅预测模式中的框部分。

   2. 要了解更多关于 predict() 结果的信息，请参阅预测模式下的结果处理部分

      For-Loop

   单个图像只会在第一个循环中迭代一次。仅包含单个检测的单个图像将在每个循环中仅迭代一次。

   ---

4. 首先从源图像生成二进制掩码，然后在掩码上绘制填充轮廓。这将使对象从图像的其他部分中被隔离出来。右侧显示了一个来自 bus.jpg 的示例，用于一个检测到的 person 类对象。

   

   import cv2
   
   # Create binary mask
   b_mask = np.zeros(img.shape[:2], np.uint8)
   
   # (1) Extract contour result
   contour = c.masks.xy.pop()
   # (2) Changing the type
   contour = contour.astype(np.int32)
   # (3) Reshaping
   contour = contour.reshape(-1, 1, 2)
   
   # Draw contour onto mask
   _ = cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED) 
   

   1. 要了解有关 c.masks.xy 的更多信息，请参阅预测模式中的掩码部分。

   2. 这里将值转换为 np.int32，以便与 OpenCV 的 drawContours() 函数兼容。

   3. OpenCV 的 drawContours() 函数期望轮廓具有 [N, 1, 2] 的形状，请展开下面的部分以了解更多细节。

      展开以了解定义 `contour` 变量时发生的情况。

   • c.masks.xy :: 提供掩码轮廓点的坐标，格式为 (x, y)。更多细节，请参阅预测模式中的掩码部分。

   • .pop() :: 由于 masks.xy 是一个包含单个元素的列表，因此使用 pop() 方法提取此元素。

   • .astype(np.int32) :: 使用 masks.xy 将返回 float32 数据类型，但这与 OpenCV 的 drawContours() 函数不兼容，因此这将数据类型更改为 int32 以确保兼容性。

   • .reshape(-1, 1, 2) :: 将数据重新格式化为所需的 [N, 1, 2] 形状，其中 N 是轮廓点的数量，每个点由单个条目 1 表示，该条目由 2 个值组成。-1 表示此维度上的值数量是灵活的。

     展开以查看 drawContours() 配置的解释。

   • 将 contour 变量封装在方括号 [contour] 内，在测试中有效生成所需的轮廓掩模。

   • 对于 drawContours() 参数，指定的值 -1 指示函数绘制图像中存在的所有轮廓。

   • tuple (255, 255, 255) 表示颜色白色，这是在此二进制掩模中绘制轮廓所需的颜色。

   • 添加 cv2.FILLED 将使得所有由轮廓边界包围的像素颜色相同，本例中，所有被包围的像素将会是白色。

   • 有关更多信息，请参阅 OpenCV drawContours() 文档。

   ---

5. 接下来有两种选项可以继续处理此图像，每种选项后面都有一个后续选项。

   对象隔离选项

   # Create 3-channel mask
   mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
   
   # Isolate object with binary mask
   isolated = cv2.bitwise_and(mask3ch, img) 
   

   这是如何工作的？

   • 首先，将二进制掩模从单通道图像转换为三通道图像。这种转换对后续步骤至关重要，其中掩模和原始图像结合。两幅图像必须具有相同的通道数，以兼容混合操作。

   • 使用 OpenCV 函数 bitwise_and() 合并原始图像和三通道二进制掩模。此操作仅保留两幅图像中大于零的像素值。由于掩模像素仅在轮廓区域内大于零，因此从原始图像中保留的像素是与轮廓重叠的像素。

使用黑色像素进行隔离：子选项

全尺寸图像

如果保留全尺寸图像，则无需任何额外步骤。



示例全尺寸输出

裁剪的对象图像

需要进一步裁剪图像以仅包括对象区域。



# (1) Bounding box coordinates
x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
# Crop image to object region
iso_crop = isolated[y1:y2, x1:x2] 

1. 有关边界框结果的更多信息，请参见预测模式中的框部分。

此代码的作用是什么？

• c.boxes.xyxy.cpu().numpy() 调用以 xyxy 格式作为 NumPy 数组检索边界框，其中 xmin、ymin、xmax 和 ymax 表示边界框矩形的坐标。有关更多详细信息，请参见预测模式中的框部分。

• squeeze()操作从 NumPy 数组中移除任何不必要的维度，确保其具有预期的形状。

• 使用.astype(np.int32)转换坐标值会将框坐标数据类型从float32更改为int32，使其适用于使用索引切片进行图像裁剪。

• 最后，使用索引切片从图像中裁剪边界框区域。边界由检测边界框的[ymin:ymax, xmin:xmax]坐标定义。

# Isolate object with transparent background (when saved as PNG)
isolated = np.dstack([img, b_mask]) 

这是如何工作的？
• 使用 NumPy dstack()函数（沿深度轴堆叠数组）与生成的二进制掩码一起，将创建一个具有四个通道的图像。在保存为PNG文件时，这允许对象轮廓外的所有像素都是透明的。

使用透明像素隔离：子选项

全尺寸图像

如果保留完整大小的图像，则不需要任何额外步骤。



示例全尺寸输出 + 透明背景

裁剪对象图像

需要额外步骤来裁剪图像，仅包括对象区域。



# (1) Bounding box coordinates
x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
# Crop image to object region
iso_crop = isolated[y1:y2, x1:x2] 

1. 若要了解边界框结果的更多信息，请参见预测模式下的框部分

这段代码做什么？

• 当使用c.boxes.xyxy.cpu().numpy()时，边界框将作为 NumPy 数组返回，使用xyxy框坐标格式，这对应于边界框（矩形）的xmin, ymin, xmax, ymax点，请参见预测模式的框部分获取更多信息。

• 添加squeeze()确保从 NumPy 数组中移除任何多余的维度。

• 使用.astype(np.int32)转换坐标值会将框坐标数据类型从float32更改为int32，在使用索引切片裁剪图像时会兼容。

• 最后，使用索引切片裁剪边界框的图像区域，其中边界由检测边界框的[ymin:ymax, xmin:xmax]坐标设置。

如果我想要包括背景在内的裁剪对象，该怎么办？

这是 Ultralytics 库的内置功能。有关详细信息，请参阅预测模式推理参数中的save_crop参数。

---

6. 接下来的操作完全取决于您作为开发人员的选择。一个可能的下一步基本示例（将图像保存为文件以备将来使用）已显示。

   • 注意： 如果对您的具体用例不需要，则可以选择跳过此步骤。
     最终示例步骤

   # Save isolated object to file
   _ = cv2.imwrite(f"{img_name}_{label}-{ci}.png", iso_crop) 
   

   • 在这个示例中，img_name 是源图像文件的基本名称，label 是检测到的类名，ci 是对象检测的索引（如果有多个具有相同类名的实例）。

完整示例代码

在这里，将前一节的所有步骤合并为一个代码块。对于重复使用，最好定义一个函数来执行for循环中的某些或所有命令，但这是留给读者的练习。

from pathlib import Path

import cv2
import numpy as np

from ultralytics import YOLO

m = YOLO("yolov8n-seg.pt")  # (4)!
res = m.predict()  # (3)!

# Iterate detection results (5)
for r in res:
    img = np.copy(r.orig_img)
    img_name = Path(r.path).stem

    # Iterate each object contour (6)
    for ci, c in enumerate(r):
        label = c.names[c.boxes.cls.tolist().pop()]

        b_mask = np.zeros(img.shape[:2], np.uint8)

        # Create contour mask (1)
        contour = c.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2)
        _ = cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED)

        # Choose one:

        # OPTION-1: Isolate object with black background
        mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
        isolated = cv2.bitwise_and(mask3ch, img)

        # OPTION-2: Isolate object with transparent background (when saved as PNG)
        isolated = np.dstack([img, b_mask])

        # OPTIONAL: detection crop (from either OPT1 or OPT2)
        x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
        iso_crop = isolated[y1:y2, x1:x2]

        # TODO your actions go here (2) 

1. 在此处将填充 contour 的行合并为单行，而不是像上面那样拆分为多行。

2. 这里的内容由您决定！

3. 有关附加信息，请参阅 Predict Mode。

4. 参见 Segment Task 获取更多信息。

5. 详细了解与结果一起工作

6. 详细了解分割掩模结果

常见问题解答

如何使用 Ultralytics YOLOv8 对象分割任务中孤立对象？

要使用 Ultralytics YOLOv8 对象分割任务中的孤立对象，请按照以下步骤进行：

1. 加载模型并运行推理：

   from ultralytics import YOLO
   
   model = YOLO("yolov8n-seg.pt")
   results = model.predict(source="path/to/your/image.jpg") 
   

2. 生成二进制掩模并绘制轮廓：

   import cv2
   import numpy as np
   
   img = np.copy(results[0].orig_img)
   b_mask = np.zeros(img.shape[:2], np.uint8)
   contour = results[0].masks.xy[0].astype(np.int32).reshape(-1, 1, 2)
   cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED) 
   

3. 使用二进制掩模孤立对象：

   mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
   isolated = cv2.bitwise_and(mask3ch, img) 
   

参考 Predict Mode 和 Segment Task 的指南获取更多信息。

分割任务中提供的保存孤立对象的选项有哪些？

Ultralytics YOLOv8 提供了两个主要选项来保存孤立对象：

1. 具有黑色背景：

   mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
   isolated = cv2.bitwise_and(mask3ch, img) 
   

2. 具有透明背景：

   isolated = np.dstack([img, b_mask]) 
   

欲了解详细信息，请访问 Predict Mode 部分。

如何使用 Ultralytics YOLOv8 对象分割任务中的边界框裁剪孤立对象？

要裁剪孤立对象至其边界框：

1. 检索边界框坐标：

   x1, y1, x2, y2 = results[0].boxes.xyxy[0].cpu().numpy().astype(np.int32) 
   

2. 裁剪孤立图像：

   iso_crop = isolated[y1:y2, x1:x2] 
   

详细了解 Predict Mode 文档中的边界框结果。

为什么应该在对象分割任务中使用 Ultralytics YOLOv8 进行对象孤立？

Ultralytics YOLOv8 提供：

• 高速 实时对象检测和分割。

• 准确的边界框和掩模生成，用于精确的对象孤立。

• 全面的文档 和易于使用的 API，用于高效开发。

探索在 Segment Task 文档中使用 YOLO 的好处。

我可以使用 Ultralytics YOLOv8 保存包括背景在内的孤立对象吗？

是的，这是 Ultralytics YOLOv8 中的内置功能。在 predict() 方法中使用 save_crop 参数。例如：

results = model.predict(source="path/to/your/image.jpg", save_crop=True) 

阅读 Predict Mode 推理参数部分中关于 save_crop 参数的更多信息。

Coral Edge TPU 在树莓派上与 Ultralytics YOLOv8

标签：中文,Ultralytics,YOLO,文档,图像,import,model,ROS
From： https://www.cnblogs.com/apachecn/p/18348809