Link to this sectionEntrena YOLOv5 con datos personalizados#

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

Link to this sectionAntes de empezar#

Primero, asegúrate de tener configurado el entorno necesario. Clona el repositorio de YOLOv5 e instala las dependencias necesarias desde requirements.txt. Es fundamental un entorno con Python>=3.8.0 y PyTorch>=1.8. Los modelos y conjuntos de datos se descargan automáticamente desde 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

Link to this sectionEntrenar con datos personalizados#

Desarrollar un modelo de detección de objetos personalizado 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 cruciales. Consulta nuestra guía sobre Recopilación y etiquetado de datos.
2. Etiqueta objetos: anota con precisión los objetos de interés dentro de tus imágenes.
3. Entrena un modelo: utiliza 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 y no vistos.
5. Recopila casos extremos: identifica los escenarios en los que el modelo tiene un rendimiento deficiente (casos extremos) y añade datos similares a tu conjunto de datos para mejorar la solidez. Repite el ciclo.

La plataforma Ultralytics ofrece una solución optimizada y sin código para todo este ciclo de operaciones de aprendizaje automático (MLOps), que incluye 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.

Link to this sectionCrea 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.

Link to this section1.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, que comprende las primeras 128 imágenes del extenso conjunto de datos COCO. Es útil para probar rápidamente el pipeline 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 los directorios que contienen imágenes o archivos de texto que listan las rutas de imágenes para los conjuntos de entrenamiento, validación y prueba.
• names: un diccionario que asigna índices de clase (empezando desde 0) a sus nombres de clase correspondientes.

Puedes establecer path a un directorio absoluto (por ejemplo, /home/user/datasets/coco128) o a 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

Link to this section1.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 grandes modelos multimodales como Gemini poseen capacidades de comprensión de imágenes potentes. Se les puede pedir que identifiquen y localicen objetos dentro de las imágenes, generando cuadros delimitadores o descripciones que pueden convertirse en etiquetas con 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 alta precisión. Aunque se utilizan principalmente para 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 imágenes sin entrenamiento previo en esas clases específicas. Esto se puede utilizar como punto de partida para generar etiquetas iniciales, que luego pueden refinarse.

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

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

• Una fila por objeto cuadro delimitador.
• 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 lograrlo, 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 están indexados en 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 de arriba, que contiene dos objetos 'persona' (índice de clase 0) y un objeto 'corbata' (índice de clase 27), tendría este aspecto:

Link to this section1.3 Organiza los directorios#

Estructura tu directorio de conjuntos de datos como se ilustra a continuación. De forma predeterminada, YOLOv5 espera que el directorio del conjunto de datos (por ejemplo, /coco128) resida dentro de una carpeta /datasets ubicada adyacente 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)
            └── ...

Link to this sectionSelecciona un modelo#

Elige un modelo preentrenado para iniciar el proceso de entrenamiento. Empezar 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 de los cuales equilibra la velocidad y la precisión de forma 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 obtener una comparación detallada de todos los modelos disponibles.

Link to this sectionEntrena#

Comienza el entrenamiento del modelo usando 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 GPU.
• --batch: Determina el tamaño de lote (p. ej., --batch 16). Elige el tamaño más grande que tu GPU pueda manejar.
• --epochs: Especifica el número total de épocas de entrenamiento (p. ej., --epochs 100). Una época representa una pasada completa 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 inicial. 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 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 ú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

Todas las salidas de entrenamiento, incluyendo pesos y 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 práctica e interactiva, explora la sección de entrenamiento en nuestros cuadernos de tutoriales oficiales:

Link to this sectionVisualiza#

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

Link to this sectionRegistro y visualización con Comet#

Comet está totalmente integrado para un seguimiento exhaustivo 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 funciones 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 Comet en Colab para ver una demostración en vivo:

Link to this sectionRegistro y automatización con ClearML#

La integración con ClearML permite un seguimiento detallado de experimentos, 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 la versión gratuita).

ClearML captura automáticamente los detalles del experimento, las cargas de modelos, las comparaciones, los cambios de código no confirmados y los paquetes instalados, garantizando una reproducibilidad total. 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.

Link to this sectionRegistro 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 traza como results.png una vez que concluye el entrenamiento. También puedes trazar 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

Link to this sectionPasos siguientes#

Una vez completado 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 inferencia en nuevas imágenes o videos utilizando el modelo entrenado a través de la CLI o Python.
• Realizar 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 extraer potencialmente ganancias de rendimiento adicionales.
• Continúa mejorando tu modelo siguiendo nuestros Consejos para obtener los mejores resultados de entrenamiento e incorporando de forma iterativa datos más diversos y desafiantes basados en el análisis de rendimiento.

Link to this sectionEntornos admitidos#

Ultralytics proporciona entornos listos para usar equipados con dependencias esenciales como CUDA, cuDNN, Python y PyTorch, facilitando un comienzo 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

Link to this sectionEstado del proyecto#

This badge indicates that all YOLOv5 GitHub Actions Continuous Integration (CI) tests are passing successfully. These rigorous CI tests cover the core functionalities, including training, validation, inference, export, and benchmarks, across macOS, Windows, and Ubuntu operating systems. Tests are executed automatically every 24 hours and upon each code commit, ensuring consistent stability and optimal performance.

