Skip to content

Ultralytics YOLO 模型预测

Ultralytics YOLO 生态系统及集成

简介

机器学习计算机视觉领域,从视觉数据中提取信息的过程被称为“推理”或“预测”。Ultralytics YOLO11提供了一个强大的功能,称为预测模式,专为在各种数据源上进行高性能、实时推理而设计。



观看: 如何从Ultralytics YOLO模型中提取输出用于自定义项目。

实际应用

制造业 体育 安全
![车辆备件检测][car spare parts] 足球运动员检测[football player detect] ![人员跌倒检测][human fall detect]
车辆备件检测 足球运动员检测 人员跌倒检测

为何使用Ultralytics YOLO进行推理?

以下是你应该考虑使用YOLO11的预测模式进行各种推理需求的原因:

  • 多功能性: 能够对图像、视频甚至实时流进行推理。
  • 性能: 专为实时、高速处理设计,同时不牺牲准确性
  • 易用性: 直观的Python和CLI接口,便于快速部署和测试。
  • 高度可定制: 多种设置和参数,可根据你的特定需求调整模型的推理行为。

预测模式的关键特性

YOLO11的预测模式设计得既稳健又多功能,具备以下特点:

  • 多数据源兼容性: 无论你的数据是单张图像、图像集合、视频文件还是实时视频流,预测模式都能应对。
  • 流媒体模式: 使用流媒体功能生成内存高效的Results对象生成器。通过在预测器的调用方法中设置stream=True来启用此功能。
  • 批处理: 能够一次性处理多张图像或视频帧,进一步加快推理时间。
  • 易于集成: 由于其灵活的API,可以轻松集成到现有的数据管道和其他软件组件中。

Ultralytics YOLO模型在推理时返回Python列表形式的Results对象,或者当stream=True时返回内存高效的Results对象生成器:

预测

from ultralytics import YOLO

# 加载模型
model = YOLO("yolo11n.pt")  # 预训练的YOLO11n模型

# 对图像列表进行批量推理
results = model(["image1.jpg", "image2.jpg"])  # 返回Results对象列表

# 处理结果列表
for result in results:
    boxes = result.boxes  # 边界框输出的Boxes对象
    masks = result.masks  # 分割掩码输出的Masks对象
    keypoints = result.keypoints  # 姿态输出的Keypoints对象
    probs = result.probs  # 分类输出的Probs对象
    obb = result.obb  # OBB输出的Oriented boxes对象
    result.show()  # 显示到屏幕
    result.save(filename="result.jpg")  # 保存到磁盘

