YOLOv8-Erkennung

Echtzeit-Objekterkennung mit YOLOv8 und YOLOv11 auf Clore.ai

Führe Objekterkennung in Echtzeit mit Ultralytics YOLOv8 und YOLOv11 aus.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Update: YOLOv11 (2025) — 22 % schneller

YOLOv11 ist jetzt über dasselbe ultralytics Paket verfügbar. Es liefert 22 % schnellere Inferenz und eine verbesserte mAP gegenüber YOLOv8, mit derselben einfachen API. Zu den neuen Funktionen gehört die Erkennung orientierter Bounding Boxes (OBB). Aktualisiere mit pip install -U ultralytics.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist YOLOv8?

YOLOv8 ist ein Hochleistungs-YOLO-Modell mit folgenden Funktionen:

• Objekterkennung

• Instanzsegmentierung

• Pose-Schätzung

• Bildklassifizierung

• Objektverfolgung

Was ist YOLOv11?

YOLOv11 (2025) ist die neueste Generation und ergänzt:

• 22 % schnellere Inferenz gegenüber YOLOv8

• Höhere mAP über alle Modellgrößen hinweg

• Orientierte Bounding Box (OBB) Erkennung — neue Aufgabe

• Verbesserte Architektur (C3k2-Blöcke, SPPF, C2PSA)

• Dasselbe ultralytics Paket, Drop-in-Ersatz

Unterstützte Aufgaben (YOLOv11)

Aufgabe	Suffix	Beschreibung
detect	(keins)	Objekterkennung mit Bounding Boxes
segment	-seg	Instanzsegmentierung mit Masken
classify	-cls	Bildklassifizierung
pose	-pose	Menschliche Pose-Schätzung
obb	-obb	NEU Orientierte Bounding Boxes (gedrehte Erkennung)

Modellgrößen

YOLOv8-Modelle

Modell	Größe	mAP	Geschwindigkeit (RTX 3090)
YOLOv8n	3,2 Mio.	37.3	~1 ms
YOLOv8s	11,2 Mio.	44.9	~2 ms
YOLOv8m	25,9 Mio.	50.2	~4 ms
YOLOv8l	43,7 Mio.	52.9	~6 ms
YOLOv8x	68,2 Mio.	53.9	~8 ms

YOLOv11-Modelle

Modell	Größe	mAP	Geschwindigkeit (RTX 3090)
yolo11n	2,6 Mio.	39.5	~0,8 ms
yolo11s	9,4 Mio.	47.0	~1,5 ms
yolo11m	20,1 Mio.	51.5	~3,2 ms
yolo11l	25,3 Mio.	53.4	~4,7 ms
yolo11x	56,9 Mio.	54.7	~6,5 ms

Vergleich YOLOv8 vs. YOLOv11

Kennzahl	YOLOv8x	yolo11x	Verbesserung
Parameter	68,2 Mio.	56,9 Mio.	-17 % kleiner
mAP50-95 (COCO)	53.9	54.7	+0,8 mAP
Inferenz (RTX 3090)	~8 ms	~6,5 ms	+22 % schneller
FPS (RTX 3090, 640 px)	~150	~183	+22 % schneller
OBB-Aufgabe	❌	✅	Neu in v11

Schnelle Bereitstellung

Docker-Image:

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

Ports:

22/tcp
7860/http

