YOLO Vision 2026:

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

Esta guía ofrece una introducción completa sobre cómo ejecutar Ultralytics YOLO26 en Modal, abarcando la inferencia de GPU sin servidor 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 el aprovisionamiento, el escalado y la ejecución de forma automática: escribes código Python localmente y Modal lo ejecuta en la nube con acceso a GPU. Esto la hace ideal para ejecutar modelos de aprendizaje profundo como YOLO26 sin necesidad de administrar infraestructura.

Lo 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

Requisitos previos#

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

Instalación#

Instala el paquete Python de Modal:

pip install modal

Luego 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. Tras la autenticación, puedes ejecutar comandos de Modal desde la terminal.

Ejecutar inferencia de YOLO26#

Crea un nuevo archivo Python llamado modal_yolo.py para ejecutar la 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:

Modal Dashboard Function Calls

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

Entrenar YOLO26 en Modal#

Para el entrenamiento, utiliza 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
Persistencia de volúmenes

Los Modal Volumes 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:

FAQ#

  • 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.

  • Modal utiliza un sistema de precios por pago por segundo. Tarifas aproximadas: CPU ~$0.05/hr, T4 ~$0.59/hr, A10G ~$1.10/hr, A100 ~$2.10/hr. Consulta los precios de Modal para ver 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
RAraimbekovm2GLglenn-jocher1

Comentarios