Erste Schritte

Modellvalidierung mit Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Einführung#

Die Validierung ist ein wichtiger Schritt in der Machine-Learning-Pipeline und ermöglicht es dir, die Qualität deiner trainierten Modelle zu beurteilen. Der Val-Modus von Ultralytics YOLO26 bietet Werkzeuge und Kennzahlen zur Bewertung von Modellen für die Objekterkennung und alle anderen unterstützten Aufgaben. Diese Anleitung erklärt, wie du mit dem Val-Modus sicherstellst, dass deine Modelle genau und zuverlässig sind.

Vorläufige Validierungsergebnisse findest du in der Vorschauversion von YOLO27.



Ansehen: Tutorial zu den Ultralytics-Modi: Validierung

Warum mit Ultralytics YOLO validieren?#

Gründe für die Verwendung des Val-Modus von YOLO26:

  • Präzision: Ermittle genaue Kennzahlen wie mAP50, mAP75 und mAP50-95, um dein Modell umfassend zu bewerten.
  • Komfort: Nutze integrierte Funktionen, die sich an die Trainingseinstellungen erinnern und so die Validierung vereinfachen.
  • Flexibilität: Validiere dein Modell mit denselben oder anderen Datensätzen und Bildgrößen.
  • Hyperparameteroptimierung: Nutze Validierungskennzahlen, um dein Modell für eine bessere Leistung fein abzustimmen.

Wichtige Funktionen des Val-Modus#

Wichtige Funktionen des Val-Modus von YOLO26:

  • Automatische Einstellungen: Modelle speichern ihre Trainingskonfigurationen für eine unkomplizierte Validierung.
  • Unterstützung mehrerer Kennzahlen: Bewerte dein Modell anhand verschiedener Genauigkeitskennzahlen.
  • CLI und Python-API: Führe die Validierung über die Befehlszeile oder die Python-API aus – ganz wie du möchtest.
  • Datenkompatibilität: Funktioniert sowohl mit den beim Training verwendeten als auch mit benutzerdefinierten Datensätzen.
Tipp
  • YOLO26-Modelle speichern ihre Trainingseinstellungen automatisch. Daher validiert yolo val model=path/to/best.pt oder YOLO("path/to/best.pt").val() mit der beim Training verwendeten Bildgröße auf dem ursprünglichen Datensatz. Bei offiziellen Gewichten wird auf den für die Aufgabe standardmäßig vorgesehenen Datensatz zurückgegriffen; mit data kannst du diesen überschreiben.

Anwendungsbeispiele#

Überprüfe die Genauigkeit eines trainierten YOLO26n-Modells. Argumente sind nicht erforderlich, da model die Trainingseinstellungen data und weitere Argumente als Modellattribute speichert: path/to/best.pt validiert anhand des Datensatzes, mit dem das Modell trainiert wurde. Bei offiziellen Gewichten ist ein Trainingsdatensatzpfad hinterlegt, der auf deinem Rechner nicht existiert. Daher wird mit einer Warnung auf den aufgabenspezifischen Standardwert coco8.yaml zurückgegriffen. Übergib data, um einen anderen Datensatz für die Validierung zu verwenden.

Fehler bei der Mehrfachverarbeitung unter Windows

Unter Windows kann beim Starten der Validierung als Skript ein RuntimeError auftreten. Füge vor deinem Validierungscode einen Block if __name__ == "__main__": ein, um das Problem zu beheben.

Beispiel
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")  # Ein offizielles Modell laden
model = YOLO("path/to/best.pt")  # Ein benutzerdefiniertes Modell laden

# Das Modell validieren
metrics = model.val()  # Keine Argumente erforderlich, Datensatz und Einstellungen werden gespeichert
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # mAP50-95 pro Klasse; Klassen, die im Validierungsdatensatz fehlen, erhalten den Gesamtwert für mAP
metrics.box.ap_class_index  # tatsächlich ausgewertete Klassenindizes
metrics.box.image_metrics  # Kennzahlenverzeichnis pro Bild mit Präzision, Trefferquote, F1, TP, FP und FN

Argumente für die YOLO-Modellvalidierung#

Bei der Validierung von YOLO-Modellen lassen sich verschiedene Argumente anpassen, um den Auswertungsprozess auf deine Anforderungen abzustimmen. Diese Argumente steuern unter anderem die Größe der Eingabebilder, die Stapelverarbeitung und die Leistungsschwellen. Die einzelnen Argumente werden im Folgenden beschrieben.

