Skip to main content
Modifica su GitHub (EN)

Guida rapida a Modal per Ultralytics

Questa guida fornisce un'introduzione completa all'esecuzione di Ultralytics YOLO26 su Modal, coprendo l'inferenza GPU serverless e l'addestramento dei modelli.

Cos'è Modal?

Modal è una piattaforma cloud computing serverless per carichi di lavoro AI e machine learning. Gestisce automaticamente il provisioning, la scalabilità e l'esecuzione: scrivi il codice Python in locale e Modal lo esegue nel cloud con accesso GPU. Questo lo rende ideale per eseguire deep learning modelli come YOLO26 senza gestire l'infrastruttura.

Cosa imparerai

  • Configurazione di Modal e autenticazione
  • Esecuzione dell'inferenza YOLO26 su Modal
  • Utilizzo delle GPU per un'inferenza più rapida
  • Addestramento dei modelli YOLO26 su Modal

Prima di iniziare, assicurati di avere accesso a un workspace AzureML. Se non ne hai uno, puoi crearne uno nuovo

  • Un account Modal (registrati gratuitamente su modal.com)
  • Python 3.9 o superiore installato sulla tua macchina locale

Installazione

Installa il pacchetto Python di Modal ed effettua l'autenticazione:

pip install modal
modal token new
Autenticazione

Il metodo modal token new il comando aprirà una finestra del browser per autenticare il tuo account Modal. Dopo l'autenticazione, puoi eseguire i comandi Modal dal terminale.

Esecuzione dell'inferenza YOLO26

Crea un nuovo file Python chiamato modal_yolo.py con il seguente codice:

"""
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")

Esegui l'inferenza:

modal run modal_yolo.py

Output previsto:

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

Puoi monitorare l'esecuzione della tua funzione nella dashboard di Modal:

Modal Dashboard Function Calls

Utilizzo della GPU per un'inferenza più rapida

Aggiungi una GPU alla tua funzione specificando la 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)
GPUMemoriaIdeale per
T416 GBInferenza, addestramento di piccoli modelli
A10G24 GBLavori di addestramento medi
A10040 GBAddestramento su larga scala
H10080 GBPrestazioni massime

Addestramento di YOLO26 su Modal

Per l'addestramento, utilizza una GPU e i Volumes di Modal per l'archiviazione persistente. Crea un nuovo file Python chiamato 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()

Esegui l'addestramento:

modal run train_yolo.py
Persistenza dei Volume

I Volume di Modal mantengono i dati tra le esecuzioni delle funzioni. I pesi addestrati vengono salvati in /data/runs/detect/train/weights/.

Congratulazioni! Hai configurato con successo Ultralytics YOLO26 su Modal. Per approfondire:

FAQ

Come scelgo la GPU giusta per il mio carico di lavoro YOLO26?

Per l'inferenza, una NVIDIA T4 (16 GB) è solitamente sufficiente ed economica. Per l'addestramento o modelli più grandi come YOLO26x, prendi in considerazione le GPU A10G o A100.

Quanto costa eseguire YOLO26 su Modal?

Modal utilizza prezzi al secondo. Tariffe approssimative: CPU ~$0.05/ora, T4 ~$0.59/ora, A10G ~$1.10/ora, A100 ~$2.10/ora. Controlla i prezzi di Modal per le tariffe attuali.

Posso usare il mio modello YOLO personalizzato?

Sì! Carica modelli personalizzati da un Volume Modal:

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

Per maggiori informazioni sull'addestramento di modelli personalizzati, consulta il guida all'addestramento.

Commenti