YOLOv8: Guía completa para la detección de objetos

YOLOv8 es la última versión del algoritmo YOLO (You Only Look Once), desarrollado por Ultralytics. Ofrece un rendimiento mejorado y una API más intuitiva.

1. Instalación y configuración

# Instalación de las dependencias
pip install ultralytics opencv-python numpy

# Importación de las bibliotecas necesarias
from ultralytics import YOLO
import cv2
import numpy as np

2. Modelos disponibles

2.1 Carga de los modelos

# Carga de los distintos modelos
model_nano = YOLO('yolov8n.pt')  # Nano
model_small = YOLO('yolov8s.pt')  # Small
model_medium = YOLO('yolov8m.pt')  # Medium
model_large = YOLO('yolov8l.pt')  # Large
model_xlarge = YOLO('yolov8x.pt')  # XLarge

2.2 Comparación de los modelos

def compare_models():
    # Configuración básica
    test_image = "path/to/test/image.jpg"
    
    # Prueba de los distintos modelos
    models = {
        'nano': model_nano,
        'small': model_small,
        'medium': model_medium,
        'large': model_large,
        'xlarge': model_xlarge
    }
    
    results = {}
    for name, model in models.items():
        # Medición del tiempo de inferencia
        start_time = time.time()
        results[name] = model(test_image)
        inference_time = time.time() - start_time
        
        print(f"Modèle {name}:")
        print(f"Temps d'inférence: {inference_time:.2f}s")
        print(f"Nombre de détections: {len(results[name][0].boxes)}")

3. Detección de objetos

3.1 Detección simple

def detect_objects(image_path):
    # Carga del modelo
    model = YOLO('yolov8n.pt')
    
    # Detección
    results = model(image_path)
    
    # Procesamiento de los resultados
    for result in results:
        boxes = result.boxes
        for box in boxes:
            # Coordenadas del recuadro
            x1, y1, x2, y2 = box.xyxy[0]
            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
            
            # Confianza
            confidence = float(box.conf[0])
            
            # Clase
            class_id = int(box.cls[0])
            class_name = model.names[class_id]
            
            # Dibujar el recuadro
            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
            
            # Añadir el texto
            label = f"{class_name} {confidence:.2f}"
            cv2.putText(image, label, (x1, y1 - 10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
    return image

3.2 Detección en tiempo real

def real_time_detection():
    # Inicialización de la cámara
    cap = cv2.VideoCapture(0)
    
    # Carga del modelo
    model = YOLO('yolov8n.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Detección
        results = model(frame)
        
        # Visualización
        annotated_frame = results[0].plot()
        
        # Visualización en pantalla
        cv2.imshow('YOLOv8 Detection', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

4. Segmentación

4.1 Segmentación de instancias

def instance_segmentation():
    # Carga del modelo de segmentación
    model = YOLO('yolov8n-seg.pt')
    
    # Segmentación
    results = model('path/to/image.jpg')
    
    # Visualización
    for result in results:
        # Máscaras de segmentación
        masks = result.masks
        if masks is not None:
            for mask in masks:
                # Conversión de la máscara en imagen
                mask_array = mask.data.cpu().numpy()
                
                # Aplicación de la máscara
                masked_image = cv2.bitwise_and(
                    image, image, mask=mask_array.astype(np.uint8)
                )
                
                # Visualización en pantalla
                cv2.imshow('Segmentation', masked_image)

4.2 Segmentación en tiempo real

def real_time_segmentation():
    # Inicialización
    cap = cv2.VideoCapture(0)
    model = YOLO('yolov8n-seg.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Segmentación
        results = model(frame)
        
        # Visualización
        annotated_frame = results[0].plot()
        
        # Visualización en pantalla
        cv2.imshow('YOLOv8 Segmentation', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

5. Clasificación

5.1 Clasificación de imágenes

def image_classification():
    # Carga del modelo de clasificación
    model = YOLO('yolov8n-cls.pt')
    
    # Clasificación
    results = model('path/to/image.jpg')
    
    # Procesamiento de los resultados
    for result in results:
        # Probabilidades de las clases
        probs = result.probs
        
        # Clase predicha
        predicted_class = probs.top1
        confidence = probs.top1conf
        
        print(f"Classe prédite: {model.names[predicted_class]}")
        print(f"Confiance: {confidence:.2f}")

5.2 Clasificación en tiempo real

def real_time_classification():
    # Inicialización
    cap = cv2.VideoCapture(0)
    model = YOLO('yolov8n-cls.pt')
    
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            continue
        
        # Clasificación
        results = model(frame)
        
        # Visualización
        annotated_frame = results[0].plot()
        
        # Visualización en pantalla
        cv2.imshow('YOLOv8 Classification', annotated_frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

6. Entrenamiento personalizado

6.1 Preparación de los datos

def prepare_training():
    # Configuración del dataset
    data_yaml = """
    path: dataset  # Chemin vers le dataset
    train: images/train  # Images d'entraînement
    val: images/val  # Images de validation
    
    # Classes
    names:
      0: person
      1: car
      2: truck
      # ... autres classes
    """
    
    # Guardado de la configuración
    with open('data.yaml', 'w') as f:
        f.write(data_yaml)

6.2 Entrenamiento del modelo

def train_model():
    # Carga del modelo
    model = YOLO('yolov8n.pt')
    
    # Configuración del entrenamiento
    results = model.train(
        data='data.yaml',
        epochs=100,
        imgsz=640,
        batch=16,
        device='0',  # GPU
        workers=8,
        project='runs/train',
        name='exp'
    )

7. Optimización y despliegue

7.1 Exportación del modelo

def export_model():
    # Carga del modelo
    model = YOLO('yolov8n.pt')
    
    # Exportación a distintos formatos
    model.export(format='onnx')  # ONNX
    model.export(format='engine')  # TensorRT
    model.export(format='coreml')  # CoreML
    model.export(format='tflite')  # TFLite

7.2 Optimización del rendimiento

def optimize_performance():
    # Configuración para obtener un mejor rendimiento
    model = YOLO('yolov8n.pt')
    
    # Optimización de los parámetros
    results = model.predict(
        source='0',  # Cámara
        conf=0.25,  # Umbral de confianza
        iou=0.45,  # Umbral de IoU
        agnostic_nms=True,  # NMS agnóstico a las clases
        max_det=300,  # Número máximo de detecciones
        half=True  # Uso de precisión FP16
    )

8. Buenas prácticas

1. Elección del modelo

   • Nano para dispositivos móviles
   • Small/Medium para aplicaciones generales
   • Large/XLarge para la máxima precisión

2. Optimización

   • Utilizar la precisión FP16 en las GPU
   • Ajustar los umbrales de confianza e IoU
   • Optimizar el tamaño del batch

3. Despliegue

   • Exportar al formato adecuado
   • Utilizar la aceleración por hardware
   • Implementar un sistema de caché

Conclusión

Puntos clave:

• Rendimiento mejorado
• API intuitiva
• Compatibilidad multiplataforma
• Exportación a distintos formatos

Recomendaciones:

• Elegir el modelo adecuado según las necesidades
• Optimizar el rendimiento
• Utilizar la aceleración por hardware
• Implementar una gestión robusta de los errores