ArgumentTypStandardBeschreibung
datastrNoneGibt den Pfad zur Dataset-YAML-Datei an (z. B. coco8.yaml), die den Pfad zu den Validierungsdaten enthalten sollte. Für die Klassifizierung wird stattdessen ein Dataset-Verzeichnis oder der Name eines integrierten Datensatzes verwendet (z. B. imagenet10).
imgszint640Legt die Größe der Eingabebilder fest. Vor der Verarbeitung werden alle Bilder auf diese Abmessungen skaliert. Größere Abmessungen können die Genauigkeit bei kleinen Objekten verbessern, erhöhen aber den Rechenaufwand.
batchint16Legt die Anzahl der Bilder pro Batch fest. Höhere Werte nutzen den GPU-Speicher effizienter, benötigen aber mehr VRAM. Passe den Wert an die verfügbaren Hardwareressourcen an.
tilebool oder intFalseFührt die Inferenz mit festen Kacheln aus und bewertet die zusammengeführten Ergebnisse anhand der Annotationen des vollständigen Originalbilds. True verwendet imgsz; eine positive Ganzzahl legt die Kachelgröße fest. Siehe Kachelung mit hoher Auflösung.
save_jsonboolFalseWenn True aktiviert ist, werden die Ergebnisse zur weiteren Analyse, zur Integration mit anderen Tools oder zur Übermittlung an Evaluierungsserver wie COCO in einer JSON-Datei gespeichert. Bei Detektionsdatensätzen werden die Vorhersagen außerdem mit faster-coco-eval ausgewertet und die mAP-Werte für kleine, mittlere und große Objekte gemeldet; während des Trainings werden sie in results.csv als metrics/mAP_small(B), metrics/mAP_medium(B) und metrics/mAP_large(B) protokolliert. Bei semantischer Segmentierung werden stattdessen PNG-Klassenmasken unter results/ gespeichert, wobei die Bild-Unterverzeichnisse erhalten bleiben.
conffloat0.001Legt den Mindestkonfidenzschwellenwert für Erkennungen fest. Niedrigere Werte erhöhen den Recall, können aber mehr falsch-positive Ergebnisse verursachen. Präzisions-Recall-Kurven, mAP und Erkennungskonfusionsmatrizen verwenden diesen Wert. Ein höherer Wert für conf, etwa 0.25, führt zu einer Matrix, die der Vorhersageausgabe stärker entspricht, kann aber die mAP senken. Die zusammengefassten Werte für Präzision und Recall verwenden die Konfidenz mit dem maximalen F1-Wert und können daher von den aus confusion_matrix.png abgeleiteten Werten abweichen. Für die OBB-Validierung standardmäßig 0.01, um den Speicherbedarf zu verringern.
ioufloat0.7Legt den Schwellenwert für die Schnittmenge über Vereinigungsmenge für die Nichtmaximalwertunterdrückung fest. Steuert das Entfernen doppelter Erkennungen.
max_detint300Begrenzt die maximale Anzahl erkannter Objekte pro Bild. Bei Erkennung, Segmentierung, Pose und OBB wird der Wert 300 automatisch auf die höchste Anzahl beschrifteter Objekte im validierten Datensatzabschnitt angehoben, falls diese Anzahl überschritten wird; in diesem Fall erscheint eine Warnung. Jeder andere Wert bleibt unverändert. Wird er überschritten, erscheint eine Warnung, dass der Recall begrenzt sein kann.
quantizeint oder strNoneValidierungspräzision: 16/"fp16" und 32/"fp32"/unset wählen FP16- oder FP32-Berechnungen für PyTorch- und TorchScript-Modelle aus (FP32 auf der CPU); andere Formate verwenden die Präzision, die ihr Artefakt und ihre Laufzeitumgebung vorgeben. Bei 16 rundet OpenVINO die Eingabe auf dem Client weiterhin auf FP16 und erweitert sie anschließend wieder auf FP32, ohne die Präzision der Laufzeitumgebung zu ändern. Die INT8/PTQ-Quantisierung wird beim Export konfiguriert und anschließend zur Validierung des exportierten Modells verwendet. Ersetzt das veraltete Flag half.
devicestrNoneGibt das Gerät für die Validierung an (cpu, cuda:0, npu, npu:0 usw.). Bei None wird automatisch das beste verfügbare Gerät ausgewählt. Mehrere CUDA-Geräte lassen sich durch Kommas getrennt angeben. OpenVINO- und LiteRT-Modelle werden auf der Intel-GPU und NPU mit xpu und npu ausgeführt; unter Inferenzgeräte findest du Informationen zu allen Formaten.
dnnboolFalseWenn True aktiviert ist, verwendet die Inferenz von ONNX-Modellen das DNN-Modul von OpenCV als Alternative zu PyTorch-Inferenzmethoden.
plotsboolTrueBei True werden Vorhersagen im Vergleich zu den Ground-Truth-Daten, Konfusionsmatrizen und PR-Kurven zur visuellen Bewertung der Modellleistung erstellt und gespeichert.
classeslist[int]NoneGibt eine Liste der auszuwertenden Klassen-IDs an. Nützlich, um während der Auswertung bestimmte Klassen herauszufiltern und sich auf sie zu konzentrieren.
rectboolTrueWenn True, werden Bilder mit ähnlichen Seitenverhältnissen zu rechteckigen Formen gruppiert. Vor dem Aufrunden jeder Dimension auf ein Vielfaches des Strides wird ein halber Stride addiert (kein zusätzlicher halber Stride für semantic). Bei einem Stride von 32 wird ein 640×640-Bild bei imgsz=640 zu 672×672 mit einem Versatz von 16 px, während predict 640×640 verwendet; daher können die Metriken abweichen. rect=False stimmt bei quadratischen Bildern mit predict überein. Wird für depth und RT-DETR ignoriert, die Bilder zu einem imgsz-Quadrat strecken.
splitstr'val'Legt den für die Validierung verwendeten Datensatz-Split fest (val, test oder train). So kannst du flexibel auswählen, welcher Datenabschnitt zur Leistungsbewertung verwendet wird.
fractionfloat, int oder list1.0Teilmenge des validierten Splits. Bei einer Liste in [train, val, test] gilt der Eintrag, der zu split passt (1 = vollständiger Split, Ganzzahlen über 1 = Anzahl der Bilder; ausgelassene Einträge entsprechen dem vollständigen Split). Ein einzelner Wert gilt nur für split=train; val und test verwenden dann den vollständigen Split.
projectstrNoneName des Projektverzeichnisses, in dem die Validierungsergebnisse gespeichert werden. Ein relativer Pfad wird unter runs_dir/<task> abgelegt, ein absoluter Pfad wird unverändert verwendet.
namestrNoneName des Validierungslaufs. Dient zum Erstellen eines Unterverzeichnisses im Projektordner, in dem Validierungsprotokolle und -ausgaben gespeichert werden.
verboseboolTrueWenn True aktiviert ist, werden während der Validierung ausführliche Informationen angezeigt, darunter Kennzahlen für jede Klasse, der Batch-Fortschritt und zusätzliche Informationen zur Fehlersuche.
save_txtboolFalseWenn True aktiviert ist, werden Erkennungsergebnisse in Textdateien gespeichert, jeweils eine Datei pro Bild. Nützlich für weiterführende Analysen, benutzerdefinierte Nachbearbeitung oder die Einbindung in andere Systeme.
save_confboolFalseWenn True aktiviert ist, werden Konfidenzwerte in die gespeicherten Textdateien aufgenommen, sofern save_txt aktiviert ist. Dadurch stehen detailliertere Ausgaben für Analysen und Filterungen zur Verfügung.
workersint8Anzahl der Worker-Threads für das Laden von Daten. Höhere Werte können die Datenvorverarbeitung beschleunigen, aber die CPU-Auslastung erhöhen. Bei 0 wird der Hauptthread verwendet, was in manchen Umgebungen stabiler sein kann.
augmentboolFalseAktiviert Testzeit-Augmentierung (TTA) während der Validierung. Durch Inferenz auf transformierten Versionen der Eingabe kann sich die Erkennungsgenauigkeit verbessern, allerdings auf Kosten der Inferenzgeschwindigkeit. Nur für Ultralytics-PyTorch-Modelle verfügbar.
agnostic_nmsboolFalseAktiviert klassenunabhängige Non-Maximum Suppression, die überlappende Rahmen mit niedrigerer Bewertung unabhängig von ihrer vorhergesagten Klasse unterdrückt. Nützlich für Anwendungen mit Fokus auf einzelne Instanzen. Bei NMS-freier Inferenz (nms=False für YOLO26 oder YOLOv10) wird dadurch lediglich verhindert, dass dieselbe Erkennung mit mehreren Klassenbezeichnungen erscheint (Duplikate mit IoU=1.0); eine Unterdrückung unterschiedlicher Rahmen anhand eines IoU-Schwellenwerts findet nicht statt.
single_clsboolFalseBehandelt während der Validierung alle Klassen als eine einzige Klasse. Nützlich, um die Modellleistung bei binären Erkennungsaufgaben zu bewerten oder wenn Klassenunterscheidungen keine Rolle spielen.
visualizeboolFalseVisualisiert für jedes Bild die Ground-Truth-Daten, richtig-positiven, falsch-positiven und falsch-negativen Ergebnisse. Nützlich für die Fehlersuche und die Interpretation des Modells.
show_labelsboolTrueZeigt Klassenbezeichnungen in Validierungsvisualisierungen an, wenn visualize=True aktiviert ist. Setze den Wert auf False, um Übereinstimmungen und Fehler übersichtlicher darzustellen.
show_confboolTrueZeigt Konfidenzwerte in Validierungsvisualisierungen an, wenn visualize=True aktiviert ist. Setze den Wert auf False, um Übereinstimmungen und Fehler übersichtlicher darzustellen.
compilebool oder strFalseAktiviert die PyTorch-2.x-Graphkompilierung torch.compile mit backend='inductor'. Akzeptiert True → "default", False → deaktiviert oder einen Zeichenfolgenmodus wie "default", "reduce-overhead", "max-autotune-no-cudagraphs". Bei Nichtunterstützung wird mit einer Warnung auf den Eager-Modus zurückgegriffen.
channels_lastboolNoneVerwendet für die native PyTorch-Validierung das Speicherformat channels_last (NHWC). None aktiviert es automatisch auf oneDNN-fähigen Linux- und Windows-x86-CPUs mit PyTorch 1.13 oder neuer, False deaktiviert es und True fordert es auf unterstützten x86-CPUs oder CUDA-Geräten an. ARM64, MPS, ältere PyTorch-Versionen, CPUs ohne oneDNN und exportierte Formate bleiben unverändert; bei der Validierung während des Trainings bleibt das Layout des Trainingsmodells erhalten.
nmsbool, optionalNoneFührt standardmäßig eine Viele-zu-eins-Inferenz mit NMS aus (None oder True). Setze False, um den NMS-freien Eins-zu-eins-Kopf zu verwenden, sofern verfügbar. Weitere Informationen findest du in der Anleitung zur End-to-End-Erkennung.

