Skip to main content
Modifier sur GitHub (EN)

Guide de démarrage rapide Modal pour Ultralytics

Ce guide fournit une introduction complète pour exécuter Ultralytics YOLO26 sur Modal, couvrant l'inférence GPU serverless et l'entraînement de modèles.

Qu'est-ce que Modal ?

Modal est une plateforme serverless cloud computing pour les charges de travail IA et machine learning. Il gère automatiquement le provisionnement, la mise à l'échelle et l'exécution : tu écris ton code Python localement et Modal l'exécute dans le cloud avec un accès GPU. Cela le rend idéal pour exécuter des modèles deep learning comme YOLO26 sans gérer l'infrastructure.

Ce que tu vas apprendre

  • Configuration de Modal et authentification
  • Exécuter l'inférence YOLO26 sur Modal
  • Utiliser des GPU pour une inférence plus rapide
  • Entraîner des modèles YOLO26 sur Modal

Prérequis

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

Installation

Installe le package Python de Modal et authentifie-toi :

pip install modal
modal token new
Authentification

La méthode modal token new la commande ouvrira une fenêtre de navigateur pour authentifier ton compte Modal. Après l'authentification, tu peux exécuter les commandes Modal depuis le terminal.

Exécuter l'inférence YOLO26

Crée un nouveau fichier Python appelé modal_yolo.py 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

Sortie attendue :

✓ 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 surveiller l'exécution de ta fonction dans le tableau de bord Modal :

Modal Dashboard Function Calls

Utiliser un GPU pour une inférence plus rapide

Ajoute un GPU à ta fonction en spécifiant le 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 moyennes
A10040 GBEntraînement à grande échelle
H10080 GBPerformance maximale

Entraîner YOLO26 sur Modal

Pour l'entraînement, utilise un GPU et les Volumes Modal pour un stockage persistant. Crée un nouveau fichier Python appelé 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()

Exécute l'entraînement :

modal run train_yolo.py
Persistance des volumes

Les Volumes Modal conservent les données entre les exécutions de fonctions. Les poids entraînés sont enregistrés dans /data/runs/detect/train/weights/.

Félicitations ! Tu as configuré avec succès Ultralytics YOLO26 sur Modal. Pour aller plus loin :

FAQ

Comment choisir le bon GPU pour ma charge de travail YOLO26 ?

Pour l'inférence, un NVIDIA T4 (16 GB) est généralement suffisant et économique. Pour l'entraînement ou des modèles plus grands comme YOLO26x, envisage des GPU A10G ou A100.

Combien coûte l'exécution de YOLO26 sur Modal ?

Modal utilise une tarification à la seconde. Tarifs approximatifs : CPU ~$0.05/h, T4 ~$0.59/h, A10G ~$1.10/h, A100 ~$2.10/h. Vérifie la tarification Modal pour les tarifs actuels.

Puis-je utiliser mon propre modèle YOLO personnalisé ?

Oui ! Charge tes modèles personnalisés depuis un Volume Modal :

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

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

Commentaires