Konfiguration

YOLO-Einstellungen und Hyperparameter spielen eine entscheidende Rolle für die Leistung, Geschwindigkeit und Genauigkeit des Modells. Diese Einstellungen können das Verhalten des Modells in verschiedenen Phasen beeinflussen, einschließlich Training, Validierung und Vorhersage.

Anschauen: Ultralytics YOLO meistern: Konfiguration

Watch: Mastering Ultralytics YOLO: Configuration

Ultralytics-Befehle verwenden die folgende Syntax:

Beispiel

yolo TASK MODE ARGS

Wobei:

TASK (optional) eines von (detect, segment, classify, pose, obb)
MODE (erforderlich) eines von (train, val, predict, export, track, benchmark)
ARGS (optional) sind arg=value Paare wie imgsz=640 die die Standardwerte überschreiben.

Standard-ARG Werte sind auf dieser Seite definiert und stammen aus der cfg/default.yaml Datei.

Aufgaben

Ultralytics YOLO-Modelle können eine Vielzahl von Computer-Vision-Aufgaben ausführen, einschließlich:

Detect: Objekterkennung identifiziert und lokalisiert Objekte innerhalb eines Bildes oder Videos.
Segment: Instanzsegmentierung unterteilt ein Bild oder Video in Bereiche, die verschiedenen Objekten oder Klassen entsprechen.
Classify: Bildklassifizierung sagt das Klassenlabel eines Eingabebildes voraus.
Pose: Pose-Schätzung identifiziert Objekte und schätzt deren Schlüsselpunkte in einem Bild oder Video.
OBB: Oriented Bounding Boxes verwendet rotierte Begrenzungsrahmen, geeignet für Satelliten- oder medizinische Bilder.

Argument	Standard	Beschreibung
`task`	`'detect'`	Spezifiziert die YOLO-Aufgabe: `detect` für Objekterkennungs, `segment` für Segmentierung, `classify` für Klassifizierung, `pose` für Pose-Schätzung und `obb` für orientierte Begrenzungsrahmen. Jede Aufgabe ist auf spezifische Ausgaben und Probleme in der Bild- und Videoanalyse zugeschnitten.

Leitfaden zu Aufgaben

Modi

Ultralytics YOLO-Modelle arbeiten in verschiedenen Modi, die jeweils für eine bestimmte Phase des Modell-Lebenszyklus konzipiert sind:

Train: Trainiere ein YOLO-Modell auf einem benutzerdefinierten Datensatz.
Val: Validiere ein trainiertes YOLO-Modell.
Vorhersage: Verwende ein trainiertes YOLO-Modell, um Vorhersagen für neue Bilder oder Videos zu treffen.
Export: Exportiere ein YOLO-Modell für die Bereitstellung.
Track: Verfolge Objekte in Echtzeit mit einem YOLO-Modell.
Benchmark: Vergleiche die Geschwindigkeit und Genauigkeit von YOLO-Exporten (ONNX, TensorRT, etc.).

Argument	Standard	Beschreibung
`mode`	`'train'`	Spezifiziert den Betriebsmodus des YOLO-Modells: `train` für Modelltraining, `val` für Validierung, `predict` für Inferenz, `export` für die Konvertierung in Bereitstellungsformate, `track` für Objektverfolgung und `benchmark` für Leistungsbewertung. Jeder Modus unterstützt verschiedene Phasen, von der Entwicklung bis zur Bereitstellung.

Leitfaden zu Modi

Trainingseinstellungen

Trainingseinstellungen für YOLO-Modelle beinhalten Hyperparameter und Konfigurationen, die die Leistung, Geschwindigkeit und Genauigkeit beeinflussen. Wichtige Einstellungen umfassen batch size, learning rate, Momentum und Gewichtsabnahme (Weight Decay). Die Wahl des Optimierers, Verlustfunktion und die Zusammensetzung des Datensatzes wirken sich ebenfalls auf das Training aus. Tuning und Experimente sind entscheidend für optimale Leistung. Weitere Details findest du in der Ultralytics Einstiegspunkt-Funktion.