Wenn du diese Einstellungen an deine Anforderungen und verfügbaren Ressourcen anpasst, findest du die richtige Balance zwischen Auswertungsgenauigkeit und Geschwindigkeit.

Rechteckige Validierungsgeometrie (rect)#

Statische Exporte verwenden zur Validierung ihre aufgezeichnete (height, width)-Eingabeform, auch bei nicht quadratischen Exporten. Zum Beispiel verwendet YOLO("yolo26n.onnx").val(data="coco8.yaml") eine 384×640-Eingabe, wenn das Modell mit imgsz=(384, 640) exportiert wurde.

Bei Erkennung, Instanzsegmentierung, Pose und OBB rundet die rechteckige Validierung (rect=True) jede Batch-Dimension mithilfe von ceil(shape * imgsz / stride + 0.5) * stride auf, wobei shape die normalisierte Höhe oder Breite des Batches ist. Das resultierende Padding wird auf gegenüberliegende Seiten verteilt. Beispielsweise verwendet ein quadratisches Bild mit 640×640 Pixeln, das mit imgsz=640 und einem Stride von 32 validiert wird, eine Eingabegröße von 672×672 mit 16 px Padding auf jeder Seite, während predict() 640×640 ohne Padding verwendet.

Dieser Unterschied kann sich auf die Validierungsmetriken auswirken. Bei quadratischen, am Stride ausgerichteten Eingaben entspricht model.val(rect=False) der Geometrie von predict() und Exporten mit quadratischer fester Form. Während des Trainings verwenden diese YOLO-Aufgaben unabhängig von der Einstellung rect für das Training rechteckige Validierungs-Batches, sodass model.train(rect=False) bei der rechteckigen Validierung weiterhin best.pt auswählt. Bei anderen Aufgaben ist es anders: Die semantische Segmentierung fügt kein zusätzliches Validierungs-Padding hinzu, die Tiefenschätzung deaktiviert die rechteckige Validierung, die Klassifizierung ignoriert rect, und RT-DETR verwendet einen eigenen Dataset-Builder mit rect=False.

