Link to this sectionGuía de inicio rápido de Modal para Ultralytics#

Esta guía proporciona una introducción completa a la ejecución de Ultralytics YOLO26 en Modal, cubriendo la inferencia con GPU serverless y el entrenamiento de modelos.

Link to this section¿Qué es Modal?#

Modal es una plataforma de cloud computing serverless para cargas de trabajo de IA y machine learning. Gestiona el aprovisionamiento, el escalado y la ejecución automáticamente; tú escribes código Python de forma local y Modal lo ejecuta en la nube con acceso a GPU. Esto lo hace ideal para ejecutar modelos de deep learning como YOLO26 sin gestionar infraestructura.

Link to this sectionLo que aprenderás#

• Configurar Modal y autenticarse
• Ejecutar inferencia de YOLO26 en Modal
• Usar GPUs para una inferencia más rápida
• Entrenar modelos YOLO26 en Modal

Link to this sectionRequisitos previos#

• Una cuenta de Modal (regístrate gratis en modal.com)
• Python 3.9 o superior instalado en tu máquina local

Link to this sectionInstalación#

Instala el paquete Python de Modal:

pip install modal

Luego autentica la CLI con tu cuenta de Modal:

modal token new

Link to this sectionEjecutar inferencia de YOLO26#

Crea un nuevo archivo Python llamado modal_yolo.py para ejecutar inferencia con el siguiente código:

"""
Modal + Ultralytics YOLO26 Quickstart
Run: modal run modal_yolo.py.
"""

import modal

app = modal.App("ultralytics-yolo")

image = modal.Image.debian_slim(python_version="3.11").apt_install("libgl1", "libglib2.0-0").pip_install("ultralytics")

@app.function(image=image)
def predict(image_url: str):
    """Run YOLO26 inference on an image URL."""
    from ultralytics import YOLO

    model = YOLO("yolo26n.pt")
    results = model(image_url)

    for r in results:
        print(f"Detected {len(r.boxes)} objects:")
        for box in r.boxes:
            print(f"  - {model.names[int(box.cls)]}: {float(box.conf):.2f}")

@app.local_entrypoint()
def main():
    """Test inference with sample image."""
    predict.remote("https://ultralytics.com/images/bus.jpg")

Ejecuta la inferencia:

modal run modal_yolo.py

Salida esperada:

✓ Initialized. View run at https://modal.com/apps/your-username/main/ap-xxxxxxxx
✓ Created objects.
├── 🔨 Created mount modal_yolo.py
└── 🔨 Created function predict.
Downloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt'...
Downloading https://ultralytics.com/images/bus.jpg to 'bus.jpg'...
image 1/1 /root/bus.jpg: 640x480 4 persons, 1 bus, 377.8ms
Speed: 5.8ms preprocess, 377.8ms inference, 0.3ms postprocess per image at shape (1, 3, 640, 480)

Detected 5 objects:
  - bus: 0.92
  - person: 0.91
  - person: 0.91
  - person: 0.87
  - person: 0.53
✓ App completed.

Puedes monitorizar la ejecución de tu función en el panel de control de Modal:

Link to this sectionUsar GPU para una inferencia más rápida#

Añade una GPU a tu función especificando el parámetro gpu:

@app.function(image=image, gpu="T4")  # Options: "T4", "A10G", "A100", "H100"
def predict_gpu(image_url: str):
    """Run YOLO26 inference on GPU."""
    from ultralytics import YOLO

    model = YOLO("yolo26n.pt")
    results = model(image_url)
    print(results[0].boxes)

Link to this sectionEntrenar YOLO26 en Modal#

Para el entrenamiento, usa una GPU y Volumes de Modal para almacenamiento persistente. Crea un nuevo archivo Python llamado train_yolo.py:

import modal

app = modal.App("ultralytics-training")

volume = modal.Volume.from_name("yolo-training-vol", create_if_missing=True)

image = modal.Image.debian_slim(python_version="3.11").apt_install("libgl1", "libglib2.0-0").pip_install("ultralytics")

@app.function(image=image, gpu="T4", timeout=3600, volumes={"/data": volume})
def train():
    """Train YOLO26 model on Modal."""
    from ultralytics import YOLO

    model = YOLO("yolo26n.pt")
    model.train(data="coco8.yaml", epochs=3, imgsz=640, project="/data/runs")

@app.local_entrypoint()
def main():
    train.remote()

Ejecuta el entrenamiento:

modal run train_yolo.py

¡Enhorabuena! Has configurado correctamente Ultralytics YOLO26 en Modal. Para seguir aprendiendo:

• Explora la documentación de Ultralytics YOLO26 para características avanzadas
• Aprende sobre entrenamiento de modelos personalizados con tus propios datasets
• Prueba la Guía de inicio rápido de Docker para despliegue en contenedores
• Visita la documentación de Modal para características avanzadas de la plataforma

Link to this sectionFAQ#

Link to this section¿Cómo elijo la GPU adecuada para mi carga de trabajo de YOLO26?#

Para inferencia, una NVIDIA T4 (16 GB) suele ser suficiente y rentable. Para entrenamiento o modelos más grandes como YOLO26x, considera GPUs A10G o A100.

Link to this section¿Cuánto cuesta ejecutar YOLO26 en Modal?#

Modal utiliza precios por segundo. Tarifas aproximadas: CPU ~$0.05/hora, T4 ~$0.59/hora, A10G ~$1.10/hora, A100 ~$2.10/hora. Consulta los precios de Modal para conocer las tarifas vigentes.

Link to this section¿Puedo usar mi propio modelo YOLO entrenado a medida?#

Sí, puedes ejecutar tu propio modelo YOLO entrenado a medida en Modal cargando el archivo de pesos desde un Volume de Modal:

model = YOLO("/data/my_custom_model.pt")

Para más información sobre cómo entrenar modelos personalizados, consulta la guía de entrenamiento.