Best Practices und Tipps für das Training von Machine-Learning-Modellen#

Einführung#

Einer der wichtigsten Schritte bei der Arbeit an einem computer vision project ist das Modelltraining. Bevor du diesen Schritt erreichst, musst du define your goals und collect and annotate your data. Nach dem preprocessing the data, um sicherzustellen, dass sie sauber und konsistent ist, kannst du mit dem Training deines Modells fortfahren.

Model training ist der Prozess, bei dem dein Modell lernt, visuelle Muster zu erkennen und Vorhersagen aus deinen Daten zu treffen, und er bestimmt direkt die Genauigkeit deiner Anwendung. Dieser Leitfaden führt dich durch bewährte Methoden, Optimierungstechniken und Tipps zur Fehlerbehebung, damit du deine Computer-Vision-Modelle effektiv trainieren kannst.

So trainierst du ein Machine-Learning-Modell#

Ein Computer-Vision-Modell wird trainiert, indem seine internen Parameter angepasst werden, um Fehler zu minimieren. Zu Beginn erhält das Modell einen großen Satz beschrifteter Bilder. Es trifft Vorhersagen darüber, was auf diesen Bildern zu sehen ist, und diese Vorhersagen werden mit den tatsächlichen Beschriftungen oder Inhalten verglichen, um Fehler zu berechnen. Diese Fehler zeigen, wie weit die Vorhersagen des Modells von den wahren Werten entfernt sind.

Während des Trainings macht das Modell iterativ Vorhersagen, berechnet Fehler und aktualisiert seine Parameter durch einen Prozess namens backpropagation. In diesem Prozess passt das Modell seine internen Parameter (Gewichte und Biases) an, um die Fehler zu reduzieren. Durch die mehrmalige Wiederholung dieses Zyklus verbessert das Modell schrittweise seine Genauigkeit. Mit der Zeit lernt es, komplexe Muster wie Formen, Farben und Texturen zu erkennen.

Dieser Lernprozess ermöglicht es dem computer vision-Modell, verschiedene tasks auszuführen, einschließlich object detection, instance segmentation, semantic segmentation und image classification. Das ultimative Ziel ist es, ein Modell zu erstellen, das sein Gelerntes auf neue, unbekannte Bilder verallgemeinern kann, um visuelle Daten in realen Anwendungen präzise zu verstehen.

Nachdem wir nun wissen, was hinter den Kulissen beim Modelltraining passiert, schauen wir uns Punkte an, die beim Trainieren eines Modells zu berücksichtigen sind.

Training auf großen Datensätzen#

Es gibt einige verschiedene Aspekte, die du berücksichtigen solltest, wenn du planst, einen großen Datensatz zum Trainieren eines Modells zu verwenden. Du kannst zum Beispiel die Batch-Größe anpassen, die GPU-Auslastung steuern, sich für Multiscale-Training entscheiden usw. Lass uns jede dieser Optionen im Detail durchgehen.

Batch-Größe und GPU-Auslastung#

Beim Training von Modellen auf großen Datensätzen ist die effiziente Nutzung deiner GPU entscheidend. Die Batch-Größe ist ein wichtiger Faktor. Sie ist die Anzahl der Datenbeispiele, die ein Machine-Learning-Modell in einem einzigen Trainingsschritt verarbeitet. Wenn du die von deiner GPU unterstützte maximale Batch-Größe verwendest, kannst du deren Kapazitäten voll ausschöpfen und die benötigte Zeit für das Modelltraining verkürzen. Du solltest jedoch vermeiden, dass der GPU-Speicher überläuft. Wenn Speicherfehler auftreten, reduziere die Batch-Größe schrittweise, bis das Modell reibungslos trainiert.

Für YOLO26 kannst du den Parameter batch in den Train mode arguments entsprechend deiner GPU-Kapazität festlegen. Auf einem einzelnen Beschleuniger profiliert batch=-1 das Modell und wählt eine batch size, die auf etwa 60 % Speicherauslastung abzielt; ein Bruchteil wie batch=0.70 zielt auf einen anderen Anteil ab. Multi-GPU-Läufe erfordern eine explizite globale Batch-Größe, die ein Vielfaches der Geräteanzahl ist. Auf CPU und Apple Silicon warnt AutoBatch und fällt auf batch=16 zurück.

Subset-Training#

