yolov8使用详解

内容来源：https://docs.ultralytics.com/zh/

一. 安装yolov8

1. 通过Pip安装

从PyPI安装ultralytics包

pip install ultralytics -i https://mirrors.aliyun.com/pypi/simple/

2. 通过Conda安装

conda install -c conda-forge ultralytics

3. Git克隆源码安装

1. 克隆ultralytics仓库

   git clone https://github.com/ultralytics/ultralytics
   

2. 导航到克隆的目录

   cd ultralytics
   

3. 为开发安装可编辑模式下的包

   pip install -e . -i https://mirrors.aliyun.com/pypi/simple/
   

   

二. yolov8基本设置

Ultralytics库提供了一个强大的设置管理系统，允许您精细控制实验。通过利用ultralytics.utils模块中的SettingsManager，用户可以轻松访问和修改设置。这些设置存储在YAML文件中，可以直接在Python环境中查看或修改。

名称	示例值	数据类型	描述
settings_version	'0.0.4'	str	Ultralytics settings 版本（不同于Ultralytics pip版本）
datasets_dir	'/path/to/datasets'	str	存储数据集的目录
weights_dir	'/path/to/weights'	str	存储模型权重的目录
runs_dir	'/path/to/runs'	str	存储实验运行的目录
uuid	'a1b2c3d4'	str	当前设置的唯一标识符
sync	True	bool	是否将分析和崩溃同步到HUB
api_key	''	str	Ultralytics HUB API Key
clearml	True	bool	是否使用ClearML记录
comet	True	bool	是否使用Comet ML进行实验跟踪和可视化
dvc	True	bool	是否使用DVC进行实验跟踪和版本控制
hub	True	bool	是否使用Ultralytics HUB集成
mlflow	True	bool	是否使用MLFlow进行实验跟踪
neptune	True	bool	是否使用Neptune进行实验跟踪
raytune	True	bool	是否使用Ray Tune进行超参数调整
tensorboard	True	bool	是否使用TensorBoard进行可视化
wandb	True	bool	是否使用Weights & Biases记录

1. 在python中查看设置

   from ultralytics import settings
   
   # 查看所有设置
   print(settings)
   
   # 返回特定设置
   value = settings['runs_dir']
   

2. 在python中修改设置

   from ultralytics import settings
   
   # 更新一个设置
   settings.update({'runs_dir': '/path/to/runs'})
   
   # 更新多个设置
   settings.update({'runs_dir': '/path/to/runs', 'tensorboard': False})
   
   # 重置设置为默认值
   settings.reset()
   

   

三. yolov8模型

1. 目标检测

目标检测器的输出是一组围绕图像中物体的边界框，以及每个框的类别标签和置信度得分。当您需要识别场景中的感兴趣对象，但不需要准确了解物体的位置或其确切形状时，目标检测是一个很好的选择。

模型	尺寸 (像素)	mAPval 50-95	速度 CPU ONNX (毫秒)	速度 A100 TensorRT (毫秒)	参数 (M)	FLOPs (B)
YOLOv8n	640	37.3	80.4	0.99	3.2	8.7
YOLOv8s	640	44.9	128.4	1.20	11.2	28.6
YOLOv8m	640	50.2	234.7	1.83	25.9	78.9
YOLOv8l	640	52.9	375.2	2.39	43.7	165.2
YOLOv8x	640	53.9	479.1	3.53	68.2	257.8

2. 实例分割

实例分割模型的输出是一组蒙版或轮廓，用于勾画图像中每个物体，以及每个物体的类别标签和置信度分数。实例分割在您需要不仅知道图像中的物体位置，还需要知道它们确切形状时非常有用。

模型	尺寸 (像素)	mAPbox 50-95	mAPmask 50-95	速度 CPU ONNX (ms)	速度 A100 TensorRT (ms)	参数 (M)	FLOPs (B)
YOLOv8n-seg	640	36.7	30.5	96.1	1.21	3.4	12.6
YOLOv8s-seg	640	44.6	36.8	155.7	1.47	11.8	42.6
YOLOv8m-seg	640	49.9	40.8	317.0	2.18	27.3	110.2
YOLOv8l-seg	640	52.3	42.6	572.4	2.79	46.0	220.5
YOLOv8x-seg	640	53.4	43.4	712.1	4.02	71.8	344.1

