# Détection YOLOv8

Exécutez la détection d'objets en temps réel avec Ultralytics YOLOv8 et YOLOv11.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Mise à jour : YOLOv11 (2025) — 22 % plus rapide**

YOLOv11 est désormais disponible via le même `package ultralytics` Il offre **une inférence 22 % plus rapide** et une mAP améliorée par rapport à YOLOv8, avec la même API simple. Les nouvelles fonctionnalités incluent la détection par boîtes englobantes orientées (OBB). Mettez à jour en exécutant `pip install -U ultralytics`.
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que YOLOv8 ?

YOLOv8 est un modèle YOLO haute performance offrant :

* Détection d'objets
* Segmentation d'instances
* Estimation de pose
* Classification d'images
* Suivi d'objets

## Qu'est-ce que YOLOv11 ?

YOLOv11 (2025) est la dernière génération, ajoutant :

* **une inférence 22 % plus rapide** vs YOLOv8
* mAP plus élevé sur toutes les tailles de modèle
* **Boîte englobante orientée (OBB)** détection — nouvelle tâche
* Architecture améliorée (blocs C3k2, SPPF, C2PSA)
* Même `package ultralytics` package, remplacement instantané

### Tâches prises en charge (YOLOv11)

| Tâche      | Suffixe   | Description                                                   |
| ---------- | --------- | ------------------------------------------------------------- |
| `detect`   | *(aucun)* | Détection d'objets avec boîtes englobantes                    |
| `segment`  | `-seg`    | Segmentation d'instances avec masques                         |
| `classify` | `-cls`    | Classification d'images                                       |
| `pose`     | `-pose`   | Estimation de la pose humaine                                 |
| `obb`      | `-obb`    | **NOUVEAU** Boîtes englobantes orientées (détection rotative) |

## Tailles de modèles

### Modèles YOLOv8

| Modèle  | Taille | mAP  | Vitesse (RTX 3090) |
| ------- | ------ | ---- | ------------------ |
| YOLOv8n | 3,2 M  | 37.3 | ≈1 ms              |
| YOLOv8s | 11,2 M | 44.9 | ≈2 ms              |
| YOLOv8m | 25,9 M | 50.2 | ≈4 ms              |
| YOLOv8l | 43,7 M | 52.9 | ≈6 ms              |
| YOLOv8x | 68,2 M | 53.9 | ≈8 ms              |

### Modèles YOLOv11

| Modèle  | Taille | mAP  | Vitesse (RTX 3090) |
| ------- | ------ | ---- | ------------------ |
| yolo11n | 2,6 M  | 39.5 | ≈0,8 ms            |
| yolo11s | 9,4 M  | 47.0 | ≈1,5 ms            |
| yolo11m | 20,1 M | 51.5 | ≈3,2 ms            |
| yolo11l | 25,3 M | 53.4 | ≈4,7 ms            |
| yolo11x | 56,9 M | 54.7 | ≈6,5 ms            |

### Comparaison YOLOv8 vs YOLOv11

| Métrique              | YOLOv8x | yolo11x | Amélioration            |
| --------------------- | ------- | ------- | ----------------------- |
| Paramètres            | 68,2 M  | 56,9 M  | **-17 % plus petit**    |
| mAP50-95 (COCO)       | 53.9    | 54.7    | **+0,8 mAP**            |
| Inférence (RTX 3090)  | ≈8 ms   | ≈6,5 ms | **+22 % plus rapide**   |
| FPS (RTX 3090, 640px) | \~150   | \~183   | **+22 % plus rapide**   |
| Tâche OBB             | ❌       | ✅       | **Nouveau dans la v11** |

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Ports :**

```
22/tcp
7860/http
```

**Commande (YOLOv11) :**

```bash
pip install ultralytics gradio && \
python -c "
import gradio as gr
from ultralytics import YOLO
from PIL import Image

model = YOLO('yolo11m.pt')

def detect(image):
    results = model(image)
    return Image.fromarray(results[0].plot())

demo = gr.Interface(fn=detect, inputs=gr.Image(type='pil'), outputs=gr.Image(), title='YOLOv11 Detection')
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Installation

```bash
pip install ultralytics
```

Même package pour YOLOv8 et YOLOv11. Mettez à niveau pour obtenir YOLOv11 :

```bash
pip install -U ultralytics
```

## Détection d'objets YOLOv11

### Détection de base avec yolo11m

```python
from ultralytics import YOLO
from PIL import Image