Subset-Training ist eine intelligente Strategie, bei der dein Modell auf einer kleineren Datenmenge trainiert wird, die den größeren Datensatz repräsentiert. Dies kann Zeit und Ressourcen sparen, insbesondere bei der ersten Modellentwicklung und beim Testen. Wenn du unter Zeitdruck stehst oder mit verschiedenen Modellkonfigurationen experimentierst, ist Subset-Training eine gute Option.

Wenn es um YOLO26 geht, kannst du das Teilm-Training ganz einfach mit dem Parameter fraction implementieren. Verwende ein Verhältnis wie fraction=0.1 für 10 % der Trainingsdaten, eine ganze Zahl wie fraction=300 für genau 300 Trainingsbilder oder eine [train, val, test]-Liste wie fraction=[300, 100, 0], um jeden Split zu begrenzen und Testbilder zu überspringen. Listen mit zwei Elementen wie [300, 100] lassen den Test-Split vollständig. NDJSON-Datensätze wählen gleichmäßig verteilte Datensätze vor dem Herunterladen aus, sodass wiederholte Durchläufe genau dieselbe Teilmenge wiederverwenden. Diese Technik unterstützt schnelle Iterationen und Optimierungen, bevor du dich auf den vollständigen Datensatz festlegst.

Multiscale-Training#

Multi-Scale-Training ist eine Technik, die die Fähigkeit deines Modells zur Verallgemeinerung verbessert, indem es mit Bildern unterschiedlicher Größe trainiert wird. Dein Modell kann lernen, Objekte in verschiedenen Maßstäben und Entfernungen zu erkennen und robuster zu werden.

Wenn du beispielsweise YOLO26 trainierst, kannst du die Skalierungs-Augmentation aktivieren, indem du den Parameter scale einstellst. Dieser Parameter passt die Größe der Trainingsbilder um einen bestimmten Faktor an und simuliert so Objekte in unterschiedlichen Entfernungen. Beispielsweise zoomt das Einstellen von scale=0.5 Trainingsbilder während des Trainings zufällig um einen Faktor zwischen 0,5 und 1,5. Durch die Konfiguration dieses Parameters kann dein Modell eine Vielzahl von Bildmaßstäben erfahren und seine Erkennungsfähigkeiten über verschiedene Objektgrößen und Szenarien hinweg verbessern.

Ultralytics unterstützt auch das Multiskalen-Training für Bildgrößen über den Parameter multi_scale. Im Gegensatz zu scale, das Bilder zoomt und dann auf imgsz auffüllt/zuschneidet, ändert multi_scale die imgsz selbst in jedem Batch (gerundet auf die Modell-Stride). Beispielsweise wird bei imgsz=640 und multi_scale=0.25 die Trainingsgröße von 480 bis 800 in Stride-Schritten (z. B. 480, 512, 544, ..., 800) abgetastet, während multi_scale=0.0 eine feste Größe beibehält.

Caching#

Caching ist eine wichtige Technik, um die Effizienz beim Training von Machine-Learning-Modellen zu verbessern. Durch das Speichern vorverarbeiteter Bilder im Arbeitsspeicher reduziert Caching die Zeit, die die GPU auf das Laden von Daten von der Festplatte warten muss. Das Modell kann kontinuierlich Daten empfangen, ohne Verzögerungen durch Festplatten-I/O-Operationen.

Das Caching kann beim Training von YOLO26 über den Parameter cache gesteuert werden:

• cache=True: Speichert Datensatzbilder im Arbeitsspeicher (RAM) und bietet so die schnellste Zugriffsgeschwindigkeit, allerdings auf Kosten eines erhöhten Speicherverbrauchs.
• cache='disk': Speichert die Bilder auf der Festplatte, was langsamer als RAM ist, aber schneller als das jedes Mal neue Laden von Daten.
• cache=False: Deaktiviert das Caching und verlässt sich vollständig auf die Festplatten-I/O, was die langsamste Option ist.

Gemischtes Präzisionstraining (Mixed Precision Training)#

Das Training mit gemischter Genauigkeit verwendet sowohl 16-Bit- (FP16) als auch 32-Bit-Gleitkommatypen (FP32). Die Stärken von FP16 und FP32 werden genutzt, indem FP16 für schnellere Berechnungen und FP32 zur Wahrung der Genauigkeit dort eingesetzt wird, wo es erforderlich ist. Die meisten Operationen des neural network werden in FP16 ausgeführt, um von schnelleren Berechnungen und geringerem Speicherverbrauch zu profitieren. Eine Masterkopie der Modellgewichte wird jedoch in FP32 aufbewahrt, um die Genauigkeit während der Gewichtungsaktualisierungsschritte sicherzustellen. Du kannst größere Modelle oder größere Batch-Größen innerhalb derselben Hardware-Einschränkungen verarbeiten.