Link to this sectionFAQ#

Link to this section¿Cómo entreno YOLOv5 con mi propio conjunto de datos personalizado?#

Entrenar YOLOv5 con un conjunto de datos personalizado implica varios pasos clave:

1. Prepara tu conjunto de datos: Recopila imágenes y anótalas. Asegúrate de que las anotaciones tengan el formato YOLO requerido. Organiza las imágenes y las etiquetas en directorios train/ y val/ (y opcionalmente test/). Considera utilizar modelos como Google Gemini, SAM2 o YOLOWorld para ayudar a automatizar el proceso de etiquetado (consulta la Sección 1.2).
2. Configura tu entorno: Clona el repositorio de YOLOv5 e instala las dependencias usando pip install -r requirements.txt.

   git clone https://github.com/ultralytics/yolov5
   cd yolov5
   pip install -r requirements.txt

3. Crea la configuración del conjunto de datos: Define las rutas del conjunto de datos, el número de clases y los nombres de las clases en un archivo dataset.yaml.
4. Inicia el entrenamiento: Ejecuta el script train.py, proporcionando las rutas a tu dataset.yaml, los pesos preentrenados deseados (por ejemplo, yolov5s.pt), el tamaño de imagen, el tamaño de lote y el número de épocas.

   python train.py --img 640 --batch 16 --epochs 100 --data path/to/your/dataset.yaml --weights yolov5s.pt

Link to this section¿Por qué debería usar Ultralytics Platform para entrenar mis modelos YOLO?#

Ultralytics Platform es una plataforma integral diseñada para simplificar todo el ciclo de vida de desarrollo de modelos YOLO, a menudo sin necesidad de escribir código. Los beneficios clave incluyen:

• Entrenamiento simplificado: Entrena modelos fácilmente usando entornos preconfigurados y una interfaz de usuario intuitiva.
• Gestión de datos integrada: Sube, controla las versiones y gestiona tus conjuntos de datos de forma eficiente dentro de la plataforma.
• Monitoreo en tiempo real: Realiza un seguimiento del progreso del entrenamiento y visualiza métricas de rendimiento utilizando herramientas integradas como Comet o TensorBoard.
• Funciones de colaboración: Facilita el trabajo en equipo a través de recursos compartidos, herramientas de gestión de proyectos y un sencillo uso compartido de modelos.
• Implementación sin código: Implementa modelos entrenados directamente en diversos destinos.

Para un tutorial práctico, echa un vistazo a nuestra entrada de blog: Cómo entrenar tus modelos personalizados con Ultralytics Platform.

Link to this section¿Cómo convierto mis datos anotados al formato YOLOv5?#

Ya sea que anotes manualmente o utilices herramientas automatizadas (como las mencionadas en la Sección 1.2), las etiquetas finales deben estar en el formato YOLO específico requerido por YOLOv5:

• Crea un archivo .txt por cada imagen. El nombre del archivo debe coincidir con el nombre de la imagen (por ejemplo, image1.jpg corresponde a image1.txt). Coloca estos archivos en un directorio labels/ paralelo a tu directorio images/ (por ejemplo, ../datasets/mydataset/labels/train/).
• Cada línea dentro de un archivo .txt representa la anotación de un objeto y sigue el formato: class_index center_x center_y width height.
• Las coordenadas (center_x, center_y, width, height) deben estar normalizadas (valores entre 0.0 y 1.0) en relación con las dimensiones de la imagen.
• Los índices de clase están basados en cero (la primera clase es 0, la segunda es 1, etc.).

Muchas herramientas de anotación manual ofrecen exportación directa al formato YOLO. Si utilizas modelos automatizados, necesitarás scripts o procesos para convertir su salida (por ejemplo, coordenadas de cuadros delimitadores, máscaras de segmentación) a este formato de texto normalizado específico. Asegúrate de que la estructura final de tu conjunto de datos cumpla con el ejemplo proporcionado en la guía. Para obtener más detalles, consulta nuestra Guía de recopilación y anotación de datos.

Link to this section¿Cuáles son las opciones de licencia para usar YOLOv5 en aplicaciones comerciales?#

Ultralytics ofrece licencias flexibles adaptadas a diferentes necesidades:

• Licencia AGPL-3.0: Esta licencia de código abierto es adecuada para investigación académica, proyectos personales y situaciones en las que el cumplimiento del código abierto sea aceptable. Exige que las modificaciones y los trabajos derivados también sean de código abierto bajo la AGPL-3.0. Revisa los detalles de la licencia AGPL-3.0.
• Licencia Enterprise: Una licencia comercial diseñada para empresas que integran YOLOv5 en productos o servicios propietarios. Esta licencia elimina las obligaciones de código abierto de la AGPL-3.0, permitiendo la distribución de código cerrado. Visita nuestra página de Licencias para obtener más detalles o para solicitar una Licencia Enterprise.

Selecciona la licencia que mejor se alinee con los requisitos y el modelo de distribución de tu proyecto.