Перейти к содержанию

Перекрестная проверка K-Fold с помощью Ultralytics

Введение

Это подробное руководство иллюстрирует реализацию K-Fold Cross Validation для наборов данных обнаружения объектов в экосистеме Ultralytics. Мы будем использовать формат обнаружения YOLO и ключевые библиотеки Python, такие как sklearn, pandas и PyYaml, чтобы провести вас через необходимую настройку, процесс создания векторов признаков и выполнение разделения набора данных K-Fold.

Обзор перекрестной проверки K-Fold

Независимо от того, включает ли ваш проект набор данных Fruit Detection или пользовательский источник данных, этот учебник призван помочь вам понять и применить перекрестную проверку K-Fold для повышения надежности и устойчивости вашего машинное обучение моделей. Пока мы применяем k=5 фолдов для этого туториала, имейте в виду, что оптимальное количество фолдов может варьироваться в зависимости от вашего набора данных и специфики вашего проекта.

Не будем долго тянуть, давайте начнем!

Настройка

  • Ваши аннотации должны быть в формате обнаружения YOLO.

  • В этом руководстве предполагается, что файлы аннотаций доступны локально.

  • Для нашей демонстрации мы используем набор данных Обнаружение фруктов.

    • Этот набор данных содержит в общей сложности 8479 изображений.
    • Он включает 6 меток классов, каждая из которых имеет общее количество экземпляров, перечисленных ниже.
Метка класса Подсчет экземпляров
Apple 7049
Виноград 7202
Ананас 1613
Оранжевый 15549
Банан 3536
Арбуз 1976

  • Необходимые пакеты python включают:

    • ultralytics
    • sklearn
    • pandas
    • pyyaml

  • Этот учебник работает с k=5 фолдов. Однако, вам следует определить наилучшее количество фолдов для вашего конкретного набора данных.

  • Инициировать новую виртуальную среду Python (venv) для вашего проекта и активируйте его. Используйте pip (или ваш предпочтительный менеджер пакетов) для установки:

    • Библиотека Ultralytics: pip install -U ultralytics. В качестве альтернативы, вы можете клонировать официальный репозиторий.
    • Scikit-learn, pandas и PyYAML: pip install -U scikit-learn pandas pyyaml.

  • Убедитесь, что ваши аннотации находятся в формате обнаружения YOLO.

    • В этом руководстве все файлы аннотаций находятся в Fruit-Detection/labels каталоге.

Генерация векторов признаков для набора данных обнаружения объектов

  1. Начните с создания нового example.py Python-файл для выполнения шагов, описанных ниже.

  2. Перейдите к извлечению всех файлов меток для вашего набора данных.

    from pathlib import Path

dataset_path = Path("./Fruit-detection")  # replace with 'path/to/dataset' for your custom data
labels = sorted(dataset_path.rglob("*labels/*.txt"))  # all data in 'labels'

  3. Теперь прочитайте содержимое файла YAML набора данных и извлеките индексы меток классов.

    import yaml

yaml_file = "path/to/data.yaml"  # your data YAML with data directories and names dictionary
with open(yaml_file, encoding="utf8") as y:
    classes = yaml.safe_load(y)["names"]
cls_idx = sorted(classes.keys())

  4. Инициализировать пустой pandas DataFrame.

    import pandas as pd

index = [label.stem for label in labels]  # uses base filename as ID (no extension)
labels_df = pd.DataFrame([], columns=cls_idx, index=index)

  5. Подсчитайте экземпляры каждой метки класса, присутствующие в файлах аннотаций.

    from collections import Counter

for label in labels:
    lbl_counter = Counter()

    with open(label) as lf:
        lines = lf.readlines()

    for line in lines:
        # classes for YOLO label uses integer at first position of each line
        lbl_counter[int(line.split(" ", 1)[0])] += 1

    labels_df.loc[label.stem] = lbl_counter

labels_df = labels_df.fillna(0.0)  # replace `nan` values with `0.0`

  6. Ниже приведен пример представления заполненного DataFrame:

                                                           0    1    2    3    4    5