Um das Training mit gemischter Genauigkeit zu implementieren, musst du deine Trainingsskripte anpassen und sicherstellen, dass deine Hardware (wie GPUs) dies unterstützt. Viele moderne deep learning-Frameworks wie PyTorch und TensorFlow bieten integrierte Unterstützung für gemischte Genauigkeit.

Das Training mit gemischter Präzision ist bei der Arbeit mit YOLO26 unkompliziert: AMP ist standardmäßig bereits aktiviert (amp=True). Auf einer CUDA-GPU führt YOLO zu Beginn des Trainings eine einmalige Eignungsprüfung durch und fällt bei einem Fehler auf vollständiges FP32 zurück; auf CPU und Apple Silicon wird AMP vollständig übersprungen. Setze amp=False, um FP32 zu erzwingen.

Vortrainierte Gewichte#

Die Verwendung vortrainierter Gewichte ist eine kluge Methode, um das Training deines Modells zu beschleunigen. Vortrainierte Gewichte stammen von Modellen, die bereits auf großen Datensätzen trainiert wurden, wodurch dein Modell einen Vorsprung erhält. Transfer learning passt vortrainierte Modelle an neue, verwandte Aufgaben an. Das Fine-Tuning eines vortrainierten Modells beinhaltet, mit diesen Gewichten zu beginnen und dann das Training mit deinem spezifischen Datensatz fortzusetzen. Diese Trainingsmethode führt zu schnelleren Trainingszeiten und oft zu einer besseren Leistung, da das Modell mit einem soliden Verständnis grundlegender Merkmale beginnt.

Vortrainierte Gewichte stammen aus dem Argument model, sodass model=yolo26n.pt bereits mit COCO-Gewichten beginnt. Der Parameter pretrained steuert, ob diese Gewichte beibehalten (True, der Standardwert), verworfen (False) oder durch einen anderen Checkpoint ersetzt werden (pretrained=path/to/best.pt). Das Setzen von pretrained=True bei einem *.yaml-Modell ruft nicht von sich aus Gewichte ab. Siehe How to Fine-Tune YOLO on a Custom Dataset für den vollständigen Transfer-Learning-Workflow.

Weitere Techniken, die bei der Handhabung großer Datensätze zu berücksichtigen sind#

Es gibt ein paar weitere Techniken, die bei der Handhabung eines großen Datensatzes zu berücksichtigen sind:

• Learning Rate Schedulers: Die Implementierung von Lernraten-Schedulern passt die Lernrate während des Trainings dynamisch an. Eine gut abgestimmte Lernrate kann verhindern, dass das Modell über Minima hinausschießt, und die Stabilität verbessern. Beim Training von YOLO26 hilft der Parameter lrf bei der Verwaltung der Lernratenplanung, indem er die finale Lernrate als Bruchteil der anfänglichen Rate festlegt. Für ein Verhalten, das kein Argument offenlegt, wie etwa schichtbezogene Lernraten oder Gradient Clipping, subclass the trainer.
• Verteiltes Training (Distributed Training): Für die Handhabung großer Datensätze kann verteiltes Training bahnbrechend sein. Du kannst die Trainingszeit verkürzen, indem du die Trainingslast auf mehrere GPUs oder Maschinen verteilst. Dieser Ansatz ist besonders wertvoll für Projekte in Unternehmensgröße mit erheblichen Rechenressourcen.
• Channels-last memory format: Das CUDA-Training verwendet ab PyTorch 1.11 und neuer automatisch das schnellere NHWC-Speicherlayout. Setze channels_last=False, um NCHW beizubehalten; PyTorch 1.10 und älter, CPU und MPS bleiben standardmäßig NCHW.

Die Anzahl der Epochen für das Training#

Beim Training eines Modells bezieht sich eine epoch auf einen vollständigen Durchlauf durch den gesamten Trainingsdatensatz. Während einer Epoche verarbeitet das Modell jedes Beispiel im Trainingsset einmal und aktualisiert seine Parameter basierend auf dem Lernalgorithmus. Mehrere Epochen sind in der Regel erforderlich, damit das Modell im Laufe der Zeit lernen und seine Parameter verfeinern kann.

