🚀 Detección de Objetos en Tiempo Real con YOLOv5 y OpenCV: Un Tutorial Práctico

¡Bienvenido a un viaje emocionante al mundo de la Visión Artificial! En este tutorial, nos sumergiremos en una de las tareas más fascinantes y útiles: la detección de objetos en tiempo real. Utilizaremos YOLOv5 (You Only Look Once versión 5), uno de los algoritmos más populares y eficientes, combinado con la versátil biblioteca OpenCV para Python. Al final, serás capaz de construir tu propio sistema de detección de objetos.

🎯 ¿Qué es la Detección de Objetos?

La detección de objetos es una técnica de visión artificial que no solo identifica qué objetos están presentes en una imagen o vídeo, sino que también localiza dónde están. Es decir, dibuja un cuadro delimitador (bounding box) alrededor de cada objeto detectado y le asigna una etiqueta de clase con una probabilidad.

Aplicaciones de la Detección de Objetos ✨

La detección de objetos tiene un sinfín de aplicaciones prácticas en el mundo real:

• Vehículos Autónomos: Detección de peatones, coches, señales de tráfico.
• Seguridad y Vigilancia: Identificación de personas u objetos sospechosos.
• Medicina: Detección de tumores o anomalías en imágenes médicas.
• Venta al por Menor: Análisis de comportamiento del cliente, gestión de inventario.
• Robótica: Navegación y manipulación de objetos.
• Agricultura: Detección de enfermedades en cultivos, conteo de frutas.

📚 Entendiendo YOLOv5

YOLO (You Only Look Once) es una familia de modelos de detección de objetos conocida por su velocidad y precisión. YOLOv5, desarrollado por Ultralytics, es una evolución que ha mejorado el rendimiento, la facilidad de uso y la flexibilidad con respecto a sus predecesores.

¿Por qué YOLOv5? 🤔

• Velocidad: Ideal para aplicaciones en tiempo real, ya que procesa imágenes muy rápidamente.
• Precisión: Alcanza un buen equilibrio entre velocidad y exactitud en la detección.
• Facilidad de Uso: La implementación y el entrenamiento son relativamente sencillos en comparación con otros modelos.
• Versatilidad: Ofrece varios tamaños de modelo (nano, small, medium, large, xlarge) para adaptarse a diferentes necesidades de computación y precisión.

"YOLOv5 democratiza el acceso a la detección de objetos de alto rendimiento, permitiendo a desarrolladores y empresas implementar soluciones robustas con mayor facilidad." - Un experto en Visión Artificial

🛠️ Preparación del Entorno de Desarrollo

Antes de sumergirnos en el código, necesitamos configurar nuestro entorno. Utilizaremos pip para gestionar los paquetes y git para clonar el repositorio de YOLOv5.

Requisitos Previos

• Python 3.7 o superior: Asegúrate de tener una versión reciente de Python instalada.
• Anaconda/Miniconda (Recomendado): Para gestionar entornos virtuales de manera eficiente.
• GPU (Opcional pero muy recomendable): Si tienes una GPU NVIDIA compatible con CUDA, la inferencia será mucho más rápida.

1. Crear un Entorno Virtual 🐍

Es una buena práctica trabajar en un entorno virtual para evitar conflictos entre las dependencias de diferentes proyectos.

conda create -n yolov5_env python=3.8
conda activate yolov5_env

O con venv:

pthon3 -m venv yolov5_env
source yolov5_env/bin/activate # En Linux/macOS
yolov5_env\Scripts\activate # En Windows

2. Clonar el Repositorio de YOLOv5 y Instalar Dependencias ⬇️

Ultralytics mantiene el repositorio oficial de YOLOv5 en GitHub. Lo clonaremos y luego instalaremos todas las dependencias necesarias.

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

🖼️ Detección de Objetos con un Modelo Pre-entrenado

¡La forma más rápida de ver YOLOv5 en acción es usar un modelo pre-entrenado! YOLOv5 viene con varios modelos listos para usar, entrenados en el conjunto de datos COCO, que puede detectar 80 clases diferentes de objetos (personas, coches, perros, etc.).

1. Descargar el Modelo Pre-entrenado

