Detección YOLOv9/v10

Detección de objetos en tiempo real de vanguardia — entrena y despliega los últimos modelos YOLO en GPU

YOLO (You Only Look Once) sigue siendo el estándar de oro para la detección de objetos en tiempo real. YOLOv9 introdujo Información de Gradiente Programable (PGI) y la Red de Agregación de Capas Eficiente Generalizada (GELAN), mientras que YOLOv10 trajo detección sin NMS con asignaciones de etiquetas duales. Ambos ofrecen compensaciones de precisión/velocidad de primer nivel en GPUs NVIDIA.

• YOLOv9 GitHub: WongKinYiu/yolov9 — 8K+ ⭐

• YOLOv10 GitHub: THU-MIG/yolov10 — 10K+ ⭐

• Ultralytics (unificado): ultralytics/ultralytics — 32K+ ⭐

---

YOLOv9 vs YOLOv10 vs YOLOv8 — Comparación rápida

Modelo	mAP50-95	Velocidad (A100)	Parámetros	NMS
YOLOv8x	53.9	14.2ms	68.2M	Requerido
YOLOv9e	55.6	16.8ms	57.3M	Requerido
YOLOv10x	54.4	10.7ms	29.5M	Libre
YOLOv10b	53.0	8.8ms	19.1M	Libre
YOLOv10s	46.8	4.2ms	7.2M	Libre

YOLOv10 es sin NMS — sin la etapa de Supresión de Máximos No Máximos en el post-procesado. Esto permite un despliegue de extremo a extremo y es particularmente beneficioso para escenarios de edge/embebidos y despliegues con TensorRT.

---

Casos de uso

• Seguridad y vigilancia — detección en tiempo real de personas/vehículos/objetos

• Vehículos autónomos — detección de peatones y obstáculos

• Control de calidad en manufactura — detección de defectos en líneas de producción

• Analítica minorista — flujo de clientes y detección de productos

• Imágenes médicas — detección de anomalías en radiografías y escaneos

• Analítica deportiva — seguimiento de jugadores y pelota

• Agricultura — detección de enfermedades de cultivos y plagas

---

Prerrequisitos

• Cuenta de Clore.ai con alquiler de GPU

• Datos de entrenamiento (para entrenar un modelo personalizado) o usar pesos preentrenados de COCO

• Conocimientos básicos de Python y línea de comandos

---

Paso 1 — Alquila una GPU en Clore.ai

1. Ve a clore.ai → Marketplace

2. Elige la GPU según tu tarea:

   • Solo inferencia: RTX 3080/3090 o RTX 4080 — excelente relación precio/rendimiento

   • Entrenamiento de modelos pequeños: RTX 4090 24GB

   • Entrenamiento de modelos grandes (YOLOv9e/YOLOv10x): A100 40/80GB

Para inferencia en tiempo real (flujos de video), la RTX 3090 o la RTX 4090 ofrecen 100–500 FPS dependiendo de la variante del modelo. Incluso la más pequeña YOLOv10n funciona a más de 1000 FPS en una 4090 con TensorRT.

---

Paso 2 — Desplegar el contenedor de Ultralytics

La imagen Docker oficial de Ultralytics admite YOLOv8, YOLOv9 y YOLOv10 a través de una API unificada:

Imagen Docker:

ultralytics/ultralytics:latest

Puertos:

22
8000

Variables de entorno:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Disco: 20GB mínimo (pesos preentrenados + tu conjunto de datos)

---

Paso 3 — Conectar y verificar

ssh root@<ip-del-servidor> -p <puerto-ssh>

# Comprobar GPU
nvidia-smi

# Comprobar instalación de Ultralytics
python3 -c "import ultralytics; ultralytics.checks()"

# Debería mostrar información de la GPU, versión de CUDA y disponibilidad de modelos

---

Paso 4 — Inferencia rápida con modelos preentrenados

Inferencia YOLOv10 (sin NMS)