Beispiel: Validierung mit Argumenten#



Ansehen: So exportierst du Modellvalidierungsergebnisse als CSV, JSON, SQL, Polars-DataFrame und mehr

Explore model validation and different export methods in Google Colab

Die folgenden Beispiele führen die Validierung eines YOLO-Modells in Python und über die CLI mit benutzerdefinierten Argumenten aus.

Beispiel
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")

# Validierungseinstellungen anpassen
metrics = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.7, device="0")
ConfusionMatrix exportieren

Du kannst Ergebnisse der Konfusionsmatrix auch in verschiedene Formate exportieren, zum Beispiel als DataFrame:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

results = model.val(data="coco8.yaml", plots=True)
print(results.confusion_matrix.to_df())
Präzision, Trefferquote und F1 pro Bild

Bei der Validierung werden für alle Aufgaben außer der Klassifizierung für jedes Bild die Kennzahlen Präzision, Recall, F1, TP, FP und FN (bei einem IoU-Schwellenwert von 0,5) gespeichert. Nach Abschluss der Validierung kannst du über results.box.image_metrics bei der Erkennung und OBB, über results.seg.image_metrics bei der Segmentierung und über results.pose.image_metrics bei der Pose darauf zugreifen.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")

# Validieren und auf Kennzahlen pro Bild zugreifen
results = model.val(data="coco8.yaml")

