Entrena YOLOv5 con datos personalizados#

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

Antes de empezar#

Primero, asegúrate de que el entorno necesario está configurado. Clona el repositorio de YOLOv5 e instala las dependencias necesarias desde requirements.txt. Es imprescindible contar con un entorno de Python>=3.8.0 y PyTorch>=1.8. Los modelos y conjuntos de datos se descargan automáticamente desde la versión más reciente 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

Entrena con datos personalizados#

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

1. Recopila y organiza imágenes: reúne imágenes relevantes para tu tarea específica. Los datos diversos y de alta calidad son fundamentales. Consulta nuestra guía sobre Recopilación y anotación de datos.
2. Etiqueta objetos: anota con precisión los objetos de interés que aparezcan en tus imágenes.
3. Entrena un modelo: usa los datos etiquetados para entrenar tu modelo YOLOv5. Aprovecha el aprendizaje por transferencia empezando con pesos preentrenados.
4. Despliega y predice: utiliza el modelo entrenado para realizar inferencias sobre datos nuevos que no haya visto.
5. Recopila casos límite: identifica las situaciones en las que el modelo tiene un rendimiento deficiente (casos límite) y añade datos similares a tu conjunto de datos para mejorar su robustez. Repite el ciclo.

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

Antes de iniciar el entrenamiento, es esencial preparar el conjunto de datos.

1. Crea un conjunto de datos#

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

1.1 Crea dataset.yaml#

El archivo de configuración del conjunto de datos (por ejemplo, coco128.yaml) describe 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 compuesto por las primeras 128 imágenes del extenso conjunto de datos COCO. Es útil para probar rápidamente la canalización de entrenamiento y diagnosticar posibles problemas, 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 directorios que contienen imágenes o archivos de texto con las rutas de las imágenes de los conjuntos de entrenamiento, validación y prueba.
• names: un diccionario que asigna los índices de clase (a partir de 0) a sus nombres de clase correspondientes.

Puedes establecer 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 método habitual, pero requiere mucho tiempo. Los modelos fundacionales pueden automatizar o semiautomatizar la anotación y acelerar la creación de conjuntos de datos. Algunos modelos que pueden ayudar a generar etiquetas son:

• Google Gemini: los grandes modelos multimodales como Gemini tienen potentes capacidades de comprensión de imágenes. Puedes pedirles que identifiquen y localicen objetos dentro de las imágenes, generando BBox o descripciones que puedan convertirse en etiquetas con formato YOLO. Explora su potencial en el cuaderno del tutorial proporcionado.
• SAM2 (Modelo Segment Anything 2): los modelos fundacionales centrados en la segmentación, como SAM2, pueden identificar y delimitar objetos con gran precisión. Aunque se utilizan principalmente para la segmentación, las máscaras resultantes suelen poder convertirse en anotaciones de BBox adecuadas para tareas de detección de objetos.
• YOLOWorld: este modelo ofrece capacidades de detección con vocabulario abierto. Puedes proporcionar descripciones de texto de los objetos que te interesan y YOLOWorld puede localizarlos en imágenes sin haber sido entrenado previamente con esas clases específicas. Esto puede servir como punto de partida para generar etiquetas iniciales que después se pueden perfeccionar.

El uso de estos modelos puede proporcionar un paso de «preetiquetado» y reducir el esfuerzo manual necesario. Sin embargo, es fundamental revisar y perfeccionar las etiquetas generadas automáticamente para garantizar su precisión y coherencia, ya que su calidad afecta directamente al rendimiento de tu modelo YOLOv5 entrenado. Después de generar (y, posiblemente, perfeccionar) las etiquetas, asegúrate de que cumplen 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 contiene objetos de interés, no se necesita ningún archivo *.txt correspondiente.

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

• Una fila por objeto de Bbox.
• Cada fila debe contener: class_index x_center y_center width height.
• Las coordenadas deben estar normalizadas en un intervalo entre 0 y 1. Para ello, divide los valores de píxel 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 clase empiezan en cero (es decir, la primera clase se representa mediante 0, la segunda mediante 1, y así sucesivamente).

El archivo de etiquetas correspondiente a la imagen anterior, que contiene dos objetos «person» (índice de clase 0) y un objeto «tie» (índice de clase 27), tendría este aspecto:

1.3 Organiza los directorios#

Estructura el directorio de tus conjuntos de datos como se muestra a continuación. De forma predeterminada, YOLOv5 espera que el directorio del conjunto de datos (por ejemplo, /coco128) se encuentre dentro de una carpeta /datasets situada junto al directorio del repositorio /yolov5.

YOLOv5 localiza automáticamente las etiquetas de cada imagen sustituyendo la última aparición 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)
            └── ...

2. Selecciona un modelo#