Argument	Typ	Standard	Beschreibung
`model`	`str`	`None`	Spezifiziert die Modelldatei für das Training. Akzeptiert einen Pfad zu entweder einem `.pt` vortrainierten Modell oder einer `.yaml` Konfigurationsdatei. Wesentlich für die Definition der Modellstruktur oder die Initialisierung der Gewichte.
`data`	`str`	`None`	Pfad zur Datensatz-Konfigurationsdatei (z. B. `coco8.yaml`). Diese Datei enthält datensatzspezifische Parameter, einschließlich Pfaden zu Trainings- und Validierungsdaten, Klassennamen und Anzahl der Klassen.
`epochs`	`int`	`100`	Gesamtzahl der Trainingsepochen. Jede epoch stellt einen vollständigen Durchlauf über den gesamten Datensatz dar. Die Anpassung dieses Wertes kann die Trainingsdauer und die Modellleistung beeinflussen.
`time`	`float`	`None`	Maximale Trainingszeit in Stunden. Falls gesetzt, überschreibt dies das `epochs` Argument, was es ermöglicht, das Training nach der angegebenen Dauer automatisch zu stoppen. Nützlich für zeitlich begrenzte Trainingsszenarien.
`patience`	`int`	`100`	Anzahl der Epochen, die ohne Verbesserung der Validierungsmetriken gewartet werden soll, bevor das Training frühzeitig beendet wird. Hilft, Overfitting durch das Stoppen des Trainings, wenn die Leistung stagniert.
`batch`	`int` oder `float`	`16`	Batch size, mit drei Modi: als Ganzzahl festgelegt (z. B. `batch=16`), Auto-Modus für 60 % GPU-Speicherauslastung (`batch=-1`), oder Auto-Modus mit festgelegtem Auslastungsanteil (`batch=0.70`).
`imgsz`	`int`	`640`	Zielbildgröße für das Training. Bilder werden auf Quadrate mit Seitenlängen entsprechend dem angegebenen Wert skaliert (falls `rect=False`), wobei das Seitenverhältnis für YOLO Modelle beibehalten wird, jedoch nicht für RT-DETR. Beeinflusst die Modell-Genauigkeit und Rechenkomplexität.
`save`	`bool`	`True`	Ermöglicht das Speichern von Trainings-Checkpoints und finalen Modellgewichten. Nützlich, um das Training fortzusetzen oder für die Modellbereitstellung.
`save_period`	`int`	`-1`	Häufigkeit des Speicherns von Modell-Checkpoints, angegeben in Epochen. Ein Wert von -1 deaktiviert diese Funktion. Nützlich, um Zwischenmodelle während langer Trainingssitzungen zu speichern.
`cache`	`bool`	`False`	Ermöglicht das Caching von Datensatzbildern im Arbeitsspeicher (`True`/`ram`), auf der Festplatte (`disk`), oder deaktiviert es (`False`). Verbessert die Trainingsgeschwindigkeit durch Reduzierung von Festplatten-I/O auf Kosten eines höheren Speicherverbrauchs.
`device`	`int` oder `str` oder `list`	`None`	Gibt das Rechengerät bzw. die Geräte für das Training an: eine einzelne GPU (`device=0`), mehrere GPUs (`device=[0,1]`), CPU (`device=cpu`), MPS für Apple Silicon (`device=mps`), Huawei Ascend NPU (`device=npu` oder `device=npu:0`), oder automatische Auswahl der am wenigsten ausgelasteten GPU (`device=-1`) oder mehrerer ungenutzter GPUs (`device=[-1,-1]`)
`workers`	`int`	`8`	Anzahl der Worker-Threads für das Laden von Daten (pro `RANK` bei Multi-GPU-Training). Beeinflusst die Geschwindigkeit der Datenvorverarbeitung und Einspeisung in das Modell, besonders nützlich bei Multi-GPU-Setups.
`project`	`str`	`None`	Name des Projektverzeichnisses, in dem die Trainingsergebnisse gespeichert werden. Ermöglicht eine organisierte Speicherung verschiedener Experimente.
`name`	`str`	`None`	Name des Trainingslaufs. Wird zum Erstellen eines Unterverzeichnisses innerhalb des Projektordners verwendet, in dem Trainingsprotokolle und Ergebnisse gespeichert werden.
`exist_ok`	`bool`	`False`	Wenn True, erlaubt es das Überschreiben eines bestehenden Projekt-/Namensverzeichnisses. Nützlich für iterative Experimente, ohne dass vorherige Ergebnisse manuell gelöscht werden müssen.
`pretrained`	`bool` oder `str`	`True`	Bestimmt, ob das Training mit vortrainierten Gewichten gestartet werden soll. Kann ein boolescher Wert oder ein String-Pfad zu den zu ladenden Gewichten sein. `pretrained=False` trainiert von zufällig initialisierten Gewichten aus, während die Modellarchitektur beibehalten wird.
`optimizer`	`str`	`'auto'`	Wahl des Optimierers für das Training. Zu den Optionen gehören `SGD`, `MuSGD`, `Adam`, `Adamax`, `AdamW`, `NAdam`, `RAdam`, `RMSProp`, oder `auto` für eine automatische Auswahl basierend auf der Modellkonfiguration. Beeinflusst die Konvergenzgeschwindigkeit und Stabilität.
`seed`	`int`	`0`	Setzt den Zufalls-Seed für das Training, um die Reproduzierbarkeit der Ergebnisse über verschiedene Läufe mit denselben Konfigurationen hinweg zu gewährleisten.
`deterministic`	`bool`	`True`	Erzwingt die Verwendung deterministischer Algorithmen, was die Reproduzierbarkeit sicherstellt, aber aufgrund der Einschränkung auf nicht-deterministische Algorithmen die Leistung und Geschwindigkeit beeinträchtigen kann.
`verbose`	`bool`	`True`	Ermöglicht eine ausführliche Ausgabe während des Trainings, die Fortschrittsbalken, Metriken pro Epoche und zusätzliche Trainingsinformationen in der Konsole anzeigt.
`single_cls`	`bool`	`False`	Behandelt alle Klassen in Datensätzen mit mehreren Klassen als eine einzige Klasse während des Trainings. Nützlich für binäre Klassifizierungsaufgaben oder wenn der Fokus auf dem Vorhandensein von Objekten statt auf der Klassifizierung liegt.
`classes`	`list[int]`	`None`	Gibt eine Liste von Klassen-IDs an, auf denen trainiert werden soll. Nützlich zum Filtern und um sich während des Trainings nur auf bestimmte Klassen zu konzentrieren.
`rect`	`bool`	`False`	Aktiviert die minimale Padding-Strategie – Bilder in einem Batch werden minimal aufgefüllt, um eine gemeinsame Größe zu erreichen, wobei die längste Seite gleich `imgsz` ist. Kann die Effizienz und Geschwindigkeit verbessern, kann aber die Modellgenauigkeit beeinflussen.
`multi_scale`	`float`	`0.0`	Variiert zufällig `imgsz` jeden Batch um +/- `multi_scale` (z. B. `0.25` -> `0.75x` bis `1.25x`), wobei auf ein Vielfaches der Modell-Stride gerundet wird; `0.0` deaktiviert das Multiskalen-Training.
`cos_lr`	`bool`	`False`	Nutzt einen Kosinus-learning rateScheduler, der die Lernrate über die Epochen hinweg nach einer Kosinuskurve anpasst. Hilft dabei, die Lernrate für eine bessere Konvergenz zu steuern.
`close_mosaic`	`int`	`10`	Deaktiviert Mosaik-Datenaugmentation in den letzten N Epochen, um das Training vor dem Abschluss zu stabilisieren. Das Setzen auf 0 deaktiviert diese Funktion.
`resume`	`bool`	`False`	Setzt das Training vom letzten gespeicherten Checkpoint aus fort. Lädt automatisch Modellgewichte, Optimierer-Status und Epochenanzahl und setzt das Training nahtlos fort.
`amp`	`bool`	`True`	Ermöglicht automatisches Mixed Precision (AMP)-Training, das den Speicherverbrauch reduziert und möglicherweise das Training beschleunigt, ohne die Genauigkeit wesentlich zu beeinträchtigen.
`fraction`	`float`	`1.0`	Gibt den Teil des Datensatzes an, der für das Training verwendet werden soll. Ermöglicht das Training auf einer Teilmenge des gesamten Datensatzes, nützlich für Experimente oder wenn die Ressourcen begrenzt sind.
`profile`	`bool`	`False`	Ermöglicht das Profiling von ONNX und TensorRT-Geschwindigkeiten während des Trainings, nützlich für die Optimierung der Modellbereitstellung.
`freeze`	`int` oder `list`	`None`	Friert die ersten N Schichten des Modells oder bestimmte Schichten nach Index ein, wodurch die Anzahl der trainierbaren Parameter reduziert wird. Nützlich für Fine-Tuning oder Transfer Learning.
`lr0`	`float`	`0.01`	Anfängliche Lernrate (d. h. `SGD=1E-2`, `Adam=1E-3`). Die Anpassung dieses Wertes ist entscheidend für den Optimierungsprozess und beeinflusst, wie schnell die Modellgewichte aktualisiert werden.
`lrf`	`float`	`0.01`	Endgültige Lernrate als Bruchteil der anfänglichen Rate = (`lr0 * lrf`), die zusammen mit Schedulern verwendet wird, um die Lernrate über die Zeit anzupassen.
`momentum`	`float`	`0.937`	Momentum-Faktor für SGD oder Beta1 für Adam-Optimierer, beeinflusst die Einbeziehung vergangener Gradienten in das aktuelle Update.
`weight_decay`	`float`	`0.0005`	L2-Regularisierung-Term, der große Gewichte bestraft, um Overfitting zu verhindern.
`warmup_epochs`	`float`	`3.0`	Anzahl der Epochen für das Learning Rate Warmup, wobei die Lernrate schrittweise von einem niedrigen Wert auf die anfängliche Lernrate erhöht wird, um das Training frühzeitig zu stabilisieren.
`warmup_momentum`	`float`	`0.8`	Anfängliches Momentum für die Warmup-Phase, das während des Warmup-Zeitraums schrittweise an das eingestellte Momentum angepasst wird.
`warmup_bias_lr`	`float`	`0.1`	Lernrate für Bias-Parameter während der Warmup-Phase, was hilft, das Modelltraining in den ersten Epochen zu stabilisieren.
`box`	`float`	`7.5`	Gewichtung der Box-Loss-Komponente im Verlustfunktion, was beeinflusst, wie viel Wert auf die genaue Vorhersage der Bounding Box-Koordinaten gelegt wird.
`cls`	`float`	`0.5`	Gewichtung des Klassifizierungsverlusts in der gesamten Verlustfunktion, was die Bedeutung der korrekten Klassenvorhersage im Verhältnis zu anderen Komponenten beeinflusst.
`cls_pw`	`float`	`0.0`	Potenz für die Klassengewichtung, um mit Klassenungleichgewichten mithilfe der inversen Klassenhäufigkeit umzugehen. `0.0` deaktiviert die Klassengewichtung, `1.0` wendet eine vollständige inverse Häufigkeitsgewichtung an. Werte zwischen 0 und 1 bieten eine teilweise Gewichtung.
`dfl`	`float`	`1.5`	Gewichtung des Distribution Focal Loss, der in bestimmten YOLO-Versionen für die fein abgestufte Klassifizierung verwendet wird.
`pose`	`float`	`12.0`	Gewichtung des Pose-Loss in Modellen, die für die Pose-Schätzung trainiert wurden, was den Fokus auf die genaue Vorhersage von Pose-Keypoints beeinflusst.
`kobj`	`float`	`1.0`	Gewichtung des Keypoint Objectness-Loss in Pose-Schätzungsmodellen, was das Vertrauen in die Erkennung mit der Pose-Genauigkeit in Einklang bringt.
`rle`	`float`	`1.0`	Gewichtung des Residual Log-Likelihood Estimation Loss in Pose-Schätzungsmodellen, was die Präzision der Keypoint-Lokalisierung beeinflusst.
`angle`	`float`	`1.0`	Gewichtung des Angle Loss in OBB-Modellen, was die Präzision der Winkelvorhersagen der orientierten Bounding Box beeinflusst.
`nbs`	`int`	`64`	Nominale Batch-Größe für die Normalisierung des Verlusts.
`overlap_mask`	`bool`	`True`	Bestimmt, ob Objektmasken für das Training zu einer einzigen Maske zusammengeführt oder für jedes Objekt separat gehalten werden sollen. Bei Überlappungen wird beim Zusammenführen die kleinere Maske über die größere Maske gelegt.
`mask_ratio`	`int`	`4`	Downsampling-Verhältnis für Segmentierungsmasken, was die Auflösung der während des Trainings verwendeten Masken beeinflusst.
`dropout`	`float`	`0.0`	Dropout-Rate für die Regularisierung bei Klassifizierungsaufgaben, um Overfitting durch zufälliges Weglassen von Einheiten während des Trainings zu verhindern.
`val`	`bool`	`True`	Ermöglicht die Validierung während des Trainings, was eine regelmäßige Bewertung der Modellleistung an einem separaten Datensatz ermöglicht.
`plots`	`bool`	`True`	Erstellt und speichert Diagramme der Trainings- und Validierungsmetriken sowie Vorhersagebeispiele, um visuelle Einblicke in die Modellleistung und den Lernfortschritt zu geben.
`compile`	`bool` oder `str`	`False`	Ermöglicht die PyTorch 2.x `torch.compile` Graph-Kompilierung mit `backend='inductor'`. Akzeptiert `True` → `"default"`, `False` → deaktiviert, oder einen String-Modus wie `"default"`, `"reduce-overhead"`, `"max-autotune-no-cudagraphs"`. Fällt bei Nichtunterstützung mit einer Warnung auf Eager-Modus zurück.
`max_det`	`int`	`300`	Gibt die maximale Anzahl von Objekten an, die während der Validierungsphase des Trainings beibehalten werden.

