Validación cruzada K-Fold con Ultralytics#

Introducción#

Esta guía completa ilustra la implementación de la validación cruzada K-Fold para conjuntos de datos de detección de objetos dentro del ecosistema de Ultralytics. Aprovecharemos el formato de detección de YOLO y bibliotecas clave de Python como sklearn, pandas y PyYAML para guiarte a través de la configuración necesaria, el proceso de generación de vectores de características y la ejecución de una división del conjunto de datos mediante K-Fold.

Tanto si tu proyecto utiliza el conjunto de datos Fruit Detection como una fuente de datos personalizada, este tutorial pretende ayudarte a comprender y aplicar la validación cruzada K-Fold para reforzar la fiabilidad y solidez de tus modelos de machine learning. Aunque para este tutorial aplicamos k=5 pliegues, ten en cuenta que el número óptimo de pliegues puede variar según tu conjunto de datos y las especificidades de tu proyecto. La validación cruzada K-Fold aporta el máximo valor cuando tu conjunto de datos es pequeño, ruidoso o muy variable; para conjuntos de datos grandes y diversos, una división de entrenamiento/validación/prueba bien construida suele ser suficiente.

Empecemos.

Configuración#

• Tus anotaciones deben estar en el formato de detección de YOLO.

• Esta guía asume que los archivos de anotación están disponibles localmente.

• Para nuestra demostración, utilizamos el conjunto de datos Fruit Detection.

  • Este conjunto de datos contiene un total de 8479 imágenes.
  • Incluye 6 etiquetas de clase, cada una con sus recuentos totales de instancias listados a continuación.

• Los paquetes de Python necesarios incluyen:

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• Este tutorial funciona con k=5 particiones (folds). Sin embargo, debes determinar el mejor número de particiones para tu conjunto de datos específico.

1. Inicia un nuevo entorno virtual de Python (venv) para tu proyecto y actívalo. Utiliza pip (o tu gestor de paquetes preferido) para instalar:

   • La biblioteca de Ultralytics: pip install -U ultralytics. De forma alternativa, puedes clonar el repositorio oficial.
   • Scikit-learn, pandas y PyYAML: pip install -U scikit-learn pandas pyyaml.

2. Verifica que tus anotaciones estén en el formato de detección de YOLO.

   • Para este tutorial, todos los archivos de anotaciones se encuentran en el directorio Fruit-Detection/labels.

Generación de vectores de características para conjuntos de datos de detección de objetos#

1. Empieza creando un nuevo archivo de Python example.py para los pasos siguientes.

2. Carga las imágenes de entrenamiento y validación configuradas a través del propietario del conjunto de datos del paquete, dejando intacta la división de pruebas.

   from pathlib import Path
   
   from ultralytics.data.dataset import YOLODataset
   from ultralytics.data.utils import check_det_dataset
   
   yaml_file = "path/to/data.yaml"
   data = check_det_dataset(yaml_file)
   dataset_path = Path(data["path"])
   sources = []
   for split in ("train", "val"):
       source = data.get(split)
       if source:
           sources.extend(source if isinstance(source, list) else [source])
   dataset = YOLODataset(sources, data=data, augment=False)
   images = [Path(p) for p in dataset.im_files]

3. Ahora, lee el contenido del archivo YAML del conjunto de datos y extrae los índices de las etiquetas de clase.

   classes = data["names"]
   cls_idx = sorted(classes.keys())

4. Inicializa un DataFrame vacío de pandas.

   import pandas as pd
   
   labels_df = pd.DataFrame(0.0, columns=cls_idx, index=images)

5. Cuenta las instancias de cada etiqueta de clase presente en los archivos de anotación.

   from collections import Counter
   
   for image, label in zip(images, dataset.labels):
       lbl_counter = Counter(label["cls"].flatten().astype(int))
       labels_df.loc[image, list(lbl_counter)] = list(lbl_counter.values())

6. La siguiente es una vista de muestra del DataFrame completado:

                                                          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

Las filas usan rutas de imagen absolutas y las columnas corresponden a índices de etiquetas de clase. Las etiquetas faltantes siguen siendo filas de fondo con todos ceros. Esta estructura de datos permite la aplicación de K-Fold Cross Validation a un conjunto de datos de detección de objetos.

División del conjunto de datos con K-Fold#