Eine häufig gestellte Frage ist, wie man die Anzahl der Epochen für das Training des Modells bestimmt. Ein guter Ausgangspunkt sind 300 Epochen. Wenn das Modell früh überanpasst (overfitting), kannst du die Anzahl der Epochen reduzieren. Wenn overfitting nach 300 Epochen nicht auftritt, kannst du das Training auf 600, 1200 oder mehr Epochen ausdehnen.

Die ideale Anzahl von Epochen kann jedoch je nach Größe deines Datensatzes und den Projektzielen variieren. Größere Datensätze erfordern möglicherweise mehr Epochen, damit das Modell effektiv lernt, während kleinere Datensätze möglicherweise weniger Epochen benötigen, um ein Overfitting zu vermeiden. In Bezug auf YOLO26 kannst du den Parameter epochs in deinem Trainingsskript festlegen.

Early Stopping#

Early Stopping ist eine wertvolle Technik zur Optimierung des Modelltrainings. Durch die Überwachung der Validierungsleistung kannst du das Training abbrechen, sobald sich das Modell nicht mehr verbessert. So sparst du Rechenressourcen und verhinderst Overfitting.

Der Prozess beinhaltet das Einstellen eines Patience-Parameters, der bestimmt, wie viele Epochen auf eine Verbesserung der Validierungsmetriken gewartet werden soll, bevor das Training gestoppt wird. Wenn sich die Leistung des Modells innerhalb dieser Epochen nicht verbessert, wird das Training gestoppt, um keine Zeit und Ressourcen zu verschwenden.

Für YOLO26 kannst du das Early Stopping aktivieren, indem du den Patience-Parameter in deiner Trainingskonfiguration festlegst. Beispielsweise bedeutet patience=5, dass das Training stoppt, wenn es 5 aufeinanderfolgende Epochen lang keine Verbesserung der Validierungsmetriken gibt. Die Verwendung dieser Methode stellt sicher, dass der Trainingsprozess effizient bleibt und eine optimale Leistung ohne übermäßigen Rechenaufwand erzielt wird.

Die Wahl zwischen Cloud- und lokalem Training#

Es gibt zwei Optionen für das Training deines Modells: Cloud-Training und lokales Training.

Cloud-Training bietet Skalierbarkeit und leistungsstarke Hardware und ist ideal für die Bewältigung großer Datensätze und komplexer Modelle. Plattformen wie Google Cloud, AWS und Azure bieten On-Demand-Zugriff auf Hochleistungs-GPUs und TPUs, was die Trainingszeiten beschleunigt und Experimente mit größeren Modellen ermöglicht. Cloud-Training kann jedoch teuer sein, insbesondere über längere Zeiträume, und die Datenübertragung kann zu zusätzlichen Kosten und Latenzen führen.

Lokales Training bietet mehr Kontrolle und Anpassungsmöglichkeiten, sodass du deine Umgebung auf spezifische Bedürfnisse zuschneiden und laufende Cloud-Kosten vermeiden kannst. Es kann für langfristige Projekte wirtschaftlicher sein, und da deine Daten lokal bleiben, ist es sicherer. Lokale Hardware kann jedoch Ressourcenbeschränkungen aufweisen und Wartung erfordern, was bei großen Modellen zu längeren Trainingszeiten führen kann.

Auswahl eines Optimierers#

Ein Optimierer ist ein Algorithmus, der die Gewichte deines neuronalen Netzes anpasst, um die loss function zu minimieren, die misst, wie gut das Modell abschneidet. Einfach ausgedrückt hilft der Optimierer dem Modell beim Lernen, indem er seine Parameter optimiert, um Fehler zu reduzieren. Die Wahl des richtigen Optimierers wirkt sich direkt darauf aus, wie schnell und genau das Modell lernt.

Du kannst auch Optimierer-Parameter feinabstimmen, um die Modellleistung zu verbessern. Durch das Anpassen der Lernrate legst du die Schrittgröße bei der Aktualisierung von Parametern fest. Für Stabilität beginnst du möglicherweise mit einer moderaten Lernrate und senkst diese im Laufe der Zeit allmählich, um das langfristige Lernen zu verbessern. Außerdem bestimmt die Einstellung des Momentums, welchen Einfluss vergangene Aktualisierungen auf aktuelle haben. Ein üblicher Wert für das Momentum liegt bei etwa 0,9. Dies bietet im Allgemeinen ein gutes Gleichgewicht.