Hinweis zu Batch-Größen-Einstellungen

Das batch-Argument bietet drei Konfigurationsoptionen:

Feste Batch-Größe: Gib die Anzahl der Bilder pro Batch mit einer Ganzzahl an (z. B. batch=16).
Auto-Modus (60% GPU-Speicher): Verwende batch=-1 für die automatische Anpassung auf ca. 60% der CUDA-Speicherauslastung.
Auto-Modus mit Auslastungsanteil: Lege einen Anteil fest (z. B. batch=0.70), um die Anpassung basierend auf einem bestimmten GPU-Speicherverbrauch vorzunehmen.

Trainings-Leitfaden

Vorhersage-Einstellungen

Die Vorhersage-Einstellungen für YOLO-Modelle umfassen Hyperparameter und Konfigurationen, die Leistung, Geschwindigkeit und Genauigkeit während der Inferenz beeinflussen. Zu den wichtigsten Einstellungen gehören der Konfidenz-Schwellenwert, der Non-Maximum Suppression (NMS)-Schwellenwert und die Anzahl der Klassen. Eingabedatengröße, Format und ergänzende Funktionen wie Masken beeinflussen ebenfalls die Vorhersagen. Das Anpassen dieser Einstellungen ist für eine optimale Leistung entscheidend.

Inferenz-Argumente:

