《使用 YOLOV8 和 KerasCV 进行高效目标检测》

《使用 YOLOV8 和 KerasCV 进行高效目标检测》

作者：Gitesh Chawda
创建日期：2023/06/26
最后修改时间：2023/06/26
描述：使用 KerasCV 训练自定义 YOLOV8 对象检测模型。

（i）此示例使用 Keras 2

在 Colab 中查看 •

GitHub 源

介绍

KerasCV 是 Keras 的扩展，用于计算机视觉任务。在此示例中，我们将看到如何使用 KerasCV 训练 YOLOV8 对象检测模型。

KerasCV 包括适用于常用计算机视觉数据集的预训练模型，例如 ImageNet、COCO 和 Pascal VOC，可用于迁移学习。KerasCV 还提供了一系列用于检查中间表示的可视化工具由模型学习，用于可视化对象检测和分割的结果任务。

如果您有兴趣了解使用 KerasCV 进行对象检测，我强烈建议您看看 Lukewood 创建的指南。此资源可在使用 KerasCV 进行对象检测中获得。全面概述了基本概念和技术使用 KerasCV 构建对象检测模型时需要。

!pip install --upgrade git+https://github.com/keras-team/keras-cv -q

[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv[0m[33m [0m

设置

import os
from tqdm.auto import tqdm
import xml.etree.ElementTree as ET

import tensorflow as tf
from tensorflow import keras

import keras_cv
from keras_cv import bounding_box
from keras_cv import visualization

/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/__init__.py:98: UserWarning: unable to load libtensorflow_io_plugins.so: unable to open file: libtensorflow_io_plugins.so, from paths: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io_plugins.so'] caused by: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io_plugins.so: undefined symbol: _ZN3tsl6StatusC1EN10tensorflow5error4CodeESt17basic_string_viewIcSt11char_traitsIcEENS_14SourceLocationE'] warnings.warn(f"unable to load libtensorflow_io_plugins.so: {e}") /opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/__init__.py:104: UserWarning: file system plugins are not loaded: unable to open file: libtensorflow_io.so, from paths: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io.so'] caused by: ['/opt/conda/lib/python3.10/site-packages/tensorflow_io/python/ops/libtensorflow_io.so: undefined symbol: _ZTVN10tensorflow13GcsFileSystemE'] warnings.warn(f"file system plugins are not loaded: {e}")

加载数据

在本指南中，我们将使用从 roboflow 获取的自动驾驶汽车数据集。为了使数据集更易于管理，我提取了较大数据集的子集，该子集最初由 15,000 个数据样本组成。从这个子集中，我选择了 7,316 个模型训练示例。

为了简化手头的任务并集中精力，我们将与减少的对象类的数量。具体来说，我们将考虑 5 个主要类别检测和分类：汽车、行人、红绿灯、骑自行车的人和卡车。这些类表示自动驾驶汽车的背景。

通过将数据集缩小到这些特定类，我们可以专注于构建强大的对象检测模型，可以准确识别和分类这些重要对象。

TensorFlow Datasets 库提供了一种下载和使用各种数据集，包括对象检测数据集。对于那些人来说，这可能是一个不错的选择想要快速开始处理数据而无需手动下载和预处理它。

您可以在此处查看各种对象检测数据集 TensorFlow 数据集

但是，在此代码示例中，我们将演示如何从头开始加载数据集使用 TensorFlow 的 tf.data 流水线。这种方法提供了更大的灵活性，并允许您可以根据需要自定义预处理步骤。

加载 TensorFlow 数据集库中不可用的自定义数据集就是其中之一使用 tf.data 管道的主要优势。此方法允许您创建针对特定需求量身定制的自定义数据预处理管道，以及要求。

超参数

SPLIT_RATIO = 0.2
BATCH_SIZE = 4
LEARNING_RATE = 0.001
EPOCH = 5
GLOBAL_CLIPNORM = 10.0

创建一个字典以将每个类名映射到唯一的数字标识符。这 mapping 用于在训练和推理期间对类标签进行编码和解码对象检测任务。

class_ids = [
    "car",
    "pedestrian",
    "trafficLight",
    "biker",
    "truck",
]
class_mapping = dict(zip(range(len(class_ids)), class_ids))

# Path to images and annotations
path_images = "/kaggle/input/dataset/data/images/"
path_annot = "/kaggle/input/dataset/data/annotations/"

# Get all XML file paths in path_annot and sort them
xml_files = sorted(
    [
        os.path.join(path_annot, file_name)
        for file_name in os.listdir(path_annot)
        if file_name.endswith(".xml")
    ]
)

# Get all JPEG image file paths in path_images and sort them
jpg_files = sorted(
    [
        os.path.join(path_images, file_name)
        for file_name in os.listdir(path_images)
        if file_name.endswith(".jpg")
    ]
)

下面的函数读取 XML 文件并查找图像名称和路径，然后迭代 XML 文件中的每个对象以提取边界框坐标，并且 class 标签。

该函数返回三个值：图像路径、边界框列表（每个表示为四个浮点数的列表：xmin、ymin、xmax、ymax）和类 ID 列表（以整数表示）对应于每个边界框。获取类 ID 通过使用名为的字典将类标签映射到整数值。class_mapping

def parse_annotation(xml_file):
    tree = ET.parse(xml_file)
    root = tree.getroot()

    image_name = root.find("filename").text
    image_path = os.path.join(path_images, image_name)

    boxes = []
    classes = []
    for obj in root.iter("object"):
        cls = obj.find("name").text
        classes.append(cls)

        bbox = obj.find("bndbox")
        xmin = float(bbox.find("xmin").text)
        ymin = float(bbox.find("ymin").text)
        xmax = float(bbox.find("xmax").text)
        ymax = float(bbox.find("ymax").text)
        boxes.append([xmin, ymin, xmax, ymax])

    class_ids = [
        list(class_mapping.keys())[list(class_mapping.values()).index(cls)]
        for cls in classes
    ]
    return image_path, boxes, class_ids


image_paths = []
bbox = []
classes = []
for xml_file in tqdm(xml_files):
    image_path, boxes, class_ids = parse_annotation(xml_file)
    image_paths.append(image_path)
    bbox.append(boxes)
    classes.append(class_ids)

 0%| | 0/7316 [00:00<?, ?it/s]

在这里，我们使用 tf.ragged.constant 从和列表创建不规则张量。参差不齐的张量是一种可以处理不同长度的数据。这在处理具有可变长度序列，例如文本或时间序列数据。bboxclasses

classes = [
    [8, 8, 8, 8, 8],      # 5 classes
    [12, 14, 14, 14],     # 4 classes
    [1],                  # 1 class
    [7, 7],               # 2 classes
 ...]

bbox = [
    [[199.0, 19.0, 390.0, 401.0],
    [217.0, 15.0, 270.0, 157.0],
    [393.0, 18.0, 432.0, 162.0],
    [1.0, 15.0, 226.0, 276.0],
    [19.0, 95.0, 458.0, 443.0]],     #image 1 has 4 objects
    [[52.0, 117.0, 109.0, 177.0]],   #image 2 has 1 object
    [[88.0, 87.0, 235.0, 322.0],
    [113.0, 117.0, 218.0, 471.0]],   #image 3 has 2 objects
 ...]

在这种情况下，每个图像的 and 列表具有不同的长度，取决于图像中的对象数量和相应的边界框，以及类。为了处理这种可变性，使用参差不齐的张量而不是常规张量。bboxclasses

稍后，这些参差不齐的张量用于使用该方法创建 tf.data.Dataset 。该方法通过以下方式从输入张量创建数据集沿第一维度对它们进行切片。通过使用不规则张量，数据集可以处理每张图像的数据长度不同，并提供灵活的输入管道以进一步加工。from_tensor_slices

bbox = tf.ragged.constant(bbox)
classes = tf.ragged.constant(classes)
image_paths = tf.ragged.constant(image_paths)

data = tf.data.Dataset.from_tensor_slices((image_paths, classes, bbox))

在训练和验证数据中拆分数据

# Determine the number of validation samples
num_val = int(len(xml_files) * SPLIT_RATIO)

# Split the dataset into train and validation sets
val_data = data.take(num_val)
train_data = data.skip(num_val)

让我们看看数据加载和边界框格式化以使事情顺利进行。边界 KerasCV 中的框具有预先确定的格式。为此，您必须捆绑边界框添加到符合下列要求的词典中：

bounding_boxes = {
    # num_boxes may be a Ragged dimension
    'boxes': Tensor(shape=[batch, num_boxes, 4]),
    'classes': Tensor(shape=[batch, num_boxes])
}

字典有两个键和，每个键都映射到 TensorFlow RaggedTensor 或 Tensor 对象。Tensor 的形状为，其中 batch 是 batch 中的图像数，num_boxes 是任何图像中的最大边界框数。4 表示定义边界框：xmin、ymin、xmax、ymax。'boxes''classes''boxes'[batch, num_boxes, 4]

Tensor 的形状为，其中每个元素表示 Tensor 中相应边界框的类标签。num_boxes 尺寸可能参差不齐，这意味着批次。'classes'[batch, num_boxes]'boxes'

最终 dict 应该是：

{"images": images, "bounding_boxes": bounding_boxes}

def load_image(image_path):
    image = tf.io.read_file(image_path)
    image = tf.image.decode_jpeg(image, channels=3)
    return image


def load_dataset(image_path, classes, bbox):
    # Read Image
    image = load_image(image_path)
    bounding_boxes = {
        "classes": tf.cast(classes, dtype=tf.float32),
        "boxes": bbox,
    }
    return {"images": tf.cast(image, tf.float32), "bounding_boxes": bounding_boxes}

在这里，我们创建一个图层，将图像大小调整为 640x640 像素，同时保持原始纵横比。与图像关联的边界框以格式指定。如有必要，调整大小后的图像将用零填充，以保持原始纵横比。xyxy

KerasCV 支持的边界框格式： 1. CENTER_XYWH 2. XYWH 3. XYXY 4. REL_XYXY 5. REL_XYWH 6. YXYX 7. REL_YXYX

你可以在 docs 中关于 KerasCV 边界框格式的信息。

此外，还可以在任意两对之间执行格式转换：

boxes = keras_cv.bounding_box.convert_format(
        bounding_box,
        images=image,
        source="xyxy",  # Original Format
        target="xywh",  # Target Format (to which we want to convert)
    )

数据增强

构建对象检测管道时最具挑战性的任务之一是数据增大。它涉及对输入图像应用各种转换，以增加训练数据的多样性，提高模型的能力概括。但是，在处理对象检测任务时，它变得更加复杂，因为这些转换需要了解底层边界框和相应地更新它们。

KerasCV 为边界框增强提供原生支持。KerasCV 提供了一个大量专为处理边界而设计的数据增强层盒。这些图层会根据图像的原样智能地调整边界框坐标 transformed，确保边界框保持准确并与增强图像。

通过利用 KerasCV 的功能，开发人员可以方便地集成边界将 Box 友好的数据增强到他们的对象检测管道中。通过执行在 tf.data 流水线中进行动态增强，该过程变得无缝且高效，从而实现更好的训练和更准确的对象检测结果。

augmenter = keras.Sequential(
    layers=[
        keras_cv.layers.RandomFlip(mode="horizontal", bounding_box_format="xyxy"),
        keras_cv.layers.RandomShear(
            x_factor=0.2, y_factor=0.2, bounding_box_format="xyxy"
        ),
        keras_cv.layers.JitteredResize(
            target_size=(640, 640), scale_factor=(0.75, 1.3), bounding_box_format="xyxy"
        ),
    ]
)

创建训练数据集

train_ds = train_data.map(load_dataset, num_parallel_calls=tf.data.AUTOTUNE)
train_ds = train_ds.shuffle(BATCH_SIZE * 4)
train_ds = train_ds.ragged_batch(BATCH_SIZE, drop_remainder=True)
train_ds = train_ds.map(augmenter, num_parallel_calls=tf.data.AUTOTUNE)

创建验证数据集

resizing = keras_cv.layers.JitteredResize(
    target_size=(640, 640),
    scale_factor=(0.75, 1.3),
    bounding_box_format="xyxy",
)

val_ds = val_data.map(load_dataset, num_parallel_calls=tf.data.AUTOTUNE)
val_ds = val_ds.shuffle(BATCH_SIZE * 4)
val_ds = val_ds.ragged_batch(BATCH_SIZE, drop_remainder=True)
val_ds = val_ds.map(resizing, num_parallel_calls=tf.data.AUTOTUNE)

可视化

def visualize_dataset(inputs, value_range, rows, cols, bounding_box_format):
    inputs = next(iter(inputs.take(1)))
    images, bounding_boxes = inputs["images"], inputs["bounding_boxes"]
    visualization.plot_bounding_box_gallery(
        images,
        value_range=value_range,
        rows=rows,
        cols=cols,
        y_true=bounding_boxes,
        scale=5,
        font_scale=0.7,
        bounding_box_format=bounding_box_format,
        class_mapping=class_mapping,
    )


visualize_dataset(
    train_ds, bounding_box_format="xyxy", value_range=(0, 255), rows=2, cols=2
)

visualize_dataset(
    val_ds, bounding_box_format="xyxy", value_range=(0, 255), rows=2, cols=2
)

PNG 格式

我们需要从 preprocessing 字典中提取输入并准备好它们馈送到模型中。

def dict_to_tuple(inputs):
    return inputs["images"], inputs["bounding_boxes"]


train_ds = train_ds.map(dict_to_tuple, num_parallel_calls=tf.data.AUTOTUNE)
train_ds = train_ds.prefetch(tf.data.AUTOTUNE)

val_ds = val_ds.map(dict_to_tuple, num_parallel_calls=tf.data.AUTOTUNE)
val_ds = val_ds.prefetch(tf.data.AUTOTUNE)

创建模型

YOLOv8 是一款尖端的 YOLO 模型，用于各种计算机视觉任务，例如对象检测、图像分类和实例分割。Ultralytics， YOLOv5 的创建者还开发了 YOLOv8，其中包含许多改进和与前代产品相比，架构和开发人员体验发生了变化。YOLOv8 是在业内受到高度评价的最新最新型号。

下表比较了 5 种不同 YOLOv8 模型的性能指标与不同大小（以像素为单位）：YOLOv8n、YOLOv8s、YOLOv8m、YOLOv8l 和 YOLOv8x。这些指标包括不同验证数据的交并比（IoU）阈值，CPU 上的推理速度 ONNX 格式和 A100 TensorRT 、参数数量和浮点数操作（FLOP）（分别以百万和数十亿为单位）。由于 model 增加时，mAP、参数和 FLOPs 通常增加，而速度减少。YOLOv8x 的 mAP、参数和 FLOP 最高，但也是最慢的推理速度，而 YOLOv8n 具有最小的尺寸、最快的推理速度和最低的推理速度 mAP、参数和 FLOPs。

您可以在此 RoboFlow 博客中阅读有关 YOLOV8 及其架构的更多信息

首先，我们将创建一个 backbone 实例，供我们的 yolov8 检测器使用类。

KerasCV 中提供的 YOLOV8 Backbones：

无权重：

1. yolo_v8_xs_backbone 2. yolo_v8_s_backbone 3. yolo_v8_m_backbone 4. yolo_v8_l_backbone 5. yolo_v8_xl_backbone

使用预先训练的 coco 重量：

backbone = keras_cv.models.YOLOV8Backbone.from_preset(
    "yolo_v8_s_backbone_coco"  # We will use yolov8 small backbone with coco weights
)

1. yolo_v8_xs_backbone_coco 2. yolo_v8_s_backbone_coco 2. yolo_v8_m_backbone_coco 2. yolo_v8_l_backbone_coco 2. yolo_v8_xl_backbone_coco Downloading data from https://storage.googleapis.com/keras-cv/models/yolov8/coco/yolov8_s_backbone.h5 20596968/20596968 [==============================] - 0s 0us/step

接下来，让我们使用构建一个 YOLOV8 模型，它接受一个特征 extractor 作为参数，则指定数字 of 对象类来根据列表的大小进行检测，该参数通知模型数据集，最后，特征金字塔网络（FPN）深度由参数指定。YOLOV8Detectorbackbonenum_classesclass_mappingbounding_box_formatfpn_depth

使用上述任何 backbone 构建 YOLOV8 都很简单，这要归功于 KerasCV 的

yolo = keras_cv.models.YOLOV8Detector(
    num_classes=len(class_mapping),
    bounding_box_format="xyxy",
    backbone=backbone,
    fpn_depth=1,
)

编译模型

用于 YOLOV8 的损失

分类损失：此损失函数计算预期类概率和实际类概率。在这种情况下，二进制分类问题的一个突出解决方案是利用。我们利用了二进制交叉熵，因为每个被识别的事物都是被归类为属于或不属于某个对象类（例如，一个人、一个汽车等）。binary_crossentropy
Box Loss：是用于衡量预测边界框和地面实况。在这种情况下，完整 IoU （CIoU）指标，它不仅衡量预测值和真实值之间的重叠边界框，但还要考虑纵横比、中心距和盒子大小。这些损失函数共同帮助优化对象检测模型，方法是最小化 Predicted 和 Ground Truth 类概率之间的差异，以及边界框。box_loss

optimizer = tf.keras.optimizers.Adam(
    learning_rate=LEARNING_RATE,
    global_clipnorm=GLOBAL_CLIPNORM,
)

yolo.compile(
    optimizer=optimizer, classification_loss="binary_crossentropy", box_loss="ciou"
)

COCO 指标回调

我们将使用 KerasCV 来评估模型并计算 Map（Mean Average Precision）分数、Recall 和 Precision。我们还会在 mAP 评分提高。BoxCOCOMetrics

class EvaluateCOCOMetricsCallback(keras.callbacks.Callback):
    def __init__(self, data, save_path):
        super().__init__()
        self.data = data
        self.metrics = keras_cv.metrics.BoxCOCOMetrics(
            bounding_box_format="xyxy",
            evaluate_freq=1e9,
        )

        self.save_path = save_path
        self.best_map = -1.0

    def on_epoch_end(self, epoch, logs):
        self.metrics.reset_state()
        for batch in self.data:
            images, y_true = batch[0], batch[1]
            y_pred = self.model.predict(images, verbose=0)
            self.metrics.update_state(y_true, y_pred)

        metrics = self.metrics.result(force=True)
        logs.update(metrics)

        current_map = metrics["MaP"]
        if current_map > self.best_map:
            self.best_map = current_map
            self.model.save(self.save_path)  # Save the model when mAP improves

        return logs

训练模型

yolo.fit(
    train_ds,
    validation_data=val_ds,
    epochs=3,
    callbacks=[EvaluateCOCOMetricsCallback(val_ds, "model.h5")],
)

Epoch 1/3 1463/1463 [==============================] - 633s 390ms/step - loss: 10.1535 - box_loss: 2.5659 - class_loss: 7.5876 - val_loss: 3.9852 - val_box_loss: 3.1973 - val_class_loss: 0.7879 - MaP: 0.0095 - MaP@[IoU=50]: 0.0193 - MaP@[IoU=75]: 0.0074 - MaP@[area=small]: 0.0021 - MaP@[area=medium]: 0.0164 - MaP@[area=large]: 0.0010 - Recall@[max_detections=1]: 0.0096 - Recall@[max_detections=10]: 0.0160 - Recall@[max_detections=100]: 0.0160 - Recall@[area=small]: 0.0034 - Recall@[area=medium]: 0.0283 - Recall@[area=large]: 0.0010 Epoch 2/3 1463/1463 [==============================] - 554s 378ms/step - loss: 2.6961 - box_loss: 2.2861 - class_loss: 0.4100 - val_loss: 3.8292 - val_box_loss: 3.0052 - val_class_loss: 0.8240 - MaP: 0.0077 - MaP@[IoU=50]: 0.0197 - MaP@[IoU=75]: 0.0043 - MaP@[area=small]: 0.0075 - MaP@[area=medium]: 0.0126 - MaP@[area=large]: 0.0050 - Recall@[max_detections=1]: 0.0088 - Recall@[max_detections=10]: 0.0154 - Recall@[max_detections=100]: 0.0154 - Recall@[area=small]: 0.0075 - Recall@[area=medium]: 0.0191 - Recall@[area=large]: 0.0280 Epoch 3/3 1463/1463 [==============================] - 558s 381ms/step - loss: 2.5930 - box_loss: 2.2018 - class_loss: 0.3912 - val_loss: 3.4796 - val_box_loss: 2.8472 - val_class_loss: 0.6323 - MaP: 0.0145 - MaP@[IoU=50]: 0.0398 - MaP@[IoU=75]: 0.0072 - MaP@[area=small]: 0.0077 - MaP@[area=medium]: 0.0227 - MaP@[area=large]: 0.0079 - Recall@[max_detections=1]: 0.0120 - Recall@[max_detections=10]: 0.0257 - Recall@[max_detections=100]: 0.0258 - Recall@[area=small]: 0.0093 - Recall@[area=medium]: 0.0396 - Recall@[area=large]: 0.0226 <keras.callbacks.History at 0x7f3e01ca6d70>

可视化预测

def visualize_detections(model, dataset, bounding_box_format):
    images, y_true = next(iter(dataset.take(1)))
    y_pred = model.predict(images)
    y_pred = bounding_box.to_ragged(y_pred)
    visualization.plot_bounding_box_gallery(
        images,
        value_range=(0, 255),
        bounding_box_format=bounding_box_format,
        y_true=y_true,
        y_pred=y_pred,
        scale=4,
        rows=2,
        cols=2,
        show=True,
        font_scale=0.7,
        class_mapping=class_mapping,
    )


visualize_detections(yolo, dataset=val_ds, bounding_box_format="xyxy")

1/1 [==============================] - 0s 115ms/step

PNG 格式