Ultralytics YOLO27: Trag dich in die Warteliste ein.
Get Started
Trainiere dein erstes YOLO-Modell·Vorhersagen·Lektion 2/10
LektionAnfänger

Vorhersage für ein Bild

Führe ein vortrainiertes YOLO26-Modell mit Python aus, lies Klassen, Konfidenzen und Pixelkoordinaten der Boxen aus den Ergebnissen aus und passe die Argumente an, mit denen sich die meisten übersehenen Objekte finden lassen.

Jede praktische Anwendung eines Detektors – Lagerbestände in einem Regal zählen, Gesichter zum Unkenntlichmachen ausschneiden, Boxen an eine JSON API senden – beginnt damit, das Ergebnisobjekt korrekt auszulesen. Ein falsch behandeltes Detail, etwa Klassennamen mit einem Tensor zu indizieren, und deine App stürzt schon beim ersten Bild ab.

Ein vortrainiertes YOLO26-Detektionsmodell kennt bereits die 80 COCO-Klassen. In dieser Lektion führst du den Vorhersagemodus mit Python aus, liest alle nützlichen Felder aus den Ergebnissen aus und erfährst, welches Argument du bei übersehenen Objekten, Duplikaten und kleinen Objekten ändern musst. Dasselbe Ergebnisobjekt erhältst du später auch von deinem eigenen trainierten Modell.

Lernergebnis

Du kannst ein Python-Skript schreiben, das YOLO26 auf Bildern ausführt und den Klassennamen, die Konfidenz und die Pixelkoordinaten der Box für jede Erkennung ausgibt. Außerdem weißt du, welches Argument welche Art von übersehenem Objekt behebt.

Schnellkurs
Wenn du dich bereits auskennst, findest du hier die Kurzfassung.
  1. Einmal laden: model = YOLO('yolo26n.pt'); dann result = model(source)[0].

  2. Über result.boxes iterieren; mit int(box.cls), float(box.conf), box.xyxy[0].tolist() umwandeln.

  3. Klassenindizes mit result.names[int(box.cls)] den Namen zuordnen.

  4. conf, iou, imgsz und classes pro Aufruf anpassen.

Praxisnah

Vorhersage ausführen und jede Erkennung ausgeben#

Ultralytics YOLO-Erkennungen auf einer Uferpromenade: beschriftete Boxen mit Konfidenzwerten um Personen, Fahrräder, einen Hund und Autos

Wenn du das Modell auf eine Quelle anwendest, wird der Vorhersagemodus ausgeführt und eine Liste mit einem Results-Objekt pro Bild zurückgegeben. Bei einem einzelnen Bild liest du results[0] aus.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model("https://ultralytics.com/images/bus.jpg")

result = results[0]
for box in result.boxes:
    name = result.names[int(box.cls)]
    conf = float(box.conf)
    x1, y1, x2, y2 = box.xyxy[0].tolist()
    print(f"{name:>8} {conf:.2f}  ({x1:.0f}, {y1:.0f}) -> ({x2:.0f}, {y2:.0f})")

result.save("bus_annotated.jpg")

Tatsächliche Ausgabe von predict.py nach der üblichen Protokollzeile:

     bus 0.88  (0, 230) -> (803, 751)
  person 0.87  (49, 398) -> (240, 902)
  person 0.86  (223, 405) -> (345, 861)
  person 0.85  (670, 395) -> (810, 880)
  person 0.65  (0, 553) -> (60, 871)

So liest du sie aus:

  • bus 0.88: Klassenname und Konfidenz. Die Boxen sind nach Konfidenz sortiert, beginnend mit dem höchsten Wert.
  • (0, 230) -> (803, 751): obere linke und untere rechte Ecke in Pixeln des Originalbilds mit 810×1080 Pixeln; der Ursprung liegt oben links. Du kannst diese Koordinaten direkt zum Ausschneiden oder Zeichnen verwenden.
  • person 0.65 bei (0, 553): Eine fünfte Person, die am linken Bildrand abgeschnitten ist, erhält einen niedrigeren Wert. Bei teilweise sichtbaren Objekten ist das üblich.

result.save() schreibt das annotierte Bild; result.show() öffnet es in einem Fenster.

Ergebnisse verstehen#

Jede Aufgabe gibt denselben Typ Results zurück; nur die ausgefüllten Felder ändern sich. Die vollständige Übersicht findest du im Leitfaden zur Python-Verwendung.

AttributEnthält
boxesErkennungen: xyxy in Pixeln, xywhn im normalisierten Mittelpunktsformat, conf, cls und id beim Tracking
masks, keypoints, obb, probsAusgaben von Segmentierungs-, Pose-, OBB- und Klassifizierungsmodellen (None bei einem Detektionsmodell)
namesWörterbuch aus Klassenindex → Klassenname
orig_img, orig_shapeDas Eingabebild als NumPy-Array sowie seine Höhe × Breite
speedVorverarbeitungs-, Inferenz- und Nachverarbeitungszeit in ms
path, save_dirHerkunft der Eingabe und Speicherort der Ausgaben

Für die Objekterkennung brauchst du meist boxes, die Begrenzungsrahmen. result.summary() gibt dieselben Erkennungen als Liste einfacher Wörterbücher zurück, bereit für eine JSON API.

Vorhersage anpassen#

Die Standardeinstellungen eignen sich für die meisten Bilder. Falls nicht, ändere immer nur ein Argument:

Beobachtetes ProblemArgumentStandardÄnderung
Objekte werden übersehen: Ein sichtbares Objekt erhält keine Boxconf0.25Verringern, z. B. 0.1
Falsch positive Erkennungen: Boxen um nichtsconf0.25Erhöhen, z. B. 0.5
Zwei Boxen für ein Objektiou0.7Verringern: den NMS-Überlappungsschwellenwert (IoU) zum Zusammenführen von Duplikaten
Kleine, weit entfernte Objekte werden übersehenimgsz640Erhöhen, z. B. 1280 (auf ein Vielfaches von 32 gerundet)
Nur einige Klassen sind relevantclassesallez. B. classes=[0] für Personen
Falsche Hardwaredeviceautocpu, mps oder ein GPU-Index wie 0

Die Konfidenz verändert das Ergebnis, nicht nur die Anzahl. Auf demselben Busbild:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model("https://ultralytics.com/images/bus.jpg", conf=0.5, classes=[0])  # 4 persons
model("https://ultralytics.com/images/bus.jpg", conf=0.1)  # 5 Personen, 1 Bus, 1 Stoppschild

Bei conf=0.1 meldet das Modell auch ein Stoppschild, bei dem es sich nicht sicher war. Wenn du conf verringerst, siehst du am schnellsten, was das Modell fast erkannt hätte. Alle übrigen Argumente findest du in der Konfigurationsreferenz.

Wenn eine Vorhersage leer zurückkommt, arbeite diese Schritte der Reihe nach ab:

Viele Bilder ausführen#

Übergib eine Liste, einen Ordner oder ein Glob-Muster wie "photos/*.jpg". Standardmäßig verwendet Predict batch=1. Setze batch, um mehrere Bilder auf einmal durch das Modell laufen zu lassen. Auf einer GPU ist das deutlich schneller:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
images = ["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/zidane.jpg"]
for result in model(images, batch=2):
    print(result.path, len(result.boxes), result.verbose())
image0.jpg 5 4 persons, 1 bus,
image1.jpg 3 2 persons, 1 tie,

Diese Fehler vermeiden#

Namen mit einem Tensor indizieren

Symptom: KeyError: tensor([5.]). Ursache: box.cls und box.conf sind PyTorch-Tensoren, und result.names ist ein Wörterbuch mit Schlüsseln vom Typ int. Lösung: Wandle zuerst um: result.names[int(box.cls)], float(box.conf), box.xyxy[0].tolist().

Das Modell bei jedem Aufruf laden

Symptom: Eine Hilfsfunktion, die YOLO("yolo26n.pt") innerhalb der Funktion aufruft, läuft langsam. Auf einer Laptop-CPU dauerte das erneute Laden pro Bild 71 ms, verglichen mit 25 ms bei einmaligem Laden des Modells. Lösung: Erstelle das Modell einmal beim Start und verwende es für jedes Bild wieder.

Hunderte Bilder oder ein Video? Verarbeite sie im Datenstrom

model(list_or_folder) sammelt alle Results-Objekte im Speicher, bevor es sie zurückgibt. Bei großen Ordnern und sämtlichen Videos übergibst du stream=True und durchläufst die Ergebnisse: Sie treffen einzeln ein. Die Videolektion behandelt das ausführlich.

Ausprobieren

Schreibe top3.py: Lade yolo26n.pt einmal, führe es auf bus.jpg, zidane.jpg und einem eigenen Foto aus und gib die Anzahl der Erkennungen sowie die drei Klassen mit den höchsten Konfidenzen für jedes Bild aus. Führe dann das Bild mit den wenigsten Erkennungen erneut mit conf=0.1 aus und schreibe einen Satz dazu, was aufgetaucht ist.

Abgeschlossen, wenn
Du hast die Lektion abgeschlossen, wenn alle folgenden Punkte zutreffen.
  • Dein Skript gibt für jedes Bild die Anzahl und die drei Klassen mit den höchsten Konfidenzen aus, ohne ein KeyError.

  • Du hast ein Bild mit conf=0.25 und conf=0.1 verglichen und festgehalten, was sich geändert hat.

  • Du kannst benennen, welches Argument du bei übersehenen Objekten, doppelten Boxen und kleinen Objekten ändern würdest.

Lösung anzeigen
from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # load once
images = ["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/zidane.jpg"]

for result in model(images, verbose=False):
    top3 = sorted(result.summary(), key=lambda d: d["confidence"], reverse=True)[:3]
    print(f"{result.path}: {len(result.boxes)} detections")
    for d in top3:
        print(f"  {d['name']:>8} {d['confidence']:.2f}")
image0.jpg: 5 detections
       bus 0.90
    person 0.85
    person 0.85
image1.jpg: 3 detections
    person 0.89
    person 0.79
       tie 0.59

summary() gibt bereits einfache Namen und Fließkommazahlen zurück, daher müssen keine Tensoren umgewandelt werden. Die Konfidenzwerte unterscheiden sich leicht von predict.py, da eine Liste von Bildern auf eine gemeinsame Form aufgefüllt wird. Bei conf=0.1 fügt bus.jpg ein Stoppschild hinzu.

Wie es weitergeht

Du hast das kleinste Modell verwendet. Als Nächstes entscheidest du, welche YOLO26-Größe dein Projekt tatsächlich trainieren und bereitstellen sollte.