Argument	Typ	Standard	Beschreibung
`source`	`str` oder `int` oder `None`	`None`	Gibt die Datenquelle für die Inferenz an. Kann ein Bildpfad, eine Videodatei, ein Verzeichnis, eine URL oder eine Geräte-ID für Live-Feeds sein. Falls weggelassen, wird eine Warnung protokolliert und das Modell greift auf die integrierten Demo-Assets zurück (`ultralytics/assets` oder eine Demo-URL für OBB). Unterstützt eine breite Palette von Formaten und Quellen, was eine flexible Anwendung über verschiedene Eingabetypen.
`conf`	`float`	`0.25`	Legt den minimalen Konfidenz-Schwellenwert für Erkennungen fest. Objekte, die mit einer Konfidenz unter diesem Wert erkannt werden, werden ignoriert. Die Anpassung dieses Wertes kann helfen, falsch-positive Ergebnisse zu reduzieren.
`iou`	`float`	`0.7`	Intersection Over Union (IoU)-Schwellenwert für Non-Maximum Suppression (NMS). Niedrigere Werte führen zu weniger Erkennungen, da überlappende Boxen eliminiert werden, was nützlich ist, um Duplikate zu reduzieren.
`imgsz`	`int` oder `tuple`	`640`	Definiert die Bildgröße für die Inferenz. Kann eine einzelne Ganzzahl `640` für die quadratische Skalierung oder ein (Höhe, Breite)-Tupel sein. Die richtige Größe kann die Erkennung Genauigkeit und die Verarbeitungsgeschwindigkeit verbessern.
`rect`	`bool`	`True`	Wenn aktiviert, wird die kürzere Seite des Bildes minimal gepaddet, bis sie durch den Stride teilbar ist, um die Inferenzgeschwindigkeit zu erhöhen. Wenn deaktiviert, wird das Bild während der Inferenz auf ein Quadrat gepaddet.
`half`	`bool`	`False`	Aktiviert die Halb-präzisions-(FP16) Inferenz, was die Modell-Inferenz auf unterstützten GPUs bei minimalen Auswirkungen auf die Genauigkeit beschleunigen kann.
`device`	`str`	`None`	Gibt das Gerät für die Inferenz an (z. B. `cpu`, `cuda:0`, `0`, `npu` oder `npu:0`). Ermöglicht es Benutzern, zwischen CPU, einer spezifischen GPU, Huawei Ascend NPU oder anderen Rechengeräten für die Modellausführung zu wählen.
`batch`	`int`	`1`	Gibt die Batch-Größe für die Inferenz an (funktioniert nur, wenn die Quelle ein Verzeichnis, eine Videodatei oder `.txt` Datei ist). Eine größere Batch-Größe kann einen höheren Durchsatz bieten und die Gesamtzeit für die Inferenz verkürzen.
`max_det`	`int`	`300`	Maximale Anzahl der erlaubten Erkennungen pro Bild. Begrenzt die Gesamtzahl der Objekte, die das Modell in einer einzigen Inferenz erkennen kann, und verhindert übermäßige Ausgaben in dichten Szenen.
`vid_stride`	`int`	`1`	Frame-Stride für Videoeingaben. Ermöglicht das Überspringen von Frames in Videos, um die Verarbeitung auf Kosten der zeitlichen Auflösung zu beschleunigen. Ein Wert von 1 verarbeitet jedes Frame, höhere Werte überspringen Frames.
`stream_buffer`	`bool`	`False`	Bestimmt, ob eingehende Frames für Videostreams in eine Warteschlange gestellt werden sollen. Wenn `False`, werden alte Frames verworfen, um Platz für neue zu schaffen (optimiert für Echtzeitanwendungen). Wenn `True`, werden neue Frames in einem Puffer gespeichert, wodurch sichergestellt wird, dass keine Frames übersprungen werden, was jedoch zu Latenz führt, wenn die Inferenz-FPS niedriger als die Stream-FPS sind.
`visualize`	`bool`	`False`	Aktiviert die Visualisierung von Modellmerkmalen während der Inferenz und gibt Einblicke in das, was das Modell "sieht". Nützlich für Debugging und Modellinterpretation.
`augment`	`bool`	`False`	Aktiviert Test-Time Augmentation (TTA) für Vorhersagen, was die Robustheit der Erkennung auf Kosten der Inferenzgeschwindigkeit potenziell verbessert.
`agnostic_nms`	`bool`	`False`	Aktiviert klassenagnostische Non-Maximum Suppression (NMS), die überlappende Boxen verschiedener Klassen zusammenführt. Nützlich in Szenarien mit Multi-Klassen-Erkennung, in denen Klassenüberlappungen häufig sind. Bei End-to-End-Modellen (YOLO26, YOLOv10) verhindert dies nur, dass dieselbe Erkennung mit mehreren Klassenbeschriftungen erscheint (IoU=1.0 Duplikate) und führt keine IoU-Schwellenwert-basierte Unterdrückung zwischen verschiedenen Boxen durch.
`classes`	`list[int]`	`None`	Filtert Vorhersagen auf eine Menge von Klassen-IDs. Nur Erkennungen, die zu den angegebenen Klassen gehören, werden zurückgegeben. Nützlich, um sich auf relevante Objekte in Multi-Klassen-Erkennungsaufgaben zu konzentrieren.
`retina_masks`	`bool`	`False`	Gibt hochauflösende Segmentierungsmasken zurück. Die zurückgegebenen Masken (`masks.data`) entsprechen der ursprünglichen Bildgröße, wenn aktiviert. Wenn deaktiviert, haben sie die während der Inferenz verwendete Bildgröße.
`embed`	`list[int]`	`None`	Gibt die Schichten an, aus denen Merkmalsvektoren oder Embeddings extrahiert werden sollen. Nützlich für nachgelagerte Aufgaben wie Clustering oder Ähnlichkeitssuche.
`project`	`str`	`None`	Name des Projektverzeichnisses, in dem Vorhersageergebnisse gespeichert werden, wenn `save` aktiviert ist.
`name`	`str`	`None`	Name des Vorhersagelaufs. Wird zum Erstellen eines Unterverzeichnisses innerhalb des Projektordners verwendet, in dem Vorhersageergebnisse gespeichert werden, wenn `save` aktiviert ist.
`stream`	`bool`	`False`	Aktiviert speichereffiziente Verarbeitung für lange Videos oder zahlreiche Bilder, indem ein Generator von Results-Objekten zurückgegeben wird, anstatt alle Frames gleichzeitig in den Speicher zu laden.
`verbose`	`bool`	`True`	Steuert, ob detaillierte Inferenzprotokolle im Terminal angezeigt werden sollen, was Echtzeit-Feedback zum Vorhersageprozess bietet.
`compile`	`bool` oder `str`	`False`	Ermöglicht die PyTorch 2.x `torch.compile` Graph-Kompilierung mit `backend='inductor'`. Akzeptiert `True` → `"default"`, `False` → deaktiviert, oder einen String-Modus wie `"default"`, `"reduce-overhead"`, `"max-autotune-no-cudagraphs"`. Fällt bei Nichtunterstützung mit einer Warnung auf Eager-Modus zurück.
`end2end`	`bool`	`None`	Überschreibt den End-to-End-Modus in YOLO-Modellen, die NMS-freie Inferenz unterstützen (YOLO26, YOLOv10). Wenn du es auf `False` setzt, kannst du die Vorhersage mithilfe der traditionellen NMS-Pipeline ausführen und zusätzlich das `iou` Argument verwenden. Siehe den End-to-End Detection Leitfaden für Details.

Visualisierungs-Argumente:

Argument	Typ	Standard	Beschreibung
`show`	`bool`	`False`	Wenn `True`, werden die annotierten Bilder oder Videos in einem Fenster angezeigt. Nützlich für sofortiges visuelles Feedback während der Entwicklung oder des Tests.
`save`	`bool`	`False or True`	Aktiviert das Speichern der annotierten Bilder oder Videos in Dateien. Nützlich für Dokumentation, weitere Analysen oder das Teilen von Ergebnissen. Standardmäßig True bei Verwendung der CLI & False bei Verwendung in Python.
`save_frames`	`bool`	`False`	Speichert bei der Videoverarbeitung einzelne Frames als Bilder. Nützlich zum Extrahieren spezifischer Frames oder für detaillierte Frame-für-Frame-Analysen.
`save_txt`	`bool`	`False`	Speichert Erkennungsergebnisse in einer Textdatei im Format `[class] [x_center] [y_center] [width] [height] [confidence]`. Nützlich für die Integration mit anderen Analysetools.
`save_conf`	`bool`	`False`	Beinhaltet Konfidenzwerte in den gespeicherten Textdateien. Erhöht den Detailgrad für die Nachbearbeitung und Analyse.
`save_crop`	`bool`	`False`	Speichert zugeschnittene Bilder der Erkennungen. Nützlich für Datensatz-Augmentierung, Analyse oder das Erstellen fokussierter Datensätze für spezifische Objekte.
`show_labels`	`bool`	`True`	Zeigt Beschriftungen für jede Erkennung in der visuellen Ausgabe an. Bietet sofortiges Verständnis der erkannten Objekte.
`show_conf`	`bool`	`True`	Zeigt den Konfidenzwert für jede Erkennung neben der Beschriftung an. Gibt Einblick in die Sicherheit des Modells für jede Erkennung.
`show_boxes`	`bool`	`True`	Zeichnet Begrenzungsboxen um erkannte Objekte. Wesentlich für die visuelle Identifizierung und Lokalisierung von Objekten in Bildern oder Videoframes.
`line_width`	`int or None`	`None`	Gibt die Linienbreite der Begrenzungsboxen an. Wenn `None`, wird die Linienbreite automatisch basierend auf der Bildgröße angepasst. Bietet visuelle Anpassung für Klarheit.

