Détection YOLOv9/v10

Détection d’objets en temps réel à la pointe de la technologie — entraînez et déployez les derniers modèles YOLO sur GPU

YOLO (You Only Look Once) reste la référence en matière de détection d’objets en temps réel. YOLOv9 a introduit les Programmable Gradient Information (PGI) et le Generalized Efficient Layer Aggregation Network (GELAN), tandis que YOLOv10 a apporté une détection sans NMS avec des affectations à double étiquette. Les deux offrent un excellent compromis précision/vitesse sur les GPU NVIDIA.

• GitHub YOLOv9 : WongKinYiu/yolov9 — 8K+ ⭐

• GitHub YOLOv10 : THU-MIG/yolov10 — 10K+ ⭐

• Ultralytics (unifié) : ultralytics/ultralytics — 32K+ ⭐

---

YOLOv9 vs YOLOv10 vs YOLOv8 — Comparaison rapide

Modèle	mAP50-95	Vitesse (A100)	Paramètres	NMS
YOLOv8x	53.9	14.2ms	68,2M	Requis
YOLOv9e	55.6	16.8ms	57.3M	Requis
YOLOv10x	54.4	10.7ms	29.5M	Sans NMS
YOLOv10b	53.0	8.8ms	19.1M	Sans NMS
YOLOv10s	46.8	4.2ms	7.2M	Sans NMS

YOLOv10 est sans NMS — aucune étape de post-traitement de suppression non maximale. Cela permet un déploiement de bout en bout et est particulièrement avantageux pour les scénarios en périphérie/intégrés ainsi que pour le déploiement TensorRT.

---

Cas d’usage

• Sécurité et surveillance — détection en temps réel de personnes/véhicules/objets

• Véhicules autonomes — détection des piétons et des obstacles

• Contrôle qualité en fabrication — détection des défauts sur les lignes de production

• Analyse du commerce de détail — flux de clients et détection de produits

• Imagerie médicale — détection d’anomalies dans les radiographies et les scans

• Analyse sportive — suivi des joueurs et du ballon

• Agriculture — détection des maladies des cultures et des ravageurs

---

Prérequis

• Compte Clore.ai avec location de GPU

• Données d’entraînement (pour l’entraînement d’un modèle personnalisé) ou utiliser les poids préentraînés COCO

• Connaissances de base en Python et en ligne de commande

---

Étape 1 — Louer un GPU sur Clore.ai

1. Accédez à clore.ai → Place de marché

2. Choisissez le GPU en fonction de votre tâche :

   • Inférence uniquement : RTX 3080/3090 ou RTX 4080 — excellent rapport qualité/prix

   • Entraînement de petits modèles : RTX 4090 24 Go

   • Entraînement de grands modèles (YOLOv9e/YOLOv10x) : A100 40/80 Go

Pour l’inférence en temps réel (flux vidéo), la RTX 3090 ou la RTX 4090 délivre 100–500 FPS selon la variante du modèle. Même le plus petit YOLOv10n fonctionne à plus de 1000 FPS sur une 4090 avec TensorRT.

---

Étape 2 — Déployer le conteneur Ultralytics

L’image Docker officielle Ultralytics prend en charge YOLOv8, YOLOv9 et YOLOv10 via une API unifiée :

Image Docker :

ultralytics/ultralytics:latest

Ports :

22
8000

Variables d'environnement :

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Disque : 20 Go minimum (poids préentraînés + votre jeu de données)

---

Étape 3 — Se connecter et vérifier

ssh root@<server-ip> -p <ssh-port>

# Vérifier le GPU
nvidia-smi

# Vérifier l’installation d’Ultralytics
python3 -c "import ultralytics; ultralytics.checks()"

# Doit afficher les informations GPU, la version CUDA et la disponibilité du modèle

---

Étape 4 — Inférence rapide avec des modèles préentraînés

Inférence YOLOv10 (sans NMS)