```python from ultralytics import YOLO

加载模型

model = YOLO("yolo11n.pt") # 预训练的YOLO11n模型

对图像列表进行批量推理

results = model(["image1.jpg", "image2.jpg"], stream=True) # 返回Results对象生成器

处理结果生成器

python for result in results: boxes = result.boxes # Boxes对象,用于边界框输出 masks = result.masks # Masks对象,用于分割掩码输出 keypoints = result.keypoints # Keypoints对象,用于姿态输出 probs = result.probs # Probs对象,用于分类输出 obb = result.obb # Oriented boxes对象,用于OBB输出 result.show() # 显示到屏幕 result.save(filename="result.jpg") # 保存到磁盘

推理源

YOLO11 可以处理不同类型的输入源进行推理,如下表所示。源包括静态图像、视频流和各种数据格式。该表还指示了每个源是否可以使用 stream=True 参数在流模式下使用 ✅。流模式有利于处理视频或实时流,因为它创建了一个结果生成器,而不是将所有帧加载到内存中。

提示

使用 stream=True 处理长视频或大数据集以有效管理内存。当 stream=False 时,所有帧或数据点的结果都存储在内存中,这可能会迅速累积并导致大输入的内存不足错误。相比之下,stream=True 使用生成器,它只将当前帧或数据点的结果保留在内存中,显著减少内存消耗并防止内存不足问题。

示例 类型 说明
图像 'image.jpg' strPath 单个图像文件。
URL 'https://ultralytics.com/images/bus.jpg' str 图像的URL。
截图 'screen' str 捕获屏幕截图。
PIL Image.open('image.jpg') PIL.Image HWC格式,RGB通道。
OpenCV cv2.imread('image.jpg') np.ndarray HWC格式,BGR通道 uint8 (0-255)
numpy np.zeros((640,1280,3)) np.ndarray HWC格式,BGR通道 uint8 (0-255)
torch torch.zeros(16,3,320,640) torch.Tensor BCHW格式,RGB通道 float32 (0.0-1.0)
CSV 'sources.csv' strPath 包含图像、视频或目录路径的CSV文件。
视频 ✅ 'video.mp4' strPath 格式如MP4、AVI等的视频文件。
目录 ✅ 'path/' strPath 包含图像或视频的目录路径。
glob ✅ 'path/*.jpg' str 匹配多个文件的glob模式。使用 * 字符作为通配符。
YouTube ✅ 'https://youtu.be/LNwODJXcvt4' str YouTube视频的URL。
流 ✅ 'rtsp://example.com/media.mp4' str 流协议如RTSP、RTMP、TCP的URL,或IP地址。
多流 ✅ 'list.streams' strPath *.streams 文本文件,每行一个流URL,即8个流将以批量大小8运行。
网络摄像头 ✅ 0 int 要运行推理的已连接摄像头设备的索引。

以下是使用每种源类型的代码示例:

预测源

对图像文件进行推理。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 定义图像文件的路径
source = "path/to/image.jpg"

# 对源进行推理
results = model(source)  # 结果对象列表

对当前屏幕内容进行截图并进行推理。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 将当前截图定义为源
source = "screen"

# 对源进行推理
results = model(source)  # 结果对象列表

对通过 URL 托管的远程图像或视频进行推理。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 定义远程图像或视频的 URL
source = "https://ultralytics.com/images/bus.jpg"

# 对源进行推理
results = model(source)  # 结果对象列表

对使用 Python Imaging Library (PIL) 打开的图像进行推理。

from PIL import Image

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 使用 PIL 打开图像
source = Image.open("path/to/image.jpg")

# 对源进行推理
results = model(source)  # 结果对象列表

对使用 OpenCV 读取的图像进行推理。

import cv2

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 使用 OpenCV 读取图像
source = cv2.imread("path/to/image.jpg")

# 对源进行推理
results = model(source)  # 结果对象列表

对表示为 numpy 数组的图像进行推理。

import numpy as np

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 创建一个形状为 HWC (640, 640, 3) 的随机 numpy 数组,值范围为 [0, 255],类型为 uint8
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype="uint8")

# 对源进行推理
results = model(source)  # 结果对象列表

对表示为 PyTorch 张量的图像进行推理。

import torch

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 创建一个形状为 BCHW (1, 3, 640, 640) 的随机 torch 张量,值范围为 [0, 1],类型为 float32
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)

# 对源进行推理
results = model(source)  # 结果对象列表

对 CSV 文件中列出的图像、URL、视频和目录集合进行推理。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 定义包含图像、URL、视频和目录的 CSV 文件路径
source = "path/to/file.csv"

# 对源进行推理
results = model(source)  # 结果对象列表

对视频文件进行推理。通过使用 stream=True,可以创建一个结果对象生成器以减少内存使用。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 定义视频文件的路径
source = "path/to/video.mp4"

# 对源进行推理
results = model(source, stream=True)  # 结果对象生成器

对目录中的所有图像和视频进行推理。要同时捕获子目录中的图像和视频,请使用 glob 模式,例如 path/to/dir/**/*

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 定义包含推理图像和视频的目录路径
source = "path/to/dir"

# 对源进行推理
results = model(source)  # 结果对象列表

results = model(source, stream=True)  # 生成器,生成Results对象

使用带有 * 字符的 glob 表达式对所有匹配的图像和视频运行推理。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 定义目录中所有 JPG 文件的 glob 搜索
source = "path/to/dir/*.jpg"

# 或者定义包括子目录在内的所有 JPG 文件的递归 glob 搜索
source = "path/to/dir/**/*.jpg"

# 对源进行推理
results = model(source, stream=True)  # 生成器,生成Results对象

对 YouTube 视频运行推理。通过使用 stream=True,您可以创建一个 Results 对象的生成器,以减少长视频的内存使用。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 将源定义为 YouTube 视频 URL
source = "https://youtu.be/LNwODJXcvt4"

# 对源进行推理
results = model(source, stream=True)  # 生成器,生成Results对象

使用流模式通过 RTSP、RTMP、TCP 或 IP 地址协议对实时视频流运行推理。如果提供单个流,模型以 批量大小 为 1 运行推理。对于多个流,可以使用 .streams 文本文件进行批量推理,其中批量大小由提供的流数量决定(例如,8 个流对应批量大小为 8)。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 单个流,批量大小为 1 的推理
source = "rtsp://example.com/media.mp4"  # RTSP、RTMP、TCP 或 IP 流地址

# 对源进行推理
results = model(source, stream=True)  # 生成器,生成Results对象

对于单个流的使用,默认批量大小设置为 1,允许高效实时处理视频流。

要同时处理多个视频流,请使用包含流源的 .streams 文本文件。模型将运行批量推理,其中批量大小等于流的数量。此设置支持同时高效处理多个视频流。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 多个流,批量推理(例如,8 个流对应批量大小为 8)
source = "path/to/list.streams"  # *.streams 文本文件,每行一个流地址

# 对源进行推理
results = model(source, stream=True)  # 生成器,生成Results对象

示例 .streams 文本文件:

rtsp://example.com/media1.mp4
rtsp://example.com/media2.mp4
rtmp://example2.com/live
tcp://192.168.1.100:554
...

文件中的每一行代表一个流源,允许您同时监控和执行多个视频流的推理。

您可以通过将特定摄像头的索引传递给 source 来对连接的摄像头设备运行推理。

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 对源进行推理
results = model(source=0, stream=True)  # 生成器,生成Results对象

推理参数

model.predict() 接受多个参数,这些参数可以在推理时传递以覆盖默认值:

Example

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 对 'bus.jpg' 运行推理并传递参数
model.predict("bus.jpg", save=True, imgsz=320, conf=0.5)

推理参数:

参数 类型 默认值 描述
source str 'ultralytics/assets' 指定推理的数据源。可以是图像路径、视频文件、目录、URL或实时视频流的设备ID。支持多种格式和数据源,适用于不同类型的输入
conf float 0.25 设置检测的最小置信度阈值。置信度低于此阈值的检测对象将被忽略。调整此值有助于减少误报。
iou float 0.7 交并比 (IoU) 用于非极大值抑制 (NMS) 的阈值。较低的值通过消除重叠框来减少检测数量,有助于减少重复。
imgsz int or tuple 640 定义推理的图像尺寸。可以是单个整数 640 用于方形缩放,或 (高度, 宽度) 元组。适当的尺寸可以提高检测的准确性和处理速度。
half bool False 启用半精度 (FP16) 推理,这可以在支持的GPU上加速模型推理,对准确性影响最小。
device str None 指定推理设备(例如,cpu, cuda:00)。允许用户在CPU、特定GPU或其他计算设备之间选择模型执行。
max_det int 300 每张图像允许的最大检测数量。限制模型在一次推理中可以检测到的对象总数,防止在密集场景中输出过多。
vid_stride int 1 视频输入的帧步长。允许跳过视频中的帧以加快处理速度,代价是时间分辨率降低。值为1处理每一帧,较高的值跳过帧。
stream_buffer bool False 确定是否为视频流队列传入帧。如果为 False,旧帧会被丢弃以容纳新帧(优化用于实时应用)。如果为 True,新帧会被缓冲,确保没有帧被跳过,但如果推理FPS低于流FPS,会导致延迟。
visualize bool False 激活推理过程中模型特征的可视化,提供模型“看到”的内容的洞察。有助于调试和模型解释。
augment bool False 启用预测时的测试时间增强 (TTA),可能会提高检测的鲁棒性,但会牺牲推理速度。
agnostic_nms bool False 启用类不可知的非极大值抑制(NMS),合并不同类别的重叠框。在多类别检测场景中,类别重叠常见时非常有用。
classes list[int] None 过滤预测结果为一组类别ID。只有属于指定类别的检测结果会被返回。在多类别检测任务中,专注于相关对象时非常有用。
retina_masks bool False 如果模型可用,使用高分辨率分割掩码。这可以提高分割任务中的掩码质量,提供更精细的细节。
embed list[int] None 指定从中提取特征向量或嵌入的层。对于聚类或相似性搜索等下游任务非常有用。

可视化参数:

参数 类型 默认值 描述
show bool False 如果为 True,则在窗口中显示带注释的图像或视频。在开发或测试期间,这对于即时视觉反馈非常有用。
save bool FalseTrue 启用将带注释的图像或视频保存到文件。对于文档记录、进一步分析或分享结果非常有用。在 CLI 使用时默认为 True,在 Python 中使用时默认为 False
save_frames bool False 在处理视频时,将单个帧保存为图像。对于提取特定帧或进行详细的逐帧分析非常有用。
save_txt bool False 将检测结果保存为文本文件,格式为 [class] [x_center] [y_center] [width] [height] [confidence]。对于与其他分析工具集成非常有用。
save_conf bool False 在保存的文本文件中包含置信度分数。增强了后处理和分析的详细信息。
save_crop bool False 保存检测到的对象的裁剪图像。对于数据集增强、分析或为特定对象创建聚焦数据集非常有用。
show_labels bool True 在视觉输出中显示每个检测的标签。提供对检测到的对象的即时理解。
show_conf bool True 在标签旁边显示每个检测的置信度分数。提供对模型对每个检测的确定性的洞察。
show_boxes bool True 在检测到的对象周围绘制边界框。对于图像或视频帧中对象的视觉识别和定位至关重要。
line_width Noneint None 指定边界框的线宽。如果为 None,则线宽会根据图像大小自动调整。提供视觉上的清晰度定制。

图像和视频格式

YOLO11 支持多种图像和视频格式,如 ultralytics/data/utils.py 中所述。请参见下表了解有效的后缀和示例预测命令。

图像

下表包含有效的 Ultralytics 图像格式。

Note

HEIC 图像仅支持推理,不支持训练。

图像后缀 示例预测命令 参考
.bmp yolo predict source=image.bmp Microsoft BMP 文件格式
.dng yolo predict source=image.dng Adobe DNG
.jpeg yolo predict source=image.jpeg JPEG
.jpg yolo predict source=image.jpg JPEG
.mpo yolo predict source=image.mpo 多图片对象
.png yolo predict source=image.png 便携式网络图形
.tif yolo predict source=image.tif 标签图像文件格式
.tiff yolo predict source=image.tiff 标签图像文件格式
.webp yolo predict source=image.webp WebP
.pfm yolo predict source=image.pfm 便携式浮点图
.HEIC yolo predict source=image.HEIC 高效图像格式

视频

下表包含有效的 Ultralytics 视频格式。

视频后缀 预测命令示例 参考
.asf yolo predict source=video.asf 高级系统格式
.avi yolo predict source=video.avi 音频视频交错
.gif yolo predict source=video.gif 图形交换格式
.m4v yolo predict source=video.m4v MPEG-4 第14部分
.mkv yolo predict source=video.mkv Matroska
.mov yolo predict source=video.mov QuickTime 文件格式
.mp4 yolo predict source=video.mp4 MPEG-4 第14部分 - 维基百科
.mpeg yolo predict source=video.mpeg MPEG-1 第2部分
.mpg yolo predict source=video.mpg MPEG-1 第2部分
.ts yolo predict source=video.ts MPEG 传输流
.wmv yolo predict source=video.wmv Windows 媒体视频
.webm yolo predict source=video.webm WebM 项目

处理结果

所有 Ultralytics 的 predict() 调用将返回一个 Results 对象列表:

结果

from ultralytics import YOLO

# 加载预训练的 YOLO11n 模型
model = YOLO("yolo11n.pt")

# 对图像进行推理
results = model("bus.jpg")  # 包含1个Results对象的列表
results = model(["bus.jpg", "zidane.jpg"])  # 包含2个Results对象的列表

Results 对象具有以下属性:

属性 类型 描述
orig_img numpy.ndarray 原始图像作为 numpy 数组。
orig_shape tuple 原始图像形状,格式为 (高度, 宽度)。
boxes Boxes, optional 包含检测边界框的 Boxes 对象。
masks Masks, optional 包含检测掩码的 Masks 对象。
probs Probs, optional 包含分类任务中每个类别的概率的 Probs 对象。
keypoints Keypoints, optional 包含每个对象检测到的关键点的 Keypoints 对象。
obb OBB, 可选 包含定向边界框的OBB对象。
speed 字典 包含每张图像的预处理、推理和后处理速度(以毫秒为单位)的字典。
names 字典 包含类别名称的字典。
path 字符串 图像文件的路径。

Results 对象具有以下方法:

方法 返回类型 描述
update() 更新Results对象的boxes、masks和probs属性。
cpu() Results 返回所有张量在CPU内存中的Results对象的副本。
numpy() Results 返回所有张量为numpy数组的Results对象的副本。
cuda() Results 返回所有张量在GPU内存中的Results对象的副本。
to() Results 返回张量在指定设备和数据类型上的Results对象的副本。
new() Results 返回具有相同图像、路径和名称的新Results对象。
plot() numpy.ndarray 绘制检测结果。返回带注释图像的numpy数组。
show() 在屏幕上显示带注释的结果。
save() 将带注释的结果保存到文件。
verbose() 字符串 返回每个任务的日志字符串。
save_txt() 将预测结果保存到txt文件。
save_crop() 将裁剪后的预测结果保存到save_dir/cls/file_name.jpg
tojson() 字符串 将对象转换为JSON格式。

更多详情请参见Results类文档

Boxes

Boxes对象可用于索引、操作和将边界框转换为不同格式。

Boxes

from ultralytics import YOLO

# 加载预训练的YOLO11n模型
model = YOLO("yolo11n.pt")

# 对图像进行推理
results = model("bus.jpg")  # 结果列表

# 查看结果
for r in results:
    print(r.boxes)  # 打印包含检测边界框的Boxes对象

以下是Boxes类方法和属性的表格,包括它们的名称、类型和描述:

名称 类型 描述
cpu() 方法 将对象移动到CPU内存。
numpy() 方法 将对象转换为numpy数组。
cuda() 方法 将对象移动到CUDA内存。
to() 方法 将对象移动到指定设备。
xyxy 属性 (torch.Tensor) 以xyxy格式返回边界框。
conf 属性 (torch.Tensor) 返回边界框的置信度值。
cls 属性 (torch.Tensor) 返回边界框的类别值。
id 属性 (torch.Tensor) 返回边界框的跟踪ID(如果可用)。
xywh 属性 (torch.Tensor) 以xywh格式返回边界框。
xyxyn 属性 (torch.Tensor) 以xyxy格式返回归一化后的边界框。
xywhn 属性 (torch.Tensor) 以xywh格式返回归一化后的边界框。

更多详情请参见Boxes类文档

Masks

Masks对象可用于索引、操作和将掩码转换为段。

Masks

```python from ultralytics import YOLO