# Charger le modèle YOLOv11 medium
model = YOLO('yolo11m.pt')

# Exécuter l'inférence
results = model('image.jpg')

# Afficher les résultats
results[0].show()

# Enregistrer les résultats
results[0].save('output.jpg')
```

### Obtenir les détections

```python
results = model('image.jpg')

for result in results:
    boxes = result.boxes
    for box in boxes:
        # Coordonnées
        x1, y1, x2, y2 = box.xyxy[0].tolist()

        # Confiance
        conf = box.conf[0].item()

        # Classe
        cls = int(box.cls[0].item())
        name = model.names[cls]

        print(f"{name}: {conf:.2f} at ({x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f})")
```

### Traitement par lots

```python
from ultralytics import YOLO
import os

model = YOLO('yolo11m.pt')

input_dir = './images'
output_dir = './detected'
os.makedirs(output_dir, exist_ok=True)

# Traiter toutes les images
results = model(input_dir, save=True, project=output_dir)
```

## Tâches YOLOv11

### Segmentation d'instances

```python
from ultralytics import YOLO

# Charger le modèle de segmentation YOLOv11
model = YOLO('yolo11m-seg.pt')

results = model('image.jpg')

for result in results:
    masks = result.masks  # Masques de segmentation
    if masks is not None:
        for mask in masks.data:
            # mask est un tenseur binaire
            pass
```

### Estimation de pose

```python
from ultralytics import YOLO

# Charger le modèle de pose YOLOv11
model = YOLO('yolo11m-pose.pt')

results = model('image.jpg')

for result in results:
    keypoints = result.keypoints
    if keypoints is not None:
        for kp in keypoints.data:
            # 17 points-clés : nez, yeux, oreilles, épaules, coudes, poignets, hanches, genoux, chevilles
            pass
```

### Classification

```python
from ultralytics import YOLO

# Charger le modèle de classification YOLOv11
model = YOLO('yolo11m-cls.pt')

results = model('image.jpg')
for result in results:
    # Classe Top-1 et confiance
    top1 = result.probs.top1
    top1conf = result.probs.top1conf.item()
    print(f"Classe : {result.names[top1]} ({top1conf:.2f})")
```

### Boîte englobante orientée (OBB) — NOUVEAU dans YOLOv11

L'OBB détecte des objets à n'importe quel angle de rotation — parfait pour l'imagerie aérienne/satellite, la numérisation de documents et la détection de texte.

```python
from ultralytics import YOLO

# Charger le modèle OBB YOLOv11
model = YOLO('yolo11m-obb.pt')

results = model('aerial_image.jpg')

for result in results:
    obb = result.obb
    if obb is not None:
        for box in obb:
            # Boîte tournée : x_center, y_center, width, height, angle
            xywhr = box.xywhr[0].tolist()
            conf = box.conf[0].item()
            cls = int(box.cls[0].item())
            print(f"{result.names[cls]}: {conf:.2f} rotated box: {xywhr}")
```

## Traitement vidéo

### Traiter la vidéo

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Traiter la vidéo
results = model('video.mp4', save=True)
```

### Webcam en temps réel

```python
from ultralytics import YOLO
import cv2

model = YOLO('yolo11n.pt')  # Utiliser le modèle nano pour le temps réel

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame)
    annotated = results[0].plot()

    cv2.imshow('YOLOv11', annotated)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
```

### Enregistrer la vidéo traitée

```python
from ultralytics import YOLO
import cv2

model = YOLO('yolo11m.pt')

cap = cv2.VideoCapture('input.mp4')
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))

out = cv2.VideoWriter('output.mp4', cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    results = model(frame)
    annotated = results[0].plot()
    out.write(annotated)

cap.release()
out.release()
```

## Suivi d'objets

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Suivre des objets dans la vidéo
results = model.track('video.mp4', save=True, tracker='bytetrack.yaml')

# Accéder aux IDs de suivi
for result in results:
    boxes = result.boxes
    if boxes.id is not None:
        track_ids = boxes.id.tolist()
```

## Entraînement personnalisé

### Préparer le jeu de données

```yaml

# dataset.yaml
path: /workspace/dataset
train: images/train
val: images/val