from ultralytics import YOLO
import cv2

# Cargar el modelo YOLOv10 (descarga automática si no está presente)
model = YOLO("yolov10x.pt")  # Opciones: n, s, m, b, l, x

# Ejecutar inferencia en una imagen
results = model("https://ultralytics.com/images/bus.jpg")

# Mostrar resultados
for result in results:
    boxes = result.boxes
    print(f"Detected {len(boxes)} objects")
    for box in boxes:
        cls = int(box.cls[0])
        conf = float(box.conf[0])
        xyxy = box.xyxy[0].tolist()
        print(f"  {model.names[cls]}: {conf:.2f} at {[int(x) for x in xyxy]}")

# Guardar imagen anotada
results[0].save("output.jpg")

Inferencia YOLOv9

from ultralytics import YOLO

# Cargar el modelo YOLOv9
model = YOLO("yolov9e.pt")  # Opciones: t, s, m, c, e

# Inferencia por lotes para máximo rendimiento
results = model(
    source=[
        "image1.jpg",
        "image2.jpg",
        "image3.jpg",
    ],
    batch=8,        # Procesar 8 imágenes en paralelo
    device="cuda",
    conf=0.25,      # Umbral de confianza
    iou=0.45,       # Umbral IoU para NMS (no necesario para v10)
    imgsz=640,
    half=True       # FP16 para 2x de aceleración
)

Inferencia en flujo de video en tiempo real

from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# Para webcam (device=0) o archivo de video
cap = cv2.VideoCapture("input_video.mp4")

# Obtener propiedades del video
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# Escritor de salida
out = cv2.VideoWriter(
    "output_video.mp4",
    cv2.VideoWriter_fourcc(*"mp4v"),
    fps,
    (width, height)
)

frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    results = model(frame, conf=0.25, verbose=False)
    annotated = results[0].plot()
    out.write(annotated)
    frame_count += 1
    
    if frame_count % 100 == 0:
        print(f"Processed {frame_count} frames")

cap.release()
out.release()
print("¡Hecho! Salida guardada en output_video.mp4")

---

Paso 5 — Entrenar un modelo personalizado

Prepara tu conjunto de datos

YOLO usa una estructura de directorios y un formato de etiquetas específicos:

dataset/
├── images/
│   ├── train/          # Imágenes de entrenamiento (.jpg/.png)
│   ├── val/            # Imágenes de validación
│   └── test/           # Imágenes de prueba (opcional)
└── labels/
    ├── train/          # Archivos de etiquetas (.txt)
    ├── val/
    └── test/

Cada archivo de etiqueta (mismo nombre que la imagen, .txt extensión) contiene:

# class_id center_x center_y width height (todos normalizados 0-1)
0 0.512 0.334 0.256 0.412
1 0.123 0.654 0.089 0.123

Crear configuración del conjunto de datos

cat > /workspace/custom_dataset.yaml << 'EOF'
# Configuración del conjunto de datos
path: /workspace/dataset
train: images/train
val: images/val
test: images/test

# Número de clases
nc: 3

# Nombres de clases
names:
  0: person
  1: car
  2: bicycle
EOF

Importar desde Roboflow (Recomendado)

# Instalar Roboflow
pip install roboflow

from roboflow import Roboflow
rf = Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace("your-workspace").project("your-project")
version = project.version(1)
dataset = version.download("yolov9")

# El conjunto de datos ahora está en ./your-project-1/

Entrenar YOLOv10

from ultralytics import YOLO

# Cargar modelo YOLOv10 preentrenado (aprendizaje por transferencia)
model = YOLO("yolov10m.pt")  # Variante mediana — buen equilibrio

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=16,               # Ajusta según la VRAM de tu GPU
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov10_custom",
    patience=50,            # Parada temprana
    save=True,
    save_period=10,         # Guardar checkpoint cada 10 épocas
    plots=True,
    val=True,
    augment=True,           # Aumento de datos
    degrees=10.0,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.1,
    copy_paste=0.1,
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    amp=True                # Precisión mixta automática (FP16)
)