Vorhersage-Leitfaden

Validierungs-Einstellungen

Die Validierungs-Einstellungen für YOLO-Modelle umfassen Hyperparameter und Konfigurationen zur Bewertung der Leistung auf einem Validierungs-Datensatz. Diese Einstellungen beeinflussen Leistung, Geschwindigkeit und Genauigkeit. Allgemeine Einstellungen umfassen Batch-Größe, Validierungshäufigkeit und Leistungskennzahlen. Die Größe und Zusammensetzung des Validierungs-Datensatzes sowie die spezifische Aufgabe beeinflussen den Prozess ebenfalls.

Argument	Typ	Standard	Beschreibung
`data`	`str`	`None`	Gibt den Pfad zur Datensatz-Konfigurationsdatei an (z. B. `coco8.yaml`). Diese Datei sollte den Pfad zum Validierungsdaten.
`imgsz`	`int`	`640`	Definiert die Größe der Eingabebilder. Alle Bilder werden vor der Verarbeitung auf diese Dimension skaliert. Größere Größen können die Genauigkeit für kleine Objekte verbessern, erhöhen aber die Rechenzeit.
`batch`	`int`	`16`	Legt die Anzahl der Bilder pro Batch fest. Höhere Werte nutzen den GPU-Speicher effizienter, erfordern jedoch mehr VRAM. Passe dies basierend auf den verfügbaren Hardwareressourcen an.
`save_json`	`bool`	`False`	Wenn `True`, speichert die Ergebnisse in einer JSON-Datei für weitere Analysen, Integration mit anderen Tools oder zur Einreichung bei Evaluierungsservern wie COCO.
`conf`	`float`	`0.001`	Legt den minimalen Konfidenz-Schwellenwert für Erkennungen fest. Niedrigere Werte erhöhen den Recall, können aber zu mehr falsch-positiven Ergebnissen führen. Wird während der Validierung verwendet, um Precision-Recall-Kurven zu berechnen.
`iou`	`float`	`0.7`	Setzt den Intersection Over Union Schwellenwert für Non-Maximum Suppression. Steuert die Eliminierung doppelter Erkennungen.
`max_det`	`int`	`300`	Begrenzt die maximale Anzahl der Erkennungen pro Bild. Nützlich in dichten Szenen, um übermäßige Erkennungen zu verhindern und Rechenressourcen zu verwalten.
`half`	`bool`	`False`	Aktiviert die Halb-präzisions- (FP16) Berechnung, was den Speicherverbrauch reduziert und die Geschwindigkeit bei minimaler Auswirkung auf Genauigkeit.
`device`	`str`	`None`	Gibt das Gerät für die Validierung an (`cpu`, `cuda:0`, `npu`, `npu:0`, etc.). Wenn `None`, wird automatisch das beste verfügbare Gerät ausgewählt. Mehrere CUDA-Geräte können durch Komma getrennt angegeben werden.
`dnn`	`bool`	`False`	Wenn `True`, verwendet das OpenCV DNN-Modul für die ONNX-Modell-Inferenz und bietet eine Alternative zu PyTorch Inferenzmethoden.
`plots`	`bool`	`True`	Wenn auf `True` gesetzt, werden Diagramme der Vorhersagen gegenüber der Ground Truth, Konfusionsmatrizen und PR-Kurven zur visuellen Bewertung der Modellleistung generiert und gespeichert.
`classes`	`list[int]`	`None`	Gibt eine Liste der zu evaluierenden Klassen-IDs an. Nützlich, um während der Evaluierung zu filtern und sich nur auf bestimmte Klassen zu konzentrieren.
`rect`	`bool`	`True`	Wenn `True`, verwendet rechteckige Inferenz für das Batching, reduziert Padding und steigert potenziell Geschwindigkeit und Effizienz durch die Verarbeitung von Bildern im ursprünglichen Seitenverhältnis.
`split`	`str`	`'val'`	Bestimmt den Datensatz-Split für die Validierung (`val`, `test`, oder `train`). Ermöglicht Flexibilität bei der Auswahl des Datensegments für die Leistungsbewertung.
`project`	`str`	`None`	Name des Projektverzeichnisses, in dem die Validierungsergebnisse gespeichert werden. Hilft beim Organisieren der Ergebnisse verschiedener Experimente oder Modelle.
`name`	`str`	`None`	Name des Validierungslaufs. Wird zum Erstellen eines Unterverzeichnisses innerhalb des Projektordners verwendet, in dem Validierungsprotokolle und Ergebnisse gespeichert werden.
`verbose`	`bool`	`True`	Wenn `True`, zeigt detaillierte Informationen während des Validierungsprozesses an, einschließlich klassenspezifischer Metriken, Batch-Fortschritt und zusätzlicher Debug-Informationen.
`save_txt`	`bool`	`False`	Wenn `True`, speichert Detektionsergebnisse in Textdateien, eine Datei pro Bild, nützlich für weitere Analysen, benutzerdefinierte Nachbearbeitung oder Integration in andere Systeme.
`save_conf`	`bool`	`False`	Wenn `True`, schließt Konfidenzwerte in die gespeicherten Textdateien ein, wenn `save_txt` aktiviert ist, was detailliertere Ausgaben für Analysen und Filterungen liefert.
`workers`	`int`	`8`	Anzahl der Worker-Threads für das Laden von Daten. Höhere Werte können die Datenvorverarbeitung beschleunigen, aber den CPU-Verbrauch erhöhen. Die Einstellung auf 0 verwendet den Hauptthread, was in manchen Umgebungen stabiler sein kann.
`augment`	`bool`	`False`	Aktiviert Test-Time Augmentation (TTA) während der Validierung, was die Detektionsgenauigkeit potenziell verbessert, auf Kosten der Inferenzgeschwindigkeit, durch die Ausführung der Inferenz auf transformierten Versionen des Inputs.
`agnostic_nms`	`bool`	`False`	Aktiviert klassenagnostisches Non-Maximum Suppression, das überlappende Boxen unabhängig von ihrer vorhergesagten Klasse zusammenführt. Nützlich für instanzfokussierte Anwendungen. Bei End-to-End-Modellen (YOLO26, YOLOv10) verhindert dies nur, dass dieselbe Detektion mit mehreren Klassen-Labels erscheint (IoU=1.0 Duplikate) und führt keine IoU-schwellenwertbasierte Unterdrückung zwischen verschiedenen Boxen durch.
`single_cls`	`bool`	`False`	Behandelt alle Klassen während der Validierung als eine einzige Klasse. Nützlich zur Bewertung der Modellleistung bei binären Detektionsaufgaben oder wenn Klassenunterschiede nicht wichtig sind.
`visualize`	`bool`	`False`	Visualisiert die Ground Truths, True Positives, False Positives und False Negatives für jedes Bild. Nützlich für Debugging und Modellinterpretation.
`compile`	`bool` oder `str`	`False`	Ermöglicht die PyTorch 2.x `torch.compile` Graph-Kompilierung mit `backend='inductor'`. Akzeptiert `True` → `"default"`, `False` → deaktiviert, oder einen String-Modus wie `"default"`, `"reduce-overhead"`, `"max-autotune-no-cudagraphs"`. Fällt bei Nichtunterstützung mit einer Warnung auf Eager-Modus zurück.
`end2end`	`bool`	`None`	Überschreibt den End-to-End-Modus in YOLO-Modellen, die NMS-freie Inferenz unterstützen (YOLO26, YOLOv10). Wenn du es auf `False` lässt dich die Validierung unter Verwendung der traditionellen NMS-Pipeline ausführen und erlaubt dir zusätzlich die Verwendung des `iou` Arguments.