'0000a16e4b057580_jpg.rf.00ab48988370f64f5ca8ea4...'  0.0  0.0  0.0  0.0  0.0  7.0
'0000a16e4b057580_jpg.rf.7e6dce029fb67f01eb19aa7...'  0.0  0.0  0.0  0.0  0.0  7.0
'0000a16e4b057580_jpg.rf.bc4d31cdcbe229dd022957a...'  0.0  0.0  0.0  0.0  0.0  7.0
'00020ebf74c4881c_jpg.rf.508192a0a97aa6c4a3b6882...'  0.0  0.0  0.0  1.0  0.0  0.0
'00020ebf74c4881c_jpg.rf.5af192a2254c8ecc4188a25...'  0.0  0.0  0.0  1.0  0.0  0.0
 ...                                                  ...  ...  ...  ...  ...  ...
'ff4cd45896de38be_jpg.rf.c4b5e967ca10c7ced3b9e97...'  0.0  0.0  0.0  0.0  0.0  2.0
'ff4cd45896de38be_jpg.rf.ea4c1d37d2884b3e3cbce08...'  0.0  0.0  0.0  0.0  0.0  2.0
'ff5fd9c3c624b7dc_jpg.rf.bb519feaa36fc4bf630a033...'  1.0  0.0  0.0  0.0  0.0  0.0
'ff5fd9c3c624b7dc_jpg.rf.f0751c9c3aa4519ea3c9d6a...'  1.0  0.0  0.0  0.0  0.0  0.0
'fffe28b31f2a70d4_jpg.rf.7ea16bd637ba0711c53b540...'  0.0  6.0  0.0  0.0  0.0  0.0

Строки индексируют файлы меток, каждый из которых соответствует изображению в вашем наборе данных, а столбцы соответствуют индексам меток классов. Каждая строка представляет собой псевдо-вектор признаков, с количеством каждой метки класса, присутствующей в вашем наборе данных. Эта структура данных позволяет применять перекрестную проверку K-Fold к набору данных обнаружения объектов.

Разделение набора данных K-Fold

  1. Теперь мы будем использовать KFold класс из sklearn.model_selection для генерации k разделения набора данных.

    • Важно:
      • Настройка shuffle=True обеспечивает рандомизированное распределение классов в ваших разбиениях.
      • Установив random_state=M где M - это выбранное целое число, с помощью которого можно получить повторяемые результаты.
    import random

from sklearn.model_selection import KFold

random.seed(0)  # for reproducibility
ksplit = 5
kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)  # setting random_state for repeatable results

kfolds = list(kf.split(labels_df))

  2. Набор данных теперь разделен на k фолдов, каждый из которых содержит список train и val индексы. Мы построим DataFrame, чтобы более четко отобразить эти результаты.

    folds = [f"split_{n}" for n in range(1, ksplit + 1)]
folds_df = pd.DataFrame(index=index, columns=folds)

for i, (train, val) in enumerate(kfolds, start=1):
    folds_df[f"split_{i}"].loc[labels_df.iloc[train].index] = "train"
    folds_df[f"split_{i}"].loc[labels_df.iloc[val].index] = "val"

  3. Теперь мы рассчитаем распределение меток классов для каждой складки как соотношение классов, присутствующих в val к тем, которые присутствуют в train.

    fold_lbl_distrb = pd.DataFrame(index=folds, columns=cls_idx)

for n, (train_indices, val_indices) in enumerate(kfolds, start=1):
    train_totals = labels_df.iloc[train_indices].sum()
    val_totals = labels_df.iloc[val_indices].sum()

    # To avoid division by zero, we add a small value (1E-7) to the denominator
    ratio = val_totals / (train_totals + 1e-7)
    fold_lbl_distrb.loc[f"split_{n}"] = ratio

    Идеальный сценарий — когда все соотношения классов достаточно похожи для каждого разделения и между классами. Однако это будет зависеть от специфики вашего набора данных.

  4. Далее, мы создаем каталоги и YAML-файлы набора данных для каждого разделения.

    import datetime

supported_extensions = [".jpg", ".jpeg", ".png"]

# Initialize an empty list to store image file paths
images = []

