# Detección YOLOv8

Ejecute la detección de objetos en tiempo real con Ultralytics YOLOv8 y YOLOv11.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Actualización: YOLOv11 (2025) — 22% más rápido**

YOLOv11 ya está disponible a través del mismo `paquete ultralytics` proporciona **inferencia un 22% más rápida** y mAP mejorado respecto a YOLOv8, con la misma API simple. Las nuevas funciones incluyen la detección con cuadros delimitadores orientados (OBB). Actualice ejecutando `pip install -U ultralytics`.
{% endhint %}

## Alquiler en CLORE.AI

1. Visitar [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio por puja)
4. Configure su pedido:
   * Seleccione la imagen de Docker
   * Establezca puertos (TCP para SSH, HTTP para interfaces web)
   * Agregue variables de entorno si es necesario
   * Ingrese el comando de inicio
5. Seleccione el pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Cree el pedido y espere el despliegue

### Acceda a su servidor

* Encuentre los detalles de conexión en **Mis pedidos**
* Interfaces web: use la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es YOLOv8?

YOLOv8 es un modelo YOLO de alto rendimiento que ofrece:

* Detección de objetos
* Segmentación de instancias
* Estimación de pose
* Clasificación de imágenes
* Seguimiento de objetos

## ¿Qué es YOLOv11?

YOLOv11 (2025) es la última generación, que añade:

* **inferencia un 22% más rápida** vs YOLOv8
* Mayor mAP en todos los tamaños de modelo
* **Detección con cuadros delimitadores orientados (OBB)** — nueva tarea
* Arquitectura mejorada (bloques C3k2, SPPF, C2PSA)
* Mismo `paquete ultralytics` paquete, reemplazo directo

### Tareas compatibles (YOLOv11)

| Tarea      | Sufijo      | Descripción                                                   |
| ---------- | ----------- | ------------------------------------------------------------- |
| `detect`   | *(ninguno)* | Detección de objetos con cuadros delimitadores                |
| `segment`  | `-seg`      | Segmentación de instancias con máscaras                       |
| `classify` | `-cls`      | Clasificación de imágenes                                     |
| `pose`     | `-pose`     | Estimación de pose humana                                     |
| `obb`      | `-obb`      | **NUEVO** Cuadros delimitadores orientados (detección rotada) |

## Tamaños de modelos

### Modelos YOLOv8

| Modelo  | Tamaño | mAP  | Velocidad (RTX 3090) |
| ------- | ------ | ---- | -------------------- |
| YOLOv8n | 3.2M   | 37.3 | \~1ms                |
| YOLOv8s | 11.2M  | 44.9 | \~2ms                |
| YOLOv8m | 25.9M  | 50.2 | \~4ms                |
| YOLOv8l | 43.7M  | 52.9 | \~6ms                |
| YOLOv8x | 68.2M  | 53.9 | \~8ms                |

### Modelos YOLOv11

| Modelo  | Tamaño | mAP  | Velocidad (RTX 3090) |
| ------- | ------ | ---- | -------------------- |
| yolo11n | 2.6M   | 39.5 | \~0.8ms              |
| yolo11s | 9.4M   | 47.0 | \~1.5ms              |
| yolo11m | 20.1M  | 51.5 | \~3.2ms              |
| yolo11l | 25.3M  | 53.4 | \~4.7ms              |
| yolo11x | 56.9M  | 54.7 | \~6.5ms              |

### Comparación YOLOv8 vs YOLOv11

| Métrica               | YOLOv8x | yolo11x | Mejora               |
| --------------------- | ------- | ------- | -------------------- |
| Parámetros            | 68.2M   | 56.9M   | **-17% más pequeño** |
| mAP50-95 (COCO)       | 53.9    | 54.7    | **+0.8 mAP**         |
| Inferencia (RTX 3090) | \~8ms   | \~6.5ms | **+22% más rápido**  |
| FPS (RTX 3090, 640px) | \~150   | \~183   | **+22% más rápido**  |
| Tarea OBB             | ❌       | ✅       | **Nuevo en v11**     |

## Despliegue rápido

**Imagen de Docker:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Puertos:**

```
22/tcp
7860/http
```

**Comando (YOLOv11):**

```bash
pip install ultralytics gradio && \
python -c "
import gradio as gr
from ultralytics import YOLO
from PIL import Image

model = YOLO('yolo11m.pt')

def detect(image):
    results = model(image)
    return Image.fromarray(results[0].plot())

demo = gr.Interface(fn=detect, inputs=gr.Image(type='pil'), outputs=gr.Image(), title='YOLOv11 Detection')
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Accediendo a su servicio

Después del despliegue, encuentre su `http_pub` URL en **Mis pedidos**:

1. Ir a **Mis pedidos** página
2. Haga clic en su pedido
3. Encuentre la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Use `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos de abajo.

