Détection YOLOv8

Détection d'objets en temps réel avec YOLOv8 et YOLOv11 sur Clore.ai

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Mise à jour : YOLOv11 (2025) — 22 % plus rapide

YOLOv11 est désormais disponible via le même ultralytics package. 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 de boîtes englobantes orientées (OBB). Mettez à niveau en exécutant pip install -U ultralytics.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À 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@<proxy-address>

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 par rapport à YOLOv8

• Une mAP plus élevée pour 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 ultralytics package, remplacement transparent

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 des modèles

Modèles YOLOv8

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

Modèles YOLOv11

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

Comparaison YOLOv8 vs YOLOv11

Métrique	YOLOv8x	yolo11x	Amélioration
Paramètres	68,2M	56,9M	-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, 640 px)	~150	~183	+22 % plus rapide
Tâche OBB	❌	✅	Nouveau dans v11

Déploiement rapide

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

Ports :

22/tcp
7860/http

Commande (YOLOv11) :

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='Détection YOLOv11')
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. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

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

Installation

pip install ultralytics

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

pip install -U ultralytics

Détection d'objets YOLOv11

Détection de base avec yolo11m

from ultralytics import YOLO
from PIL import Image

# Charger le modèle moyen YOLOv11
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

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

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

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

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

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"Class: {result.names[top1]} ({top1conf:.2f})")

Boîte englobante orientée (OBB) — NOUVEAUTÉ dans YOLOv11

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

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

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

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

Webcam en temps réel

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

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

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

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

# Accéder aux identifiants 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

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

names:
  0: chat
  1: chien
  2: oiseau

Entraîner YOLOv11

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

model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,
    workers=8,
    patience=50,         # Arrêt anticipé
    save=True,
    save_period=10,      # Sauvegarder tous les N epochs
    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

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

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)

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

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

Optimisation des performances

Export TensorRT

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 lot

# Traiter plusieurs images en une seule fois
images = ['img1.jpg', 'img2.jpg', 'img3.jpg', 'img4.jpg']
results = model(images, batch=4)

Références de performance

FPS YOLOv11 (entrée 640 px)

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 640 px) — 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

# 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

Faible précision

• Utiliser un modèle plus grand (yolo11x au lieu de yolo11n)

• Entraîner sur des données personnalisées

• Augmenter la taille de l'image

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• Segment Anything - Segmentation avancée

• Detectron2 - Plus d'options de détection

• Real-ESRGAN - Améliorer les objets détectés