No necesitas hacer nada especial; cuando ejecutes el script detect.py por primera vez, YOLOv5 descargará automáticamente el modelo elegido (por ejemplo, yolov5s.pt para el modelo 'small').

2. Ejecutar Detección en Imágenes o Vídeos 📸

El script principal para la inferencia es detect.py. Aquí tienes cómo usarlo:

python detect.py --weights yolov5s.pt --source path/to/your/image.jpg

Para un vídeo:

python detect.py --weights yolov5s.pt --source path/to/your/video.mp4

Para la cámara web en tiempo real:

python detect.py --weights yolov5s.pt --source 0

Opciones Comunes de detect.py

⚙️ Entrenamiento de un Modelo Personalizado con YOLOv5

Si necesitas detectar objetos que no están en el dataset COCO (por ejemplo, frutas específicas, herramientas, etc.), tendrás que entrenar tu propio modelo. Esto implica varias etapas.

Flujo de Entrenamiento de un Modelo Personalizado

1. Preparación y Anotación de Datos 📊

Esta es la parte más crítica y que consume más tiempo. Necesitas un conjunto de imágenes o vídeos que contengan los objetos que quieres detectar.

Recopilación de Imágenes

• Asegúrate de tener suficientes imágenes (cientos o miles, dependiendo de la complejidad y variabilidad de tus objetos).
• Las imágenes deben ser diversas: diferentes ángulos, condiciones de iluminación, fondos, tamaños de objeto, etc.

Anotación de Imágenes

Para cada imagen, debes dibujar un bounding box alrededor de cada objeto de interés y asignarle una etiqueta de clase. YOLOv5 espera las anotaciones en formato YOLO TXT:

class_id center_x center_y width height

Donde todas las coordenadas están normalizadas (valores entre 0 y 1) con respecto al ancho y alto de la imagen.

• Herramientas de Anotación:
  • LabelImg: Popular y fácil de usar, soporta formato YOLO.
  • Roboflow: Plataforma online que facilita la anotación, aumento de datos y exportación en múltiples formatos.

2. Organización del Dataset 📂

Una vez anotados, tus datos deben organizarse en la siguiente estructura:

my_custom_dataset/
  images/
    train/
      img1.jpg
      img2.jpg
    val/
      img3.jpg
    test/ (opcional)
      img4.jpg
  labels/
    train/
      img1.txt
      img2.txt
    val/
      img3.txt
    test/ (opcional)
      img4.txt

images contiene las imágenes, y labels contiene los archivos .txt de anotación correspondientes para cada imagen. Es crucial que cada imagen tenga un archivo de etiqueta con el mismo nombre y en la carpeta labels correspondiente.

3. Crear el Archivo de Configuración YAML de Datos 📝

Este archivo le dice a YOLOv5 dónde encontrar tus datos y cuántas clases tienes. Crea un archivo data.yaml (o similar) en la raíz de tu carpeta yolov5 o en la carpeta de tu dataset:

# data.yaml

train: ../my_custom_dataset/images/train  # Ruta a la carpeta de imágenes de entrenamiento
val: ../my_custom_dataset/images/val      # Ruta a la carpeta de imágenes de validación

nc: 3                                    # Número de clases
names: ['apple', 'banana', 'orange']     # Nombres de las clases en orden

../ se usa para indicar que la carpeta my_custom_dataset está un nivel arriba de donde está el archivo data.yaml si lo pones dentro de yolov5.

4. Entrenar el Modelo Personalizado 🔥

Ahora que tenemos los datos y la configuración, podemos entrenar. Usaremos el script train.py de YOLOv5.

python train.py --img 640 --batch 16 --epochs 100 --data custom_data.yaml --cfg yolov5s.yaml --weights yolov5s.pt --name custom_yolov5_model

Explicación de los Argumentos:

• --img 640: Tamaño de la imagen de entrenamiento (640x640 píxeles).
• --batch 16: Tamaño del lote (cuántas imágenes se procesan a la vez).
• --epochs 100: Número de épocas de entrenamiento (cuántas veces el modelo ve todo el dataset).
• --data custom_data.yaml: Ruta a tu archivo YAML de configuración de datos.
• --cfg yolov5s.yaml: Arquitectura del modelo base a usar (aquí, la versión 'small'). Puedes probar yolov5m.yaml para un modelo más grande y potencialmente más preciso.
• --weights yolov5s.pt: Ruta a los pesos pre-entrenados para fine-tuning. Esto es transfer learning y acelera mucho el entrenamiento.
• --name custom_yolov5_model: Nombre del directorio donde se guardarán los resultados del entrenamiento (runs/train/custom_yolov5_model).