## Instalación

```bash
pip install ultralytics
```

Mismo paquete para YOLOv8 y YOLOv11. Actualice para obtener YOLOv11:

```bash
pip install -U ultralytics
```

## Detección de objetos con YOLOv11

### Detección básica con yolo11m

```python
from ultralytics import YOLO
from PIL import Image

# Cargar modelo mediano YOLOv11
model = YOLO('yolo11m.pt')

# Ejecutar inferencia
results = model('image.jpg')

# Mostrar resultados
results[0].show()

# Guardar resultados
results[0].save('output.jpg')
```

### Obtener detecciones

```python
results = model('image.jpg')

for result in results:
    boxes = result.boxes
    for box in boxes:
        # Coordenadas
        x1, y1, x2, y2 = box.xyxy[0].tolist()

        # Confianza
        conf = box.conf[0].item()

        # Clase
        cls = int(box.cls[0].item())
        name = model.names[cls]

        print(f"{name}: {conf:.2f} at ({x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f})")
```

### Procesamiento por lotes

```python
from ultralytics import YOLO
import os

model = YOLO('yolo11m.pt')

input_dir = './images'
output_dir = './detected'
os.makedirs(output_dir, exist_ok=True)

# Procesar todas las imágenes
results = model(input_dir, save=True, project=output_dir)
```

## Tareas de YOLOv11

### Segmentación de instancias

```python
from ultralytics import YOLO

# Cargar modelo de segmentación YOLOv11
model = YOLO('yolo11m-seg.pt')

results = model('image.jpg')

for result in results:
    masks = result.masks  # Máscaras de segmentación
    if masks is not None:
        for mask in masks.data:
            # mask es un tensor binario
            pass
```

### Estimación de pose

```python
from ultralytics import YOLO

# Cargar modelo de pose YOLOv11
model = YOLO('yolo11m-pose.pt')

results = model('image.jpg')

for result in results:
    keypoints = result.keypoints
    if keypoints is not None:
        for kp in keypoints.data:
            # 17 puntos clave: nariz, ojos, orejas, hombros, codos, muñecas, caderas, rodillas, tobillos
            pass
```

### Clasificación

```python
from ultralytics import YOLO

# Cargar modelo de clasificación YOLOv11
model = YOLO('yolo11m-cls.pt')

results = model('image.jpg')
for result in results:
    # Clase Top-1 y confianza
    top1 = result.probs.top1
    top1conf = result.probs.top1conf.item()
    print(f"Class: {result.names[top1]} ({top1conf:.2f})")
```

### Cuadro delimitador orientado (OBB) — NUEVO en YOLOv11

OBB detecta objetos en cualquier ángulo de rotación — perfecto para imágenes aéreas/satélite, escaneo de documentos y detección de texto.

```python
from ultralytics import YOLO

# Cargar modelo OBB de YOLOv11
model = YOLO('yolo11m-obb.pt')

results = model('aerial_image.jpg')

for result in results:
    obb = result.obb
    if obb is not None:
        for box in obb:
            # Caja rotada: x_center, y_center, width, height, angle
            xywhr = box.xywhr[0].tolist()
            conf = box.conf[0].item()
            cls = int(box.cls[0].item())
            print(f"{result.names[cls]}: {conf:.2f} rotated box: {xywhr}")
```

## Procesamiento de video

### Procesar video

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Procesar video
results = model('video.mp4', save=True)
```

### Webcam en tiempo real

```python
from ultralytics import YOLO
import cv2

model = YOLO('yolo11n.pt')  # Use el modelo nano para tiempo real

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame)
    annotated = results[0].plot()

    cv2.imshow('YOLOv11', annotated)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
```

### Guardar video procesado

```python
from ultralytics import YOLO
import cv2

model = YOLO('yolo11m.pt')

cap = cv2.VideoCapture('input.mp4')
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))

out = cv2.VideoWriter('output.mp4', cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame)
    annotated = results[0].plot()
    out.write(annotated)

cap.release()
out.release()
```

## Seguimiento de objetos

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Rastrear objetos en el video
results = model.track('video.mp4', save=True, tracker='bytetrack.yaml')

# Acceder a los IDs de seguimiento
for result in results:
    boxes = result.boxes
    if boxes.id is not None:
        track_ids = boxes.id.tolist()
```

## Entrenamiento personalizado

### Preparar conjunto de datos

```yaml

# dataset.yaml
path: /workspace/dataset
train: images/train
val: images/val

names:
  0: cat
  1: dog
  2: bird
```

### Entrenar YOLOv11