Sorgfältige Abstimmung und Experimente sind entscheidend, um eine optimale Leistung zu gewährleisten und Overfitting.

Validierungsanleitung

Export-Einstellungen

Export-Einstellungen für YOLO-Modelle beinhalten Konfigurationen zum Speichern oder Exportieren des Modells zur Verwendung in verschiedenen Umgebungen. Diese Einstellungen beeinflussen Leistung, Größe und Kompatibilität. Zu den wichtigsten Einstellungen gehören das exportierte Dateiformat (z. B. ONNX, TensorFlow SavedModel), das Zielgerät (z. B. CPU, GPU) und Funktionen wie Masken. Die Aufgabe des Modells und die Beschränkungen der Zielumgebung beeinflussen ebenfalls den Exportprozess.

Argument	Typ	Standard	Beschreibung
`format`	`str`	`'torchscript'`	Zielformat für das exportierte Modell, wie `'onnx'`, `'torchscript'`, `'engine'` (TensorRT) oder andere. Jedes Format ermöglicht die Kompatibilität mit verschiedenen Bereitstellungsumgebungen.
`imgsz`	`int` oder `tuple`	`640`	Gewünschte Bildgröße für den Modelleingang. Kann eine Ganzzahl für quadratische Bilder (z. B. `640` für 640×640) oder ein Tupel `(height, width)` für spezifische Dimensionen sein.
`keras`	`bool`	`False`	Aktiviert den Export in das Keras-Format für TensorFlow SavedModel, was die Kompatibilität mit TensorFlow Serving und APIs bietet.
`optimize`	`bool`	`False`	Wendet eine Optimierung für Mobilgeräte beim Export in TorchScript an, was potenziell die Modellgröße reduziert und die Inferenzleistung verbessert. Nicht kompatibel mit NCNN-Format oder CUDA-Geräten.
`half`	`bool`	`False`	Aktiviert die FP16-Quantisierung (Halbpräzision), reduziert die Modellgröße und beschleunigt potenziell die Inferenz auf unterstützter Hardware. Nicht kompatibel mit INT8-Quantisierung oder CPU-only-Exporten. Nur für bestimmte Formate verfügbar, z. B. ONNX (siehe unten).
`int8`	`bool`	`False`	Aktiviert die INT8-Quantisierung, komprimiert das Modell weiter und beschleunigt die Inferenz mit minimalem Genauigkeit Verlust, primär für Edge-Geräte. Bei Verwendung mit TensorRT wird eine Post-Training Quantization (PTQ) durchgeführt.
`dynamic`	`bool`	`False`	Erlaubt dynamische Eingabegrößen für TorchScript-, ONNX-, OpenVINO-, TensorRT- und CoreML-Exporte, was die Flexibilität beim Umgang mit variierenden Bilddimensionen verbessert. Wird bei Verwendung von TensorRT mit INT8 automatisch auf `True` gesetzt.
`simplify`	`bool`	`True`	Vereinfacht den Modellgraphen für ONNX-Exporte mit `onnxslim`, was potenziell die Leistung und Kompatibilität mit Inferenz-Engines verbessert.
`opset`	`int`	`None`	Gibt die ONNX-Opset-Version für die Kompatibilität mit verschiedenen ONNX-Parsern und -Runtimes an. Falls nicht festgelegt, wird die neueste unterstützte Version verwendet.
`workspace`	`float` oder `None`	`None`	Setzt die maximale Workspace-Größe in GiB für TensorRT-Optimierungen, wobei Speichernutzung und Leistung abgewogen werden. Verwende `None` für die automatische Zuweisung durch TensorRT bis zum Geräte-Maximum.
`nms`	`bool`	`False`	Fügt Non-Maximum Suppression (NMS) zum exportierten Modell hinzu, wenn unterstützt (siehe Export-Formate), was die Effizienz der Detektions-Nachbearbeitung verbessert. Nicht verfügbar für End2End-Modelle.
`batch`	`int`	`1`	Gibt die Batch-Inferenzgröße des Export-Modells oder die maximale Anzahl an Bildern an, die das exportierte Modell gleichzeitig im `predict` Modus verarbeitet. Bei Edge TPU-Exporten wird dies automatisch auf 1 gesetzt.
`device`	`str`	`None`	Gibt das Gerät für den Export an: GPU (`device=0`), CPU (`device=cpu`), MPS für Apple Silicon (`device=mps`), Huawei Ascend NPU (`device=npu` oder `device=npu:0`), oder DLA für NVIDIA Jetson (`device=dla:0` oder `device=dla:1`). TensorRT-Exporte verwenden automatisch die GPU.
`data`	`str`	`'coco8.yaml'`	Pfad zur Datensatz-Konfigurationsdatei, essenziell für die Kalibrierung der INT8-Quantisierung. Falls bei aktiviertem INT8 nicht angegeben, wird `coco8.yaml` als Fallback für die Kalibrierung verwendet.
`fraction`	`float`	`1.0`	Gibt den Bruchteil des Datensatzes an, der für die INT8-Quantisierungskalibrierung verwendet werden soll. Erlaubt die Kalibrierung auf einer Teilmenge des gesamten Datensatzes, nützlich für Experimente oder bei begrenzten Ressourcen. Falls bei aktiviertem INT8 nicht angegeben, wird der gesamte Datensatz verwendet.
`end2end`	`bool`	`None`	Überschreibt den End-to-End-Modus in YOLO-Modellen, die NMS-freie Inferenz unterstützen (YOLO26, YOLOv10). Wenn du es auf `False` lässt dich diese Modelle so exportieren, dass sie mit der traditionellen NMS-basierten Nachbearbeitungspipeline kompatibel sind. Siehe die End-to-End Detection Leitfaden für Details.

Eine durchdachte Konfiguration stellt sicher, dass das exportierte Modell für seinen Anwendungsfall optimiert ist und in der Zielumgebung effektiv funktioniert.

Export-Anleitung

Lösungen-Einstellungen

Die Konfigurationseinstellungen von Ultralytics Solutions bieten Flexibilität, um Modelle für Aufgaben wie Objektzählung, Heatmap-Erstellung, Workout-Tracking, Datenanalyse, Zonen-Tracking, Warteschlangenmanagement und regionsbasierte Zählung anzupassen. Diese Optionen erlauben einfache Anpassungen für genaue und nützliche Ergebnisse, die auf spezifische Bedürfnisse zugeschnitten sind.