Elige un modelo preentrenado para iniciar el proceso de entrenamiento. Empezar con pesos preentrenados acelera considerablemente el aprendizaje y mejora el rendimiento frente al entrenamiento desde cero. YOLOv5 ofrece varios tamaños de modelo, cada uno con un equilibrio diferente entre velocidad y precisión. 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 comparar detalladamente todos los modelos disponibles.

3. Entrena#

Inicia el entrenamiento del modelo usando el script train.py. Entre los argumentos esenciales se incluyen:

• --img: define el tamaño de imagen de entrada (por ejemplo, --img 640). Los tamaños mayores suelen ofrecer una precisión superior, 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 al archivo dataset.yaml (por ejemplo, --data coco128.yaml).
• --weights: ruta al archivo de pesos iniciales. Se recomienda encarecidamente usar pesos preentrenados (por ejemplo, --weights yolov5s.pt) para lograr una convergencia más rápida y mejores resultados. Para entrenar desde cero (no recomendado a menos que tengas un conjunto de datos muy grande y necesidades específicas), usa --weights '' --cfg yolov5s.yaml.

Los pesos preentrenados se descargan automáticamente desde la versión más reciente 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 del entrenamiento, incluidos los pesos y los registros, se guardan en el directorio runs/train/. Cada sesión de entrenamiento crea un subdirectorio nuevo (por ejemplo, runs/train/exp, runs/train/exp2, etc.). Para disfrutar de una experiencia práctica e interactiva, explora la sección de entrenamiento en nuestros notebooks oficiales del tutorial:

4. Visualiza#

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

Registro y visualización con Comet#

Comet está totalmente integrado para realizar un seguimiento exhaustivo de los experimentos. Visualiza las métricas en directo, guarda los hiperparámetros, gestiona los conjuntos de datos y los puntos de control de los modelos, y analiza las predicciones de los modelos mediante paneles personalizados de Comet interactivos.

Empezar es muy 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 funciones compatibles en nuestra guía de integración de Comet. Descubre más información sobre las capacidades de Comet en su documentación oficial. Prueba el cuaderno de Comet en Colab para ver una demostración en directo:

Registro y automatización con ClearML#

La integración con ClearML permite realizar un seguimiento detallado de los experimentos, gestionar las versiones de los conjuntos de datos e incluso ejecutar entrenamientos de forma remota. 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 (autoalojado o del nivel gratuito).

ClearML captura automáticamente los detalles de los experimentos, las cargas de modelos, las comparaciones, los cambios de código sin confirmar y los paquetes instalados, garantizando una reproducibilidad completa. Puedes programar fácilmente tareas de entrenamiento en agentes remotos y gestionar versiones de conjuntos de datos mediante ClearML Data. Consulta la guía de integración de ClearML para obtener información detallada.

Registro local#

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

• Pérdida y métricas de rendimiento del entrenamiento y la validación.
• Imágenes de muestra que muestran las aumentaciones aplicadas (como mosaicos).
• Etiquetas de referencia junto con las predicciones del modelo para su inspección visual.
• Métricas de evaluación clave, como las curvas de precisión-exhaustividad (PR).
• Matrices de confusión para analizar detalladamente el rendimiento de cada clase.

El archivo results.csv se actualiza después de cada época y se representa como results.png una vez finalizado el entrenamiento. También puedes representar manualmente cualquier archivo results.csv mediante 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

5. Próximos pasos#

Una vez completado correctamente el entrenamiento, el punto de control del modelo con mejor rendimiento (best.pt) se guarda y está listo para su despliegue o posterior perfeccionamiento. Entre los siguientes pasos posibles se incluyen:

• Realiza inferencias sobre imágenes o vídeos nuevos usando el modelo entrenado mediante la CLI o Python.
• Realiza la validación para evaluar la precisión y la capacidad de generalización del modelo con distintas particiones de datos (por ejemplo, un conjunto de prueba reservado).
• Exporta el modelo a varios formatos de despliegue, como ONNX, TensorFlow SavedModel o TensorRT, para realizar inferencias optimizadas en diversas plataformas.
• Emplea técnicas de ajuste de hiperparámetros para intentar obtener mejoras de rendimiento adicionales.
• Sigue mejorando tu modelo con nuestros Consejos para obtener los mejores resultados de entrenamiento y añade iterativamente datos más diversos y exigentes basándote en el análisis del rendimiento.

Entornos compatibles#

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

• 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#

Esta insignia indica que todas las pruebas de Integración continua (CI) de GitHub Actions de YOLOv5 se superan correctamente. Estas rigurosas pruebas de CI cubren las funcionalidades principales, incluido el entrenamiento, la validación, la inferencia, la exportación y las evaluaciones comparativas, en los sistemas operativos macOS, Windows y Ubuntu. Las pruebas se ejecutan automáticamente cada 24 horas y con cada confirmación de código, lo que garantiza una estabilidad constante y un rendimiento óptimo.

Preguntas frecuentes#