> 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 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](https://github.com/WongKinYiu/yolov9) — 8K+ ⭐
* **GitHub YOLOv10 :** [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.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** |

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

***

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

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

***

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

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

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

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

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

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

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

```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 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
  {% 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 é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

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

```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="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

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

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

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

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

```bash
# 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](https://docs.ultralytics.com/)
* [Article sur YOLOv9](https://arxiv.org/abs/2402.13616)
* [Article sur YOLOv10](https://arxiv.org/abs/2405.14458)
* [Roboflow Universe](https://universe.roboflow.com/) — Plus de 100 000 jeux de données publics
* [Ultralytics HUB](https://hub.ultralytics.com/) — Plateforme d'entraînement cloud
* [Jeu de données COCO](https://cocodataset.org/) — 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](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.