# 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](/guides/guides_v2-fr/traitement-dimages/segment-anything.md) - Segmentation avancée
* Detectron2 - Plus d'options de détection
* [Real-ESRGAN](/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling.md) - Améliorer les objets détectés


---

# Agent Instructions: 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/yolov8-detection.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.