3. 图像分类

图像分类器的输出是单个类别标签和一个置信度分数。当您只需要知道一幅图像属于哪个类别、而不需要知道该类别对象的位置或它们的确切形状时，图像分类非常有用。

模型	尺寸 (像素)	准确率 top1	准确率 top5	速度 CPU ONNX (ms)	速度 A100 TensorRT (ms)	参数 (M)	FLOPs (B) at 640
YOLOv8n-cls	224	66.6	87.0	12.9	0.31	2.7	4.3
YOLOv8s-cls	224	72.3	91.1	23.4	0.35	6.4	13.5
YOLOv8m-cls	224	76.4	93.2	85.4	0.62	17.0	42.7
YOLOv8l-cls	224	78.0	94.1	163.0	0.87	37.5	99.7
YOLOv8x-cls	224	78.4	94.3	232.0	1.01	57.4	154.8

4. 姿态估计

姿态估计模型的输出是一组点集，这些点代表图像中物体上的关键点，通常还包括每个点的置信度得分。当你需要在场景中识别物体的特定部位及其相互之间的位置时，姿态估计是一个不错的选择。

Model	size (pixels)	mAPpose 50-95	mAPpose 50	Speed CPU ONNX (ms)	Speed A100 TensorRT (ms)	params (M)	FLOPs (B)
YOLOv8n-pose	640	50.4	80.1	131.8	1.18	3.3	9.2
YOLOv8s-pose	640	60.0	86.2	233.2	1.42	11.6	30.2
YOLOv8m-pose	640	65.0	88.8	456.3	2.00	26.4	81.0
YOLOv8l-pose	640	67.6	90.0	784.5	2.59	44.4	168.6
YOLOv8x-pose	640	69.2	90.2	1607.1	3.73	69.4	263.2
YOLOv8x-pose-p6	1280	71.6	91.2	4088.7	10.04	99.1	1066.4

5. 多对象跟踪

交通运输	零售	水产养殖
车辆追踪	人员追踪	鱼类追踪

(1) 可用的追踪器

Ultralytics YOLO支持以下追踪算法。可以通过传递相关的YAML配置文件如tracker=tracker_type.yaml来启用：

• BoT-SORT - 使用 botsort.yaml 启用此追踪器。
• ByteTrack - 使用 bytetrack.yaml 启用此追踪器。

默认追踪器是BoT-SORT。要在视频流中运行追踪器，请使用已训练的检测、分割或姿态模型，例如YOLOv8n、YOLOv8n-seg和YOLOv8n-pose。

from ultralytics import YOLO

# 加载官方或自定义模型
model = YOLO('yolov8n.pt')  # 加载一个官方的检测模型
model = YOLO('yolov8n-seg.pt')  # 加载一个官方的分割模型
model = YOLO('yolov8n-pose.pt')  # 加载一个官方的姿态模型
model = YOLO('path/to/best.pt')  # 加载一个自定义训练的模型

# 使用模型进行追踪
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)  # 使用默认追踪器进行追踪
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # 使用ByteTrack追踪器进行追踪

(2) 选择追踪器

Ultralytics还允许您使用修改后的追踪器配置文件。要执行此操作，只需从ultralytics/cfg/trackers中复制一个追踪器配置文件（例如，custom_tracker.yaml）并根据您的需求修改任何配置（除了tracker_type）。

from ultralytics import YOLO

# 加载模型并使用自定义配置文件运行追踪器
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')

有关追踪参数的全面列表，请参考ultralytics/cfg/trackers页面。

(3) 持续追踪循环

这是一个使用OpenCV（cv2）和YOLOv8在视频帧上运行物体追踪的Python脚本。此脚本假设您已经安装了必要的包（opencv-python和ultralytics）。参数persist=True告诉追踪器当前的图像或帧是序列中的下一个，并且期望在当前图像中从上一个图像中获得追踪路径。