```python
from ultralytics import YOLO

# Cargar modelo YOLOv11 preentrenado
model = YOLO('yolo11n.pt')

# Entrenar
results = model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0
)
```

### Argumentos de entrenamiento

```python
model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,
    workers=8,
    patience=50,         # Detención temprana
    save=True,
    save_period=10,      # Guardar cada N épocas
    cache=True,          # Cachear imágenes
    amp=True,            # Precisión mixta
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    box=7.5,
    cls=0.5,
    dfl=1.5,
    augment=True,
    hsv_h=0.015,
    hsv_s=0.7,
    hsv_v=0.4,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.0,
)
```

## Exportar modelo

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Exportar a diferentes formatos
model.export(format='onnx')           # ONNX
model.export(format='tensorrt')       # TensorRT
model.export(format='openvino')       # OpenVINO
model.export(format='coreml')         # CoreML
model.export(format='tflite')         # TensorFlow Lite
```

## Servidor API

```python
from fastapi import FastAPI, UploadFile
from fastapi.responses import JSONResponse
from ultralytics import YOLO
from PIL import Image
import io

app = FastAPI()
model = YOLO('yolo11m.pt')

@app.post("/detect")
async def detect(file: UploadFile):
    contents = await file.read()
    image = Image.open(io.BytesIO(contents))

    results = model(image)

    detections = []
    for box in results[0].boxes:
        detections.append({
            "class": model.names[int(box.cls[0])],
            "confidence": float(box.conf[0]),
            "bbox": box.xyxy[0].tolist()
        })

    return JSONResponse(content={"detections": detections})

@app.post("/segment")
async def segment(file: UploadFile):
    contents = await file.read()
    image = Image.open(io.BytesIO(contents))

    model_seg = YOLO('yolo11m-seg.pt')
    results = model_seg(image)

    # Devolver imagen anotada
    annotated = results[0].plot()
    # ... convertir y devolver

# Ejecutar: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Optimización del rendimiento

### Exportación TensorRT

```python
model = YOLO('yolo11m.pt')
model.export(format='tensorrt', half=True)

# Usar modelo exportado
model_trt = YOLO('yolo11m.engine')
results = model_trt('image.jpg')
```

### Inferencia por lotes

```python

# Procesar múltiples imágenes a la vez
images = ['img1.jpg', 'img2.jpg', 'img3.jpg', 'img4.jpg']
results = model(images, batch=4)
```

## Benchmarks de rendimiento

### FPS de YOLOv11 (entrada 640px)

| Modelo  | GPU      | FPS    |
| ------- | -------- | ------ |
| yolo11n | RTX 3090 | \~1100 |
| yolo11s | RTX 3090 | \~730  |
| yolo11m | RTX 3090 | \~370  |
| yolo11x | RTX 3090 | \~183  |
| yolo11x | RTX 4090 | \~305  |

### FPS de YOLOv8 (entrada 640px) — Generación anterior

| Modelo  | GPU      | FPS   |
| ------- | -------- | ----- |
| YOLOv8n | RTX 3090 | \~900 |
| YOLOv8s | RTX 3090 | \~600 |
| YOLOv8m | RTX 3090 | \~300 |
| YOLOv8x | RTX 3090 | \~150 |
| YOLOv8x | RTX 4090 | \~250 |

## Solución de problemas

### Falta de memoria

```python

# Use un modelo más pequeño
model = YOLO('yolo11n.pt')

# O reduzca el tamaño de la imagen
results = model('image.jpg', imgsz=320)
```

### Procesamiento lento

* Use exportación TensorRT
* Use un modelo más pequeño (yolo11n o yolo11s)
* Reduzca el tamaño de la imagen

### Baja precisión

* Use un modelo más grande (yolo11x en lugar de yolo11n)
* Entrene con datos personalizados
* Aumente el tamaño de la imagen

## Estimación de costos

Tarifas típicas del marketplace CLORE.AI (a partir de 2025):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| RTX 3060  | \~$0.03         | \~$0.70       | \~$0.12           |
| RTX 3090  | \~$0.06         | \~$1.50       | \~$0.25           |
| RTX 4090  | \~$0.10         | \~$2.30       | \~$0.40           |
| A100 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulte* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorre dinero:**

* Use **Spot** mercado para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Pague con **CLORE** tokens
* Compare precios entre diferentes proveedores

## Siguientes pasos

* [Segmentar cualquier cosa](/guides/guides_v2-es/procesamiento-de-imagenes/segment-anything.md) - Segmentación avanzada
* Detectron2 - Más opciones de detección
* [Real-ESRGAN](/guides/guides_v2-es/procesamiento-de-imagenes/real-esrgan-upscaling.md) - Mejorar objetos detectados


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/vision-por-computadora/yolov8-detection.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.