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.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

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.

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

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):

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

pip install ultralytics

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

pip install -U ultralytics

Detección de objetos YOLOv11

Detección básica con yolo11m

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

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

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

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

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

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.

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

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

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

Cámara web en tiempo real

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

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

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

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

names:
  0: cat
  1: dog
  2: bird

Entrenar YOLOv11

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

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

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

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

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

# 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

# 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 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 - Segmentación avanzada

• Detectron2 - Más opciones de detección

• Real-ESRGAN - Mejorar los objetos detectados