import cv2
from ultralytics import YOLO

# 加载YOLOv8模型
model = YOLO('yolov8n.pt')

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

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

    if success:
        # 在帧上运行YOLOv8追踪，持续追踪帧间的物体
        results = model.track(frame, persist=True)

        # 在帧上展示结果
        annotated_frame = results[0].plot()

        # 展示带注释的帧
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

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

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

请注意从model(frame)更改为model.track(frame)的变化，这使能够启用物体追踪而不只是简单的检测。这个修改的脚本将在视频的每一帧上运行追踪器，可视化结果，并在窗口中显示它们。通过按’q’可以退出循环。

(4) 随时间绘制追踪路径

在连续帧上可视化物体追踪路径可以提供有关视频中检测到的物体的运动模式和行为的有价值的洞见。使用Ultralytics YOLOv8，绘制这些路径是一个无缝且高效的过程。

在以下示例中，我们演示了如何利用YOLOv8的追踪功能在多个视频帧上绘制检测物体的移动。这个脚本涉及打开视频文件、逐帧读取，并使用YOLO模型识别并追踪各种物体。通过保留检测到的边界框的中心点并连接它们，我们可以绘制表示跟踪物体路径的线条。

 from collections import defaultdict

 import cv2
 import numpy as np

 from ultralytics import YOLO

 # 加载YOLOv8模型
 model = YOLO('yolov8n.pt')

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

 # 存储追踪历史
 track_history = defaultdict(lambda: [])

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

     if success:
         # 在帧上运行YOLOv8追踪，持续追踪帧间的物体
         results = model.track(frame, persist=True)

         # 获取框和追踪ID
         boxes = results[0].boxes.xywh.cpu()
         track_ids = results[0].boxes.id.int().cpu().tolist()

         # 在帧上展示结果
         annotated_frame = results[0].plot()

         # 绘制追踪路径
         for box, track_id in zip(boxes, track_ids):
             x, y, w, h = box
             track = track_history[track_id]
             track.append((float(x), float(y)))  # x, y中心点
             if len(track) > 30:  # 在90帧中保留90个追踪点
                 track.pop(0)

             # 绘制追踪线
             points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
             cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

         # 展示带注释的帧
         cv2.imshow("YOLOv8 Tracking", annotated_frame)

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

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

四. yolov8数据集

Ultralytics 支持多种数据集，方便开展计算机视觉任务，诸如检测、实例分割、姿态估计、分类和多对象跟踪。以下是主要 Ultralytics 数据集的列表，以及每个计算机视觉任务及其相应数据集的概述。

1. 检测数据集

边界框对象检测是一种计算机视觉技术，涉及通过在图像中的每个对象周围绘制边界框来检测和定位对象。

• Argoverse：包含城市环境中的 3D 追踪和运动预测数据，并提供丰富的注释。
• COCO：一个大型数据集，专为对象检测、分割和描述设计，包含 20 多万带有标签的图像。
• COCO8：包含 COCO 训练集和 COCO 验证集的前 4 张图像，适合快速测试。
• Global Wheat 2020：一个小麦头部图像的数据集，收集自世界各地，用于对象检测和定位任务。
• Objects365：一个高质量的大规模对象检测数据集，含 365 个对象类别和逾 60 万个注释图像。
• OpenImagesV7：谷歌提供的综合数据集，包含 170 万训练图像和 4.2 万验证图像。
• SKU-110K：一个特点是在零售环境中进行密集对象检测的数据集，包含 1.1 万图像和 170 万个边界框。
• VisDrone：包含无人机拍摄图像中的对象检测和多对象跟踪数据的数据集，包含超过 1 万张图像和视频序列。
• VOC：Pascal Visual Object Classes (VOC) 对象检测和分割数据集，包含 20 个对象类别和逾 1.1 万图像。
• xView：用于航拍图像对象检测的数据集，包含 60 个对象类别和逾 100 万个注释对象。

2. 实例分割数据集

