> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/vision-par-ordinateur/yolov9-v10.md).

# 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](https://github.com/WongKinYiu/yolov9) — 8K+ ⭐
* **YOLOv10 GitHub :** [THU-MIG/yolov10](https://github.com/THU-MIG/yolov10) — 10K+ ⭐
* **Ultralytics (unifié) :** [ultralytics/ultralytics](https://github.com/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** |

{% hint style="success" %}
**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.
{% endhint %}

***

## 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](https://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

{% hint style="info" %}
**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.
{% endhint %}

***

## É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

```bash
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)

```python
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

```python
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

```python
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

```bash
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é)

```python
# 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

```python
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

```python
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
)
```

{% hint style="info" %}
**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
  {% endhint %}

***

## Étape 6 — Exporter vers TensorRT pour une vitesse maximale

```python
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

```python
# 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

```bash
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

```python
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

```bash
# 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

```python
# 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

```python
# 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

```bash
# 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](https://docs.ultralytics.com/)
* [Article YOLOv9](https://arxiv.org/abs/2402.13616)
* [Article YOLOv10](https://arxiv.org/abs/2405.14458)
* [Roboflow Universe](https://universe.roboflow.com/) — 100K+ jeux de données publics
* [Ultralytics HUB](https://hub.ultralytics.com/) — Plateforme d'entraînement cloud
* [Dataset COCO](https://cocodataset.org/) — 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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/vision-par-ordinateur/yolov9-v10.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.