from ultralytics import YOLO
import cv2

# Charger le modèle YOLOv10 (téléchargement automatique s’il n’est pas présent)
model = YOLO("yolov10x.pt")  # Options : n, s, m, b, l, x

# Lancer l’inférence sur une image
results = model("https://ultralytics.com/images/bus.jpg")

# Afficher les résultats
for result in results:
    boxes = result.boxes
    print(f"{len(boxes)} objets détectés")
    for box in boxes:
        cls = int(box.cls[0])
        conf = float(box.conf[0])
        xyxy = box.xyxy[0].tolist()
        print(f"  {model.names[cls]} : {conf:.2f} à {[int(x) for x in xyxy]}")

# Enregistrer l’image annotée
results[0].save("output.jpg")

Inférence YOLOv9

from ultralytics import YOLO

# Charger le modèle YOLOv9
model = YOLO("yolov9e.pt")  # Options : t, s, m, c, e

# Inférence par lots pour un débit maximal
results = model(
    source=[
        "image1.jpg",
        "image2.jpg",
        "image3.jpg",
    ],
    batch=8,        # Traiter 8 images en parallèle
    device="cuda",
    conf=0.25,      # Seuil de confiance
    iou=0.45,       # Seuil IoU du NMS (pas nécessaire pour v10)
    imgsz=640,
    half=True       # FP16 pour un gain de vitesse x2
)

Inférence en flux vidéo en temps réel

from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# Pour webcam (device=0) ou fichier vidéo
cap = cv2.VideoCapture("input_video.mp4")

# Obtenir les propriétés vidéo
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# Écrivain de sortie
out = cv2.VideoWriter(
    "output_video.mp4",
    cv2.VideoWriter_fourcc(*"mp4v"),
    fps,
    (width, height)
)

frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    results = model(frame, conf=0.25, verbose=False)
    annotated = results[0].plot()
    out.write(annotated)
    frame_count += 1
    
    if frame_count % 100 == 0:
        print(f"{frame_count} images traitées")

cap.release()
out.release()
print("Terminé ! Sortie enregistrée dans output_video.mp4")

---

Étape 5 — Entraîner un modèle personnalisé

Préparez votre ensemble de données

YOLO utilise une structure de répertoires et un format d’étiquettes spécifiques :

dataset/
├── images/
│   ├── train/          # Images d’entraînement (.jpg/.png)
│   ├── val/            # Images de validation
│   └── test/           # Images de test (facultatif)
└── labels/
    ├── train/          # Fichiers d’étiquettes (.txt)
    ├── val/
    └── test/

Chaque fichier d’étiquettes (même nom que l’image, .txt extension) contient :

# class_id center_x center_y width height (tous normalisés 0-1)
0 0.512 0.334 0.256 0.412
1 0.123 0.654 0.089 0.123

Créer la configuration du jeu de données

cat > /workspace/custom_dataset.yaml << 'EOF'
# Configuration du jeu de données
path: /workspace/dataset
train: images/train
val: images/val
test: images/test

# Nombre de classes
nc: 3

# Noms des classes
names:
  0: person
  1: car
  2: bicycle
EOF

Importer depuis Roboflow (recommandé)

# Installer Roboflow
pip install roboflow

from roboflow import Roboflow
rf = Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace("your-workspace").project("your-project")
version = project.version(1)
dataset = version.download("yolov9")

# Le jeu de données se trouve maintenant dans ./your-project-1/

Entraîner YOLOv10

from ultralytics import YOLO

# Charger le modèle YOLOv10 préentraîné (apprentissage par transfert)
model = YOLO("yolov10m.pt")  # Variante moyenne — bon équilibre

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=16,               # Ajuster selon la VRAM de votre GPU
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov10_custom",
    patience=50,            # Arrêt anticipé
    save=True,
    save_period=10,         # Enregistrer un checkpoint tous les 10 epochs
    plots=True,
    val=True,
    augment=True,           # Augmentation de données
    degrees=10.0,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.1,
    copy_paste=0.1,
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    amp=True                # Précision mixte automatique (FP16)
)