实例分割是一种计算机视觉技术，涉及在像素级别识别和定位图像中的对象。

• COCO：一个大型数据集，专为对象检测、分割和描述任务设计，包含 20 多万带有标签的图像。
• COCO8-seg：一个用于实例分割任务的较小数据集，包含 8 张带有分割注释的 COCO 图像。

3. 姿态估计

姿态估计是一种用于确定对象相对于相机或世界坐标系统的姿势的技术。

• COCO：一个包含人体姿态注释的大型数据集，专为姿态估计任务设计。
• COCO8-pose：一个用于姿态估计任务的较小数据集，包含 8 张带有人体姿态注释的 COCO 图像。
• Tiger-pose：一个紧凑型数据集，包含 263 张专注于老虎的图像，每只老虎注释有 12 个关键点，用于姿态估计任务。

4. 分类

图像分类是一个计算机视觉任务，涉及基于其视觉内容将图像分类到一个或多个预定义类别中。

• Caltech 101：包含 101 个对象类别图像的数据集，用于图像分类任务。
• Caltech 256：Caltech 101 的扩展版本，具有 256 个对象类别和更具挑战性的图像。
• CIFAR-10：包含 60K 32x32 彩色图像的数据集，分为 10 个类别，每个类别有 6K 图像。
• CIFAR-100：CIFAR-10 的扩展版本，具有 100 个对象类别和每类 600 个图像。
• Fashion-MNIST：包含 70,000 张灰度图像的数据集，图像来自 10 个时尚类别，用于图像分类任务。
• ImageNet：一个大型的用于对象检测和图像分类的数据集，包含超过 1400 万图像和 2 万个类别。
• ImageNet-10：ImageNet 的一个较小子集，包含 10 个类别，用于更快速的实验和测试。
• Imagenette：ImageNet 的一个较小子集，其中包含 10 个容易区分的类别，用于更快速的训练和测试。
• Imagewoof：ImageNet 的一个更具挑战性的子集，包含 10 个狗品种类别用于图像分类任务。
• MNIST：包含 70,000 张手写数字灰度图像的数据集，用于图像分类任务。

5. 定向边界框 (OBB)

定向边界框 (OBB) 是一种计算机视觉方法，用于使用旋转的边界框检测图像中的倾斜对象，常应用于航空和卫星图像。

• DOTAv2：一个流行的 OBB 航拍图像数据集，拥有 170 万个实例和 11,268 张图像。

6. 多对象跟踪

多对象跟踪是一种计算机视觉技术，涉及在视频序列中检测和跟踪多个对象的运动。

• Argoverse：包含城市环境中的 3D 追踪和运动预测数据，并提供丰富的注释，适用于多对象跟踪任务。
• VisDrone：包含无人机拍摄图像中的对象检测和多对象跟踪数据的数据集，包含超过 1 万张图像和视频序列。

7. 自定义数据集

自定义一个新数据集需要几个步骤，来确保它与现有基础设施良好对齐。以下是必要的步骤：

(1) 自定义新数据集的步骤

1. 收集图像：收集属于数据集的图像。这些可能来自公共数据库或您自己的收藏。

2. 注释图像：根据任务对这些图像进行边界框、分段或关键点的标记。

3. 导出注释：将这些注释转换为 Ultralytics 支持的 YOLO *.txt 文件格式。

4. 组织数据集：按正确的文件夹结构排列您的数据集。您应该有 train/ 和 val/ 顶级目录，在每个目录内，有 images/ 和 labels/ 子目录。

   dataset/
   ├── train/
   │   ├── images/
   │   └── labels/
   └── val/
       ├── images/
       └── labels/
   

5. 创建一个 data.yaml 文件：在数据集的根目录中，创建一个描述数据集的 data.yaml 文件，包括类别信息等必要内容。

6. 优化图像（可选）：如果您想为了更高效的处理而减小数据集的大小，可以使用以下代码来优化图像。这不是必需的，但推荐用于减小数据集大小和加快下载速度。

7. 压缩数据集：将整个数据集文件夹压缩成一个 zip 文件。