Intermedio Importante

El entrenamiento puede tomar desde minutos hasta horas o incluso días, dependiendo del tamaño de tu dataset, la complejidad del modelo y el hardware disponible. Si tienes una GPU, el proceso será significativamente más rápido.

5. Evaluación de los Resultados del Entrenamiento 📈

Después del entrenamiento, encontrarás los resultados en runs/train/your_experiment_name. Aquí, puedes ver gráficos de métricas como:

• mAP (mean Average Precision): Una métrica clave que evalúa la precisión del modelo en todas las clases y umbrales de IoU.
• Recall: Capacidad del modelo para encontrar todos los objetos relevantes.
• Precision: Capacidad del modelo para identificar solo objetos relevantes.
• Loss (Pérdida): Indica qué tan bien el modelo está aprendiendo.

Los archivos results.csv y las imágenes de confusion_matrix.png, F1_curve.png, P_curve.png, R_curve.png te darán una visión detallada del rendimiento de tu modelo.

🚀 Despliegue e Inferencias con tu Modelo Entrenado

Una vez que estés satisfecho con el rendimiento de tu modelo, puedes usar los pesos best.pt generados para hacer inferencias en nuevas imágenes o vídeos, o en tiempo real con una cámara web, exactamente igual que como lo hicimos con el modelo pre-entrenado:

python detect.py --weights runs/train/custom_yolov5_model/weights/best.pt --source path/to/new/image.jpg --conf-thres 0.4

# Ejemplo de código para usar tu modelo en Python
import torch
import cv2

# Cargar el modelo personalizado
# Asegúrate de estar en la carpeta 'yolov5' o ajusta la ruta del modelo
model = torch.hub.load('ultralytics/yolov5', 'custom', path='runs/train/custom_yolov5_model/weights/best.pt', force_reload=True)

# Opcional: ajustar umbrales
model.conf = 0.25  # umbral de confianza
model.iou = 0.45   # umbral de IoU para NMS

# Inferir en una imagen
img = 'https://ultralytics.com/images/zidane.jpg' # o 'ruta/a/tu/imagen.jpg'
results = model(img)

# Mostrar resultados
results.print()
results.show()

# Inferir en vídeo (ejemplo básico, no en tiempo real)
# cap = cv2.VideoCapture(0) # Para webcam
# while True:
#     ret, frame = cap.read()
#     if not ret:
#         break
#     results = model(frame)
#     frame_with_detections = results.render()[0] # Dibuja los bounding boxes en el frame
#     cv2.imshow('YOLOv5 Custom Detections', frame_with_detections)
#     if cv2.waitKey(1) & 0xFF == ord('q'):
#         break
# cap.release()
# cv2.destroyAllWindows()

🔚 Conclusión

¡Felicidades! Has completado un recorrido exhaustivo por la detección de objetos en tiempo real con YOLOv5 y OpenCV. Ahora tienes las herramientas y el conocimiento para:

• Configurar un entorno de desarrollo para YOLOv5.
• Realizar inferencias con modelos pre-entrenados.
• Preparar y anotar tu propio dataset.
• Entrenar un modelo YOLOv5 personalizado.
• Evaluar el rendimiento de tu modelo.
• Desplegar tu modelo para detección en tiempo real.

La detección de objetos es un campo en constante evolución, y YOLOv5 es una de las opciones más robustas y accesibles disponibles hoy en día. ¡Experimenta, crea y sigue explorando las infinitas posibilidades de la Visión Artificial!

Fácil Intermedio Avanzado

📚 Recursos Adicionales

• Documentación oficial de YOLOv5: https://docs.ultralytics.com/yolov5/
• Repositorio GitHub de YOLOv5: https://github.com/ultralytics/yolov5
• Documentación de OpenCV: https://docs.opencv.org/