print(f"Entraînement terminé ! meilleur mAP : {results.results_dict['metrics/mAP50-95(B)']:.3f}")

Entraîner YOLOv9

from ultralytics import YOLO

model = YOLO("yolov9e.pt")

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=8,               # v9e est plus grand, nécessite un batch plus petit
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov9_custom",
    amp=True,
    optimizer="SGD",
    momentum=0.937,
    weight_decay=0.0005
)

Conseils d’entraînement :

• Taille du batch : Commencez avec batch=16 pour RTX 4090, batch=32 pour A100 40 Go

• Taille d’image : imgsz=640 est la norme ; utilisez 1280 pour les tâches haute résolution

• Époques : 100 epochs est typique pour le fine-tuning, 300+ pour un entraînement from scratch

• AMP (précision mixte) : Toujours activer amp=True pour un gain de vitesse de 1,5 à 2x

---

Étape 6 — Exporter vers TensorRT pour une vitesse maximale

from ultralytics import YOLO

# Charger le modèle entraîné
model = YOLO("/workspace/runs/yolov10_custom/weights/best.pt")

# Exporter vers TensorRT (FP16 pour le meilleur équilibre vitesse/précision)
model.export(
    format="engine",        # Moteur TensorRT
    device="cuda",
    half=True,              # FP16
    dynamic=False,          # Formes statiques pour une optimisation TRT maximale
    batch=1,                # Optimiser pour une taille de lot de 1 (temps réel)
    imgsz=640,
    workspace=4             # Espace de travail TRT en Go
)
# Enregistré sous : best.engine

# Charger et exécuter le moteur TRT
trt_model = YOLO("best.engine")
results = trt_model("image.jpg")

Exporter vers ONNX

# Exporter vers ONNX pour plus de flexibilité de déploiement
model.export(
    format="onnx",
    opset=17,
    half=True,              # Poids FP16
    dynamic=True,           # Taille de lot dynamique
    simplify=True
)

---

Étape 7 — Servir en tant qu’API REST

pip install fastapi uvicorn python-multipart

cat > /workspace/yolo_api.py << 'EOF'
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse, FileResponse
from ultralytics import YOLO
from PIL import Image
import io
import uuid
import os

app = FastAPI(title="API de détection YOLOv10")
model = YOLO("yolov10x.pt")

@app.get("/health")
async def health():
    return {"status": "ok", "model": "yolov10x", "device": "cuda"}

@app.post("/detect")
async def detect(
    file: UploadFile = File(...),
    conf: float = 0.25,
    iou: float = 0.45,
    return_image: bool = False
):
    # Lire l’image téléchargée
    image_data = await file.read()
    img = Image.open(io.BytesIO(image_data)).convert("RGB")
    
    # Lancer la détection
    results = model(img, conf=conf, iou=iou, verbose=False)
    result = results[0]
    
    # Construire la réponse
    detections = []
    for box in result.boxes:
        detections.append({
            "class": model.names[int(box.cls[0])],
            "confidence": round(float(box.conf[0]), 4),
            "bbox": [round(x, 2) for x in box.xyxy[0].tolist()],
            "class_id": int(box.cls[0])
        })
    
    response = {
        "count": len(detections),
        "detections": detections,
        "image_size": list(result.orig_shape)
    }
    
    if return_image:
        output_path = f"/tmp/{uuid.uuid4()}.jpg"
        result.save(filename=output_path)
        return FileResponse(output_path, media_type="image/jpeg")
    
    return JSONResponse(response)

