Vai al contenuto

Guida rapida ai modelli per Ultralytics

Questa guida offre un'introduzione completa all'esecuzione Ultralytics su Modal, trattando sia GPU serverless che l'addestramento dei modelli.

Che cos'è Modal?

Modal è una piattaforma di cloud computing serverless dedicata ai carichi di lavoro di intelligenza artificiale e machine learning. Gestisce automaticamente il provisioning, il ridimensionamento e l'esecuzione: basta scrivere Python in locale e Modal lo esegue nel cloud con GPU . Ciò la rende ideale per l'esecuzione di modelli di deep learning come YOLO26 senza doversi occupare della gestione dell'infrastruttura.

Cosa imparerai

  • Configurazione di Modal e autenticazione
  • Eseguire l'inferenza YOLO26 su Modal
  • Utilizzo delle GPU per un'inferenza più veloce
  • Addestramento dei modelli YOLO26 su Modal

Prerequisiti

  • Un account Modal (registrati gratuitamente su modal.com)
  • Python .9 o versioni successive installato sul tuo computer

Installazione

Installa il Python Modal ed effettua l'autenticazione:

pip install modal

modal token new

Autenticazione

Il modal token new Il comando aprirà una finestra del browser per autenticare il tuo account Modal. Una volta completata l'autenticazione, potrai eseguire i comandi Modal dal terminale.

Eseguire l'inferenza con YOLO26

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

Risultato atteso:

✓ 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 delle tue funzioni nella dashboard di Modal:

Chiamate alle funzioni della dashboard Modal

Utilizzo GPU un'inferenza più veloce

Aggiungi una GPU tua funzione specificando il gpu parametro:

@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 modelli di piccole dimensioni
A10G24 GBLavori di formazione di livello medio
A10040 GBFormazione su larga scala
H10080 GBMassime prestazioni

Addestramento di YOLO26 su Modal

Per l'addestramento, usa una GPU Modal Volumi per l'archiviazione permanente. Crea un nuovo Python denominato 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()

Allenamento di corsa:

modal run train_yolo.py

Persistenza del volume

I volumi modali mantengono i dati tra un'esecuzione e l'altra della funzione. I pesi addestrati vengono salvati in /data/runs/detect/train/weights/.

Congratulazioni! Hai configurato correttamente Ultralytics su Modal. Per approfondire:

FAQ

Come faccio a scegliere la GPU giusta GPU il mio carico di lavoro YOLO26?

Per l'inferenza, una NVIDIA (16 GB) è in genere sufficiente e conveniente. Per l'addestramento o per modelli più grandi come YOLO26x, prendi in considerazione le GPU A10G o A100.

Quanto costa eseguire YOLO26 su Modal?

Modal applica una tariffa a consumo al secondo. Tariffe indicative: CPU 0,05 $/ora, T4 ~0,59 $/ora, A10G ~1,10 $/ora, A100 ~2,10 $/ora. Consulta il listino prezzi di Modal per conoscere le tariffe attuali.

Posso usare YOLO mio YOLO addestrato su misura?

Sì! Carica modelli personalizzati da un volume modale:

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

Per ulteriori informazioni sull'addestramento di modelli personalizzati, consulta la guida all'addestramento.



📅 Creato 0 giorni fa ✏️ Aggiornato 0 giorni fa
raimbekovm

Commenti