Ultralytics YOLO27:

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: escribes código Python en local y Modal lo ejecuta en la nube con acceso a GPU. Esto la convierte en una opción ideal para ejecutar modelos de aprendizaje profundo como YOLO26 sin tener que gestionar la infraestructura.

Qué aprenderás#

  • Configuración y autenticación de Modal
  • Ejecución de inferencias de YOLO26 en Modal
  • Uso de GPU para acelerar la inferencia
  • Entrenamiento de modelos YOLO26 en Modal

Requisitos previos#

  • Una cuenta de Modal (regístrate gratis en modal.com)
  • Python 3.9 o una versión 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 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

Resultado esperado:

✓ 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 la 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 y entrenamiento de modelos pequeños
A10G24 GBTrabajos de entrenamiento de tamaño medio
A10040 GBEntrenamiento a gran escala
H10080 GBMáximo rendimiento

Entrenamiento de YOLO26 en Modal#

Para entrenar, usa una GPU y los volúmenes de Modal para el almacenamiento persistente. Crea un 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 volúmenes 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 inferencia, una NVIDIA T4 (16 GB) suele ser suficiente y rentable. Para entrenar o trabajar con modelos más grandes, como YOLO26x, plantéate usar GPU A10G o A100.

  • Modal cobra 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 ver las tarifas actuales.

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

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

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

Colaboradores
RAraimbekovm3GLglenn-jocher1

Comentarios