# Loop through supported extensions and gather image files
for ext in supported_extensions:
    images.extend(sorted((dataset_path / "images").rglob(f"*{ext}")))

# Create the necessary directories and dataset YAML files
save_path = Path(dataset_path / f"{datetime.date.today().isoformat()}_{ksplit}-Fold_Cross-val")
save_path.mkdir(parents=True, exist_ok=True)
ds_yamls = []

for split in folds_df.columns:
    # Create directories
    split_dir = save_path / split
    split_dir.mkdir(parents=True, exist_ok=True)
    (split_dir / "train" / "images").mkdir(parents=True, exist_ok=True)
    (split_dir / "train" / "labels").mkdir(parents=True, exist_ok=True)
    (split_dir / "val" / "images").mkdir(parents=True, exist_ok=True)
    (split_dir / "val" / "labels").mkdir(parents=True, exist_ok=True)

    # Create dataset YAML files
    dataset_yaml = split_dir / f"{split}_dataset.yaml"
    ds_yamls.append(dataset_yaml)

    with open(dataset_yaml, "w") as ds_y:
        yaml.safe_dump(
            {
                "path": split_dir.as_posix(),
                "train": "train",
                "val": "val",
                "names": classes,
            },
            ds_y,
        )

  5. Наконец, скопируйте изображения и метки в соответствующие каталоги ('train' или 'val') для каждого разбиения.

    • ПРИМЕЧАНИЕ: Время, необходимое для этой части кода, будет варьироваться в зависимости от размера вашего набора данных и аппаратного обеспечения вашей системы.
    import shutil

from tqdm import tqdm

for image, label in tqdm(zip(images, labels), total=len(images), desc="Copying files"):
    for split, k_split in folds_df.loc[image.stem].items():
        # Destination directory
        img_to_path = save_path / split / k_split / "images"
        lbl_to_path = save_path / split / k_split / "labels"

        # Copy image and label files to new directory (SamefileError if file already exists)
        shutil.copy(image, img_to_path / image.name)
        shutil.copy(label, lbl_to_path / label.name)

Сохранить записи (опционально)

При необходимости вы можете сохранить записи K-Fold разбиения и DataFrames распределения меток в виде CSV-файлов для дальнейшего использования.

folds_df.to_csv(save_path / "kfold_datasplit.csv")
fold_lbl_distrb.to_csv(save_path / "kfold_label_distribution.csv")

Обучение YOLO с использованием K-Fold разбиений данных

  1. Сначала загрузите модель YOLO.

    from ultralytics import YOLO

weights_path = "path/to/weights.pt"  # use yolo11n.pt for a small model
model = YOLO(weights_path, task="detect")

  2. Далее, выполните итерацию по YAML-файлам набора данных для запуска обучения. Результаты будут сохранены в каталоге, указанном в project и name аргументы. По умолчанию, этот каталог имеет вид 'runs/detect/train#', где # — целочисленный индекс.

    results = {}

# Define your additional arguments here
batch = 16
project = "kfold_demo"
epochs = 100

for k, dataset_yaml in enumerate(ds_yamls):
    model = YOLO(weights_path, task="detect")
    results[k] = model.train(
        data=dataset_yaml, epochs=epochs, batch=batch, project=project, name=f"fold_{k + 1}"
    )  # include any additional train arguments

  3. Вы также можете использовать функцию Ultralytics data.utils.autosplit для автоматического разделения набора данных:

    from ultralytics.data.split import autosplit

# Automatically split dataset into train/val/test
autosplit(path="path/to/images", weights=(0.8, 0.2, 0.0), annotated_only=True)

Заключение

В этом руководстве мы изучили процесс использования перекрестной проверки K-Fold для обучения модели обнаружения объектов YOLO. Мы узнали, как разделить наш набор данных на K разделов, обеспечив сбалансированное распределение классов по различным складкам.

Мы также изучили процедуру создания отчетов DataFrames для визуализации разделения данных и распределения меток по этим разделениям, что дало нам четкое представление о структуре наших наборов для обучения и проверки.