8. 文档和 PR：创建描述您的数据集和它如何融入现有框架的文档页面。之后，提交一个 Pull Request (PR)。更多关于如何提交 PR 的详细信息，请参照 Ultralytics 贡献指南。

(2) 优化和压缩数据集的示例代码

from pathlib import Path
from ultralytics.data.utils import compress_one_image
from ultralytics.utils.downloads import zip_directory

# 定义数据集目录
path = Path('path/to/dataset')

# 优化数据集中的图像（可选）
for f in path.rglob('*.jpg'):
    compress_one_image(f)

# 将数据集压缩成 'path/to/dataset.zip'
zip_directory(path)

通过遵循这些步骤，您可以自定义一个与 Ultralytics 现有结构良好融合的新数据集。

五. yolov8训练模型

YOLO模型的训练设置是指用于对数据集进行模型训练的各种超参数和配置。这些设置会影响模型的性能、速度和准确性。一些常见的YOLO训练设置包括批大小、学习率、动量和权重衰减。其他可能影响训练过程的因素包括优化器的选择、损失函数的选择以及训练数据集的大小和组成。仔细调整和实验这些设置以实现给定任务的最佳性能是非常重要的。

键	值	描述
model	None	模型文件路径，例如 yolov8n.pt, yolov8n.yaml
data	None	数据文件路径，例如 coco128.yaml
epochs	100	训练的轮次数量
patience	50	早停训练的等待轮次
batch	16	每批图像数量（-1为自动批大小）
imgsz	640	输入图像的大小，以整数表示
save	True	保存训练检查点和预测结果
save_period	-1	每x轮次保存检查点（如果<1则禁用）
cache	False	True/ram, disk 或 False。使用缓存加载数据
device	None	运行设备，例如 cuda device=0 或 device=0,1,2,3 或 device=cpu
workers	8	数据加载的工作线程数（如果DDP则为每个RANK）
project	None	项目名称
name	None	实验名称
exist_ok	False	是否覆盖现有实验
pretrained	True	(bool 或 str) 是否使用预训练模型（bool）或从中加载权重的模型（str）
optimizer	'auto'	使用的优化器，选择范围=[SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto]
verbose	False	是否打印详细输出
seed	0	随机种子，用于可重复性
deterministic	True	是否启用确定性模式
single_cls	False	将多类数据作为单类训练
rect	False	矩形训练，每批为最小填充整合
cos_lr	False	使用余弦学习率调度器
close_mosaic	10	(int) 最后轮次禁用马赛克增强（0为禁用）
resume	False	从最后检查点恢复训练
amp	True	自动混合精度（AMP）训练，选择范围=[True, False]
fraction	1.0	训练的数据集比例（默认为1.0，即训练集中的所有图像）
profile	False	在训练期间为记录器分析ONNX和TensorRT速度
freeze	None	(int 或 list, 可选) 在训练期间冻结前n层，或冻结层索引列表
lr0	0.01	初始学习率（例如 SGD=1E-2, Adam=1E-3）
lrf	0.01	最终学习率 (lr0 * lrf)
momentum	0.937	SGD动量/Adam beta1
weight_decay	0.0005	优化器权重衰减5e-4
warmup_epochs	3.0	热身轮次（小数ok）
warmup_momentum	0.8	热身初始动量
warmup_bias_lr	0.1	热身初始偏差lr
box	7.5	框损失增益
cls	0.5	cls损失增益（根据像素缩放）
dfl	1.5	dfl损失增益
pose	12.0	姿态损失增益（仅限姿态）
kobj	2.0	关键点obj损失增益（仅限姿态）
label_smoothing	0.0	标签平滑（小数）
nbs	64	标称批大小
overlap_mask	True	训练期间掩码应重叠（仅限分割训练）
mask_ratio	4	掩码降采样比率（仅限分割训练）
dropout	0.0	使用dropout正则化（仅限分类训练）
val	True	训练期间验证/测试

from ultralytics import YOLO