1. Ahora utilizaremos la clase KFold de sklearn.model_selection para generar k particiones del conjunto de datos.

   • Importante:
     • Establecer shuffle=True garantiza una distribución aleatoria de las clases en tus particiones.
     • Al establecer random_state=M donde M es un número entero seleccionado, puedes obtener resultados repetibles.

   from sklearn.model_selection import KFold
   
   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. El conjunto de datos se ha dividido ahora en k particiones, cada una con una lista de índices train y val. Construiremos un DataFrame para mostrar estos resultados con mayor claridad.

   folds = [f"split_{n}" for n in range(1, ksplit + 1)]
   folds_df = pd.DataFrame(index=labels_df.index, columns=folds)
   
   for i, (train, val) in enumerate(kfolds, start=1):
       folds_df.loc[labels_df.index[train], f"split_{i}"] = "train"
       folds_df.loc[labels_df.index[val], f"split_{i}"] = "val"

3. Ahora calcularemos la distribución de las etiquetas de clase para cada partición como una proporción de las clases presentes en val frente a las presentes en 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

   El escenario ideal es que todas las proporciones de clase sean razonablemente similares para cada división y entre clases. Esto, sin embargo, estará sujeto a las particularidades de tu conjunto de datos.

4. Escribe listas de imágenes y un archivo YAML de conjunto de datos para cada división. Las listas de texto evitan copiar el conjunto de datos k veces.

   import yaml
   
   save_path = dataset_path.parent / f"{ksplit}-Fold_Cross-val"
   save_path.mkdir(parents=True, exist_ok=True)
   ds_yamls = []
   
   for split in folds_df.columns:
       for partition in ("train", "val"):
           split_images = folds_df.index[folds_df[split] == partition]
           paths = "\n".join(map(str, split_images))
           (save_path / f"{split}_{partition}.txt").write_text(f"{paths}\n")
   
       dataset_yaml = save_path / f"{split}.yaml"
       ds_yamls.append(dataset_yaml)
       with open(dataset_yaml, "w") as ds_y:
           yaml.safe_dump(
               {
                   "path": save_path.as_posix(),
                   "train": f"{split}_train.txt",
                   "val": f"{split}_val.txt",
                   "names": classes,
               },
               ds_y,
           )

Guardar registros (Opcional)#

Opcionalmente, puedes guardar los registros de la división K-Fold y los DataFrames de distribución de etiquetas como archivos CSV para futuras referencias.

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

Entrenar YOLO usando divisiones de datos K-Fold#

1. Primero, carga el modelo YOLO.

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

2. A continuación, recorre los archivos YAML del conjunto de datos para ejecutar el entrenamiento. Los resultados se guardarán en un directorio especificado por los argumentos project y name. De forma predeterminada, este directorio es 'runs/detect/train#' donde # es un índice entero.

   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. También puedes utilizar la función Ultralytics data.split.autosplit para la división automática del conjunto de datos:

   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)

Conclusión#

En esta guía, hemos explorado el proceso de usar validación cruzada K-Fold para entrenar el modelo de detección de objetos YOLO. Aprendimos a dividir el grupo de entrenamiento y validación en K particiones y a usar la tabla de proporciones generada para inspeccionar el equilibrio de clases después de la división aleatoria.

También exploramos el procedimiento para crear DataFrames de informe para visualizar las divisiones de datos y las distribuciones de etiquetas entre estas divisiones, brindándonos una visión clara de la estructura de nuestros conjuntos de entrenamiento y validación.

Opcionalmente, guardamos nuestros registros para futuras referencias, lo cual podría ser particularmente útil en proyectos a gran escala o al solucionar problemas de rendimiento del modelo.

Finalmente, implementamos el entrenamiento del modelo real usando cada división en un bucle, guardando nuestros resultados de entrenamiento para un análisis y comparación posteriores.

Esta técnica de validación cruzada K-Fold es una forma sólida de aprovechar al máximo los datos disponibles y ayuda a garantizar que el rendimiento de tu modelo sea fiable y coherente en diferentes subconjuntos de datos. Esto da como resultado un modelo más generalizable y fiable que es menos propenso al sobreajuste (overfitting) ante patrones de datos específicos.

Recuerda que, aunque usamos YOLO en esta guía, estos pasos son mayormente transferibles a otros modelos de aprendizaje automático. Entender estos pasos te permite aplicar la validación cruzada de manera efectiva en tus propios proyectos de aprendizaje automático.

FAQ#