При необходимости мы сохранили наши записи для дальнейшего использования, что может быть особенно полезно в масштабных проектах или при устранении неполадок в работе модели.

Наконец, мы реализовали фактическое обучение модели, используя каждый сплит в цикле, сохраняя результаты обучения для дальнейшего анализа и сравнения.

Этот метод перекрестной проверки K-Fold - надежный способ максимально эффективно использовать имеющиеся данные, и он помогает обеспечить надежность и согласованность производительности вашей модели в различных подмножествах данных. Это приводит к созданию более обобщаемой и надежной модели, которая с меньшей вероятностью будет переобучена для конкретных шаблонов данных.

Помните, что, хотя в этом руководстве мы использовали YOLO, эти шаги в основном применимы и к другим моделям машинного обучения. Понимание этих шагов позволит вам эффективно применять перекрестную проверку в ваших собственных проектах машинного обучения. Удачи в программировании!

Часто задаваемые вопросы

Что такое K-Fold Cross Validation и почему она полезна в обнаружении объектов?

Перекрестная проверка K-Fold — это метод, при котором набор данных делится на «k» подмножеств (фолдов) для более надежной оценки производительности модели. Каждый фолд служит как обучающими, так и проверочными данными. В контексте обнаружения объектов использование перекрестной проверки K-Fold помогает обеспечить надежность и обобщаемость вашей модели Ultralytics YOLO для различных разделений данных, повышая ее надежность. Подробные инструкции по настройке перекрестной проверки K-Fold с помощью Ultralytics YOLO см. в разделе Перекрестная проверка K-Fold с помощью Ultralytics.

Как реализовать перекрестную проверку K-Fold с использованием Ultralytics YOLO?

Чтобы реализовать перекрестную проверку K-Fold с Ultralytics YOLO, вам необходимо выполнить следующие шаги:

  1. Убедитесь, что аннотации находятся в формате обнаружения YOLO.
  2. Используйте такие библиотеки Python, как sklearn, pandasи pyyaml.
  3. Создайте векторы признаков из вашего набора данных.
  4. Разделите свой набор данных, используя KFold из sklearn.model_selection.
  5. Обучите модель YOLO на каждом разбиении.

Подробное руководство можно найти в разделе Разделение набора данных K-Fold в нашей документации.

Почему мне следует использовать Ultralytics YOLO для обнаружения объектов?

Ultralytics YOLO предлагает современное обнаружение объектов в реальном времени с высокой точностью и эффективностью. Он универсален и поддерживает множество задач компьютерного зрения, таких как обнаружение, сегментация и классификация. Кроме того, он легко интегрируется с такими инструментами, как Ultralytics HUB для обучения и развертывания моделей без кода. Для получения более подробной информации ознакомьтесь с преимуществами и функциями на нашей странице Ultralytics YOLO.

Как я могу убедиться, что мои аннотации находятся в правильном формате для Ultralytics YOLO?

Ваши аннотации должны соответствовать формату обнаружения YOLO. Каждый файл аннотаций должен содержать список классов объектов, а также координаты ограничивающего прямоугольника на изображении. Формат YOLO обеспечивает оптимизированную и стандартизированную обработку данных для обучения моделей обнаружения объектов. Для получения дополнительной информации о правильном форматировании аннотаций посетите руководство по формату обнаружения YOLO.

Могу ли я использовать перекрестную проверку K-Fold с пользовательскими наборами данных, отличными от Fruit Detection?

Да, вы можете использовать перекрестную проверку K-Fold с любым пользовательским набором данных, если аннотации находятся в формате обнаружения YOLO. Замените пути к набору данных и метки классов на те, которые специфичны для вашего пользовательского набора данных. Эта гибкость гарантирует, что любой проект обнаружения объектов может извлечь выгоду из надежной оценки модели с использованием перекрестной проверки K-Fold. Для практического примера ознакомьтесь с нашим разделом Создание векторов признаков.



📅 Создано 1 год назад ✏️ Обновлено 19 дней назад
glenn-jocher RizwanMunawar ambitious-octopus Y-T-G willie.maddox@gmail.com Burhan-Q M-Amrollahi IvorZhu331

Комментарии