Entrena YOLOv5 en 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.

Antes de empezar

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

El desarrollo de 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 Anotación de Datos.
2. Etiquetar objetos: Anote los objetos de interés dentro de sus imágenes con precisión.
3. Entrenar un modelo: Utilice los datos etiquetados para entrenar su modelo YOLOv5. Aproveche el aprendizaje por transferencia comenzando con pesos preentrenados.
4. Implementar y predecir: Utilice el modelo entrenado para la inferencia en datos nuevos y no vistos.
5. Recopila casos límite: Identifica escenarios donde el modelo tiene un rendimiento deficiente (casos límite) y añade datos similares a tu conjunto de datos para mejorar la robustez. Repite el ciclo.

Ultralytics HUB 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 la implementación.

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

1. Crear un Conjunto de Datos

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

1.1 Crear dataset.yaml

El archivo de configuración del conjunto de datos (p. ej., 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 COCO conjunto de datos. Es útil para probar rápidamente la canalización de entrenamiento y diagnosticar posibles problemas como sobreajuste.

El dataset.yaml la estructura del archivo 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 que enumeran las rutas de las imágenes para los conjuntos de entrenamiento, validación y prueba.
• names: Un diccionario que asigna los índices de clase (comenzando desde 0) a sus nombres de clase correspondientes.

A continuación, se muestra la estructura para 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 Aprovechar los Modelos para el Etiquetado Automatizado

Si bien el etiquetado manual con herramientas es un enfoque común, el proceso puede llevar mucho tiempo. Los avances recientes en los modelos básicos ofrecen posibilidades para automatizar o semiautomatizar el proceso de anotación, lo que podría acelerar significativamente la creación del conjunto de datos. Aquí hay algunos 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 indicar que identifiquen y localicen objetos dentro de las imágenes, generando cuadros delimitadores o descripciones que se pueden convertir en etiquetas de formato YOLO. Explora su potencial en el cuaderno 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. Si bien son principalmente para 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. Puede proporcionar descripciones de texto de los objetos que le interesan, y YOLOWorld puede localizarlos en las imágenes sin necesidad de un entrenamiento previo en esas clases específicas. Esto puede utilizarse como punto de partida para generar etiquetas iniciales, que luego pueden ser refinadas.

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

El formato YOLO *.txt las especificaciones del archivo son precisas:

• Una fila por cada bounding box de objeto.
• Cada fila debe contener: class_index x_center y_center width height.
• Las coordenadas deben ser normalizado 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 dividir y_center y height por la altura total de la imagen.
• Los índices de clase están indexados desde cero (es decir, la primera clase está representada por 0, el segundo 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 'tie' (índice de clase 27), se vería así:

1.3 Organizar los Directorios

Estructure su conjuntos de datos directorio como se ilustra a continuación. De forma predeterminada, YOLOv5 anticipa el directorio del conjunto de datos (p. ej., /coco128) para residir dentro de un /datasets carpeta ubicada adyacente a el /yolov5 directorio del repositorio.

YOLOv5 localiza automáticamente las etiquetas de cada imagen sustituyendo la última instancia de /images/ en la ruta de la imagen con /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. Seleccionar 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 el entrenamiento 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 README para obtener una comparación detallada de todos los modelos disponibles.

3. Entrenar

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

• --img: Define la entrada Tamaño de la imagen (p. ej., --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 de lote (p. ej., --batch 16). Elija el tamaño más grande que su GPU pueda soportar.
• --epochs: Especifica el número total de épocas (p. ej., --epochs 100). Una época representa un paso completo sobre todo el conjunto de datos de entrenamiento.
• --data: Ruta a tu dataset.yaml archivo (p. ej., --data coco128.yaml).
• --weights: Ruta al archivo de pesos inicial. Usando pesos preentrenados (por ejemplo, --weights yolov5s.pt) es altamente recomendable para una convergencia más rápida y mejores resultados. Para entrenar desde cero (no se aconseja a menos que tenga un conjunto de datos muy grande y necesidades específicas), utilice --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 del entrenamiento, incluyendo los pesos y los registros, se guardan en el runs/train/ directorio. Cada sesión de entrenamiento crea un nuevo subdirectorio (p. ej., runs/train/exp, runs/train/exp2, etc.). Para una experiencia interactiva y práctica, explore la sección de entrenamiento en nuestros cuadernos de tutoriales oficiales:

4. Visualizar

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

Registro y visualización de Comet 🌟 NUEVO

Comet está totalmente integrado para un seguimiento exhaustivo de los experimentos. Visualice las métricas en directo, guarde los hiperparámetros, gestione los conjuntos de datos y los puntos de control de los modelos, y analice las predicciones de los modelos mediante 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!

Profundice en las características admitidas en nuestro Guía de integración de Comet. Obtenga más información sobre las capacidades de Comet en su documentación. Pruebe el cuaderno Comet Colab para una demostración en vivo:

Registro y automatización de ClearML 🌟 NUEVO

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

• Instala el paquete: pip install clearml
• Inicializar ClearML: Ejecutar clearml-init una vez para conectarte a tu servidor ClearML (ya sea auto alojado o el nivel gratuito).

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, lo que garantiza una reproducibilidad total. Puede programar fácilmente tareas de entrenamiento en agentes remotos y administrar las versiones de los conjuntos de datos utilizando ClearML Data. Explore 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 guardado como CSV archivos dentro del directorio de experimento específico (p. ej., runs/train/exp). Los datos registrados incluyen:

• Pérdida de entrenamiento y validación, y métricas de rendimiento.
• Imágenes de muestra que muestran aumentos aplicados (como mosaicos).
• Etiquetas de ground truth junto con las predicciones del modelo para la inspección visual.
• Métricas de evaluación clave como las curvas de Precisión-Recall (PR).
• Matrices de confusión para un análisis detallado del rendimiento por clases.

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

5. Próximos Pasos

Tras la finalización exitosa del entrenamiento, el punto de control del modelo con mejor rendimiento (best.pt) se guarda y está listo para su despliegue o para un mayor perfeccionamiento. Los posibles pasos siguientes incluyen:

• Ejecute la inferencia en nuevas imágenes o videos utilizando el modelo entrenado a través de la CLI o Python.
• Realice una validación para evaluar la precisión del modelo y sus capacidades de generalización en diferentes divisiones de datos (p. ej., un conjunto de prueba reservado).
• Exporta el modelo a varios formatos de implementación como ONNX, TensorFlow SavedModel o TensorRT para una inferencia optimizada en diversas plataformas.
• Emplea técnicas de ajuste de hiperparámetros para exprimir potencialmente ganancias de rendimiento adicionales.
• Continúe mejorando su modelo siguiendo nuestros Consejos para obtener los mejores resultados de entrenamiento y agregando iterativamente datos más diversos y desafiantes basados 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 sin problemas.

• Notebooks 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 GitHub Actions de Integración Continua (CI) de YOLOv5 están pasando con éxito. Estas rigurosas pruebas de CI cubren las funcionalidades principales, incluyendo el entrenamiento, la validación, la inferencia, la exportación y los benchmarks, en los sistemas operativos macOS, Windows y Ubuntu. Las pruebas se ejecutan automáticamente cada 24 horas y tras cada confirmación de código, lo que garantiza una estabilidad constante y un rendimiento óptimo.

Preguntas frecuentes

Preguntas frecuentes

¿Cómo entreno YOLOv5 en mi dataset personalizado?

El entrenamiento de YOLOv5 en 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 estén en el formato requerido formato YOLO. Organice las imágenes y las etiquetas en train/ y val/ (y opcionalmente test/) directorios. Considere el uso de modelos como Google Gemini, SAM2, o YOLOWorld para ayudar o automatizar el proceso de etiquetado (ver Sección 1.2).
2. Configurar su entorno: Clona el repositorio 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. Crear 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 dataset.yaml archivo.
4. Comenzar el entrenamiento: Ejecute el train.py script, proporcionando las rutas a tus dataset.yaml, pesos preentrenados deseados (p. ej., yolov5s.pt), el tamaño de la imagen, el tamaño del 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
   

¿Por qué debería usar Ultralytics HUB para entrenar mis modelos YOLO?

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

• Entrenamiento Simplificado: Entrene modelos fácilmente utilizando entornos preconfigurados y una interfaz de usuario intuitiva.
• Gestión de datos integrada: Cargue, controle las versiones y gestione sus conjuntos de datos de forma eficiente dentro de la plataforma.
• Monitoreo en Tiempo Real: Realice un seguimiento del progreso del entrenamiento y visualice las 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 fácil intercambio de modelos.
• Implementación sin código: Implemente modelos entrenados directamente en varios objetivos.

Para una guía práctica, consulta nuestra entrada de blog: Cómo entrenar tus modelos personalizados con Ultralytics HUB.

¿Cómo convierto mis datos anotados al formato YOLOv5?

Tanto si anota manualmente como si utiliza 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:

• Crear uno .txt archivo para cada imagen. El nombre del archivo debe coincidir con el nombre del archivo de la imagen (p. ej., image1.jpg corresponde a image1.txt). Coloque estos archivos en un labels/ directorio paralelo a su images/ directorio (p. ej., ../datasets/mydataset/labels/train/).
• Cada línea dentro de un .txt archivo representa una anotación de objeto y sigue el formato: class_index center_x center_y width height.
• Coordenadas (center_x, center_y, width, height) debe ser normalizado (valores entre 0.0 y 1.0) relativos a las dimensiones de la imagen.
• Los índices de clase son basado en cero (la primera clase es 0, el segundo es 1, etc.).

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

¿Cuáles son las opciones de licencia para usar YOLOv5 en aplicaciones comerciales?

Ultralytics proporciona licencias flexibles adaptadas a diferentes necesidades:

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

Selecciona la licencia que mejor se ajuste a los requisitos de tu proyecto y al modelo de distribución.

📅 Creado hace 1 año ✏️ Actualizado hace 2 meses

Comentarios