Segmentación de Imágenes en Tiempo Real con Yolo y Python
Clase 5 de 16 • Curso de Visión Artificial con Python
Resumen
La segmentación de imágenes con YOLO representa una de las técnicas más avanzadas en visión por computadora, permitiendo identificar y delimitar objetos específicos en tiempo real. Esta tecnología no solo detecta objetos, sino que también crea máscaras precisas que los separan del fondo, ofreciendo aplicaciones revolucionarias en campos como la robótica, la vigilancia y el análisis de video.
¿Qué es YOLO y por qué es importante para la segmentación de imágenes?
YOLO (You Only Look Once) es un algoritmo de detección de objetos que analiza una imagen en una sola pasada, lo que le permite ser extremadamente rápido. Actualmente, la empresa Ultralytics está desarrollando nuevas versiones de YOLO, ofreciendo una librería de código abierto con una gran comunidad de soporte.
Las características principales de YOLO incluyen:
- Procesamiento en tiempo real
- Segmentación de imágenes
- Detección de objetos
- Identificación de puntos característicos del cuerpo
La popularidad de YOLO se debe a su eficiencia y versatilidad, permitiendo implementaciones en diversos dispositivos, desde potentes GPUs hasta sistemas con recursos limitados como CPUs estándar.
¿Cómo implementar la segmentación con YOLO en tiempo real?
Para implementar la segmentación con YOLO necesitamos algunas herramientas fundamentales:
- OpenCV para el procesamiento de imágenes
- NumPy para operaciones matemáticas
- Ultralytics para acceder a los modelos YOLO
Si aún no tienes instalada la librería Ultralytics, puedes hacerlo con un simple comando de instalación mediante pip.
Selección del modelo adecuado
Para la segmentación, utilizaremos YOLOv11 en su versión "nano", que es el modelo más pequeño disponible. Esta elección es ideal cuando trabajamos con CPUs en lugar de GPUs, ya que requiere menos recursos computacionales.
# Importar las librerías necesarias
import cv2
import numpy as np
from ultralytics import YOLO
# Cargar el modelo YOLOv11 nano
model = YOLO('yolov11n.pt')
# Configurar la fuente de video (0 para la cámara principal, 1 para la segunda cámara)
cap = cv2.VideoCapture(1)
# Configurar la resolución
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
Procesamiento de frames y medición de latencia
Un aspecto importante al trabajar con segmentación en tiempo real es medir la latencia, es decir, cuánto tiempo tarda el sistema en procesar cada frame:
while True:
# Capturar frame
ret, frame = cap.read()
# Medir tiempo de inicio
start_time = time.time()
# Procesar el frame con YOLO
results = model(frame)
# Calcular latencia
latency = time.time() - start_time
# Mostrar FPS
cv2.putText(frame, f"Latencia: {latency:.3f}s", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
Visualización de bounding boxes y segmentación
La segmentación con YOLO proporciona dos elementos principales:
- Bounding boxes: Rectángulos que encierran los objetos detectados
- Máscaras de segmentación: Áreas coloreadas que delimitan exactamente la forma del objeto
# Acceder a las detecciones
for r in results:
boxes = r.boxes
masks = r.masks
# Procesar cada detección
for i, box in enumerate(boxes):
# Obtener coordenadas del bounding box
x1, y1, x2, y2 = map(int, box.xyxy[0])
# Obtener confianza y clase
confidence = float(box.conf[0])
class_id = int(box.cls[0])
# Dibujar bounding box
cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
# Añadir etiqueta
label = f"{class_names[class_id]}: {confidence:.2f}"
cv2.putText(frame, label, (x1, y1 - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
Creación y aplicación de máscaras de segmentación
La parte más distintiva de la segmentación es la creación de máscaras que se superponen a la imagen original:
# Procesar máscaras de segmentación
if masks is not None:
for i, mask in enumerate(masks):
# Redimensionar la máscara al tamaño del frame
mask_image = mask.data.cpu().numpy()
mask_image = cv2.resize(mask_image, (frame.shape[1], frame.shape[0]))
# Crear máscara booleana
mask_bool = mask_image > 0.5
# Generar color aleatorio para la máscara
color = np.random.randint(0, 255, 3, dtype=np.uint8)
# Aplicar color a la máscara
colored_mask = np.zeros_like(frame)
colored_mask[mask_bool] = color
# Combinar máscara con el frame original
frame = cv2.addWeighted(frame, 1, colored_mask, 0.5, 0)
¿Cómo filtrar objetos específicos en la segmentación?
Una de las ventajas de YOLO es la capacidad de filtrar objetos específicos según nuestras necesidades. Podemos hacerlo de dos maneras:
Filtrado por confianza
Podemos establecer un umbral de confianza para mostrar solo las detecciones con alta probabilidad:
# Configurar umbral de confianza
confidence_threshold = 0.7
# Filtrar detecciones por confianza
results = model(frame, conf=confidence_threshold)
Filtrado por clase de objeto
YOLO viene preentrenado para detectar 80 categorías diferentes de objetos. Podemos filtrar para mostrar solo las clases que nos interesan:
# Clases de interés (0 = persona, 13 = silla)
classes_of_interest = [0, 13]
# Filtrar por clase y confianza
results = model(frame, conf=0.7, classes=classes_of_interest)
El modelo preentrenado de YOLO asigna un número a cada categoría de objeto. Por ejemplo:
- 0: Persona
- 13: Silla
- 41: Taza
- 77: Oso de peluche
Esto permite una gran flexibilidad para aplicaciones específicas, como sistemas de seguridad que solo detecten personas o aplicaciones de inventario que se centren en productos particulares.
La segmentación con YOLO representa una herramienta poderosa para el análisis de imágenes, combinando velocidad y precisión en un solo sistema. Su capacidad para procesar video en tiempo real y generar máscaras precisas abre un mundo de posibilidades para desarrolladores e investigadores. ¿Has probado implementar YOLO en alguno de tus proyectos? Comparte tu experiencia en los comentarios.