Skip to main content
Editar en GitHub (EN)

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

Esta guía ofrece una introducción completa para ejecutar Ultralytics YOLO26 en Modal, abarcando la inferencia de GPU sin servidor (serverless) y el entrenamiento de modelos.

¿Qué es Modal?

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

Lo que aprenderás

  • Configuración de Modal y autenticación
  • Ejecución de inferencia de YOLO26 en Modal
  • Uso de GPU para una inferencia más rápida
  • Entrenamiento de modelos YOLO26 en Modal

Antes de empezar, asegúrate de tener acceso a un área de trabajo de AzureML. Si no tienes una, puedes crear una nueva

  • 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 y autentícate:

pip install modal
modal token new
Autenticación

El método modal token new el comando abrirá una ventana del navegador para autenticar tu cuenta de Modal. Tras la autenticación, puedes ejecutar comandos de Modal desde el terminal.

Ejecución de inferencia de YOLO26

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

Uso de GPU para una inferencia más rápida

Añade una GPU a tu función especificando el 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

Entrenamiento de 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 Volumes de Modal mantienen los datos entre ejecuciones de funciones. Los pesos entrenados se guardan en /data/runs/detect/train/weights/.

¡Enhorabuena! Has configurado con éxito Ultralytics YOLO26 en Modal. Para seguir aprendiendo:

Preguntas frecuentes

¿Cómo elijo la GPU adecuada para mi carga de trabajo de YOLO26?

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

¿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 precios de Modal para ver las tarifas actuales.

¿Puedo usar mi propio modelo YOLO entrenado a medida?

¡Sí! Carga modelos personalizados desde un Volume de Modal:

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

Para más información sobre el entrenamiento de modelos personalizados, consulta el guía de entrenamiento.

Comentarios