> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/vision-por-computadora/yolov9-v10.md).

# Detección con YOLOv9/v10

> **Detección de objetos en tiempo real de última generación — entrena e implementa los modelos YOLO más recientes 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 Programable Gradient Information (PGI) y Generalized Efficient Layer Aggregation Network (GELAN), mientras que YOLOv10 trajo detección sin NMS con asignaciones de doble etiqueta. Ambos ofrecen una relación precisión/velocidad de primer nivel en GPUs NVIDIA.

* **GitHub de YOLOv9:** [WongKinYiu/yolov9](https://github.com/WongKinYiu/yolov9) — 8K+ ⭐
* **GitHub de YOLOv10:** [THU-MIG/yolov10](https://github.com/THU-MIG/yolov10) — 10K+ ⭐
* **Ultralytics (unificado):** [ultralytics/ultralytics](https://github.com/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** |

{% hint style="success" %}
**YOLOv10 no requiere NMS** — sin paso de posprocesamiento de Supresión No Máxima. Esto permite una implementación de extremo a extremo y es especialmente beneficioso para escenarios perimetrales/embebidos y la implementación con TensorRT.
{% endhint %}

***

## Casos de uso

* **Seguridad y vigilancia** — detección de personas/vehículos/objetos en tiempo real
* **Vehículos autónomos** — detección de peatones y obstáculos
* **Control de calidad en fabricación** — 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 balón
* **Agricultura** — detección de enfermedades de cultivos y plagas

***

## Requisitos previos

* Cuenta de Clore.ai con alquiler de GPU
* Datos de entrenamiento (para entrenamiento de modelos personalizados) o usa pesos preentrenados de COCO
* Conocimientos básicos de Python y de línea de comandos

***

## Paso 1 — Alquila una GPU en Clore.ai

1. Ve a [clore.ai](https://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

{% hint style="info" %}
**Para inferencia en tiempo real** (flujos de video), la RTX 3090 o RTX 4090 ofrece 100–500 FPS según la variante del modelo. Incluso el YOLOv10n más pequeño funciona a más de 1000 FPS en una 4090 con TensorRT.
{% endhint %}

***

## Paso 2 — Despliega el contenedor de Ultralytics

La imagen oficial de Docker de Ultralytics admite YOLOv8, YOLOv9 y YOLOv10 mediante una API unificada:

**Imagen de 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 — Conecta y verifica

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

# Verificar GPU
nvidia-smi

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

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

***

## Paso 4 — Inferencia rápida con modelos preentrenados

### Inferencia YOLOv10 (sin NMS)

```python
from ultralytics import YOLO
import cv2

# Cargar el modelo YOLOv10 (se descarga automáticamente 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"Se detectaron {len(boxes)} objetos")
    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} en {[int(x) for x in xyxy]}")

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

### Inferencia YOLOv9

```python
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 de NMS (no necesario para v10)
    imgsz=640,
    half=True       # FP16 para una aceleración de 2x
)
```

### Inferencia de transmisión de video en tiempo real

```python
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"Procesadas {frame_count} fotogramas")

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

***

## Paso 5 — Entrena 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 etiquetas (con el mismo nombre que la imagen, `.txt` extensión) contiene:

```
# class_id center_x center_y width height (todo normalizado de 0 a 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

```bash
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 las clases
names:
  0: persona
  1: coche
  2: bicicleta
EOF
```

### Importar desde Roboflow (Recomendado)

```python
# 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

```python
from ultralytics import YOLO

# Cargar el modelo YOLOv10 preentrenado (transfer learning)
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 anticipada
    save=True,
    save_period=10,         # Guardar un punto de control cada 10 épocas
    plots=True,
    val=True,
    augment=True,           # Aumentación 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 completo! Mejor mAP: {results.results_dict['metrics/mAP50-95(B)']:.3f}")
```

### Entrenar YOLOv9

```python
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, requiere un batch menor
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov9_custom",
    amp=True,
    optimizer="SGD",
    momentum=0.937,
    weight_decay=0.0005
)
```

{% hint style="info" %}
**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 lo habitual para ajuste fino, 300+ para entrenamiento desde cero
* **AMP (Precisión mixta):** Actívalo siempre `amp=True` para una aceleración de 1.5–2x
  {% endhint %}

***

## Paso 6 — Exporta a TensorRT para máxima velocidad

```python
from ultralytics import YOLO

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

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

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

### Exportar a ONNX

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

***

## Paso 7 — Servir como una API REST

```bash
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="API de detección YOLOv10")
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 la 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 — Valida y evalúa tu modelo

```python
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}")

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

***

## Descargar resultados

```bash
# 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 se quedó sin memoria durante el entrenamiento

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

# O activa la verificación de gradientes por puntos de control
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)
```

### Velocidad de entrenamiento lenta

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

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

### mAP bajo / Detección deficiente

```bash
# 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)
# Revisa /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](https://docs.ultralytics.com/)
* [Artículo sobre YOLOv9](https://arxiv.org/abs/2402.13616)
* [Artículo sobre YOLOv10](https://arxiv.org/abs/2405.14458)
* [Roboflow Universe](https://universe.roboflow.com/) — más de 100 mil conjuntos de datos públicos
* [Ultralytics HUB](https://hub.ultralytics.com/) — plataforma de entrenamiento en la nube
* [Conjunto de datos COCO](https://cocodataset.org/) — conjunto de datos de referencia estándar

***

*YOLOv9 y YOLOv10 en los alquileres de GPU de Clore.ai ofrecen una forma asequible de entrenar modelos personalizados de detección de objetos e implementar canalizaciones de inferencia en tiempo real, sin la complejidad de AWS SageMaker o Google Vertex AI.*

***

## Recomendaciones de GPU para Clore.ai

| Caso de uso                     | GPU recomendada | Costo estimado en Clore.ai                |
| ------------------------------- | --------------- | ----------------------------------------- |
| Desarrollo/Pruebas              | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| Inferencia en producción        | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| Entrenamiento con lotes grandes | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

> 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/vision-por-computadora/yolov9-v10.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.