Befehl (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-Erkennung')
demo.launch(server_name='0.0.0.0', server_port=7860)
"

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Installation

pip install ultralytics

Dasselbe Paket für sowohl YOLOv8 als auch YOLOv11. Upgraden, um YOLOv11 zu erhalten:

pip install -U ultralytics

YOLOv11-Objekterkennung

Grundlegende Erkennung mit yolo11m

from ultralytics import YOLO
from PIL import Image

# Lade das YOLOv11-Medium-Modell
model = YOLO('yolo11m.pt')

# Führe Inferenz aus
results = model('image.jpg')

# Ergebnisse anzeigen
results[0].show()

# Ergebnisse speichern
results[0].save('output.jpg')

Erkennungen abrufen

results = model('image.jpg')

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

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

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

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

Batch-Verarbeitung

from ultralytics import YOLO
import os

model = YOLO('yolo11m.pt')

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

# Alle Bilder verarbeiten
results = model(input_dir, save=True, project=output_dir)

YOLOv11-Aufgaben

Instanzsegmentierung

from ultralytics import YOLO

# Lade das YOLOv11-Segmentierungsmodell
model = YOLO('yolo11m-seg.pt')

results = model('image.jpg')

for result in results:
    masks = result.masks  # Segmentierungsmasken
    if masks is not None:
        for mask in masks.data:
            # Maske ist ein binärer Tensor
            pass

Pose-Schätzung

from ultralytics import YOLO

# Lade das YOLOv11-Pose-Modell
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 Keypoints: Nase, Augen, Ohren, Schultern, Ellbogen, Handgelenke, Hüften, Knie, Knöchel
            pass

Klassifizierung

from ultralytics import YOLO

# Lade das YOLOv11-Klassifizierungsmodell
model = YOLO('yolo11m-cls.pt')

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

Orientierte Bounding Box (OBB) — NEU in YOLOv11

OBB erkennt Objekte bei beliebigem Rotationswinkel — perfekt für Luft-/Satellitenbilder, Dokumentenscans und Texterkennung.

from ultralytics import YOLO

# Lade das YOLOv11-OBB-Modell
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:
            # Gedrehte Box: 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} gedrehte Box: {xywhr}")

Videoverarbeitung

Video verarbeiten

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Video verarbeiten
results = model('video.mp4', save=True)

Webcam in Echtzeit

from ultralytics import YOLO
import cv2

model = YOLO('yolo11n.pt')  # Verwende das Nano-Modell für Echtzeit

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

Verarbeiteten Videostream speichern

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

Objektverfolgung

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# Objekte im Video verfolgen
results = model.track('video.mp4', save=True, tracker='bytetrack.yaml')

# Tracking-IDs abrufen
for result in results:
    boxes = result.boxes
    if boxes.id is not None:
        track_ids = boxes.id.tolist()

Benutzerdefiniertes Training

Datensatz vorbereiten

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

names:
  0: cat
  1: dog
  2: bird

YOLOv11 trainieren

from ultralytics import YOLO

# Vorgetrainiertes YOLOv11-Modell laden
model = YOLO('yolo11n.pt')

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

Trainingsargumente

model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,
    workers=8,
    patience=50,         # Frühes Stoppen
    save=True,
    save_period=10,      # Alle N Epochen speichern
    cache=True,          # Bilder zwischenspeichern
    amp=True,            # Gemischte Präzision
    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,
)

Modell exportieren

from ultralytics import YOLO

model = YOLO('yolo11m.pt')

# In verschiedene Formate exportieren
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

API-Server

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)

    # Kommentiertes Bild zurückgeben
    annotated = results[0].plot()
    # ... konvertieren und zurückgeben

# Ausführen: uvicorn server:app --host 0.0.0.0 --port 8000

Leistungsoptimierung

TensorRT-Export

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

# Exportiertes Modell verwenden
model_trt = YOLO('yolo11m.engine')
results = model_trt('image.jpg')

Batch-Inferenz

# Mehrere Bilder auf einmal verarbeiten
images = ['img1.jpg', 'img2.jpg', 'img3.jpg', 'img4.jpg']
results = model(images, batch=4)

Leistungs-Benchmarks

YOLOv11 FPS (640px Eingabe)

Modell	GPU	FPS
yolo11n	RTX 3090	~1100
yolo11s	RTX 3090	~730
yolo11m	RTX 3090	~370
yolo11x	RTX 3090	~183
yolo11x	RTX 4090	~305

YOLOv8 FPS (640px Eingabe) — Vorherige Generation

Modell	GPU	FPS
YOLOv8n	RTX 3090	~900
YOLOv8s	RTX 3090	~600
YOLOv8m	RTX 3090	~300
YOLOv8x	RTX 3090	~150
YOLOv8x	RTX 4090	~250

Fehlerbehebung

Speicher erschöpft

# Kleinere Modell verwenden
model = YOLO('yolo11n.pt')

# Oder die Bildgröße verringern
results = model('image.jpg', imgsz=320)

Langsame Verarbeitung

• TensorRT-Export verwenden

• Kleineres Modell verwenden (yolo11n oder yolo11s)

• Bildgröße verringern

Geringe Genauigkeit

• Größeres Modell verwenden (yolo11x statt yolo11n)

• Auf benutzerspezifischen Daten trainieren

• Bildgröße erhöhen

Kostenschätzung

Typische CLORE.AI-Marktplatzpreise (Stand 2025):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• Segment Anything - Fortgeschrittene Segmentierung

• Detectron2 - Weitere Detektionsoptionen

• Real-ESRGAN - Erkannte Objekte verbessern