yolov8训练笔记

'FaPpY

已于 2024-03-15 11:28:29 修改

阅读量400

点赞数 7

分类专栏：机器学习区文章标签： python 笔记

于 2024-01-18 10:43:49 首次发布

本文链接：https://blog.csdn.net/qq_46014045/article/details/135668311

版权

机器学习区专栏收录该内容

1 篇文章 0 订阅

订阅专栏

yolo训练实践

yolo训练

语义分割用seg.pt模型训练，具体配置在yaml文件下，每次8张训练200次。

from ultralytics import YOLO
import multiprocessing


model = YOLO('D:/wyd_pythonProject/wyd_v8_zhuzi/ultralytics-main/yolov8n-seg.pt')

if __name__ == '__main__':
    multiprocessing.freeze_support()

    results = model.train(data='D:/wyd_pythonProject/wyd_v8_zhuzi/ultralytics-main/datasets/zhupian.yaml',batch=8,epochs=200, imgsz=640)

yaml文件配置如下，最后一行终端代码是用来目标检测训练的。train，val是标签文件夹的位置。

# Ultralytics YOLO 🚀, AGPL-3.0 license
# COCO 2017 dataset http://cocodataset.org by Microsoft
# Example usage: yolo train data=coco.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── coco  ← downloads here (20.1 GB)


# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
#path: E:/pythonProject/wyd_v8_zhuzi/ultralytics-main/datasets/zhupian  # dataset root dir
train: D:/wyd_pythonProject/wyd_v8_zhuzi/图片/故障/txt/images  # train images (relative to 'path') 118287 images
val: D:/wyd_pythonProject/wyd_v8_zhuzi/图片/故障/txt/images  # val images (relative to 'path') 5000 images
test:   # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794

# Classes
names:
  0: 竹片
  1: 故障

 #yolo task=detect mode=train model=./ultralytics-main/yolov8n.pt data=ultralytics-main/datasets/zhupian.yaml epochs=10 workers=1 batch=32

yolo标签文件夹建立

一般train和val按照9：1的比例分一下就可以，test可以不用

标签转化

使用labelme标注玩的json标签转化为txt，代码如下。

import base64  # 用于处理base64编码
import random  # 用于生成随机数
import shutil  # 用于文件操作，如复制、移动文件
from tqdm import tqdm  # 用于显示进度条
import math  # 提供基本的数学运算函数
import json  # 用于处理JSON数据
import os  # 提供了与操作系统交互的功能
import numpy as np  # 强大的数学库，用于数组计算
import PIL.Image  # 图像处理库
import PIL.ImageDraw  # 图像处理库，用于绘制图像
import cv2  # OpenCV库，用于图像和视频处理