@app.post("/detect/batch")
async def detect_batch(files: list[UploadFile] = File(...)):
    results = []
    for file in files:
        data = await file.read()
        img = Image.open(io.BytesIO(data)).convert("RGB")
        res = model(img, verbose=False)[0]
        results.append({
            "filename": file.filename,
            "count": len(res.boxes),
            "detections": [
                {"class": model.names[int(b.cls[0])], "conf": float(b.conf[0])}
                for b in res.boxes
            ]
        })
    return JSONResponse({"results": results})

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF

python3 /workspace/yolo_api.py &

# Tester l'API
curl -X POST "http://localhost:8000/detect" \
    -F "file=@test_image.jpg" | python3 -m json.tool

---

Étape 8 — Valider et mesurer votre modèle

from ultralytics import YOLO

model = YOLO("yolov10x.pt")

# Valider sur le jeu de données COCO
metrics = model.val(
    data="coco.yaml",
    imgsz=640,
    batch=32,
    device="cuda",
    half=True
)

print(f"mAP50 :    {metrics.box.map50:.3f}")
print(f"mAP50-95 : {metrics.box.map:.3f}")
print(f"Précision : {metrics.box.mp:.3f}")
print(f"Rappel :    {metrics.box.mr:.3f}")

# Mesurer la vitesse
model.benchmark(
    format="engine",   # Comparer plusieurs formats d’export
    imgsz=640,
    half=True,
    device="cuda"
)

---

Télécharger les résultats

# Depuis votre machine locale :
scp -P <ssh-port> root@<server-ip>:/workspace/runs/yolov10_custom/weights/best.pt ./
scp -P <ssh-port> root@<server-ip>:/workspace/output_video.mp4 ./

# Télécharger l’intégralité de l’entraînement
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/workspace/runs/ \
    ./yolo_training_runs/

---

Dépannage

Mémoire GPU insuffisante pendant l’entraînement

# Réduire la taille du batch
model.train(data="data.yaml", batch=4, imgsz=640)

# Ou activer le checkpointing des gradients
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)

Vitesse d’entraînement lente

# Activer la mise en cache (charge le jeu de données dans la RAM/le GPU)
model.train(data="data.yaml", cache=True)  # Mettre en cache en RAM
model.train(data="data.yaml", cache="disk")  # Mettre en cache sur disque

# Augmenter le nombre de workers (attention : trop peut ralentir)
model.train(data="data.yaml", workers=8)

mAP faible / Mauvaise détection

# Vérifier que les étiquettes sont correctes (normalisées, entre 0 et 1)
python3 -c "
from ultralytics.data.utils import check_det_dataset
check_det_dataset('custom_dataset.yaml')
"

# Visualiser les échantillons d’entraînement
python3 -c "
from ultralytics import YOLO
model = YOLO('yolov10m.pt')
model.train(data='data.yaml', epochs=1, batch=4, plots=True)
# Vérifier /workspace/runs/train/exp/train_batch*.jpg
"

---

Référence de performance (GPU Clore.ai)

Modèle	GPU	Lot	FPS (inférence)	mAP50-95
YOLOv10n	RTX 3090	1	1,200	38.5
YOLOv10s	RTX 3090	1	780	46.8
YOLOv10m	RTX 4090	1	950	51.3
YOLOv10x	RTX 4090	1	380	54.4
YOLOv9e	A100 40 Go	1	720	55.6
YOLOv10x TRT	RTX 4090	1	920	54.2

---

Ressources supplémentaires

• Documentation Ultralytics

• Article sur YOLOv9

• Article sur YOLOv10

• Roboflow Universe — Plus de 100 000 jeux de données publics

• Ultralytics HUB — Plateforme d'entraînement cloud

• Jeu de données COCO — Jeu de données de référence standard

---

Les locations de GPU Clore.ai pour YOLOv9 et YOLOv10 offrent une voie abordable pour entraîner des modèles de détection d'objets personnalisés et déployer des pipelines d'inférence en temps réel — sans la lourdeur d'AWS SageMaker ou de Google Vertex AI.

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Inférence en production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Entraînement sur grands lots	A100 80 Go	bare metal

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.