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 CLORE.AI Marketplace.

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.

Location sur CLORE.AI

1. Visitez 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) :

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

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

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"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.

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

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

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)

    # 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

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

# 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

# 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 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 - Segmentation avancée

• Detectron2 - Plus d'options de détection

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