Validación cruzada K-Fold con Ultralytics#

Introducción#

Esta guía completa explica cómo implementar la validación cruzada K-Fold en conjuntos de datos de detección de objetos dentro del ecosistema Ultralytics. Usaremos el formato de detección YOLO y bibliotecas clave de Python como sklearn, pandas y PyYAML para guiarte en la configuración necesaria, el proceso de generación de vectores de características y la creación de una partición K-Fold del conjunto de datos.

Tanto si tu proyecto utiliza el conjunto de datos Fruit Detection como una fuente de datos personalizada, este tutorial te ayudará a comprender y aplicar la validación cruzada K-Fold para mejorar la fiabilidad y la robustez de tus modelos de aprendizaje automático. En este tutorial aplicamos k=5 particiones, pero ten en cuenta que el número óptimo de particiones puede variar según tu conjunto de datos y las características de tu proyecto. La validación cruzada K-Fold aporta más valor cuando el conjunto de datos es pequeño, ruidoso o muy variable; para conjuntos de datos grandes y diversos, suele bastar con una partición train/val/test bien diseñada.

Empecemos.

Configuración#

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

• Esta guía presupone que los archivos de anotaciones están disponibles localmente.

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

  • Este conjunto de datos contiene un total de 8479 imágenes.
  • Incluye 6 etiquetas de clase, cuyos recuentos totales de instancias se indican a continuación.

• Los paquetes de Python necesarios son:

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• En este tutorial se trabaja con k=5 particiones. Sin embargo, debes determinar el número de particiones más adecuado para tu conjunto de datos.

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

   • La biblioteca Ultralytics: pip install -U ultralytics. También puedes clonar el repositorio oficial.
   • Scikit-learn, pandas y PyYAML: pip install -U scikit-learn pandas pyyaml.

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

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

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

1. Empieza creando un nuevo archivo de Python example.py para seguir los pasos que se indican a continuación.

2. Carga las imágenes de entrenamiento y validación configuradas mediante el propietario del conjunto de datos del paquete, sin modificar la partición de prueba.

   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. A continuación, 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 pandas vacío.

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

5. Cuenta las instancias de cada etiqueta de clase presentes en los archivos de anotaciones.

   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. A continuación se muestra un ejemplo del DataFrame con datos:

                                                          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 absolutas de imágenes y las columnas corresponden a los índices de las etiquetas de clase. Las etiquetas ausentes se representan mediante filas con ceros en todas las columnas. Esta estructura de datos permite aplicar la validación cruzada K-Fold a un conjunto de datos de detección de objetos.

Partición K-Fold del conjunto de datos#

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

   • Importante:
     • Al establecer shuffle=True, se garantiza una distribución aleatoria de las clases en las particiones.
     • Si estableces random_state=M con M como un entero elegido, obtendrás resultados reproducibles.

   from sklearn.model_selection import KFold
   
   ksplit = 5
   kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)  # establecer random_state para obtener resultados reproducibles
   
   kfolds = list(kf.split(labels_df))

2. El conjunto de datos ya está dividido en k particiones, cada una con una lista de índices train y val. Crearemos un DataFrame para mostrar estos resultados con más 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 de cada partición como la proporción entre las clases presentes en val y 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

   Lo ideal es que las proporciones de todas las clases sean razonablemente similares en cada partición y entre las distintas clases. Sin embargo, esto dependerá de las características de tu conjunto de datos.

4. Escribe listas de imágenes y un YAML del conjunto de datos para cada partició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)#

Si quieres, puedes guardar como archivos CSV los registros de la partición K-Fold y los DataFrames de distribución de etiquetas para consultarlos más adelante.

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

Entrenar YOLO con particiones de datos K-Fold#

1. Primero, carga el modelo YOLO.

   from ultralytics import YOLO
   
   weights_path = "path/to/weights.pt"  # usa yolo26n.pt para un modelo pequeño
   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 el 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 usar la función Ultralytics data.split.autosplit para dividir automáticamente el conjunto de datos:

   from ultralytics.data.split import autosplit
   
   # Dividir automáticamente el conjunto de datos en 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 explicado cómo usar la validación cruzada K-Fold para entrenar el modelo YOLO de detección de objetos. Hemos aprendido a dividir el conjunto de entrenamiento y validación en K particiones y a utilizar la tabla de proporciones generada para analizar el equilibrio entre clases después de la división aleatoria.

También hemos explicado cómo crear DataFrames de informes para visualizar las particiones de datos y la distribución de etiquetas entre ellas, lo que nos permite comprender claramente la estructura de los conjuntos de entrenamiento y validación.

De forma opcional, hemos guardado nuestros registros para consultarlos más adelante, algo que puede resultar especialmente útil en proyectos a gran escala o al investigar problemas de rendimiento del modelo.

Por último, hemos implementado el entrenamiento del modelo propiamente dicho mediante un bucle que utiliza cada partición y guarda los resultados del entrenamiento para analizarlos y compararlos más adelante.

Esta técnica de validación cruzada K-Fold permite aprovechar al máximo los datos disponibles y ayuda a garantizar que el rendimiento del modelo sea fiable y uniforme en distintos subconjuntos de datos. Así se obtiene un modelo más generalizable y fiable, con menos probabilidades de sobreajustarse a patrones de datos concretos.

Ten en cuenta que, aunque en esta guía hemos usado YOLO, estos pasos se pueden aplicar en gran medida a otros modelos de aprendizaje automático. Si los comprendes, podrás aplicar la validación cruzada con eficacia en tus propios proyectos de aprendizaje automático.

Preguntas frecuentes#