Entrena YOLOv5 con datos personalizados#

📚 Esta guía explica cómo entrenar tu propio conjunto de datos personalizado utilizando el modelo YOLOv5 🚀. El entrenamiento de modelos personalizados es un paso fundamental para adaptar las soluciones de visión artificial a aplicaciones específicas del mundo más allá de la detección de objetos genérica.

Antes de empezar#

Primero, asegúrate de tener configurado el entorno necesario. Clona el repositorio de YOLOv5 e instala las dependencias requeridas desde requirements.txt. Un entorno con Python>=3.8.0 y PyTorch>=1.8 es esencial. Los modelos y conjuntos de datos se descargan automáticamente de la última versión de YOLOv5 si no se encuentran localmente.

git clone https://github.com/ultralytics/yolov5 # Clone the repository
cd yolov5
pip install -r requirements.txt # Install dependencies

Entrenar con datos personalizados#

Desarrollar un modelo de detección de objetos personalizado es un proceso iterativo:

1. Recopilar y organizar imágenes: Reúne imágenes relevantes para tu tarea específica. Los datos diversos y de alta calidad son cruciales. Consulta nuestra guía sobre Recopilación de datos y anotación.
2. Etiqueta objetos: anota con precisión los objetos de interés dentro de tus imágenes.
3. Entrenar un modelo: Utiliza los datos etiquetados para entrenar tu modelo YOLOv5. Aprovecha el aprendizaje por transferencia comenzando con pesos preentrenados.
4. Desplegar y predecir: Utiliza el modelo entrenado para la inferencia en datos nuevos y no vistos.
5. Recopilar casos límite: Identifica escenarios en los que el modelo funcione mal (casos límite) y añade datos similares a tu conjunto de datos para mejorar la solidez. Repite el ciclo.

Ultralytics Platform ofrece una solución optimizada y sin código para todo este ciclo de operaciones de aprendizaje automático (MLOps), incluida la gestión de conjuntos de datos, el entrenamiento de modelos y el despliegue.

Antes de iniciar el entrenamiento, la preparación del conjunto de datos es esencial.

Crea un conjunto de datos#

Los modelos YOLOv5 requieren datos etiquetados para aprender las características visuales de las clases de objetos. Organizar tu conjunto de datos correctamente es clave.

1.1 Crear dataset.yaml#

El archivo de configuración del conjunto de datos (por ejemplo, coco128.yaml) detalla la estructura del conjunto de datos, los nombres de las clases y las rutas a los directorios de imágenes. COCO128 sirve como un pequeño conjunto de datos de ejemplo, que comprende las primeras 128 imágenes del extenso conjunto de datos COCO. Es útil para probar rápidamente la tubería de entrenamiento y diagnosticar problemas potenciales como el sobreajuste.

La estructura del archivo dataset.yaml incluye:

• path: El directorio raíz que contiene el conjunto de datos.
• train, val, test: Rutas relativas desde path a los directorios que contienen imágenes o archivos de texto que enumeran las rutas de las imágenes para los conjuntos de entrenamiento, validación y prueba.
• names: Un diccionario que mapea los índices de las clases (empezando desde 0) con sus nombres de clase correspondientes.

Puedes configurar path como un directorio absoluto (por ejemplo, /home/user/datasets/coco128) o como una ruta relativa como ../datasets/coco128 al iniciar el entrenamiento desde la raíz del repositorio de YOLOv5.

A continuación se muestra la estructura de coco128.yaml (ver en GitHub):

# Dataset root directory relative to the yolov5 directory
path: coco128

# Train/val/test sets: specify directories, *.txt files, or lists
train: images/train2017 # 128 images for training
val: images/train2017 # 128 images for validation
test: # Optional path to test images

# Classes (example using 80 COCO classes)
names:
    0: person
    1: bicycle
    2: car
    # ... (remaining COCO classes)
    77: teddy bear
    78: hair drier
    79: toothbrush

1.2 Aprovecha los modelos para el etiquetado automatizado#

El etiquetado manual es el enfoque habitual, pero consume mucho tiempo. Los modelos base pueden automatizar o semiautomatizar la anotación y acelerar la creación del conjunto de datos. Ejemplos de modelos que pueden ayudar a generar etiquetas:

• Google Gemini: Los modelos multimodales grandes como Gemini poseen potentes capacidades de comprensión de imágenes. Se les puede pedir que identifiquen y ubiquen objetos dentro de las imágenes, generando cuadros delimitadores o descripciones que se pueden convertir en etiquetas con el formato YOLO. Explora su potencial en el cuaderno de tutorial proporcionado.
• SAM2 (Segment Anything Model 2): Los modelos base centrados en la segmentación, como SAM2, pueden identificar y delinear objetos con gran precisión. Aunque están destinados principalmente a la segmentación, las máscaras resultantes a menudo se pueden convertir en anotaciones de cuadros delimitadores adecuadas para tareas de detección de objetos.
• YOLOWorld: Este modelo ofrece capacidades de detección de vocabulario abierto. Puedes proporcionar descripciones de texto de los objetos que te interesan, y YOLOWorld puede localizarlos en las imágenes sin un entrenamiento previo en esas clases específicas. Esto se puede utilizar como punto de partida para generar etiquetas iniciales, que luego se pueden refinar.