# image_metrics ist ein Verzeichnis mit Bilddateinamen als Schlüsseln
print(results.box.image_metrics)
# Ausgabe: {'image1.jpg': {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}, ...}

# Auf Kennzahlen für ein bestimmtes Bild zugreifen
results.box.image_metrics["image1.jpg"]  # {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}

Jeder Eintrag in image_metrics enthält die folgenden Schlüssel:

SchlüsselBeschreibung
precisionPräzisionswert für das Bild (tp / (tp + fp)).
recallTrefferquotenwert für das Bild (tp / (tp + fn)).
f1Harmonisches Mittel von Präzision und Trefferquote.
tpAnzahl der richtig-positiven Erkennungen für das Bild.
fpAnzahl der falsch-positiven Erkennungen für das Bild.
fnAnzahl der falsch-negativen Erkennungen für das Bild.

Diese Funktion ist für die Aufgaben Detektion, Segmentierung, Pose und OBB verfügbar.

Das zurückgegebene Kennzahlenobjekt stellt außerdem Exportfunktionen aus DataExportMixin für nachgelagerte Analysen bereit:

MethodeRückgabetypBeschreibung
summary()List[Dict[str, Any]]Gibt die Validierungsergebnisse als Liste von Wörterbüchern zurück, eines pro Zeile.
to_df()DataFrameGibt die Validierungsergebnisse als strukturierten Polars-DataFrame zurück.
to_csv()strExportiert die Validierungsergebnisse im CSV-Format und gibt die CSV-Zeichenfolge zurück.
to_json()strExportiert die Validierungsergebnisse im JSON-Format und gibt die JSON-Zeichenfolge zurück.

Erkennungs-, Segmentierungs-, semantische Segmentierungs-, Pose- und OBB-Ergebnisse enthalten eine Zeile pro Klasse in den Validierungslabels. Daher exportieren to_csv() und to_json() Metriken pro Klasse:

AufgabeSpalten pro Klasse
ErkennungClass, Images, Instances, Box-P, Box-R, Box-F1, mAP50, mAP75, mAP50-95
SegmentierungDie Erkennungsspalten, dann Mask-P, Mask-R, Mask-F1, Mask-mAP50, Mask-mAP75, Mask-mAP50-95
SemantikClass, Images, Pixels, IoU, mIoU und pixel_acc (beide global), class_pixel_acc
PoseDie Erkennungsspalten, dann Pose-P, Pose-R, Pose-F1, Pose-mAP50, Pose-mAP75, Pose-mAP50-95
obbDie Erkennungsspalten

Die Tiefenschätzung liefert eine einzelne Zeile mit delta1, delta2, delta3, abs_rel, rmse und silog; die Klassifizierung liefert eine einzelne Zeile mit top1_acc und top5_acc.

from ultralytics import YOLO

model = YOLO("yolo26n-seg.pt")
metrics = model.val(data="coco8-seg.yaml")
metrics.to_csv()  # eine Zeile pro Klasse mit Box- und Maskenmetriken

Wie geht es weiter?#

Zufrieden mit den Kennzahlen? Exportiere das Modell in ein Bereitstellungsformat. Wenn die Genauigkeit nicht stimmt, kehre zurück und trainiere erneut – mit anderen Hyperparametern oder mehr Trainingsdaten.