# 加载一个模型
model = YOLO('yolov8n.yaml')  # 从YAML建立一个新模型
model = YOLO('yolov8n.pt')  # 加载预训练模型（推荐用于训练）
model = YOLO('yolov8n.yaml').load('yolov8n.pt')  # 从YAML建立并转移权重

# 训练模型
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)

六. 使用yolov8进行推理

来源	参数	类型	备注
图像	'image.jpg'	str 或 Path	单个图像文件。
URL	'https://ultralytics.com/images/bus.jpg'	str	图像的 URL 地址。
截屏	'screen'	str	截取屏幕图像。
PIL	Image.open('im.jpg')	PIL.Image	RGB 通道的 HWC 格式图像。
OpenCV	cv2.imread('im.jpg')	np.ndarray	BGR 通道的 HWC 格式图像 uint8 (0-255)。
numpy	np.zeros((640,1280,3))	np.ndarray	BGR 通道的 HWC 格式图像 uint8 (0-255)。
torch	torch.zeros(16,3,320,640)	torch.Tensor	RGB 通道的 BCHW 格式图像 float32 (0.0-1.0)。
CSV	'sources.csv'	str 或 Path	包含图像、视频或目录路径的 CSV 文件。
视频 ?	'video.mp4'	str 或 Path	如 MP4, AVI 等格式的视频文件。
目录 ?	'path/'	str 或 Path	包含图像或视频文件的目录路径。
通配符 ?	'path/*.jpg'	str	匹配多个文件的通配符模式。使用 * 字符作为通配符。
YouTube ?	'https://youtu.be/LNwODJXcvt4'	str	YouTube 视频的 URL 地址。
流媒体 ?	'rtsp://example.com/media.mp4'	str	RTSP, RTMP, TCP 或 IP 地址等流协议的 URL 地址。
多流媒体 ?	'list.streams'	str 或 Path	一个流 URL 每行的 *.streams 文本文件，例如 8 个流将以 8 的批处理大小运行。

1. 对图像文件进行推理。

from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

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

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

##2. 对当前屏幕内容作为截屏进行推理。

from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

# 定义当前截屏为来源
source = 'screen'

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

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

from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

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

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

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

from PIL import Image
from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

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

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

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

import cv2
from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

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

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

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

import numpy as np
from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.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)  # Results 对象列表

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

import torch
from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

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

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

8. 对 CSV 文件中列出的图像、URLs、视频和目录进行推理。

import torch
from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

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

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

9. 对视频文件进行推理。

使用 stream=True 时，可以创建一个 Results 对象的生成器，减少内存使用。

from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

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

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

10. 对目录中的所有图像和视频进行推理。

要包含子目录中的图像和视频，使用通配符模式，例如 path/to/dir/**/*。

from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

# 定义包含图像和视频文件用于推理的目录路径
source = 'path/to/dir'

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

11. 对与 * 字符匹配的所有图像和视频进行推理。

from ultralytics import YOLO

# 加载预训练的 YOLOv8n 模型
model = YOLO('yolov8n.pt')

# 定义一个目录下所有 JPG 文件的通配符搜索
source = 'path/to/dir/*.jpg'

# 或定义一个包括子目录的所有 JPG 文件的递归通配符搜索
source = 'path/to/dir/**/*.jpg'

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

12. 在YouTube视频上运行推理。

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

from ultralytics import YOLO

# 加载预训练的YOLOv8n模型
model = YOLO('yolov8n.pt')

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

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

13. 使用RTSP、RTMP、TCP和IP地址协议在远程流媒体源上运行推理。

如果在*.streams文本文件中提供了多个流，则将运行批量推理，例如，8个流将以批大小8运行，否则单个流将以批大小1运行。

from ultralytics import YOLO

# 加载预训练的YOLOv8n模型
model = YOLO('yolov8n.pt')

# 单流媒体源批大小1推理
source = 'rtsp://example.com/media.mp4'  # RTSP、RTMP、TCP或IP流媒体地址

# 多个流媒体源的批量推理（例如，8个流的批大小为8）
source = 'path/to/list.streams'  # *.streams文本文件，每行一个流媒体地址

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

五. yolov8推理参数设置