Gängige Optimierer#

Verschiedene Optimierer haben unterschiedliche Stärken und Schwächen. Werfen wir einen Blick auf einige gängige Optimierer.

• SGD (Stochastic Gradient Descent):

  • Aktualisiert Modellparameter unter Verwendung des Gradienten der Verlustfunktion in Bezug auf die Parameter.
  • Einfach und effizient, kann aber langsam konvergieren und möglicherweise in lokalen Minima stecken bleiben.

• Adam (Adaptive Moment Estimation):

  • Kombiniert die Vorteile von SGD mit Momentum und RMSProp.
  • Passt die Lernrate für jeden Parameter basierend auf Schätzungen der ersten und zweiten Momente der Gradienten an.
  • Gut geeignet für verrauschte Daten und dünn besetzte Gradienten.
  • Effizient und erfordert im Allgemeinen weniger Feinabstimmung. Für kürzere Trainingsläufe wählt optimizer=auto von YOLO26 das eng verwandte AdamW anstelle von Adam selbst.

• RMSProp (Root Mean Square Propagation):

  • Passt die Lernrate für jeden Parameter an, indem der Gradient durch einen gleitenden Durchschnitt der Größen der letzten Gradienten geteilt wird.
  • Hilft bei der Bewältigung des Problems des verschwindenden Gradienten und ist effektiv für recurrent neural networks.

• MuSGD (Muon + SGD hybrid):

  • Kombiniert SGD-artige Aktualisierungen mit von Muon inspiriertem Verhalten für verbesserte Stabilität beim Training im großen Maßstab.
  • Eine gute Wahl, wenn du eine SGD-ähnliche Verallgemeinerung wünschst, aber eine glattere Konvergenz als bei herkömmlichem SGD benötigst.
  • Besonders relevant für YOLO26 training recipes; wenn du dir nicht sicher bist, beginne mit optimizer=auto und vergleiche es mit MuSGD auf deinem Datensatz.

Für YOLO26 kannst du mit dem Parameter optimizer aus verschiedenen Optimierern wie SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam und RMSProp wählen oder ihn auf auto einstellen, um eine automatische Auswahl basierend auf der Anzahl der Trainingsiterationen zu treffen.

yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGD

Verbindung mit der Community#

Teil einer Community von Computer-Vision-Enthusiasten zu sein, kann dir helfen, Probleme zu lösen und schneller zu lernen. Hier sind einige Möglichkeiten, sich zu vernetzen, Hilfe zu bekommen und Ideen auszutauschen.

Community-Ressourcen#

• GitHub Issues: Besuche das YOLO26 GitHub repository und nutze den Issues-Tab, um Fragen zu stellen, Fehler zu melden und neue Funktionen vorzuschlagen. Die Community und die Maintainer sind sehr aktiv und bereit zu helfen.
• Ultralytics Discord Server: Tritt dem Ultralytics Discord server bei, um dich mit anderen Nutzern und Entwicklern auszutauschen, Unterstützung zu erhalten und deine Erfahrungen zu teilen.

Offizielle Dokumentation#

• Ultralytics YOLO26 Documentation: Schau dir die official YOLO26 documentation an, um detaillierte Anleitungen und hilfreiche Tipps zu verschiedenen Computer-Vision-Projekten zu erhalten.

Die Nutzung dieser Ressourcen wird dir helfen, Herausforderungen zu lösen und bei den neuesten Trends und Praktiken in der Computer-Vision-Community auf dem Laufenden zu bleiben.

Wichtige Erkenntnisse#

Das Training von Computer-Vision-Modellen erfordert die Befolgung bewährter Verfahren, die Optimierung deiner Strategien und die Lösung von Problemen, sobald sie auftreten. Techniken wie das Anpassen von Batch-Größen, das Training mit gemischter precision und das Beginnen mit vortrainierten Gewichten können dazu führen, dass deine Modelle besser funktionieren und schneller trainieren. Methoden wie Subset-Training und Early Stopping helfen dir, Zeit und Ressourcen zu sparen. Wenn du mit der Community in Verbindung bleibst und mit neuen Trends Schritt hältst, kannst du deine Fähigkeiten im Modelltraining kontinuierlich verbessern.

FAQ#