print(f"¡Entrenamiento completado! Mejor mAP: {results.results_dict['metrics/mAP50-95(B)']:.3f}")

Entrenar YOLOv9

from ultralytics import YOLO

model = YOLO("yolov9e.pt")

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=8,               # v9e es más grande, necesita menos batch
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov9_custom",
    amp=True,
    optimizer="SGD",
    momentum=0.937,
    weight_decay=0.0005
)

Consejos de entrenamiento:

• Tamaño de lote: Comienza con batch=16 para RTX 4090, batch=32 para A100 40GB

• Tamaño de imagen: imgsz=640 es estándar; usa 1280 para tareas de alta resolución

• Épocas: 100 épocas es típico para fine-tuning, 300+ para entrenar desde cero

• AMP (Precisión Mixta): Siempre habilita amp=True para 1.5–2x de aceleración

---

Paso 6 — Exportar a TensorRT para máxima velocidad

from ultralytics import YOLO

# Cargar modelo entrenado
model = YOLO("/workspace/runs/yolov10_custom/weights/best.pt")

# Exportar a TensorRT (FP16 para mejor balance velocidad/precisión)
model.export(
    format="engine",        # Motor de TensorRT
    device="cuda",
    half=True,              # FP16
    dynamic=False,          # Formas estáticas para máxima optimización TRT
    batch=1,                # Optimizar para tamaño de lote 1 (tiempo real)
    imgsz=640,
    workspace=4             # Espacio de trabajo TRT en GB
)
# Guardado como: best.engine

# Cargar y ejecutar motor TRT
trt_model = YOLO("best.engine")
results = trt_model("image.jpg")

Exportar a ONNX

# Exportar a ONNX para flexibilidad de despliegue
model.export(
    format="onnx",
    opset=17,
    half=True,              # Pesos FP16
    dynamic=True,           # Tamaño de lote dinámico
    simplify=True
)

---

Paso 7 — Servir como API REST

pip install fastapi uvicorn python-multipart

cat > /workspace/yolo_api.py << 'EOF'
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse, FileResponse
from ultralytics import YOLO
from PIL import Image
import io
import uuid
import os

app = FastAPI(title="YOLOv10 Detection API")
model = YOLO("yolov10x.pt")

@app.get("/health")
async def health():
    return {"status": "ok", "model": "yolov10x", "device": "cuda"}

@app.post("/detect")
async def detect(
    file: UploadFile = File(...),
    conf: float = 0.25,
    iou: float = 0.45,
    return_image: bool = False
):
    # Leer imagen subida
    image_data = await file.read()
    img = Image.open(io.BytesIO(image_data)).convert("RGB")
    
    # Ejecutar detección
    results = model(img, conf=conf, iou=iou, verbose=False)
    result = results[0]
    
    # Construir respuesta
    detections = []
    for box in result.boxes:
        detections.append({
            "class": model.names[int(box.cls[0])],
            "confidence": round(float(box.conf[0]), 4),
            "bbox": [round(x, 2) for x in box.xyxy[0].tolist()],
            "class_id": int(box.cls[0])
        })
    
    response = {
        "count": len(detections),
        "detections": detections,
        "image_size": list(result.orig_shape)
    }
    
    if return_image:
        output_path = f"/tmp/{uuid.uuid4()}.jpg"
        result.save(filename=output_path)
        return FileResponse(output_path, media_type="image/jpeg")
    
    return JSONResponse(response)

@app.post("/detect/batch")
async def detect_batch(files: list[UploadFile] = File(...)):
    results = []
    for file in files:
        data = await file.read()
        img = Image.open(io.BytesIO(data)).convert("RGB")
        res = model(img, verbose=False)[0]
        results.append({
            "filename": file.filename,
            "count": len(res.boxes),
            "detections": [
                {"class": model.names[int(b.cls[0])], "conf": float(b.conf[0])}
                for b in res.boxes
            ]
        })
    return JSONResponse({"results": results})

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF

