> 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/yolov8-detection.md).

# Detección con YOLOv8

Detección de objetos en tiempo real con YOLOv8 y YOLOv11 en Clore.ai

Ejecuta 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 [Marketplace de CLORE.AI](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 `ultralytics` paquete. Ofrece **inferencia un 22% más rápida** y una mAP mejorada respecto a YOLOv8, con la misma API sencilla. Las nuevas funciones incluyen la detección de caja delimitadora orientada (OBB). Actualiza ejecutando `pip install -U ultralytics`.
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis pedidos**
* Interfaces web: Usa 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 y añade:

* **inferencia un 22% más rápida** frente a YOLOv8
* Mayor mAP en todos los tamaños de modelo
* **Caja delimitadora orientada (OBB)** detección — nueva tarea
* Arquitectura mejorada (bloques C3k2, SPPF, C2PSA)
* Mismo `ultralytics` paquete, reemplazo directo

### Tareas compatibles (YOLOv11)

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

## Tamaños de modelo

### 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 entre YOLOv8 y 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, 640 px) | \~150   | \~183   | **+22% más rápido**  |
| Tarea OBB              | ❌       | ✅       | **Nuevo en v11**     |

## Despliegue rápido

**Imagen de Docker:**

```
pytorch/pytorch:2.11.0-cuda12.8-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='Detección YOLOv11')
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Instalación

```bash
pip install ultralytics
```

El mismo paquete para YOLOv8 y YOLOv11. Actualiza para obtener YOLOv11:

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

## Detección de objetos YOLOv11

### Detección básica con yolo11m

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

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

# Ejecuta la inferencia
results = model('image.jpg')

# Muestra los resultados
results[0].show()

# Guarda los 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} en ({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)

# Procesa 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

# Carga el 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

# Carga el 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

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

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

### Caja delimitadora orientada (OBB) — NUEVO en YOLOv11

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

```python
from ultralytics import YOLO

# Carga el modelo OBB 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} caja rotada: {xywhr}")
```

## Procesamiento de video

### Procesar video

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

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

### Cámara web en tiempo real

```python
from ultralytics import YOLO
import cv2

model = YOLO('yolo11n.pt')  # Usa 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')

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

# Accede 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

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

# Entrena
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,         # Parada temprana
    save=True,
    save_period=10,      # Guarda cada N épocas
    cache=True,          # Almacena imágenes en caché
    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')

# Exporta 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 a TensorRT

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

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

### Inferencia por lotes

```python

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

## Benchmark de rendimiento

### FPS de YOLOv11 (entrada de 640 px)

| 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 de 640 px) — 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

### Sin memoria

```python

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

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

### Procesamiento lento

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

### Baja precisión

* Usa un modelo más grande (yolo11x en lugar de yolo11n)
* Entrena con datos personalizados
* Aumenta el tamaño de la imagen

## Estimación de costos

Tarifas típicas del mercado 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. Consulta* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de \~13% de descuento), el resto lo iguala
* Paga con **CLORE** tokens
* Compara precios entre distintos proveedores

## Próximos pasos

* [Segment Anything](/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 los objetos detectados


---

# 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/yolov8-detection.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.