Détection YOLOv9/v10

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

YOLO (You Only Look Once) reste la référence pour la détection d'objets en temps réel. YOLOv9 a introduit l'Information de Gradient Programmable (PGI) et le Réseau d'Agrégation de Couches Efficace Généralisé (GELAN), tandis que YOLOv10 a apporté une détection sans NMS avec des affectations à double étiquette. Les deux offrent des compromis précision/vitesse de premier ordre sur les GPU NVIDIA.

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

• YOLOv10 GitHub : 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,2 ms	68,2 M	Requis
YOLOv9e	55.6	16,8 ms	57,3 M	Requis
YOLOv10x	54.4	10,7 ms	29,5 M	Libre
YOLOv10b	53.0	8,8 ms	19,1 M	Libre
YOLOv10s	46.8	4,2 ms	7,2 M	Libre

YOLOv10 est sans NMS — pas d'étape de post-traitement de suppression des non-maxima. Cela permet un déploiement de bout en bout et est particulièrement bénéfique pour les scénarios embarqués/à la périphérie et le déploiement TensorRT.

---

Cas d'utilisation

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

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

• Contrôle qualité en production — détection de 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 scanners

• Analyse sportive — suivi des joueurs et de la balle

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

---

Prérequis

• Compte Clore.ai avec location de GPU

• Données d'entraînement (pour l'entraînement de modèles personnalisés) ou utiliser des poids pré-entraînés COCO

• Connaissances de base en Python et en ligne de commande

---

Étape 1 — Louez un GPU sur Clore.ai

1. Aller à clore.ai → Place de marché

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

   • Uniquement inférence : RTX 3080/3090 ou RTX 4080 — excellent rapport prix/performance

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

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

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

---

Étape 2 — Déployer le conteneur Ultralytics

L'image Docker officielle d'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()"

# Devrait afficher les infos GPU, la version CUDA et la disponibilité des modèles

---

É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écharge automatiquement si absent)
model = YOLO("yolov10x.pt")  # Options : n, s, m, b, l, x

# Exécuter 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"Detected {len(boxes)} objects")
    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} at {[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 lot 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 pour la NMS (pas nécessaire pour v10)
    imgsz=640,
    half=True       # FP16 pour un accélération ×2
)

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

from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# Pour la webcam (device=0) ou un 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"Processed {frame_count} frames")

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

---

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

Préparez votre jeu de données

YOLO utilise une structure de répertoires spécifique et un format d'étiquettes :

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

Chaque fichier d'étiquette (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 medium — 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 précoce
    save=True,
    save_period=10,         # Sauvegarder un checkpoint toutes les 10 époques
    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 de lot : Commencez avec batch=16 pour RTX 4090, batch=32 pour A100 40GB

• Taille d'image : imgsz=640 est standard ; utilisez 1280 pour les tâches à haute résolution

• Époques : 100 époques est typique pour le fine-tuning, 300+ pour l'entraînement depuis zéro

• 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 compromis vitesse/precision)
model.export(
    format="engine",        # moteur TensorRT
    device="cuda",
    half=True,              # FP16
    dynamic=False,          # Formes statiques pour une optimisation maximale TRT
    batch=1,                # Optimisé pour une taille de lot 1 (temps réel)
    imgsz=640,
    workspace=4             # Espace de travail TRT en GB
)
# Enregistré sous : best.engine

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

Exporter en ONNX

# Exporter en ONNX pour la 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="YOLOv10 Detection API")
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")
    
    # Exécuter 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 benchmarker votre modèle

from ultralytics import YOLO

model = YOLO("yolov10x.pt")

# Valider sur le dataset 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"Precision: {metrics.box.mp:.3f}")
print(f"Recall:    {metrics.box.mr:.3f}")

# Benchmark de 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 la session d'entraînement
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/workspace/runs/ \
    ./yolo_training_runs/

---

Dépannage

CUDA Out of Memory pendant l'entraînement

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

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

Vitesse d'entraînement lente

# Activer le caching (charge le dataset en RAM/GPU)
model.train(data="data.yaml", cache=True)  # Mise en cache en RAM
model.train(data="data.yaml", cache="disk")  # Mise en cache sur disque

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

mAP faible / Mauvaise détection

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

# Visualiser des é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	Batch	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 40G	1	720	55.6
YOLOv10x TRT	RTX 4090	1	920	54.2

---

Ressources supplémentaires

• Documentation Ultralytics

• Article YOLOv9

• Article YOLOv10

• Roboflow Universe — 100K+ jeux de données publics

• Ultralytics HUB — Plateforme d'entraînement cloud

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

---

YOLOv9 et YOLOv10 sur les locations GPU Clore.ai 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 surcharge d'AWS SageMaker ou Google Vertex AI.

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Inférence en production	RTX 4090 (24GB)	~$0.70/gpu/hr
Entraînement en gros lot	A100 80GB	~$1.20/gpu/hr

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