El uso de estos modelos puede proporcionar un paso de «pre-etiquetado», reduciendo el esfuerzo manual requerido. Sin embargo, es fundamental revisar y refinar las etiquetas generadas automáticamente para garantizar la precisión y la consistencia, ya que la calidad afecta directamente al rendimiento de tu modelo YOLOv5 entrenado. Después de generar (y posiblemente refinar) tus etiquetas, asegúrate de que cumplan con el formato YOLO: un archivo *.txt por imagen, donde cada línea representa un objeto como class_index x_center y_center width height (coordenadas normalizadas, clase indexada desde cero). Si una imagen no tiene objetos de interés, no se necesita ningún archivo *.txt correspondiente.

Las especificaciones del archivo con el formato YOLO *.txt son precisas:

• Una fila por cada cuadro delimitador de objeto.
• Cada fila debe contener: class_index x_center y_center width height.
• Las coordenadas deben estar normalizadas a un rango entre 0 y 1. Para lograr esto, divide los valores de píxeles de x_center y width por el ancho total de la imagen, y divide y_center y height por la altura total de la imagen.
• Los índices de las clases están indexados desde cero (es decir, la primera clase está representada por 0, la segunda por 1, y así sucesivamente).

El archivo de etiquetas correspondiente a la imagen anterior, que contiene dos objetos 'persona' (índice de clase 0) y un objeto 'corbata' (índice de clase 27), se vería así:

1.3 Organiza los directorios#

Estructura tu directorio de conjuntos de datos como se ilustra a continuación. De forma predeterminada, YOLOv5 anticipa que el directorio del conjunto de datos (por ejemplo, /coco128) resida dentro de una carpeta /datasets ubicada junto al directorio del repositorio /yolov5.

YOLOv5 localiza automáticamente las etiquetas de cada imagen sustituyendo la última instancia de /images/ en la ruta de la imagen por /labels/. Por ejemplo:

../datasets/coco128/images/im0.jpg # Path to the image file
../datasets/coco128/labels/im0.txt # Path to the corresponding label file

La estructura de directorios recomendada es:

/datasets/
└── coco128/  # Dataset root
    ├── images/
    │   ├── train2017/  # Training images
    │   │   ├── 000000000009.jpg
    │   │   └── ...
    │   └── val2017/    # Validation images (optional if using same set for train/val)
    │       └── ...
    └── labels/
        ├── train2017/  # Training labels
        │   ├── 000000000009.txt
        │   └── ...
        └── val2017/    # Validation labels (optional if using same set for train/val)
            └── ...

Selecciona un modelo#

Elige un modelo preentrenado para iniciar el proceso de entrenamiento. Comenzar con pesos preentrenados acelera significativamente el aprendizaje y mejora el rendimiento en comparación con entrenar desde cero. YOLOv5 ofrece varios tamaños de modelo, cada uno equilibrando la velocidad y la precisión de manera diferente. Por ejemplo, YOLOv5s es el segundo modelo más pequeño y rápido, adecuado para entornos con recursos limitados. Consulta la tabla del README para ver una comparación detallada de todos los modelos disponibles.

Entrena#

Comienza el entrenamiento del modelo utilizando el script train.py. Los argumentos esenciales incluyen:

• --img: Define el tamaño de imagen de entrada (por ejemplo, --img 640). Los tamaños más grandes generalmente producen una mejor precisión, pero requieren más memoria de la GPU.
• --batch: Determina el tamaño del lote (por ejemplo, --batch 16). Elige el tamaño más grande que tu GPU pueda manejar.
• --epochs: Especifica el número total de épocas de entrenamiento (por ejemplo, --epochs 100). Una época representa un recorrido completo por todo el conjunto de datos de entrenamiento.
• --data: Ruta a tu archivo dataset.yaml (por ejemplo, --data coco128.yaml).
• --weights: Ruta al archivo de pesos iniciales. Se recomienda encarecidamente utilizar pesos preentrenados (por ejemplo, --weights yolov5s.pt) para una convergencia más rápida y resultados superiores. Para entrenar desde cero (no aconsejado a menos que tengas un conjunto de datos muy grande y necesidades específicas), utiliza --weights '' --cfg yolov5s.yaml.

Los pesos preentrenados se descargan automáticamente de la última versión de YOLOv5 si no se encuentran localmente.

# Example: Train YOLOv5s on the COCO128 dataset for 3 epochs
python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt

Todos los resultados de entrenamiento, incluidos los pesos y los registros, se guardan en el directorio runs/train/. Cada sesión de entrenamiento crea un nuevo subdirectorio (por ejemplo, runs/train/exp, runs/train/exp2, etc.). Para una experiencia interactiva y práctica, explora la sección de entrenamiento en nuestros cuadernos de tutorial oficiales:

Visualiza#

YOLOv5 se integra perfectamente con varias herramientas para visualizar el progreso del entrenamiento, evaluar resultados y monitorear el rendimiento en tiempo real.

Registro y visualización con Comet#

Comet está totalmente integrado para un seguimiento completo de los experimentos. Visualiza métricas en directo, guarda hiperparámetros, gestiona conjuntos de datos y puntos de control de modelos, y analiza las predicciones del modelo utilizando los Paneles Personalizados de Comet interactivos.

Empezar es sencillo:

pip install comet_ml                                                          # 1. Install Comet library
export COMET_API_KEY=YOUR_API_KEY_HERE                                        # 2. Set your Comet API key (create a free account at Comet.ml)
python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt # 3. Train your model - Comet automatically logs everything!

Profundiza en las características compatibles en nuestra Guía de integración de Comet. Obtén más información sobre las capacidades de Comet en su documentación oficial. Prueba el cuaderno de Colab de Comet para ver una demostración en directo:

Registro y automatización con ClearML#

La integración de ClearML permite un seguimiento detallado de los experimentos, la gestión de versiones de conjuntos de datos e incluso la ejecución remota de ejecuciones de entrenamiento. Activa ClearML con estos sencillos pasos:

• Instala el paquete: pip install clearml
• Inicializa ClearML: Ejecuta clearml-init una vez para conectarte a tu servidor de ClearML (ya sea autohospedado o en el nivel gratuito).

ClearML captura automáticamente los detalles de los experimentos, las subidas de modelos, las comparaciones, los cambios de código no confirmados y los paquetes instalados, garantizando una total reproducibilidad. Puedes programar fácilmente tareas de entrenamiento en agentes remotos y gestionar versiones de conjuntos de datos utilizando ClearML Data. Explora la Guía de integración de ClearML para obtener detalles completos.

Registro local#

Los resultados del entrenamiento se registran automáticamente utilizando TensorBoard y se guardan como archivos CSV dentro del directorio de experimentos específico (por ejemplo, runs/train/exp). Los datos registrados incluyen:

• Métricas de pérdida y rendimiento de entrenamiento y validación.
• Imágenes de muestra que muestran las aumentaciones aplicadas (como mosaicos).
• Etiquetas de verdad fundamental junto con las predicciones del modelo para su inspección visual.
• Métricas clave de evaluación como las curvas de Precisión-Exhaustividad (PR).
• Matrices de confusión para un análisis detallado del rendimiento por clase.

El archivo results.csv se actualiza después de cada época y se grafica como results.png una vez que concluye el entrenamiento. También puedes graficar cualquier archivo results.csv manualmente utilizando la función de utilidad proporcionada:

from utils.plots import plot_results

# Plot results from a specific training run directory
plot_results("runs/train/exp/results.csv")  # This will generate 'results.png' in the same directory

Pasos siguientes#

Una vez finalizado con éxito el entrenamiento, el punto de control del modelo con mejor rendimiento (best.pt) se guarda y está listo para su despliegue o refinamiento adicional. Los posibles pasos siguientes incluyen:

• Ejecutar la inferencia en nuevas imágenes o vídeos utilizando el modelo entrenado a través de la CLI o Python.
• Realizar la validación para evaluar la precisión del modelo y sus capacidades de generalización en diferentes divisiones de datos (por ejemplo, un conjunto de prueba reservado).
• Exportar el modelo a varios formatos de despliegue como ONNX, TensorFlow SavedModel o TensorRT para una inferencia optimizada en diversas plataformas.
• Emplear técnicas de ajuste de hiperparámetros para exprimir potencialmente ganancias de rendimiento adicionales.
• Continúa mejorando tu modelo siguiendo nuestros Consejos para obtener los mejores resultados de entrenamiento y añadiendo iterativamente datos más diversos y desafiantes basados en el análisis de rendimiento.

Entornos admitidos#

Ultralytics proporciona entornos listos para usar equipados con dependencias esenciales como CUDA, cuDNN, Python y PyTorch, lo que facilita un inicio sin contratiempos.

• Cuadernos de GPU gratuitos:
  • 
  • 
  • 
• Plataformas en la nube:
  • Google Cloud: Guía de inicio rápido de GCP
  • Amazon AWS: Guía de inicio rápido de AWS
  • Microsoft Azure: Guía de inicio rápido de AzureML
• Configuración local:
  • Docker: Guía de inicio rápido de Docker

Estado del proyecto#

Este distintivo indica que todas las pruebas de Continuous Integration (CI) de GitHub Actions de YOLOv5 se están superando con éxito. Estas rigurosas pruebas de CI cubren las funcionalidades principales, incluyendo el entrenamiento, la validación, la inferencia, la exportación y los rendimientos de referencia, en los sistemas operativos macOS, Windows y Ubuntu. Las pruebas se ejecutan automáticamente cada 24 horas y en cada confirmación de código, lo que garantiza una estabilidad constante y un rendimiento óptimo.

FAQ#