加载预训练的YOLO11n-seg分割模型

model = YOLO("yolo11n-seg.pt")

对图像进行推理

results = model("bus.jpg") # 结果列表

查看结果

```python for r in results: print(r.masks) # 打印包含检测到的实例掩码的Masks对象

以下是`Masks`类方法和属性的表格,包括它们的名称、类型和描述:

| 名称      | 类型                      | 描述                                                     |
| --------- | ------------------------- | --------------------------------------------------------------- |
| `cpu()`   | 方法                    | 返回位于CPU内存中的掩码张量。                         |
| `numpy()` | 方法                    | 返回掩码张量作为numpy数组。                      |
| `cuda()`  | 方法                    | 返回位于GPU内存中的掩码张量。                         |
| `to()`    | 方法                    | 返回具有指定设备和数据类型的掩码张量。   |
| `xyn`     | 属性 (`torch.Tensor`) | 表示为张量的归一化段列表。           |
| `xy`      | 属性 (`torch.Tensor`) | 表示为张量的像素坐标中的段列表。 |

更多详情请参阅[`Masks`类文档](../reference/engine/results.md#ultralytics.engine.results.Masks)。

### 关键点

`Keypoints`对象可用于索引、操作和归一化坐标。

!!! 示例 "关键点"

    ```python
    from ultralytics import YOLO

    # 加载预训练的YOLO11n-pose姿态模型
    model = YOLO("yolo11n-pose.pt")

    # 对图像进行推理
    results = model("bus.jpg")  # 结果列表

    # 查看结果
    for r in results:
        print(r.keypoints)  # 打印包含检测到的关键点的Keypoints对象
    ```

以下是`Keypoints`类方法和属性的表格,包括它们的名称、类型和描述:

| 名称      | 类型                      | 描述                                                       |
| --------- | ------------------------- | ----------------------------------------------------------------- |
| `cpu()`   | 方法                    | 返回位于CPU内存中的关键点张量。                       |
| `numpy()` | 方法                    | 返回关键点张量作为numpy数组。                    |
| `cuda()`  | 方法                    | 返回位于GPU内存中的关键点张量。                       |
| `to()`    | 方法                    | 返回具有指定设备和数据类型的关键点张量。 |
| `xyn`     | 属性 (`torch.Tensor`) | 表示为张量的归一化关键点列表。            |
| `xy`      | 属性 (`torch.Tensor`) | 表示为张量的像素坐标中的关键点列表。  |
| `conf`    | 属性 (`torch.Tensor`) | 如果可用,返回关键点的置信度值,否则返回None。   |

更多详情请参阅[`Keypoints`类文档](../reference/engine/results.md#ultralytics.engine.results.Keypoints)。

### 概率

`Probs`对象可用于索引、获取分类的`top1`和`top5`索引和分数。

!!! 示例 "概率"

    ```python
    from ultralytics import YOLO

    # 加载预训练的YOLO11n-cls分类模型
    model = YOLO("yolo11n-cls.pt")

    # 对图像进行推理
    results = model("bus.jpg")  # 结果列表

    # 查看结果
    for r in results:
        print(r.probs)  # 打印包含检测到的类别概率的Probs对象
    ```

以下是`Probs`类方法和属性的表格总结:

| 名称       | 类型                      | 描述                                                             |
| ---------- | ------------------------- | ----------------------------------------------------------------------- |
| `cpu()`    | 方法                    | 返回位于CPU内存中的probs张量副本。                       |
| `numpy()`  | 方法                    | 返回probs张量作为numpy数组的副本。                    |
| `cuda()`   | 方法                    | 返回位于GPU内存中的probs张量副本。                       |
| `to()`     | 方法                    | 返回具有指定设备和数据类型的probs张量副本。 |
| `top1`     | 属性 (`int`)          | 排名第一的类别的索引。                                               |
| `top5`     | 属性 (`list[int]`)    | 排名前五的类别的索引。                                           |
| `top1conf` | 属性 (`torch.Tensor`) | 排名第一的类别的置信度。                                          |
| `top5conf` | 属性 (`torch.Tensor`) | 排名前五的类别的置信度。                                       |

更多详情请参阅[`Probs`类文档](../reference/engine/results.md#ultralytics.engine.results.Probs)。

### OBB

`OBB`对象可用于索引、操作和将定向边界框转换为不同格式。

!!! 示例 "OBB"

    ```python
    from ultralytics import YOLO

    # 加载预训练的YOLO11n模型
