Modellvalidierung mit Ultralytics YOLO#
Einleitung#
Die Validierung ist ein entscheidender Schritt in der Machine-Learning-Pipeline. Sie ermöglicht es dir, die Qualität deiner trainierten Modelle zu beurteilen. Der Val-Modus in Ultralytics YOLO26 bietet eine robuste Sammlung von Werkzeugen und Metriken zur Bewertung der Leistung deiner Objekterkennungsmodelle. Dieser Leitfaden hilft dir umfassend dabei, den Val-Modus effektiv zu nutzen und sicherzustellen, dass deine Modelle sowohl präzise als auch zuverlässig sind.
Sieh dir die unreleased YOLO27 preview an, um vorläufige Validierungsergebnisse zu erhalten.
Watch: Ultralytics Modes Tutorial: Validation
Warum mit Ultralytics YOLO validieren?#
Darum ist der Val-Modus von YOLO26 vorteilhaft:
- Präzision: Ermittle genaue Metriken wie mAP50, mAP75 und mAP50-95, um dein Modell umfassend zu bewerten.
- Komfort: Nutze integrierte Funktionen, die sich an die Trainingseinstellungen erinnern und den Validierungsprozess vereinfachen.
- Flexibilität: Validiere dein Modell mit denselben oder anderen Datensätzen und Bildgrößen.
- Hyperparameter-Optimierung: Nutze Validierungsmetriken, um dein Modell für eine bessere Leistung fein abzustimmen.
Wichtige Funktionen des Val-Modus#
Der Val-Modus von YOLO26 bietet unter anderem folgende Funktionen:
- Automatische Einstellungen: Modelle speichern ihre Trainingskonfigurationen, sodass die Validierung unkompliziert durchgeführt werden kann.
- Unterstützung mehrerer Metriken: Bewerte dein Modell anhand verschiedener Genauigkeitsmetriken.
- CLI und Python-API: Wähle je nach deinen Vorlieben für die Validierung zwischen der Befehlszeile und der Python-API.
- Datenkompatibilität: Funktioniert nahtlos sowohl mit den während des Trainings verwendeten als auch mit benutzerdefinierten Datensätzen.
- YOLO26-Modelle speichern ihre Trainingseinstellungen automatisch. Du kannst ein Modell daher einfach mit derselben Bildgröße und auf dem ursprünglichen Datensatz validieren, indem du nur
yolo val model=yolo26n.ptoderYOLO("yolo26n.pt").val()verwendest.
Verwendungsbeispiele#
Validiere die Genauigkeit eines trainierten YOLO26n-Modells auf dem COCO8-Datensatz. Es sind keine Argumente erforderlich, da model seine Trainings-data und -Argumente als Modellattribute speichert. Eine vollständige Liste der Validierungsargumente findest du im Abschnitt „Argumente“ weiter unten.
Unter Windows wird möglicherweise RuntimeError angezeigt, wenn du die Validierung als Skript startest. Füge vor deinem Validierungscode einen Block mit if __name__ == "__main__": ein, um den Fehler zu beheben.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom model
# Validate the model
metrics = model.val() # no arguments needed, dataset and settings remembered
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # a list containing mAP50-95 for each category
metrics.box.image_metrics # per-image metrics dictionary with precision, recall, F1, TP, FP, and FNArgumente für die YOLO-Modellvalidierung#
Bei der Validierung von YOLO-Modellen können verschiedene Argumente fein abgestimmt werden, um den Bewertungsprozess zu optimieren. Diese Argumente steuern unter anderem die Eingabebildgröße, die Stapelverarbeitung und Leistungsschwellenwerte. Im Folgenden findest du eine detaillierte Beschreibung jedes Arguments, damit du deine Validierungseinstellungen effektiv anpassen kannst.
| Argument | Typ | Standardwert | Beschreibung |
|---|---|---|---|
data | str | None | Gibt den Pfad zur YAML-Datei des Datensatzes an (z. B. coco8.yaml), die den Pfad zu den Validierungsdaten enthalten sollte. Für die Klassifikation wird stattdessen ein Datensatzverzeichnis oder der Name eines integrierten Datensatzes verwendet (z. B. imagenet10). |
imgsz | int | 640 | Legt die Größe der Eingabebilder fest. Alle Bilder werden vor der Verarbeitung auf diese Abmessungen skaliert. Größere Abmessungen können die Genauigkeit bei kleinen Objekten verbessern, erhöhen jedoch die Berechnungszeit. |
batch | int | 16 | Legt die Anzahl der Bilder pro Stapel fest. Höhere Werte nutzen den GPU-Speicher effizienter, benötigen aber mehr VRAM. Passe den Wert an die verfügbaren Hardware-Ressourcen an. |
save_json | bool | False | Wenn True, speichert dies die Ergebnisse in einer JSON-Datei zur weiteren Analyse, Integration mit anderen Tools oder Einreichung bei Evaluierungsservern wie COCO. Bei Erfassungsdatensätzen werden die Vorhersagen zudem mit faster-coco-eval evaluiert und das mAP für kleine, mittlere und große Objekte gemeldet, was während des Trainings als metrics/mAP_small(B), metrics/mAP_medium(B) und metrics/mAP_large(B) in results.csv protokolliert wird. |
conf | float | 0.001 | Legt den minimalen Konfidenzschwellenwert für Erkennungen fest. Niedrigere Werte erhöhen den Recall, können aber mehr False Positives verursachen. Präzisions-Recall-Kurven verwenden standardmäßig 0.001; Erkennungskonfusionsmatrizen verwenden explizit den Wert conf oder, falls dieser fehlt, 0.25. Die zusammengefasste Präzision und der Recall verwenden die Max-F1-Konfidenz und können daher von Werten abweichen, die aus confusion_matrix.png abgeleitet wurden. Für die OBB-Validierung ist der Standardwert 0.01, um den Speicherbedarf zu reduzieren. |
iou | float | 0.7 | Legt den Schwellenwert für die Schnittmenge über der Vereinigungsmenge bei der Unterdrückung nicht maximaler Werte fest. Steuert die Entfernung doppelter Erkennungen. |
max_det | int | 300 | Begrenzt die maximale Anzahl von Detektionen pro Bild. Bei detect, segment, pose und OBB wird der Wert bei Belassung auf 300 auf die höchste Anzahl mit einem Label versehener Objekte im validierten Split angehoben, wenn ein Bild diesen Wert überschreitet, begleitet von einer Warnung; jeder andere Wert wird beibehalten, verbunden mit der Warnung, dass der Recall gedeckelt sein kann, wenn ein Bild ihn überschreitet. |
quantize | int oder str | None | Validierungsgenauigkeit: 16/"fp16" und 32/"fp32"/nicht gesetzt wählen FP16- oder FP32-Berechnungen für PyTorch- und TorchScript-Modelle; andere Formate berechnen mit der Genauigkeit, die ihr Artefakt und ihre Laufzeit auswählen. Bei 16 rundet OpenVINO die Eingabe auf dem Client weiterhin auf FP16 und erweitert sie wieder auf FP32, ohne zu ändern, worin die Laufzeit rechnet. Die INT8-/PTQ-Quantisierung wird während des Exports konfiguriert und anschließend durch das Validieren des exportierten Modells verwendet. Ersetzt das veraltete half-Flag. |
device | str | None | Gibt 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 können durch Kommata getrennt angegeben werden. |
dnn | bool | False | Bei True wird das OpenCV-DNN-Modul für die Inferenz von ONNX-Modellen verwendet und bietet damit eine Alternative zu PyTorch-Inferenzmethoden. |
plots | bool | True | Wenn True, werden Diagramme der Vorhersagen im Vergleich zu den Ground-Truth-Daten, Konfusionsmatrizen und PR-Kurven zur visuellen Bewertung der Modellleistung erstellt und gespeichert. |
classes | list[int] | None | Gibt eine Liste der zu bewertenden Klassen-IDs an. Dies ist nützlich, um während der Bewertung bestimmte Klassen herauszufiltern und sich auf sie zu konzentrieren. |
rect | bool | True | Bei True wird für die Stapelverarbeitung eine rechteckige Inferenz verwendet. Dadurch wird die Auffüllung reduziert und die Geschwindigkeit sowie Effizienz können steigen, da Bilder in ihrem ursprünglichen Seitenverhältnis verarbeitet werden. Bei der Validierung von depth wird diese Einstellung ignoriert; jedes Bild wird stattdessen auf ein festes quadratisches imgsz gestreckt und nicht aufgefüllt. |
split | str | 'val' | Legt den für die Validierung zu verwendenden Datensatzabschnitt fest (val, test oder train). Dadurch kannst du flexibel den Datenbereich für die Leistungsbewertung auswählen. |
fraction | float, int oder list | 1.0 | Teilmenge des validierten Splits. Bei einer Liste von [train, val, test] gilt der Eintrag, der zu split passt (1 = vollständiger Split, Ganzzahlen über 1 = Bildanzahlen; ausgelassene Einträge sind vollständig). Ein Skalar gilt nur bei split=train; val und test verwenden dann den vollständigen Split. |
project | str | None | Name des Projektverzeichnisses, in dem die Validierungsausgaben gespeichert werden. Dies hilft, Ergebnisse verschiedener Experimente oder Modelle zu organisieren. |
name | str | None | Name des Validierungslaufs. Wird zum Erstellen eines Unterverzeichnisses im Projektordner verwendet, in dem Validierungsprotokolle und Ausgaben gespeichert werden. |
verbose | bool | True | Bei True werden während der Validierung detaillierte Informationen angezeigt, darunter klassenbezogene Metriken, der Stapelfortschritt und zusätzliche Informationen zur Fehlersuche. |
save_txt | bool | False | Bei True werden die Erkennungsergebnisse in Textdateien gespeichert, eine Datei pro Bild. Dies ist für weitere Analysen, benutzerdefinierte Nachverarbeitung oder die Integration mit anderen Systemen nützlich. |
save_conf | bool | False | Bei True werden Konfidenzwerte in die gespeicherten Textdateien aufgenommen, wenn save_txt aktiviert ist. Dadurch stehen detailliertere Ausgaben für Analyse und Filterung zur Verfügung. |
workers | int | 8 | Anzahl der Worker-Threads zum Laden der 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. |
augment | bool | False | Aktiviert Test-Time Augmentation (TTA) während der Validierung. Dies kann die Erkennungsgenauigkeit auf Kosten der Inferenzgeschwindigkeit verbessern, da die Inferenz auf transformierten Versionen der Eingabe ausgeführt wird. Nur für Ultralytics PyTorch-Modelle verfügbar. |
agnostic_nms | bool | False | Aktiviert die klassenagnostische Non-Maximum Suppression, wodurch überlappende Boxen mit niedrigerem Score unabhängig von ihrer vorhergesagten Klasse unterdrückt werden. Nützlich für instanzfokussierte Anwendungen. Bei NMS-freier Inferenz (nms=False auf YOLO26 oder YOLOv10) verhindert dies lediglich, dass dieselbe Erkennung mit mehreren Klassenlabels erscheint (IoU=1.0-Duplikate), und führt keine Schwellenwert-basierte Unterdrückung von IoU zwischen unterschiedlichen Boxen durch. |
single_cls | bool | False | Behandelt während der Validierung alle Klassen als eine einzige Klasse. Dies ist nützlich, um die Modellleistung bei binären Erkennungsaufgaben zu bewerten oder wenn Klassenunterscheidungen keine Rolle spielen. |
visualize | bool | False | Visualisiert für jedes Bild die Ground-Truth-Daten, True Positives, False Positives und False Negatives. Dies ist für die Fehlersuche und die Interpretation des Modells nützlich. |
show_labels | bool | True | Zeigt Klassenbezeichnungen in Validierungsvisualisierungen an, wenn visualize=True. Setze den Wert auf False, um Übereinstimmungen und Fehler übersichtlicher darzustellen. |
show_conf | bool | True | Zeigt Konfidenzwerte in Validierungsvisualisierungen an, wenn visualize=True. Setze den Wert auf False, um Übereinstimmungen und Fehler übersichtlicher darzustellen. |
compile | bool oder str | False | Aktiviert die Graphkompilierung mit torch.compile von PyTorch 2.x über backend='inductor'. Akzeptiert True → "default", False → Deaktivierung oder einen Zeichenkettenmodus wie "default", "reduce-overhead", "max-autotune-no-cudagraphs". Bei fehlender Unterstützung wird mit einer Warnung auf den Eager-Modus zurückgefallen. |
channels_last | bool | None | Verwendet das Speicherformat channels_last (NHWC) für die native PyTorch-Validierung. None aktiviert es automatisch auf Linux- und Windows-x86-CPUs mit oneDNN und 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; die Validierung während des Trainings behält das Layout des Trainingsmodells bei. |
nms | bool, optional | None | Führt standardmäßig One-to-Many-Inferenz mit NMS aus (None oder True). Setze False, um den NMS-freien One-to-One-Kopf zu verwenden, sofern verfügbar. Weitere Details findest du im End-to-End Detection guide. |
Jede dieser Einstellungen spielt eine wichtige Rolle im Validierungsprozess und ermöglicht eine anpassbare und effiziente Bewertung von YOLO-Modellen. Wenn du diese Parameter an deine spezifischen Anforderungen und Ressourcen anpasst, kannst du ein optimales Gleichgewicht zwischen Genauigkeit und Leistung erreichen.
Beispiel für eine Validierung mit Argumenten#
Watch: How to Export Model Validation Results in CSV, JSON, SQL, Polars DataFrame & More
Die folgenden Beispiele zeigen die Validierung von YOLO-Modellen mit benutzerdefinierten Argumenten in Python und über die CLI.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt")
# Customize validation settings
metrics = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.7, device="0")Du kannst die Ergebnisse der Konfusionsmatrix mit dem bereitgestellten Code auch in verschiedenen Formaten speichern.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.val(data="coco8.yaml", plots=True)
print(results.confusion_matrix.to_df())Bei der Validierung werden für alle Aufgaben außer der Klassifikation die Metriken für Präzision, Recall, F1, TP, FP und FN pro Bild gespeichert (bei einem IoU-Schwellenwert von 0,5). Nach Abschluss der Validierung kannst du über results.box.image_metrics auf sie für Erkennung und OBB, über results.seg.image_metrics auf sie für die Segmentierung und über results.pose.image_metrics auf sie für die Posenschätzung zugreifen.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt")
# Validate and access per-image metrics
results = model.val(data="coco8.yaml")
# image_metrics is a dictionary with image filenames as keys
print(results.box.image_metrics)
# Output: {'image1.jpg': {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}, ...}
# Access metrics for a specific image
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üssel | Beschreibung |
|---|---|
precision | Präzisionswert für das Bild (tp / (tp + fp)). |
recall | Recall-Wert für das Bild (tp / (tp + fn)). |
f1 | Harmonisches Mittel von Präzision und Recall. |
tp | Anzahl der True Positives für das Bild. |
fp | Anzahl der False Positives für das Bild. |
fn | Anzahl der False Negatives für das Bild. |
Diese Funktion ist für Aufgaben zur Erkennung, Segmentierung, Posenschätzung und OBB verfügbar.
Das zurückgegebene Metrikobjekt stellt außerdem Export-Hilfsfunktionen für die nachgelagerte Analyse bereit:
| Methode | Rückgabetyp | Beschreibung |
|---|---|---|
summary() | List[Dict[str, Any]] | Wandelt die Validierungsergebnisse in ein zusammengefasstes Dictionary um. |
to_df() | DataFrame | Gibt die Validierungsergebnisse als strukturierten Polars DataFrame zurück. |
to_csv() | str | Exportiert die Validierungsergebnisse im CSV-Format und gibt die CSV-Zeichenkette zurück. |
to_json() | str | Exportiert die Validierungsergebnisse im JSON-Format und gibt die JSON-Zeichenkette zurück. |
Weitere Informationen findest du in der Dokumentation der Klasse DataExportMixin.
Wie geht es weiter?#
Zufrieden mit den Metriken? Exportiere das Modell in ein Bereitstellungsformat. Wenn die Genauigkeit nicht ausreicht, trainiere es erneut mit anderen Hyperparametern oder mehr Trainingsdaten.
FAQ#
Um dein YOLO26-Modell zu validieren, kannst du den von Ultralytics bereitgestellten Val-Modus verwenden. Mit der Python-API kannst du beispielsweise ein Modell laden und die Validierung ausführen mit:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Validate the model metrics = model.val() print(metrics.box.map) # map50-95Alternativ kannst du die Befehlszeile (CLI) verwenden:
yolo val model=yolo26n.ptFür weitere Anpassungen kannst du verschiedene Argumente wie
imgsz,batchundconfsowohl im Python- als auch im CLI-Modus anpassen. Eine vollständige Liste der Parameter findest du im Abschnitt Argumente für die YOLO-Modellvalidierung.Die Validierung eines YOLO26-Modells liefert mehrere wichtige Metriken zur Bewertung der Modellleistung. 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 auf diese Metriken wie folgt zugreifen:
metrics = model.val() # assumes `model` has been loaded print(metrics.box.map) # mAP50-95 print(metrics.box.map50) # mAP50 print(metrics.box.map75) # mAP75 print(metrics.box.maps) # list of mAP50-95 for each category print(metrics.box.image_metrics) # per-image metrics dictionary with precision, recall, F1, TP, FP, and FNFür eine vollständige Leistungsbewertung ist es entscheidend, all diese Metriken zu überprüfen. Weitere Informationen findest du unter Wichtige Funktionen des Val-Modus.
Die Verwendung von Ultralytics YOLO zur Validierung bietet mehrere Vorteile:
- Präzision: YOLO26 liefert präzise Leistungskennzahlen, darunter mAP50, mAP75 und mAP50-95.
- Benutzerfreundlichkeit: Die Modelle speichern ihre Trainingseinstellungen, wodurch die Validierung unkompliziert ist.
- Flexibilität: Du kannst anhand derselben oder anderer Datensätze und Bildgrößen validieren.
- Abstimmung der Hyperparameter: Validierungskennzahlen helfen dabei, Modelle für eine bessere Leistung fein abzustimmen.
Diese Vorteile stellen sicher, dass deine Modelle gründlich evaluiert und für bessere Ergebnisse optimiert werden können. Weitere Informationen zu diesen Vorteilen findest du im Abschnitt Warum mit Ultralytics YOLO validieren.
Ja, du kannst dein YOLO26-Modell mit einem benutzerdefinierten Datensatz validieren. Gib das Argument
datamit dem Pfad zu deiner Datensatz-YAML-Datei an. Diese sollte den Pfad zu den Validierungsdaten enthalten. Für die Klassifikation wird stattdessen ein Datensatzverzeichnis oder der Name eines integrierten Datensatzes verwendet, z. B.imagenet10.HinweisDie Validierung wird anhand der eigenen Klassennamen des Modells durchgeführt. Diese kannst du mit
model.namesanzeigen. Sie können sich von den Klassennamen unterscheiden, die im Datensatz selbst definiert sind.Beispiel in Python:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Validate with a custom dataset metrics = model.val(data="path/to/your/custom_dataset.yaml") print(metrics.box.map) # map50-95Beispiel mit CLI:
yolo val model=yolo26n.pt data=path/to/your/custom_dataset.yamlWeitere anpassbare Optionen während der Validierung findest du im Abschnitt Beispielvalidierung mit Argumenten.
Um die Validierungsergebnisse in einer JSON-Datei zu speichern, kannst du das Argument
save_jsonbei der Ausführung der Validierung aufTruesetzen. Dies ist sowohl über die Python API als auch über die CLI möglich.Beispiel in Python:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Save validation results to JSON metrics = model.val(save_json=True)Beispiel mit CLI:
yolo val model=yolo26n.pt save_json=TrueAuf Erkennungsdatensätzen berichtet
save_json=Trueauch die mAP für kleine, mittlere und große Objekte überfaster-coco-eval. Weitere Details findest du unter Argumente für die YOLO-Modellvalidierung.