yolov8进行推理时支持的所有参数：

名称	类型	默认值	描述
source	str	'ultralytics/assets'	图像或视频的源目录
conf	float	0.25	检测对象的置信度阈值
iou	float	0.7	用于NMS的交并比（IoU）阈值
imgsz	int or tuple	640	图像大小，可以是标量或（h, w）列表，例如（640, 480）
half	bool	False	使用半精度（FP16）
device	None or str	None	运行设备，例如 cuda device=0/1/2/3 或 device=cpu
show	bool	False	如果可能，显示结果
save	bool	False	保存带有结果的图像
save_txt	bool	False	将结果保存为.txt文件
save_conf	bool	False	保存带有置信度分数的结果
save_crop	bool	False	保存带有结果的裁剪图像
show_labels	bool	True	隐藏标签
show_conf	bool	True	隐藏置信度分数
max_det	int	300	每张图像的最大检测数量
vid_stride	bool	False	视频帧速率跳跃
stream_buffer	bool	False	缓冲所有流媒体帧（True）或返回最新帧（False）
line_width	None or int	None	边框线宽度。如果为None，则按图像大小缩放。
visualize	bool	False	可视化模型特征
augment	bool	False	应用图像增强到预测源
agnostic_nms	bool	False	类别不敏感的NMS
retina_masks	bool	False	使用高分辨率分割掩码
classes	None or list	None	按类别过滤结果，例如 classes=0，或 classes=[0,2,3]
boxes	bool	True	在分割预测中显示框

model.predict() 在推理时接受多个参数，可以用来覆盖默认值：

from ultralytics import YOLO

# 加载预训练的YOLOv8n模型
model = YOLO('yolov8n.pt')

# 在'bus.jpg'上运行推理，并附加参数
model.predict('bus.jpg', save=True, imgsz=320, conf=0.5)

七. yolov8预测结果的处理

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

from ultralytics import YOLO