Häufig gestellte Fragen#

  • Um dein YOLO26-Modell zu validieren, kannst du den von Ultralytics bereitgestellten Val-Modus verwenden. Mit der Python-API kannst du zum Beispiel ein Modell laden und die Validierung folgendermaßen ausführen:

    from ultralytics import YOLO
    
    # Ein Modell laden
    model = YOLO("yolo26n.pt")
    
    # Das Modell validieren
    metrics = model.val()
    print(metrics.box.map)  # map50-95

    Alternativ kannst du die Befehlszeile (CLI) verwenden:

    yolo detect val model=yolo26n.pt data=coco8.yaml

    Für weitere Anpassungen kannst du sowohl im Python- als auch im CLI-Modus verschiedene Argumente wie imgsz, batch und conf ändern. Die vollständige Liste der Parameter findest du im Abschnitt Argumente für die YOLO-Modellvalidierung.

  • Bei der Validierung eines YOLO26-Modells werden mehrere wichtige Kennzahlen zur Bewertung der Modellleistung ermittelt. Dazu gehören:

    • mAP50 (mittlere durchschnittliche Präzision bei einem IoU-Schwellenwert von 0.5)
    • mAP75 (mittlere durchschnittliche Präzision bei einem IoU-Schwellenwert von 0.75)
    • mAP50-95 (mittlere durchschnittliche Präzision über mehrere IoU-Schwellenwerte von 0.5 bis 0.95)

    Mit der Python-API kannst du wie folgt auf diese Kennzahlen zugreifen:

    metrics = model.val()  # setzt voraus, dass `model` geladen wurde
    print(metrics.box.map)  # mAP50-95
    print(metrics.box.map50)  # mAP50
    print(metrics.box.map75)  # mAP75
    print(metrics.box.maps)  # mAP50-95 pro Klasse; Klassen, die im Validierungsdatensatz fehlen, erhalten den Gesamtwert für mAP
    print(metrics.box.ap_class_index)  # tatsächlich ausgewertete Klassenindizes
    print(metrics.box.image_metrics)  # Kennzahlenverzeichnis pro Bild mit Präzision, Trefferquote, F1, TP, FP und FN

    Berücksichtige alle diese Kennzahlen, um die Leistung vollständig zu bewerten.

  • Die Validierung mit Ultralytics YOLO bietet mehrere Vorteile:

    • Präzision: YOLO26 bietet genaue Leistungskennzahlen, darunter mAP50, mAP75 und mAP50-95.
    • Komfort: Die Modelle speichern ihre Trainingseinstellungen, sodass sich die Validierung unkompliziert durchführen lässt.
    • Flexibilität: Du kannst mit denselben oder anderen Datensätzen und Bildgrößen validieren.
    • Hyperparameteroptimierung: Validierungskennzahlen helfen dabei, Modelle für eine bessere Leistung fein abzustimmen.

    Diese Vorteile helfen dir, Modelle gründlich zu bewerten und zu optimieren.

  • Ja, du kannst dein YOLO26-Modell mit einem benutzerdefinierten Datensatz validieren. Gib für das Argument data den Pfad zu deiner Dataset-YAML-Datei an. Diese sollte den Pfad zu den Validierungsdaten enthalten. Für die Klassifizierung gibst du stattdessen ein Datensatzverzeichnis oder den Namen eines integrierten Datensatzes an (z. B. imagenet10).

    Hinweis

    Die Validierung erfolgt anhand der Klassennamen des Modells, die du mit model.names anzeigen kannst und die von den im Datensatz definierten Klassennamen abweichen können.

    Beispiel in Python:

    from ultralytics import YOLO
    
    # Ein Modell laden
    model = YOLO("yolo26n.pt")
    
    # Mit einem benutzerdefinierten Datensatz validieren
    metrics = model.val(data="path/to/your/custom_dataset.yaml")
    print(metrics.box.map)  # map50-95

    Beispiel mit der CLI:

    yolo val model=yolo26n.pt data=path/to/your/custom_dataset.yaml

    Weitere Anpassungsmöglichkeiten während der Validierung findest du im Abschnitt Beispiel: Validierung mit Argumenten.

  • Um die Validierungsergebnisse in einer JSON-Datei zu speichern, kannst du beim Ausführen der Validierung das Argument save_json auf True setzen. Das funktioniert sowohl mit der Python-API als auch mit der CLI.

    Beispiel in Python:

    from ultralytics import YOLO
    
    # Ein Modell laden
    model = YOLO("yolo26n.pt")
    
    # Validierungsergebnisse als JSON speichern
    metrics = model.val(save_json=True)

    Beispiel mit der CLI:

    yolo val model=yolo26n.pt save_json=True

    Bei Detektionsdatensätzen gibt save_json=True über faster-coco-eval auch die mAP-Werte für kleine, mittlere und große Objekte aus. Weitere Informationen findest du unter Argumente für die YOLO-Modellvalidierung.

