Mecanismo de Pesos Base en Precisión Mixta (AMP)

El entrenamiento en precisión mixta automática (AMP) es fundamental para acelerar el proceso de aprendizaje profundo y optimizar el uso de la VRAM. En el ecosistema de Ultralytics, la implementación de AMP requiere un modelo de referencia estandarizado para inicializar y estabilizar los cálculos de punto flotante de 16 bits. A partir de la versión 8.3.x, el framework modificó su lógica de carga, lo que provoca que el sistema descargue automáticamente el archivo yolov11n.pt incluso si el modelo principal en entrenamiento es una variante de YOLOv8 o YOLOv10.

• Punto de anclaje computacional: El peso base actúa como un calibrador para los escalares de pérdida (loss scalers) en AMP, garantizando que no haya desbordamientos (overflows) numéricos.
• Aislamiento de arquitecturas: El modelo que se está entrenando (por ejemplo, yolov8m.pt) y el peso de referencai para AMP (yolov11n.pt) son entidades independientes en memoria.
• Resolución automática: Si el archivo de referencia no se encuentra en el directorio local o en la caché, el gestor de descargas integrado lo obtiene de los repositorios oficiales.

Evolución de los Requisitos de Pesos por Versión

La transición entre versiones de la biblioteca introdujo cambios en los archivos de inicialización de AMP. Comprender esta transición evita confusiones durante la ejecución de los scripts.

Estrategias de Configuración para Arquitecturas Específicas

Entrenamiento de la Familia YOLOv8

Para desplegar un modelo de la serie v8 bajo la versión 8.3.x, es obligatorio disponer del peso de la nano-versión de v11. A continuación, se muestra una implementación reestructurada:

from ultralytics import YOLO

# Carga del modelo objetivo para el entrenamiento
target_network = YOLO("yolov8m.pt")

# Definición de hiperparámetros en un diccionario para mayor claridad
training_config = {
    "data": "dataset_config.yaml",
    "epochs": 250,
    "imgsz": 640,
    "batch": 32,
    "amp": True,  # Activa la precisión mixta y requiere yolov11n.pt
    "device": "0"
}

# Ejecución del bucle de entrenamiento
target_network.train(**training_config)

Consideraciones Especiales para YOLOv10

La arquitectura v10 carece de la capa NMS (Non-Maximum Suppression) tradicional, lo que exige una carga explícita de sus pesos preentrenados, menteniendo simultáneamente el requisito del calibrador AMP.

import os
from ultralytics import YOLO

# Asegurar la existencia del peso preentrenado v10
v10_weights = "yolov10n.pt"
if not os.path.exists(v10_weights):
    os.system(f"wget https://github.com/ultralytics/assets/releases/download/v8.2.0/{v10_weights}")

# Inicialización con archivo YAML y carga de pesos
v10_detector = YOLO("yolov10n.yaml").load(v10_weights)

# El framework buscará automáticamente yolov11n.pt para la calibración AMP
v10_detector.train(data="custom_data.yaml", epochs=150, amp=True)

Aislamiento de Entornos para Múltiples Versiones

Si el flujo de trabajo requiere alternar entre versiones antiguas y nuevas del framework, se recomienda utilizar entornos virtuales segregados para evitar conflictos de dependencias y pesos:

# Entorno para versiones legacy (8.2.x y anteriores)
conda create -n env_yolo_legacy python=3.9 -y
conda activate env_yolo_legacy
pip install ultralytics==8.2.40

# Entorno para versiones modernas (8.3.x en adelante)
conda create -n env_yolo_modern python=3.11 -y
conda activate env_yolo_modern
pip install ultralytics>=8.3.0

Resolución de Problemas y Optimización de Recursos

Manejo de Fallos en la Descarga Automática

En entornos con restricciones de red o servidores sin acceso a internet, la descarga automática del peso base fallará. La solución consiste en inyectar la ruta local del archivo:

import shutil
from pathlib import Path
from ultralytics import YOLO

# Ruta local donde se almacenó manualmente el peso base
local_amp_weight = Path("/opt/weights/yolov11n.pt")
cache_dir = Path.home() / ".config" / "Ultralytics" / "weights"

# Copia forzada a la caché del sistema si no existe
if not (cache_dir / local_amp_weight.name).exists():
    cache_dir.mkdir(parents=True, exist_ok=True)
    shutil.copy(local_amp_weight, cache_dir)

network = YOLO("yolov8l.pt")
network.train(data="coco8.yaml", epochs=50)

Ajuste de Hiperparámetros para Estabilidad en AMP

La precisión mixta puede causar inestabilidad en los gradientes si la tasa de aprendizaje es demasiado agresiva. Se sugiere modificar la configuración del optimizador:

Mitigación de Errores de Memoria (OOM)

Cuando la VRAM se agota durante la fase de validación o entrenamiento con AMP activado, aplique las siguientes técnicas de compensación:

detector = YOLO("yolov8x.pt")

# Configuración con acumulación de gradientes y congelación parcial
detector.train(
    data="large_dataset.yaml",
    batch=8,
    accumulate=8,       # Simula un batch de 64 sin aumentar la VRAM
    freeze=10,          # Congela las primeras 10 capas del backbone
    imgsz=512,          # Reduce la resolución espacial de entrada
    amp=True
)

Técnicas Avanzadas: Validación y Personalización

Script de Verificación de Compatibilidad del Entorno

Antes de lanzar procesos de entrenamiento prolongados, es recomendable ejecutar un script que valide la versión instalada y los requisitos de hardware:

import ultralytics
from packaging.version import parse

def validate_amp_requirements():
    current_version = parse(ultralytics.__version__)
    target_version = parse("8.3.0")
    
    if current_version >= target_version:
        print(f"[INFO] Versión {current_version} detectada. Se requiere 'yolov11n.pt' para AMP.")
    else:
        print(f"[INFO] Versión {current_version} detectada. Se requiere 'yolov8n.pt' para AMP.")
        
    # Verificación de soporte de hardware para FP16
    import torch
    if torch.cuda.is_available():
        device_props = torch.cuda.get_device_properties(0)
        compute_capability = device_props.major
        print(f"[INFO] GPU: {device_props.name} (Compute Capability: {compute_capability}.x)")
        if compute_capability < 7:
            print("[WARN] La arquitectura de la GPU no soporta nativamente Tensor Cores para FP16.")

validate_amp_requirements()

Exportación de Pesos Base Optimizados

Para clústeres de inferencia o entrenamiento distribuido, puede compilar una versión optimizada del peso de referencia AMP utilizando el motor de exportación:

# Generación de un modelo base en formato ONNX con precisión FP16
yolo export model=yolov11n.pt format=onnx half=True dynamic=False opset=12