# 加载预训练的YOLOv8n模型
model = YOLO('yolov8n.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, 可选	包含检测边界框的Boxes对象。
masks	Masks, 可选	包含检测掩码的Masks对象。
probs	Probs, 可选	包含每个类别的概率的Probs对象，用于分类任务。
keypoints	Keypoints, 可选	包含每个对象检测到的关键点的Keypoints对象。
speed	dict	以毫秒为单位的每张图片的预处理、推理和后处理速度的字典。
names	dict	类别名称的字典。
path	str	图像文件的路径。

Results对象具有以下方法：

方法	返回类型	描述
__getitem__()	Results	返回指定索引的Results对象。
__len__()	int	返回Results对象中的检测数量。
update()	None	更新Results对象的boxes, masks和probs属性。
cpu()	Results	将所有张量移动到CPU内存上的Results对象的副本。
numpy()	Results	将所有张量转换为numpy数组的Results对象的副本。
cuda()	Results	将所有张量移动到GPU内存上的Results对象的副本。
to()	Results	返回将张量移动到指定设备和dtype的Results对象的副本。
new()	Results	返回一个带有相同图像、路径和名称的新Results对象。
keys()	List[str]	返回非空属性名称的列表。
plot()	numpy.ndarray	绘制检测结果。返回带有注释的图像的numpy数组。
verbose()	str	返回每个任务的日志字符串。
save_txt()	None	将预测保存到txt文件中。
save_crop()	None	将裁剪的预测保存到save_dir/cls/file_name.jpg。
tojson()	None	将对象转换为JSON格式。

有关更多详细信息，请参阅Results类的文档。

1. 边界框（Boxes）

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

from ultralytics import YOLO

# 加载预训练的YOLOv8n模型
model = YOLO('yolov8n.pt')

# 在图片上运行推理
results = model('bus.jpg')

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

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

名称	类型	描述
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类的文档。

2. 掩码（Masks）

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

from ultralytics import YOLO

# 加载预训练的YOLOv8n-seg分割模型
model = YOLO('yolov8n-seg.pt')

# 在图片上运行推理
results = model('bus.jpg')  # results列表

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

以下是Masks类方法和属性的表格，包括它们的名称、类型和description:

名称	类型	描述
cpu()	方法	将掩码张量返回到CPU内存。
numpy()	方法	将掩码张量转换为numpy数组。
cuda()	方法	将掩码张量返回到GPU内存。
to()	方法	将掩码张量带有指定设备和dtype返回。
xyn	属性 (torch.Tensor)	以张量表示的归一化分段的列表。
xy	属性 (torch.Tensor)	以像素坐标表示的分段的张量列表。

有关更多详细信息，请参阅Masks类的文档。

3. 关键点 (Keypoints)

Keypoints 对象可以用于索引、操作和规范化坐标。

from ultralytics import YOLO

# 加载预训练的YOLOv8n-pose 姿态模型
model = YOLO('yolov8n-pose.pt')

# 在图像上运行推理
results = model('bus.jpg')  # 结果列表

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

以下是Keypoints类方法和属性的表格，包括它们的名称、类型和description:

名称	类型	描述
cpu()	方法	返回CPU内存上的关键点张量。
numpy()	方法	返回作为numpy数组的关键点张量。
cuda()	方法	返回GPU内存上的关键点张量。
to()	方法	返回指定设备和dtype的关键点张量。
xyn	属性（torch.Tensor）	规范化关键点的列表，表示为张量。
xy	属性（torch.Tensor）	以像素坐标表示的关键点列表，表示为张量。
conf	属性（torch.Tensor）	返回关键点的置信度值（如果有），否则返回None。

有关更多详细信息，请参阅Keypoints类文档。

4. 概率 (Probs)

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

from ultralytics import YOLO

# 加载预训练的YOLOv8n-cls 分类模型
model = YOLO('yolov8n-cls.pt')

# 在图像上运行推理
results = model('bus.jpg')  # 结果列表

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

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

名称	类型	描述
cpu()	方法	返回CPU内存上的概率张量的副本。
numpy()	方法	返回概率张量的副本作为numpy数组。
cuda()	方法	返回GPU内存上的概率张量的副本。
to()	方法	返回带有指定设备和dtype的概率张量的副本。
top1	属性（int）	第1类的索引。
top5	属性（list[int]）	前5类的索引。
top1conf	属性（torch.Tensor）	第1类的置信度。
top5conf	属性（torch.Tensor）	前5类的置信度。

有关更多详细信息，请参阅Probs类文档。

八. yolov8对结果进行绘图

您可以使用Result对象的plot()方法来可视化预测结果。它会将Results对象中包含的所有预测类型（框、掩码、关键点、概率等）绘制到一个numpy数组上，然后可以显示或保存。

from PIL import Image
from ultralytics import YOLO

# 加载预训练的YOLOv8n模型
model = YOLO('yolov8n.pt')

# 在'bus.jpg'上运行推理
results = model('bus.jpg')  # 结果列表

# 展示结果
for r in results:
    im_array = r.plot()  # 绘制包含预测结果的BGR numpy数组
    im = Image.fromarray(im_array[..., ::-1])  # RGB PIL图像
    im.show()  # 显示图像
    im.save('results.jpg')  # 保存图像

plot()方法支持以下参数：

参数	类型	描述	默认值
conf	bool	是否绘制检测置信度分数。	True
line_width	float	边框线宽度。如果为None，则按图像大小缩放。	None
font_size	float	文本字体大小。如果为None，则按图像大小缩放。	None
font	str	文本字体。	'Arial.ttf'
pil	bool	是否将图像返回为PIL图像。	False
img	numpy.ndarray	绘制到另一个图像上。如果没有，则绘制到原始图像上。	None
im_gpu	torch.Tensor	形状为(1, 3, 640, 640)的规范化GPU图像，用于更快地绘制掩码。	None
kpt_radius	int	绘制关键点的半径。默认为5。	5
kpt_line	bool	是否绘制连接关键点的线条。	True
labels	bool	是否绘制边框标签。	True
boxes	bool	是否绘制边框。	True
masks	bool	是否绘制掩码。	True
probs	bool	是否绘制分类概率	True