Kommentare279

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

  1. BedoHatemGitHub

    I have a couple of models (a mix of object detection and segmentation), so I want to run them on the same validation dataset to compare them properly. The exact tasks for the seg and obj-det models are the same at a certain level, so I'm aware that seg models give a B-Box and Mask, while obj-det gives just a B-Box.

    With that said, will a segmentation dataset work on both seg and obj-det models ? Or should i make a seg and a obj-det version of the same dataset, so i can use it to equally validate the models ?

    Thanks in Advance

    1
    1. BedoHatemGitHub

      I tested it. It seems you can use a segmentation dataset to validate an obj-det model, as the seg datasets include B-Boxes and Masks of the classes.

      1
    2. Glenn JocherUltralytics(bearbeitet)

      @BedoHatem yes, you're correct! Segmentation datasets can be used to validate object detection models because they contain the bounding box annotations needed for detection evaluation. The segmentation masks are simply ignored when the dataset is used with a detection model.

      This flexibility is an advantage of the YOLO annotation format - the additional segmentation data doesn't interfere with detection evaluation. For the most accurate comparison between models, using the same validation dataset ensures you're evaluating performance on exactly the same ground truth data.

      @417dq the recall reported by val() is taken at the confidence value that maximizes F1, while the confusion matrix is built at the validation conf (0.001 by default) with an IoU matching threshold of 0.45, so the two can differ. The metrics output from val() is the reference for your model's performance.

  2. CyedenGitHub

    请问如果验针集是已经被多尺度分割了,那么再进行验证的时候imgsz应该设置为不同尺度验证的逻辑吗?例如: if name == 'main': model = YOLO(r'C:\Users\Lazy\Desktop\yolo_detect\weights\best.pt')

    multi_scale_sizes = [640, 800, 1024, 1280] 
    
    for size in multi_scale_sizes:
        model.val(
            data='ultralytics/cfg/datasets/DOTAv1.yaml',
            split='val',
            imgsz=size,
            batch=16,
            project='runs/val',
            name=f'v8n-obb-LSKNet_prev8x-obbpt_{size}',
        )
    1
    1. Glenn JocherUltralytics

      @Cyeden for multi-scale validation, you can indeed set imgsz to different scales within a loop. This approach allows you to evaluate the model's performance across various image sizes. Your implementation looks correct. Ensure you are using the latest version of the Ultralytics package to avoid any potential issues. For more details, you can refer to the validation documentation.

  3. YunYeTangGitHub

    hi, when I use yolov8-obb to validate DOTAv1, I found that confusion matrix is empty. Does it mean that confusion matrix is not supported in OBB validation?

    1
    1. Glenn JocherUltralytics(bearbeitet)

      Hi there! 👋

      The confusion matrix is supported for OBB validation in current Ultralytics versions. If yours is empty, update with pip install -U ultralytics and re-run validation with plots=True. If it is still empty, please share your yolo checks output and the validation command so we can look into it.

      In the meantime, you can still rely on the other validation metrics such as mAP, precision, and recall.

    2. Glenn JocherUltralytics(bearbeitet)

      Hey there! 🚀

      Thank you for reaching out! The confusion matrix is supported for OBB validation in current Ultralytics versions. If yours is empty, update with pip install -U ultralytics and re-run validation with plots=True; if it is still empty, share your yolo checks output and validation command so we can look into it.

      For a comprehensive evaluation you can also rely on the other metrics provided during validation, such as mAP, precision, and recall. Cheers! 🌟

  4. xyzxyzxyzxyzxzGitHub

    I want to read this page in English. Why it automatically become Chinese even though I click "GB English".

    1. Glenn JocherUltralytics

      It looks like you’re on the Chinese locale (the URL contains "/zh/"). Remove "/zh/" to view the English version, or use the top‑right language selector (GB English) and hard‑refresh; also ensure your browser’s auto‑translate is disabled.

    2. Glenn JocherUltralytics

      Thanks for the detailed description—that behavior sounds like a docs locale‑routing bug on our side rather than anything you can fix locally; we’ll get it forwarded to the web/docs team, and in the meantime could you confirm whether going directly to the English URL Model Validation with Ultralytics YOLO (English) still forces you back to Chinese and share your OS + browser version so we can reproduce it?

    3. Glenn JocherUltralytics

      Thanks for the extra details—that confirms this is an issue on the docs side, likely tied to your system/browser language being Chinese and our locale detection forcing /zh/ even when you pick English. I’ve passed this to the web/docs team to investigate; as a temporary workaround you can try using a browser whose interface language is set to English (or move English to the top of Chrome’s language preferences) so the site stops auto‑redirecting to the Chinese locale.

  5. AA278-HUBGitHub

    I have a model trained on a dataset containing four classes (car, bus, motorbike, and trunk). Now, I have a new dataset with only one class (vehicle). How can I validate this model using the new dataset, given that I only care about whether the model can identify the vehicle and its position, without concern for the specific type of vehicle?

    1. AA278-HUBGitHub

      f I want to change the validation rules in this specific situation, which .py files need to be modified

    2. Glenn JocherUltralytics

      @liujixingit save_txt writes normalized YOLO xywh (center x/y, width, height) relative to the original image size; recover pixel xyxy via the original W,H then center→corner conversion, e.g.:

      # line format: class x y w h [conf]
      cls, x, y, w, h, *rest = map(float, line.split())
      x1 = (x - w/2) * W; y1 = (y - h/2) * H
      x2 = (x + w/2) * W; y2 = (y + h/2) * H

      Function details are in the save_one_txt reference and the save_txt format is noted under Validation settings.

      @carlos-cell To get APs/APm/APl, run COCO-style evaluation with JSON saving and check the printed COCO summary:

      yolo detect val model=yolo11n.pt data=coco.yaml save_json=True

      This triggers COCO eval inside validation; see COCO evaluation in val and the size-specific metrics overview in the Performance metrics deep dive.

      @AA278-HUB For “any vehicle” validation, use single-class evaluation so all types collapse to one:

      metrics = model.val(data='vehicle.yaml', single_cls=True, agnostic_nms=True)

      Argument behavior is documented in the Val mode arguments.

      @AA278-HUB You don’t need code changes for the above, but if you must customize matching/metrics, start from DetectionValidator and the val() entry point: see the DetectionValidator reference and the val() method in engine/model.py; if proposing a PR, please keep scope minimal and include tests.

  6. liujixingitGitHub

    YOLOv8 调用验证功能开启save_txt后保存的坐标如何还原到原图,我尝试了直接×原图宽高,还原的坐标是错误的。save_txt保存的结果是相对什么计算得出的归一化坐标?

  7. CherishzyhGitHub

    hello, I read some dialog about the IOU threshold and confidence threshold and have some questions.

    1. CherishzyhGitHub
      1. the document shows that 'iou' is the threshold for NMS.Is it also a threshold for calculate the confusion matrix? eg. I hope that if the IoU between the prediction and the ground truth is greater than 0.2, it will be considered a true positive (TP). At the same time, does the NMS threshold also have to be 0.2?
    2. CherishzyhGitHub
      1. For confidence threshold, if I set it to 0.1, that mean all bboxes with a score lower than 0.1 will be removed when calculate the PR-curve?. If so, does it will also be remove in result json or txt ?
    3. Glenn JocherUltralytics

      @Cherishzyh great questions:

      1. The iou argument in val() controls NMS overlap removal only; it does not change the IoU used to determine TP/FP or mAP. Metrics are computed over fixed IoU thresholds 0.50–0.95. If you need evaluation at IoU=0.2, export predictions and compute custom metrics offline. See the Performance Metrics deep dive.

      2. The conf argument is a minimum score filter. Setting conf=0.1 removes all predictions with score < 0.1 prior to evaluation and from saved outputs (save_json/save_txt). You can still access PR data from the results object:

      from ultralytics import YOLO
      model = YOLO("yolo11n.pt")
      res = model.val(conf=0.1, iou=0.7, save_json=True, save_txt=True, plots=True)
      print(res.box.p_curve)  # precision curve vs score thresholds
      print(res.box.r_curve)  # recall curve vs score thresholds

      Argument details are in the Val mode arguments.

  8. lauravchrobakGitHub

    When I run validate without setting plots=True I still get the f1, PR curve plots in the val folder. Potentially the default for this flag is actually true despite it being false in the table above?

  9. sea190GitHub

    The question about val of yoloworld, and I used my custom dataset, and I make sure the format of ma dataset is corret. While when I run the val.py the code still validate the categories of COCO Dataset instead of my dataset? How can I solve this problem?

    1. ihciabGitHub

      You can try specifying the path of the validation set. When calling the val function, specify model.val(data=‘your_data’)

    2. Glenn JocherUltralytics

      @sea190 for YOLO-World validation with custom datasets, ensure your dataset YAML file correctly defines the class names and paths. YOLO-World may default to COCO categories if the dataset configuration isn't properly specified. Try:

      model.val(data='path/to/your/custom_dataset.yaml')

      Make sure your YAML file includes the correct names field with your custom class names and verify the val path points to your validation images and labels. If issues persist, check that your dataset follows the expected format for YOLO-World validation.