python3 /workspace/yolo_api.py &

# Prueba la API
curl -X POST "http://localhost:8000/detect" \
    -F "file=@test_image.jpg" | python3 -m json.tool

---

Paso 8 — Validar y medir el rendimiento de tu modelo

from ultralytics import YOLO

model = YOLO("yolov10x.pt")

# Validar en el conjunto de datos COCO
metrics = model.val(
    data="coco.yaml",
    imgsz=640,
    batch=32,
    device="cuda",
    half=True
)

print(f"mAP50:    {metrics.box.map50:.3f}")
print(f"mAP50-95: {metrics.box.map:.3f}")
print(f"Precisión: {metrics.box.mp:.3f}")
print(f"Recall:    {metrics.box.mr:.3f}")

# Medir la velocidad
model.benchmark(
    format="engine",   # Comparar múltiples formatos de exportación
    imgsz=640,
    half=True,
    device="cuda"
)

---

Descargar resultados

# Desde tu máquina local:
scp -P <ssh-port> root@<server-ip>:/workspace/runs/yolov10_custom/weights/best.pt ./
scp -P <ssh-port> root@<server-ip>:/workspace/output_video.mp4 ./

# Descargar toda la ejecución de entrenamiento
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/workspace/runs/ \
    ./yolo_training_runs/

---

Solución de problemas

CUDA fuera de memoria durante el entrenamiento

# Reduce el tamaño del batch
model.train(data="data.yaml", batch=4, imgsz=640)

# O habilitar checkpointing de gradientes
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)

Velocidad de entrenamiento lenta

# Habilitar caché (carga el conjunto de datos en RAM/GPU)
model.train(data="data.yaml", cache=True)  # Caché en RAM
model.train(data="data.yaml", cache="disk")  # Caché en disco

# Aumentar workers (cuidado: demasiados pueden ralentizar)
model.train(data="data.yaml", workers=8)

Bajo mAP / Detección deficiente

# Verificar que las etiquetas sean correctas (normalizadas, dentro de 0-1)
python3 -c "
from ultralytics.data.utils import check_det_dataset
check_det_dataset('custom_dataset.yaml')
"

# Visualizar muestras de entrenamiento
python3 -c "
from ultralytics import YOLO
model = YOLO('yolov10m.pt')
model.train(data='data.yaml', epochs=1, batch=4, plots=True)
# Revisar /workspace/runs/train/exp/train_batch*.jpg
"

---

Referencia de rendimiento (GPUs de Clore.ai)

Modelo	GPU	Lote	FPS (inferencia)	mAP50-95
YOLOv10n	RTX 3090	1	1,200	38.5
YOLOv10s	RTX 3090	1	780	46.8
YOLOv10m	RTX 4090	1	950	51.3
YOLOv10x	RTX 4090	1	380	54.4
YOLOv9e	A100 40G	1	720	55.6
YOLOv10x TRT	RTX 4090	1	920	54.2

---

Recursos adicionales

• Documentación de Ultralytics

• Artículo YOLOv9

• Artículo YOLOv10

• Roboflow Universe — 100K+ conjuntos de datos públicos

• Ultralytics HUB — Plataforma de entrenamiento en la nube

• Conjunto de datos COCO — Conjunto de datos de referencia estándar

---

YOLOv9 y YOLOv10 en los alquileres de GPU de Clore.ai ofrecen una vía asequible para entrenar modelos personalizados de detección de objetos y desplegar canalizaciones de inferencia en tiempo real — sin la sobrecarga de AWS SageMaker o Google Vertex AI.

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Inferencia en Producción	RTX 4090 (24GB)	~$0.70/gpu/hr
Entrenamiento con lotes grandes	A100 80GB	~$1.20/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.