YOLO Vision 2026:

Guía de inicio rápido de Modal para Ultralytics#

Esta guía ofrece una introducción completa a la ejecución de Ultralytics YOLO26 en Modal, e incluye la inferencia sin servidor con GPU y el entrenamiento de modelos.

¿Qué es Modal?#

Modal es una plataforma de computación en la nube sin servidor para cargas de trabajo de IA y aprendizaje automático. Gestiona automáticamente el aprovisionamiento, el escalado y la ejecución: tú escribes código Python localmente y Modal lo ejecuta en la nube con acceso a GPU. Esto lo hace ideal para ejecutar modelos de aprendizaje profundo como YOLO26 sin gestionar la infraestructura.

Qué aprenderás#

  • Configurar Modal y autenticarte
  • Ejecutar inferencias de YOLO26 en Modal
  • Usar GPU para acelerar la inferencia
  • Entrenar modelos YOLO26 en Modal

Requisitos previos#

  • Una cuenta de Modal (regístrate gratis en modal.com)
  • Python 3.9 o posterior instalado en tu equipo local

Instalación#

Instala el paquete de Python de Modal:

pip install modal

A continuación, autentica la CLI con tu cuenta de Modal:

modal token new
Autenticación

El comando modal token new abrirá una ventana del navegador para autenticar tu cuenta de Modal. Después de autenticarte, podrás ejecutar comandos de Modal desde el terminal.

Ejecución de inferencias de YOLO26#

Crea un archivo Python nuevo llamado modal_yolo.py para ejecutar inferencias 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 supervisar la ejecución de tu función en el panel de Modal:

Modal Dashboard Function Calls

Uso de GPU para acelerar la inferencia#

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)
GPUMemoriaIdeal para
T416 GBInferencia, entrenamiento de modelos pequeños
A10G24 GBTrabajos de entrenamiento medianos
A10040 GBEntrenamiento a gran escala
H10080 GBMáximo rendimiento

Entrenamiento de YOLO26 en Modal#

Para el entrenamiento, utiliza una GPU y Volumes de Modal para el almacenamiento persistente. Crea un archivo Python nuevo 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
Persistencia de Volumes

Los Volumes de Modal conservan los datos entre ejecuciones de funciones. Los pesos entrenados se guardan en /data/runs/train/weights/.

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

Preguntas frecuentes#

  • Para la inferencia, una NVIDIA T4 (16 GB) suele ser suficiente y rentable. Para entrenar o trabajar con modelos más grandes, como YOLO26x, considera las GPU A10G o A100.

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

  • 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 obtener más información sobre el entrenamiento de modelos personalizados, consulta la guía de entrenamiento.

Colaboradores
RAraimbekovm3GLglenn-jocher1

Comentarios