names:
  0: chat
  1: chien
  2: oiseau
```

### Entraîner YOLOv11

```python
from ultralytics import YOLO

# Charger le modèle YOLOv11 pré-entraîné
model = YOLO('yolo11n.pt')

# Entraîner
results = model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0
)
```

### Arguments d'entraînement

```python
model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,
    workers=8,
    patience=50,         # Arrêt précoce
    save=True,
    save_period=10,      # Sauvegarder toutes les N époques
    cache=True,          # Mettre en cache les images
    amp=True,            # Précision mixte
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    box=7.5,
    cls=0.5,
    dfl=1.5,
    augment=True,
    hsv_h=0.015,
    hsv_s=0.7,
    hsv_v=0.4,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.0,
)
```

## Exporter le modèle

```python
from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Exporter vers différents formats
model.export(format='onnx')           # ONNX
model.export(format='tensorrt')       # TensorRT
model.export(format='openvino')       # OpenVINO
model.export(format='coreml')         # CoreML
model.export(format='tflite')         # TensorFlow Lite
```

## Serveur API

```python
from fastapi import FastAPI, UploadFile
from fastapi.responses import JSONResponse
from ultralytics import YOLO
from PIL import Image
import io

app = FastAPI()
model = YOLO('yolo11m.pt')

@app.post("/detect")
async def detect(file: UploadFile):
    contents = await file.read()
    image = Image.open(io.BytesIO(contents))

    results = model(image)

    detections = []
    for box in results[0].boxes:
        detections.append({
            "class": model.names[int(box.cls[0])],
            "confidence": float(box.conf[0]),
            "bbox": box.xyxy[0].tolist()
        })

    return JSONResponse(content={"detections": detections})

@app.post("/segment")
async def segment(file: UploadFile):
    contents = await file.read()
    image = Image.open(io.BytesIO(contents))

    model_seg = YOLO('yolo11m-seg.pt')
    results = model_seg(image)

    # Retourner l'image annotée
    annotated = results[0].plot()
    # ... convertir et retourner

# Exécuter : uvicorn server:app --host 0.0.0.0 --port 8000
```

## Optimisation des performances

### Export TensorRT

```python
model = YOLO('yolo11m.pt')
model.export(format='tensorrt', half=True)

# Utiliser le modèle exporté
model_trt = YOLO('yolo11m.engine')
results = model_trt('image.jpg')
```

### Inférence par lots

```python

# Traiter plusieurs images à la fois
images = ['img1.jpg', 'img2.jpg', 'img3.jpg', 'img4.jpg']
results = model(images, batch=4)
```

## Benchmarks de performance

### FPS YOLOv11 (entrée 640px)

| Modèle  | GPU      | FPS    |
| ------- | -------- | ------ |
| yolo11n | RTX 3090 | \~1100 |
| yolo11s | RTX 3090 | \~730  |
| yolo11m | RTX 3090 | \~370  |
| yolo11x | RTX 3090 | \~183  |
| yolo11x | RTX 4090 | \~305  |

### FPS YOLOv8 (entrée 640px) — Génération précédente

| Modèle  | GPU      | FPS   |
| ------- | -------- | ----- |
| YOLOv8n | RTX 3090 | \~900 |
| YOLOv8s | RTX 3090 | \~600 |
| YOLOv8m | RTX 3090 | \~300 |
| YOLOv8x | RTX 3090 | \~150 |
| YOLOv8x | RTX 4090 | \~250 |

## Dépannage

### Mémoire insuffisante

```python

# Utiliser un modèle plus petit
model = YOLO('yolo11n.pt')

# Ou réduire la taille de l'image
results = model('image.jpg', imgsz=320)
```

### Traitement lent

* Utiliser l'export TensorRT
* Utiliser un modèle plus petit (yolo11n ou yolo11s)
* Réduire la taille de l'image

### Précision faible

* Utiliser un modèle plus grand (yolo11x au lieu de yolo11n)
* Entraîner sur des données personnalisées
* Augmenter la taille des images

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI (à partir de 2025) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| RTX 3060  | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090  | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090  | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [Segmenter tout](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/segment-anything) - Segmentation avancée
* Detectron2 - Plus d'options de détection
* [Real-ESRGAN](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling) - Améliorer les objets détectés