class ConvertManager(object):
    def __init__(self):
        pass  # 构造函数，此处未进行任何操作

    def base64_to_numpy(self, img_bs64):
        img_bs64 = base64.b64decode(img_bs64)  # 对base64编码的图片进行解码
        img_array = np.frombuffer(img_bs64, np.uint8)  # 将图片解码后的数据转换为numpy数组
        cv2_img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)  # 将numpy数组解码为图像
        return cv2_img  # 返回解码后的图像

    @classmethod
    def load_labels(cls, name_file):
        '''
        从文件中加载标签名，每行一个名字
        :param name_file: 文件路径
        :return: 标签名列表
        '''
        with open(name_file, 'r') as f:
            lines = f.read().rstrip('\n').split('\n')  # 读取文件，去除尾部换行符，按行分割
        return lines  # 返回分割后的行列表，即标签名列表

    def get_class_names_from_all_json(self, json_dir):
        classnames = []  # 初始化类名列表
        for file in os.listdir(json_dir):  # 遍历json目录下的所有文件
            if not file.endswith('.json'):  # 如果文件不是json格式，跳过
                continue
            with open(os.path.join(json_dir, file), 'r', encoding='utf-8') as f:
                data_dict = json.load(f)  # 加载json文件内容
                for shape in data_dict['shapes']:  # 遍历所有形状
                    if not shape['label'] in classnames:  # 如果形状的标签不在类名列表中
                        classnames.append(shape['label'])  # 添加到类名列表
        return classnames  # 返回类名列表

    def create_save_dir(self, save_dir):
        images_dir = os.path.join(save_dir, 'images')  # 定义保存图片的目录
        labels_dir = os.path.join(save_dir, 'labels')  # 定义保存标签的目录
        if not os.path.exists(save_dir):  # 如果保存目录不存在
            os.makedirs(save_dir)  # 创建保存目录
            os.mkdir(images_dir)  # 创建图片目录
            os.mkdir(labels_dir)  # 创建标签目录
        else:  # 如果保存目录已存在
            if not os.path.exists(images_dir):  # 如果图片目录不存在
                os.mkdir(images_dir)  # 创建图片目录
            if not os.path.exists(labels_dir):  # 如果标签目录不存在
                os.mkdir(labels_dir)  # 创建标签目录
        return images_dir + os.sep, labels_dir + os.sep  # 返回图片目录和标签目录的路径

    def save_list(self, data_list, save_file):
        with open(save_file, 'w') as f:  # 打开文件进行写入
            f.write('\n'.join(data_list))  # 将列表中的数据以换行符分隔并写入文件

    def __rectangle_points_to_polygon(self, points):
        # 将矩形的两个对角点转换为多边形的四个顶点
        xmin = 0
        ymin = 0
        xmax = 0
        ymax = 0
        if points[0][0] > points[1][0]:
            xmax = points[0][0]
            ymax = points[0][1]
            xmin = points[1][0]
            ymin = points[1][1]
        else:
            xmax = points[1][0]
            ymax = points[1][1]
            xmin = points[0][0]
            ymin = points[0][1]
        return [[xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]]  # 返回多边形的四个顶点

    def convert_dataset(self, json_dir, json_list, images_dir, labels_dir, names, save_mode='train'):
        # 转换数据集，将json格式的标注转换为训练所需的格式
        images_dir = os.path.join(images_dir, save_mode) + os.sep  # 根据保存模式定义图片目录
        labels_dir = os.path.join(labels_dir, save_mode) + os.sep  # 根据保存模式定义标签目录
        if not os.path.exists(images_dir):  # 如果图片目录不存在
            os.mkdir(images_dir)  # 创建图片目录
        if not os.path.exists(labels_dir):  # 如果标签目录不存在
            os.mkdir(labels_dir)  # 创建标签目录
        for file in tqdm(json_list):  # 遍历json文件列表，显示进度条
            with open(os.path.join(json_dir, file), 'r', encoding='utf-8') as f:
                data_dict = json.load(f)  # 加载json文件内容
            image_file = os.path.join(json_dir, os.path.basename(data_dict['imagePath']))  # 定义图片文件路径
            if os.path.exists(image_file):  # 如果图片文件存在
                shutil.copyfile(image_file, images_dir + os.path.basename(image_file))  # 复制图片文件到目标目录
            else:  # 如果图片文件不存在
                imageData = data_dict.get('imageData')  # 获取图片数据
                if not imageData:
                    imageData = base64.b64encode(imageData).decode('utf-8')  # 对图片数据进行base64编码
                    img = self.img_b64_to_arr(imageData)  # 将base64编码的图片数据转换为数组
                    PIL.Image.fromarray(img).save(images_dir + file[:-4] + 'png')  # 保存图片
            # 转换为txt格式的标签文件
            width = data_dict['imageWidth']  # 获取图片宽度
            height = data_dict['imageHeight']  # 获取图片高度
            line_list = []  # 初始化标签行列表
            for shape in data_dict['shapes']:  # 遍历所有形状
                data_list = []  # 初始化数据列表
                data_list.append(str(names.index(shape['label'])))  # 添加形状的标签索引
                if shape['shape_type'] == 'rectangle':  # 如果形状类型为矩形
                    points = self.__rectangle_points_to_polygon(shape['points'])  # 将矩形的对角点转换为多边形的顶点
                    for point in points:  # 遍历顶点
                        data_list.append(str(point[0] / width))  # 添加顶点的x坐标比例
                        data_list.append(str(point[1] / height))  # 添加顶点的y坐标比例
                elif shape['shape_type'] == 'polygon':  # 如果形状类型为多边形
                    points = shape['points']  # 获取多边形的顶点
                    for point in points:  # 遍历顶点
                        data_list.append(str(point[0] / width))  # 添加顶点的x坐标比例
                        data_list.append(str(point[1] / height))  # 添加顶点的y坐标比例
                line_list.append(' '.join(data_list))  # 将数据列表转换为字符串，并添加到标签行列表
            self.save_list(line_list, labels_dir + file[:-4] + "txt")  # 保存标签行列表到文件

    def split_train_val_test_dataset(self, file_list, train_ratio=0.9, trainval_ratio=0.9, need_test_dataset=False,
                                     shuffle_list=True):
        # 将文件列表分割为训练、验证和测试集
        if shuffle_list:  # 如果需要打乱列表
            random.shuffle(file_list)  # 打乱文件列表
        total_file_count = len(file_list)  # 获取文件总数
        train_list = []  # 初始化训练集列表
        val_list = []  # 初始化验证集列表
        test_list = []  # 初始化测试集列表
        if need_test_dataset:  # 如果需要测试集
            trainval_count = int(total_file_count * trainval_ratio)  # 计算训练和验证集的总数
            trainval_list = file_list[:trainval_count]  # 获取训练和验证集列表
            test_list = file_list[trainval_count:]  # 获取测试集列表
            train_count = int(train_ratio * len(trainval_list))  # 计算训练集的总数
            train_list = trainval_list[:train_count]  # 获取训练集列表
            val_list = trainval_list[train_count:]  # 获取验证集列表
        else:  # 如果不需要测试集
            train_count = int(train_ratio * total_file_count)  # 计算训练集的总数
            train_list = file_list[:train_count]  # 获取训练集列表
            val_list = file_list[train_count:]  # 获取验证集列表
        return train_list, val_list, test_list  # 返回训练集、验证集和测试集列表

    def start(self, json_dir, save_dir, names=None, train_ratio=0.9):
        # 启动转换过程
        images_dir, labels_dir = self.create_save_dir(save_dir)  # 创建保存目录
        if names is None or len(names) == 0:  # 如果没有提供类名列表
            print('class names will load from all json file')  # 打印提示信息
            names = self.get_class_names_from_all_json(json_dir)  # 从所有json文件中加载类名
        print('find {} class names :'.format(len(names)), names)  # 打印找到的类名数量和列表
        if len(names) == 0:  # 如果没有找到类名
            return  # 结束函数
        self.save_list(names, os.path.join(save_dir, 'labels.txt'))  # 保存类名列表到文件
        print('start convert')  # 打印开始转换的提示信息
        all_json_list = []  # 初始化json文件列表
        for file in os.listdir(json_dir):  # 遍历json目录下的所有文件
            if not file.endswith('.json'):  # 如果文件不是json格式，跳过
                continue
            all_json_list.append(file)  # 添加到json文件列表
        train_list, val_list, test_list = self.split_train_val_test_dataset(all_json_list, train_ratio)  # 分割训练、验证和测试集
        self.convert_dataset(json_dir, train_list, images_dir, labels_dir, names, 'train')  # 转换训练集
        self.convert_dataset(json_dir, val_list, images_dir, labels_dir, names, 'val')  # 转换验证集


