Ultralytics YOLO27 :

Guide de démarrage rapide de Modal pour Ultralytics#

Ce guide présente de manière exhaustive l’exécution de Ultralytics YOLO26 sur Modal, en abordant l’inférence GPU sans serveur et l’entraînement de modèles.

Qu’est-ce que Modal ?#

Modal est une plateforme d’informatique en nuage sans serveur, conçue pour les charges de travail d’IA et d’apprentissage automatique. Elle gère automatiquement le provisionnement, la mise à l’échelle et l’exécution : tu écris du code Python en local, et Modal l’exécute dans le cloud avec un accès GPU. Modal est donc idéal pour exécuter des modèles d’apprentissage profond comme YOLO26 sans gérer l’infrastructure.

Ce que tu vas apprendre#

  • Configurer Modal et t’authentifier
  • Exécuter l’inférence YOLO26 sur Modal
  • Utiliser des GPU pour accélérer l’inférence
  • Entraîner des modèles YOLO26 sur Modal

Prérequis#

  • Un compte Modal (inscris-toi gratuitement sur modal.com)
  • Python 3.9 ou une version ultérieure installé sur ta machine locale

Installation#

Installe le package Python Modal :

pip install modal

Authentifie ensuite la CLI avec ton compte Modal :

modal token new
Authentification

La commande modal token new ouvrira une fenêtre de navigateur pour authentifier ton compte Modal. Une fois l’authentification effectuée, tu pourras exécuter des commandes Modal depuis le terminal.

Exécuter l’inférence YOLO26#

Crée un fichier Python nommé modal_yolo.py pour exécuter l’inférence avec le code suivant :

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

Exécute l’inférence :

modal run modal_yolo.py

Résultat attendu :

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

Tu peux suivre l’exécution de ta fonction dans le tableau de bord Modal :

Modal Dashboard Function Calls

Utiliser un GPU pour accélérer l’inférence#

Ajoute un GPU à ta fonction en précisant le paramètre 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)
GPUMémoireIdéal pour
T416 GBInférence, entraînement de petits modèles
A10G24 GBTâches d’entraînement de taille moyenne
A10040 GBEntraînement à grande échelle
H10080 GBPerformances maximales

Entraîner YOLO26 sur Modal#

Pour l’entraînement, utilise un GPU et les volumes de Modal pour le stockage persistant. Crée un fichier Python nommé 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()

Lance l’entraînement :

modal run train_yolo.py
Persistance des volumes

Les volumes Modal conservent les données d’une exécution de fonction à l’autre. Les poids entraînés sont enregistrés dans /data/runs/train/weights/.

Félicitations ! Tu as configuré Ultralytics YOLO26 sur Modal. Pour approfondir le sujet :

FAQ#

  • Pour l’inférence, une NVIDIA T4 (16 Go) est généralement suffisante et économique. Pour l’entraînement ou les modèles plus volumineux comme YOLO26x, envisage un GPU A10G ou A100.

  • Modal facture à la seconde. Tarifs approximatifs : CPU ~$0.05/h, T4 ~$0.59/h, A10G ~$1.10/h, A100 ~$2.10/h. Consulte les tarifs de Modal pour connaître les prix actuels.

  • Oui, tu peux exécuter ton propre modèle YOLO entraîné sur mesure sur Modal en chargeant le fichier de poids depuis un volume Modal :

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

    Pour en savoir plus sur l’entraînement de modèles personnalisés, consulte le guide d’entraînement.

Contributeurs
RAraimbekovm3GLglenn-jocher1

Commentaires