```python
model = YOLO("yolo11n-obb.pt")

# 对图像进行推理
results = model("bus.jpg")  # 结果列表

# 查看结果
for r in results:
    print(r.obb)  # 打印包含定向检测边界框的OBB对象

以下是OBB类方法和属性的表格,包括它们的名称、类型和描述:

名称 类型 描述
cpu() 方法 将对象移动到CPU内存。
numpy() 方法 将对象转换为numpy数组。
cuda() 方法 将对象移动到CUDA内存。
to() 方法 将对象移动到指定设备。
conf 属性 (torch.Tensor) 返回边界框的置信度值。
cls 属性 (torch.Tensor) 返回边界框的类别值。
id 属性 (torch.Tensor) 返回边界框的跟踪ID(如果可用)。
xyxy 属性 (torch.Tensor) 返回xyxy格式的水平边界框。
xywhr 属性 (torch.Tensor) 返回xywhr格式的旋转边界框。
xyxyxyxy 属性 (torch.Tensor) 返回xyxyxyxy格式的旋转边界框。
xyxyxyxyn 属性 (torch.Tensor) 返回按图像尺寸归一化的xyxyxyxy格式的旋转边界框。

更多详情请参见OBB类文档

绘制结果

Results对象中的plot()方法通过在原始图像上叠加检测到的对象(如边界框、掩码、关键点和概率)来方便地可视化预测结果。该方法返回一个带注释的图像作为NumPy数组,便于显示或保存。

绘制

from PIL import Image

from ultralytics import YOLO

# 加载预训练的YOLO11n模型
model = YOLO("yolo11n.pt")

# 对'bus.jpg'进行推理
results = model(["bus.jpg", "zidane.jpg"])  # 结果列表

# 可视化结果
for i, r in enumerate(results):
    # 绘制结果图像
    im_bgr = r.plot()  # BGR顺序的numpy数组
    im_rgb = Image.fromarray(im_bgr[..., ::-1])  # RGB顺序的PIL图像

    # 在支持的环境中显示结果
    r.show()

    # 将结果保存到磁盘
    r.save(filename=f"results{i}.jpg")

plot()方法参数

plot()方法支持多种参数来自定义输出:

参数 类型 描述 默认值
conf bool 包含检测置信度分数。 True
line_width float 边界框的线宽。如果为None,则根据图像尺寸缩放。 None
font_size float 文本字体大小。如果为None,则根据图像尺寸缩放。 None
font str 文本注释的字体名称。 'Arial.ttf'
pil bool 返回图像作为PIL Image对象。 False
img numpy.ndarray 用于绘制的替代图像。如果为None,则使用原始图像。 None
im_gpu torch.Tensor 用于更快掩码绘制的GPU加速图像。形状:(1, 3, 640, 640)。 None
kpt_radius int 绘制的关键点半径。 5
kpt_line bool 用线连接关键点。 True
labels bool 在注释中包含类别标签。 True
boxes bool 在图像上叠加边界框。 True
masks bool 在图像上叠加掩码。 True
probs bool 包含分类概率。 True
show bool 使用默认图像查看器直接显示带注释的图像。 False
save bool 如果 saveTrue,则将带注释的图像保存到由 filename 指定的文件中。 False
filename str 如果 saveTrue,则指定保存带注释图像的文件路径和名称。 None
color_mode str 指定颜色模式,例如 'instance' 或 'class'。 'class'

线程安全推理

在不同线程中并行运行多个 YOLO 模型时,确保推理过程中的线程安全至关重要。线程安全推理保证了每个线程的预测是隔离的,不会相互干扰,从而避免竞争条件并确保一致且可靠的输出。

在多线程应用程序中使用 YOLO 模型时,重要的是为每个线程实例化单独的模型对象,或使用线程本地存储以防止冲突:

线程安全推理

在每个线程内部实例化一个模型以进行线程安全推理:

from threading import Thread

from ultralytics import YOLO


def thread_safe_predict(model, image_path):
    """使用本地实例化的 YOLO 模型对图像进行线程安全预测。"""
    model = YOLO(model)
    results = model.predict(image_path)
    # 处理结果


# 启动每个线程都有自己的模型实例
Thread(target=thread_safe_predict, args=("yolo11n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo11n.pt", "image2.jpg")).start()

有关 YOLO 模型线程安全推理的深入了解和逐步说明,请参阅我们的 YOLO 线程安全推理指南。本指南将为您提供避免常见陷阱并确保多线程推理顺利运行的所有必要信息。

流式源 for 循环

以下是一个使用 OpenCV (cv2) 和 YOLO 对视频帧进行推理的 Python 脚本。此脚本假设您已经安装了必要的包 (opencv-pythonultralytics)。

流式 for 循环

import cv2

from ultralytics import YOLO

# 加载 YOLO 模型
model = YOLO("yolo11n.pt")

# 打开视频文件
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# 循环遍历视频帧
while cap.isOpened():
    # 从视频中读取一帧
    success, frame = cap.read()

    if success:
        # 对帧运行 YOLO 推理
        results = model(frame)

        # 在帧上可视化结果
        annotated_frame = results[0].plot()

        # 显示带注释的帧
        cv2.imshow("YOLO Inference", annotated_frame)

        # 如果按下 'q' 键则退出循环
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # 如果到达视频结尾则退出循环
        break

# 释放视频捕获对象并关闭显示窗口
cap.release()
cv2.destroyAllWindows()

此脚本将对视频的每一帧进行预测,可视化结果并在窗口中显示。可以通过按 'q' 键退出循环。

常见问题

什么是 Ultralytics YOLO 及其用于实时推理的预测模式?

Ultralytics YOLO 是一个用于实时目标检测、分割和分类的先进模型。其预测模式允许用户对各种数据源(如图像、视频和实时流)进行高速推理。它还提供批处理和流式处理模式,设计用于性能和多功能性。有关其功能的更多详细信息,请查看 Ultralytics YOLO 预测模式的关键功能

如何在不同数据源上使用 Ultralytics YOLO 进行推理?

Ultralytics YOLO 可以处理广泛的数据源,包括单个图像、视频、目录、URL 和流。您可以在 model.predict() 调用中指定数据源。例如,使用 'image.jpg' 表示本地图像或 'https://ultralytics.com/images/bus.jpg' 表示 URL。请查看文档中关于各种推理源的详细示例。

如何优化 YOLO 推理速度和内存使用?

为了优化推理速度并有效管理内存,您可以在预测器的调用方法中设置 stream=True 来使用流模式。流模式会生成一个内存高效的 Results 对象生成器,而不是将所有帧加载到内存中。对于处理长视频或大数据集,流模式特别有用。了解更多关于流模式的信息。

Ultralytics YOLO 支持哪些推理参数?

YOLO 中的 model.predict() 方法支持多种参数,如 confiouimgszdevice 等。这些参数允许您自定义推理过程,设置置信度阈值、图像大小和用于计算的设备等参数。这些参数的详细描述可以在推理参数部分找到。

如何可视化和保存 YOLO 预测的结果?

在运行 YOLO 推理后,Results 对象包含显示和保存标注图像的方法。您可以使用 result.show()result.save(filename="result.jpg") 等方法来可视化和保存结果。有关这些方法的完整列表,请参阅处理结果部分。


📅 Created 11 months ago ✏️ Updated 1 day ago

Comments