Ir al contenido

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

Esta guía ofrece una introducción completa al uso de Ultralytics en Modal, y abarca tanto GPU sin servidor como el entrenamiento de modelos.

¿Qué es Modal?

Modal es una plataforma de computación en la nube sin servidor diseñada para cargas de trabajo de inteligencia artificial y aprendizaje automático. Se encarga automáticamente del aprovisionamiento, el escalado y la ejecución: tú escribes Python localmente y Modal lo ejecuta en la nube con GPU . Esto la convierte en la opción ideal para ejecutar modelos de aprendizaje profundo como YOLO26 sin necesidad de gestionar la infraestructura.

Qué aprenderás

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

Prerrequisitos

  • Una cuenta de Modal (regístrate gratis en modal.com)
  • Python .9 o una versión posterior instalada en tu ordenador

Instalación

Instala el Python Modal Python y autentícate:

pip install modal

modal token new

Autenticación

El modal token new Este comando abrirá una ventana del navegador para que te identifiques en tu cuenta de Modal. Una vez que te hayas identificado, podrás ejecutar comandos de Modal desde el terminal.

Ejecución de la inferencia con YOLO26

Crea un nuevo 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

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 tus funciones en el panel de control de Modal:

Llamadas a funciones del panel modal

Uso de GPU acelerar la inferencia

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

@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 GBPuestos de formación de nivel medio
A10040 GBFormación a gran escala
H10080 GBMáximo rendimiento

Entrenamiento de YOLO26 en Modal

Para el entrenamiento, utiliza una GPU Modal Volúmenes para el almacenamiento persistente. Crea un nuevo 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()

Entrenamiento de carrera:

modal run train_yolo.py

Persistencia del volumen

Los volúmenes modales conservan los datos entre ejecuciones de la función. Los pesos entrenados se guardan en /data/runs/detect/train/weights/.

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

Preguntas frecuentes

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

Para tareas de inferencia, una NVIDIA (16 GB) suele ser suficiente y rentable. Para el entrenamiento o para modelos más grandes, como YOLO26x, se recomienda considerar las GPU A10G o A100.

¿Cuánto cuesta ejecutar YOLO26 en Modal?

Modal aplica una tarifa de pago por segundo. Tarifas aproximadas: CPU 0,05 $/h, T4 ~0,59 $/h, A10G ~1,10 $/h, A100 ~2,10 $/h. Consulte las tarifas actuales de Modal.

¿Puedo utilizar mi propio YOLO entrenado a medida?

¡Sí! Cargar modelos personalizados desde un volumen 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.



📅 Creado hace 0 días ✏️ Actualizado hace 0 días
raimbekovm

Comentarios