Argument	Typ	Standard	Beschreibung
`model`	`str`	`None`	Pfad zu einer Ultralytics YOLO-Modelldatei.
`region`	`list`	`'[(20, 400), (1260, 400)]'`	Liste von Punkten, die die Zählregion definieren.
`show_in`	`bool`	`True`	Flag zur Steuerung, ob die In-Counts im Video-Stream angezeigt werden sollen.
`show_out`	`bool`	`True`	Flag zur Steuerung, ob die Out-Counts im Video-Stream angezeigt werden sollen.
`analytics_type`	`str`	`'line'`	Art des Diagramms, d. h. `line`, `bar`, `area`, oder `pie`.
`colormap`	`int`	`cv2.COLORMAP_DEEPGREEN`	Farbschema für die Heatmap.
`json_file`	`str`	`None`	Pfad zur JSON-Datei, die alle Parkkoordinatendaten enthält.
`up_angle`	`float`	`145.0`	Winkelschwellenwert für die 'up'-Pose.
`kpts`	`list[int]`	`'[6, 8, 10]'`	Liste von drei Keypoint-Indizes, die zur Überwachung von Workouts verwendet werden. Diese Keypoints entsprechen Körpergelenken oder Teilen, wie Schultern, Ellbogen und Handgelenken, für Übungen wie Liegestütze, Klimmzüge, Kniebeugen und Bauchmuskelübungen.
`down_angle`	`int`	`90`	Winkelschwellenwert für die 'down'-Pose.
`blur_ratio`	`float`	`0.5`	Passt den Prozentsatz der Unschärfe-Intensität an, mit Werten im Bereich `0.1 - 1.0`.
`crop_dir`	`str`	`'cropped-detections'`	Verzeichnisname zum Speichern von zugeschnittenen Detektionen.
`records`	`int`	`5`	Gesamtzahl der Detektionen, um eine E-Mail mit dem Sicherheitsalarmsystem auszulösen.
`vision_point`	`tuple[int, int]`	`(20, 20)`	Der Punkt, an dem die Vision Objekte verfolgt und Pfade mithilfe der VisionEye-Lösung zeichnet.
`source`	`str`	`None`	Pfad zur Eingangsquelle (Video, RTSP, etc.). Nur mit dem Solutions-CLI (Command Line Interface) verwendbar.
`figsize`	`tuple[int, int]`	`(12.8, 7.2)`	Größe der Abbildung für Analysediagramme wie Heatmaps oder Graphen.
`fps`	`float`	`30.0`	Bilder pro Sekunde, die für Geschwindigkeitsberechnungen verwendet werden.
`max_hist`	`int`	`5`	Maximale historische Punkte zur Verfolgung pro Objekt für Geschwindigkeits-/Richtungsberechnungen.
`meter_per_pixel`	`float`	`0.05`	Skalierungsfaktor zur Umrechnung der Pixeldistanz in reale Einheiten.
`max_speed`	`int`	`120`	Maximales Geschwindigkeitslimit in visuellen Overlays (verwendet in Alarmen).
`data`	`str`	`'images'`	Pfad zum Bildverzeichnis für die Ähnlichkeitssuche.

Lösungen-Anleitung

Augmentierungs-Einstellungen

Datenaugmentierung-Techniken sind entscheidend für die Verbesserung der Robustheit und Leistung des YOLO-Modells, indem sie Variabilität in die Trainingsdaten einführen, was dem Modell hilft, besser auf ungesehene Daten zu generalisieren. Die folgende Tabelle erläutert den Zweck und die Auswirkung jedes Augmentierungs-Arguments:

Argument	Typ	Standard	Unterstützte Aufgaben	Bereich	Beschreibung
`hsv_h`	`float`	`0.015`	`detect`, `segment`, `pose`, `obb`, `classify`	`0.0 - 1.0`	Passt den Farbton des Bildes um einen Bruchteil des Farbkreises an und führt Farbvariabilität ein. Hilft dem Modell, über verschiedene Lichtverhältnisse hinweg zu generalisieren.
`hsv_s`	`float`	`0.7`	`detect`, `segment`, `pose`, `obb`, `classify`	`0.0 - 1.0`	Ändert die Sättigung des Bildes um einen Bruchteil und beeinflusst so die Farbintensität. Nützlich, um verschiedene Umgebungsbedingungen zu simulieren.
`hsv_v`	`float`	`0.4`	`detect`, `segment`, `pose`, `obb`, `classify`	`0.0 - 1.0`	Ändert den Wert (Helligkeit) des Bildes um einen Bruchteil und hilft dem Modell, unter verschiedenen Lichtverhältnissen gut zu funktionieren.
`degrees`	`float`	`0`	`detect`, `segment`, `pose`, `obb`	`0.0 - 180`	Dreht das Bild zufällig innerhalb des angegebenen Gradbereichs, was die Fähigkeit des Modells verbessert, Objekte in verschiedenen Ausrichtungen zu erkennen.
`translate`	`float`	`0.1`	`detect`, `segment`, `pose`, `obb`	`0.0 - 1.0`	Verschiebt das Bild horizontal und vertikal um einen Bruchteil der Bildgröße, was dabei hilft, teilweise sichtbare Objekte erkennen zu lernen.
`scale`	`float`	`0.5`	`detect`, `segment`, `pose`, `obb`, `classify`	`0 - 1`	Skaliert das Bild um einen Verstärkungsfaktor, um Objekte in unterschiedlichen Entfernungen von der Kamera zu simulieren.
`shear`	`float`	`0`	`detect`, `segment`, `pose`, `obb`	`-180 - +180`	Scherung des Bildes um einen bestimmten Grad, um den Effekt nachzuahmen, dass Objekte aus verschiedenen Winkeln betrachtet werden.
`perspective`	`float`	`0`	`detect`, `segment`, `pose`, `obb`	`0.0 - 0.001`	Wendet eine zufällige Perspektivtransformation auf das Bild an, um die Fähigkeit des Modells zu verbessern, Objekte im 3D-Raum zu verstehen.
`flipud`	`float`	`0`	`detect`, `segment`, `pose`, `obb`, `classify`	`0.0 - 1.0`	Spiegelt das Bild mit der angegebenen Wahrscheinlichkeit vertikal, was die Datenvariabilität erhöht, ohne die Eigenschaften des Objekts zu beeinträchtigen.
`fliplr`	`float`	`0.5`	`detect`, `segment`, `pose`, `obb`, `classify`	`0.0 - 1.0`	Spiegelt das Bild mit der angegebenen Wahrscheinlichkeit horizontal, nützlich, um symmetrische Objekte zu lernen und die Vielfalt des Datensatzes zu erhöhen.
`bgr`	`float`	`0`	`detect`, `segment`, `pose`, `obb`	`0.0 - 1.0`	Vertauscht die Bildkanäle von RGB zu BGR mit der angegebenen Wahrscheinlichkeit, nützlich, um die Robustheit gegenüber falscher Kanalreihenfolge zu erhöhen.
`mosaic`	`float`	`1`	`detect`, `segment`, `pose`, `obb`	`0.0 - 1.0`	Kombiniert vier Trainingsbilder zu einem, was verschiedene Szenenzusammensetzungen und Objektinteraktionen simuliert. Sehr effektiv für das Verständnis komplexer Szenen.
`mixup`	`float`	`0`	`detect`, `segment`, `pose`, `obb`	`0.0 - 1.0`	Mischt zwei Bilder und deren Labels, wodurch ein zusammengesetztes Bild entsteht. Verbessert die Generalisierungsfähigkeit des Modells durch Einführung von Label-Rauschen und visueller Variabilität.
`cutmix`	`float`	`0`	`detect`, `segment`, `pose`, `obb`	`0.0 - 1.0`	Kombiniert Teile von zwei Bildern und erzeugt eine teilweise Mischung unter Beibehaltung unterschiedlicher Bereiche. Erhöht die Robustheit des Modells durch die Erstellung von Okklusionsszenarien.
`copy_paste`	`float`	`0`	`segment`	`0.0 - 1.0`	Kopiert und fügt Objekte über Bilder hinweg ein, um die Anzahl der Objektinstanzen zu erhöhen.
`copy_paste_mode`	`str`	`flip`	`segment`	-	Gibt die `copy-paste` Strategie an, die verwendet werden soll. Zu den Optionen gehören `'flip'` und `'mixup'`.
`auto_augment`	`str`	`randaugment`	`classify`	-	Wendet eine vordefinierte Augmentierungsrichtlinie (`'randaugment'`, `'autoaugment'`, oder `'augmix'`) an, um die Modellleistung durch visuelle Vielfalt zu verbessern.
`erasing`	`float`	`0.4`	`classify`	`0.0 - 1.0`	Löscht während des Trainings zufällig Bereiche des Bildes, um das Modell dazu zu ermutigen, sich auf weniger offensichtliche Merkmale zu konzentrieren.
`augmentations`	`list`	``	`detect`, `segment`, `pose`, `obb`	-	Benutzerdefinierte Albumentations-Transformationen für fortgeschrittene Datenaugmentierung (nur Python API). Akzeptiert eine Liste von Transformations-Objekten für spezielle Augmentierungsanforderungen.