if __name__ == '__main__':
    cm = ConvertManager()  # 创建转换管理器实例
    cm.start(r'存放json文件的文件夹地址', r'计划存放txt文件的文件夹地址')  # 启动转换过程

只需要把最后一行的文件夹地址改为自己的就可以

如果修改训练集和验证集比例则修改train_ratio=0.9（0.9代表训练集占90%）

yolo使用文档

训练

单GPU训练，无GPU自动会用CPU，yaml文件需要改成自己的

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.yaml')  # build a new model from YAML
model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
model = YOLO('yolov8n.yaml').load('yolov8n.pt')  # build from YAML and transfer weights

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

恢复中断的训练（感觉目前做项目用不到，几个小时就训练完了，挂着就行）

from ultralytics import YOLO

# Load a model
model = YOLO('path/to/last.pt')  # load a partially trained model

# Resume training
results = model.train(resume=True)

训练的一些参数

`model`	`None`	模型文件的路径，即yolov8n.pt,yolov8n.yaml
`data`	`None`	数据文件的路径，即 coco128.yaml
`epochs`	`100`	训练的历元数
`time`	`None`	训练的小时数，如果已提供，则覆盖纪元数
`patience`	`50`	在没有明显改善的情况下，提前停止训练的等待时间
`batch`	`16`	每批图像数（-1 表示自动批次）
`imgsz`	`640`	输入图像的整数大小
`save`	`True`	保存训练检查点并预测结果
`save_period`	`-1`	Save checkpoint every x epochs (disabled if < 1)
`cache`	`False`	true/ram，磁盘或 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) 训练，选择=[真，假］
`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`	新元动量/亚当贝塔1
`weight_decay`	`0.0005`	优化器权重衰减 5e-4
`warmup_epochs`	`3.0`	预热时间（可以是分数）
`warmup_momentum`	`0.8`	热身初始动力
`warmup_bias_lr`	`0.1`	预热初始偏置
`box`	`7.5`	箱内损失收益
`cls`	`0.5`	CLS 损耗增益（按像素缩放）
`dfl`	`1.5`	DFL 损失收益
`pose`	`12.0`	姿势损失增益（仅姿势）
`kobj`	`2.0`	关键点对象损失增益（仅姿势）
`label_smoothing`	`0.0`	标签平滑（分数）
`nbs`	`64`	标称批量
`overlap_mask`	`True`	遮罩应在训练期间重叠（仅分段训练）
`mask_ratio`	`4`	掩码下采样率（仅限段列车）
`dropout`	`0.0`	使用 dropout 正则化（仅对训练进行分类）
`val`	`True`	在培训期间验证/测试
`plots`	`False`	在训练/评估过程中保存绘图和图像

训练结果查看

看一下别的博主

https://blog.csdn.net/weixin_45277161/article/details/131046636

验证

验证代码

还没用过暂时不详细写了

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.pt')  # load an official model
model = YOLO('path/to/best.pt')  # load a custom model

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.box.map    # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps   # a list contains map50-95 of each category

验证参数

`data`	`None`	数据文件的路径，即 coco128.yaml
`imgsz`	`640`	输入图像的整数大小
`batch`	`16`	每批图像数（-1 表示自动批次）
`save_json`	`False`	将结果保存到 JSON 文件
`save_hybrid`	`False`	保存标签的混合版本（标签 + 附加预测）
`conf`	`0.001`	检测对象置信度阈值
`iou`	`0.6`	NMS 的 "相交大于结合"（IoU）阈值
`max_det`	`300`	每幅图像的最大检测次数
`half`	`True`	使用半精度 (FP16)
`device`	`None`	设备上运行，如 cuda device=0/1/2/3 或 device=cpu
`dnn`	`False`	使用 OpenCV DNN 进行ONNX 推断
`plots`	`False`	在训练/评估过程中保存绘图和图像
`rect`	`False`	矩形缬氨酸，每批都经过整理，以减少填充物
`split`	`val`	用于验证的数据集分集，即 "val"、"test "或 "train

预测

预测代码

stream = True时能以流媒体的形式运行推理或批量推理，能够连贯显示视频或者很多帧的推理。

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.jpg'])  # return a list of Results objects

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bbox outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.jpg'], stream=True)  # return a generator of Results objects

# Process results generator
for result in results:
    boxes = result.boxes  # Boxes object for bbox outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs

预测可支持的资料类型

图像	`'image.jpg'`	`str` 或 `Path`	单个图像文件。
网址	`'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）的 URL 或 IP 地址。
多流 ✅	`'list.streams'`	`str` 或 `Path`	`*.streams` 文本文件，每行一个流 URL，即 8 个流将以 8 的批处理大小运行。

预测时可以设定一些参数

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on 'bus.jpg' with arguments
model.predict('bus.jpg', save=True, imgsz=320, conf=0.5)

`source`	`str`	`'ultralytics/assets'`	图像或视频的源目录
`conf`	`float`	`0.25`	检测对象置信度阈值
`iou`	`float`	`0.7`	NMS 的 "相交大于结合"（IoU）阈值
`imgsz`	`int or tuple`	`640`	图像尺寸标量或（高，宽）列表，即（640，480）
`half`	`bool`	`False`	使用半精度 (FP16)
`device`	`None or str`	`None`	设备上运行，如 cuda device=0/1/2/3 或 device=cpu
`max_det`	`int`	`300`	每幅图像的最大检测次数
`vid_stride`	`bool`	`False`	视频帧速率跨度
`stream_buffer`	`bool`	`False`	缓冲所有流媒体帧（真）或返回最新帧（假）
`visualize`	`bool`	`False`	可视化模型特征
`augment`	`bool`	`False`	对预测源进行图像增强
`agnostic_nms`	`bool`	`False`	不分等级的 NMS
`classes`	`list[int]`	`None`	按类别筛选结果，即 classes=0，或 classes=[0,2,3]
`retina_masks`	`bool`	`False`	使用高分辨率分割掩膜
`embed`	`list[int]`	`None`	返回给定层的特征向量/嵌入值

可视化参数：

名称	类型	默认值	说明
`show`	`bool`	`False`	如果环境允许，展示预测的图像和视频
`save`	`bool`	`False`	保存预测的图像和视频
`save_frames`	`bool`	`False`	保存预测的单个视频帧
`save_txt`	`bool`	`False`	将结果保存为 `.txt` 文件
`save_conf`	`bool`	`False`	用置信度分数保存结果
`save_crop`	`bool`	`False`	保存裁剪后的图像和结果
`show_labels`	`bool`	`True`	显示预测标签，即 "人
`show_conf`	`bool`	`True`	显示预测置信度，即 "0.99
`show_boxes`	`bool`	`True`	显示预测框
`line_width`	`None or int`	`None`	边界框的线宽。如果无，则按图像大小缩放。

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

图像后缀	预测命令示例	参考资料
`.bmp`	`yolo predict source=image.bmp`	微软 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`	便携式浮图

下表包含有效的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`	马特罗斯卡
`.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 项目

预测结果处理

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on an image
results = model('bus.jpg')  # list of 1 Results object
results = model(['bus.jpg', 'zidane.jpg'])  # list of 2 Results objects

Results 对象具有以下属性

属性	类型	说明
`orig_img`	`numpy.ndarray`	原始图像的 numpy 数组。
`orig_shape`	`tuple`	原始图像的形状，格式为（高、宽）。
`boxes`	`Boxes, optional`	包含检测边界框的方框对象。
`masks`	`Masks, optional`	包含检测掩码的掩码对象。
`probs`	`Probs, optional`	Probs 对象，包含分类任务中每个类别的概率。
`keypoints`	`Keypoints, optional`	关键点对象，包含每个对象的检测关键点。
`obb`	`OBB, optional`	包含定向检测边界框的 OBB 对象。
`speed`	`dict`	每幅图像的预处理、推理和后处理速度字典，单位为毫秒。
`names`	`dict`	类名字典。
`path`	`str`	图像文件的路径。

Results 对象有以下方法：

方法	返回类型	说明
`__getitem__()`	`Results`	返回指定索引的结果对象。
`__len__()`	`int`	返回结果对象中的检测次数。
`update()`	`None`	更新结果对象的方框、掩码和 probs 属性。
`cpu()`	`Results`	返回包含 CPU 内存中所有张量的结果对象副本。
`numpy()`	`Results`	返回结果对象的副本，其中所有张量均为 numpy 数组。
`cuda()`	`Results`	返回包含 GPU 内存中所有张量的 Results 对象副本。
`to()`	`Results`	返回带有指定设备和 dtype 上张量的 Results 对象副本。
`new()`	`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 格式。

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.boxes)  # print the Boxes object containing the detection bounding 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 格式返回按原始图像大小归一化的方框。

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n-seg Segment model
model = YOLO('yolov8n-seg.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.masks)  # print the Masks object containing the detected instance masks

下面是一个表格 Masks 类方法和属性，包括名称、类型和说明：

名称	类型	说明
`cpu()`	方法	返回 CPU 内存中的掩码tensor 。
`numpy()`	方法	以 numpy 数组形式返回掩码tensor 。
`cuda()`	方法	返回 GPU 内存中的掩码tensor 。
`to()`	方法	返回带有指定设备和 dtype 的掩码tensor 。
`xyn`	财产 (`torch.Tensor`)	以张量表示的标准化片段列表。
`xy`	财产 (`torch.Tensor`)	以张量表示的像素坐标线段列表。

`Keypoints` 对象可用于索引、处理和归一化坐标

from ultralytics import YOLO

# Load a pretrained YOLOv8n-pose Pose model
model = YOLO('yolov8n-pose.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.keypoints)  # print the Keypoints object containing the detected keypoints

下面是一个表格 Keypoints 类方法和属性，包括名称、类型和说明：

名称	类型	说明
`cpu()`	方法	返回 CPU 内存中的关键点tensor 。
`numpy()`	方法	以 numpy 数组形式返回关键点tensor 。
`cuda()`	方法	返回 GPU 内存中的关键点tensor 。
`to()`	方法	返回指定设备和 dtype 的关键点tensor 。
`xyn`	财产 (`torch.Tensor`)	以张量表示的标准化关键点列表。
`xy`	财产 (`torch.Tensor`)	以张量表示的像素坐标关键点列表。
`conf`	财产 (`torch.Tensor`)	返回关键点的置信度值（如果有），否则为空。

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n-cls Classify model
model = YOLO('yolov8n-cls.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.probs)  # print the Probs object containing the detected class probabilities

下面的表格总结了 Probs 类：

名称	类型	说明
`cpu()`	方法	返回 CPU 内存中 probstensor 的副本。
`numpy()`	方法	以 numpy 数组形式返回 probstensor 的副本。
`cuda()`	方法	返回 GPU 内存中 probstensor 的副本。
`to()`	方法	返回带有指定设备和 dtype 的 probstensor 的副本。
`top1`	财产 (`int`)	前 1 级的指数。
`top5`	财产 (`list[int]`)	前 5 个等级的指数。
`top1conf`	财产 (`torch.Tensor`)	对前 1 级置信度
`top5conf`	财产 (`torch.Tensor`)	前五级的置信度

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n-obb.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

下面是一个表格 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 格式返回按图像大小归一化的旋转方框。

线程安全推理

在多线程应用程序中使用YOLO 模型时，必须为每个线程实例化单独的模型对象，或使用线程本地存储以防止冲突：

from ultralytics import YOLO
from threading import Thread

def thread_safe_predict(image_path):
    # Instantiate a new model inside the thread
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results


# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

流媒体源 `for`-循环

import cv2
from ultralytics import YOLO

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

# Open the video file
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

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

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

        # Display the annotated frame
        cv2.imshow("YOLOv8 Inference", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

该脚本将对视频的每一帧进行预测，将结果可视化并显示在窗口中。按 "q "键可退出循环。

绘制结果

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

from PIL import Image
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on 'bus.jpg'
results = model('bus.jpg')  # results list

# Show the results
for r in results:
    im_array = r.plot()  # plot a BGR numpy array of predictions
    im = Image.fromarray(im_array[..., ::-1])  # RGB PIL image
    im.show()  # show image
    im.save('results.jpg')  # save image

论据	类型	说明	默认值
`conf`	`bool`	是否绘制检测置信度得分。	`True`
`line_width`	`float`	边界框的线宽。如果无，则按图像大小缩放。	`None`
`font_size`	`float`	文本的字体大小。如果无，则按图像大小缩放。	`None`
`font`	`str`	文本使用的字体。	`'Arial.ttf'`
`pil`	`bool`	是否将图像作为 PIL 图像返回。	`False`
`img`	`numpy.ndarray`	如果没有，则绘制到原始图像。	`None`
`im_gpu`	`torch.Tensor`	在 gpu 中以形状（1, 3, 640, 640）归一化图像，以便更快地绘制掩膜图。	`None`
`kpt_radius`	`int`	绘制关键点的半径。默认值为 5。	`5`
`kpt_line`	`bool`	是否绘制连接关键点的线条。	`True`
`labels`	`bool`	是否绘制边界框的标签。	`True`
`boxes`	`bool`	是否绘制边界框。	`True`
`masks`	`bool`	是否绘制面具。	`True`
`probs`	`bool`	是否绘制分类概率	`True`

将结果标签和检测到该标签的数量打印出来

for result in results:
    # 遍历预测结果。每个 'result' 包含一个图像的检测结果
    det = result.boxes
    # 'result.boxes' 包含该图像的所有检测框（边界框）信息

    for c in det.cls.unique():
        # 遍历每个独特的类别索引 'c'。'det.cls.unique()' 返回在所有检测框中出现的不重复类别索引

        n = (det.cls == c).sum()  
        # 计算类别 'c' 出现的次数。'(det.cls == c)' 创建一个布尔数组，其中每个检测框的类别如果是 'c' 则为 True，否则为 False。'.sum()' 对 True 值进行计数，给出该类别的总数

        print(model.names[int(c)], int(n))
        # 打印类别名称和数量。'model.names[int(c)]' 从类别索引转换为类别名称。'int(n)' 是该类别的检测次数