Passe diese Einstellungen an, um die Anforderungen deines Datensatzes und deiner Aufgabe zu erfüllen. Das Experimentieren mit verschiedenen Werten kann dabei helfen, die optimale Augmentierungsstrategie für die beste Modellleistung zu finden.

Augmentierungs-Guide

Logging, Checkpoints und Plotting-Einstellungen

Logging, Checkpoints, Plotting und Dateiverwaltung sind wichtig beim Training eines YOLO Modells:

Logging: Verfolge den Fortschritt des Modells und diagnostiziere Probleme mithilfe von Bibliotheken wie TensorBoard oder durch Schreiben in eine Datei.
Checkpoints: Speichere das Modell in regelmäßigen Abständen, um das Training fortzusetzen oder mit verschiedenen Konfigurationen zu experimentieren.
Plotting: Visualisiere die Leistung und den Trainingsfortschritt mit Bibliotheken wie matplotlib oder TensorBoard.
Dateiverwaltung: Organisiere die während des Trainings generierten Dateien, wie Checkpoints, Log-Dateien und Plots, für einfachen Zugriff und Analyse.

Ein effektives Management dieser Aspekte hilft dabei, den Fortschritt zu verfolgen und erleichtert das Debugging und die Optimierung.

Argument	Standard	Beschreibung
`project`	`'runs'`	Gibt das Stammverzeichnis zum Speichern von Trainingsläufen an. Jeder Lauf wird in einem separaten Unterverzeichnis gespeichert.
`name`	`'exp'`	Definiert den Namen des Experiments. Wenn nicht spezifiziert, erhöht YOLO diesen Namen für jeden Lauf (z. B. `exp`, `exp-2`), um Überschreibungen zu vermeiden.
`exist_ok`	`False`	Bestimmt, ob ein existierendes Experimentverzeichnis überschrieben werden soll. `True` erlaubt das Überschreiben; `False` verhindert es.
`plots`	`True`	Steuert die Erstellung und Speicherung von Trainings- und Validierungs-Plots. Auf `True` setzen, um Plots wie Loss-Kurven, präzisions--recall-Kurven und Beispielvorhersagen für die visuelle Verfolgung der Leistung zu erstellen.
`save`	`True`	Aktiviert das Speichern von Trainings-Checkpoints und finalen Modellgewichten. Auf `True` setzen, um Modellzustände periodisch zu speichern, was die Wiederaufnahme des Trainings oder die Bereitstellung des Modells ermöglicht.

Benutzerdefinierte Konfigurationsdatei

Lade ein gespeichertes YAML, um einen vollständigen Satz an Argumenten wiederzuverwenden, ohne sie inline übergeben zu müssen. Das cfg Argument überschreibt Werte aus default.yaml, während zusätzliche Argumente, die zusammen übergeben werden, weiterhin Vorrang haben.

Argument	Standard	Beschreibung
`cfg`	`None`	Pfad zu einer YAML-Datei, deren Werte `default.yaml` Einträge ersetzen. Siehe Überschreiben der Standard-Konfigurationsdatei für ein ausgearbeitetes CLI-Beispiel.

FAQ

Wie verbessere ich die Leistung meines YOLO Modells während des Trainings?

Verbessere die Leistung durch das Tuning von Hyperparametern wie batch size, learning rate, Momentum und Weight Decay. Passe Datenaugmentation Einstellungen an, wähle den richtigen Optimizer und verwende Techniken wie Early Stopping oder mixed precision. Für Details siehe den Trainings-Leitfaden.

Was sind die wichtigsten Hyperparameter für die YOLO Modellgenauigkeit?

Zu den wichtigen Hyperparametern, die die Genauigkeit beeinflussen, gehören:

Batch-Größe (batch): Größere Größen können das Training stabilisieren, benötigen aber mehr Speicher.
Lernrate (lr0): Kleinere Raten bieten feinere Anpassungen, aber langsamere Konvergenz.
Momentum (momentum): Beschleunigt Gradientenvektoren und dämpft Oszillationen.
Bildgröße (imgsz): Größere Größen verbessern die Genauigkeit, erhöhen aber die Rechenlast.

Passe diese basierend auf deinem Datensatz und deiner Hardware an. Erfahre mehr unter Trainingseinstellungen.

Wie lege ich die Lernrate für das Training eines YOLO Modells fest?

Die Lernrate (lr0) ist entscheidend; starte mit 0.01 für SGD oder 0.001 für Adam Optimizer. Überwache Metriken und passe sie bei Bedarf an. Verwende Cosine Learning Rate Schedulers (cos_lr) oder Warmup (warmup_epochs, warmup_momentum). Details findest du im Trainings-Leitfaden.

Was sind die Standard-Inferenz-Einstellungen für YOLO Modelle?

Zu den Standardeinstellungen gehören:

Konfidenzschwellenwert (conf=0.25): Minimale Konfidenz für Erkennungen.
IoU Schwellenwert (iou=0.7): Für Non-Maximum Suppression (NMS).
Bildgröße (imgsz=640): Ändert die Größe der Eingabebilder.
Gerät (device=None): Wählt CPU, GPU, Apple MPS oder Huawei Ascend NPU (npu).

Für einen vollständigen Überblick siehe Vorhersage-Einstellungen und den Vorhersage-Leitfaden.

Warum Mixed-Precision-Training bei YOLO Modellen verwenden?

Mixed precision Training (amp=True) reduziert die Speichernutzung und beschleunigt das Training mithilfe von FP16 und FP32. Dies ist vorteilhaft für moderne GPUs und ermöglicht größere Modelle sowie schnellere Berechnungen ohne signifikanten Genauigkeitsverlust. Erfahre mehr im Trainings-Leitfaden.