Bewährte Vorgehensweisen und Tipps für das Training von Machine-Learning-Modellen#

Einleitung#

Einer der wichtigsten Schritte bei der Arbeit an einem Computer-Vision-Projekt ist das Training des Modells. Bevor du diesen Schritt erreichst, musst du zunächst deine Ziele definieren sowie deine Daten erfassen und annotieren. Nachdem du die Daten vorverarbeitet hast, um sicherzustellen, dass sie sauber und konsistent sind, kannst du mit dem Training deines Modells beginnen.

Modelltraining bezeichnet den Prozess, einem Modell beizubringen, visuelle Muster zu erkennen und anhand deiner Daten Vorhersagen zu treffen. Dieser Prozess beeinflusst die Genauigkeit deiner Anwendung direkt. Dieser Leitfaden behandelt bewährte Vorgehensweisen, 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 eine große Menge annotierter Bilder. Es erstellt Vorhersagen darüber, was auf diesen Bildern zu sehen ist. Anschließend werden die Vorhersagen mit den tatsächlichen Labels oder Inhalten verglichen, um die Fehler zu berechnen. Diese Fehler zeigen, wie stark die Vorhersagen des Modells von den tatsächlichen Werten abweichen.

Während des Trainings erstellt das Modell iterativ Vorhersagen, berechnet Fehler und aktualisiert seine Parameter durch einen Prozess namens Backpropagation. Dabei passt das Modell seine internen Parameter (Gewichte und Biases) an, um die Fehler zu reduzieren. Durch die vielfache Wiederholung dieses Zyklus verbessert sich seine Genauigkeit allmählich. Mit der Zeit lernt es, komplexe Muster wie Formen, Farben und Texturen zu erkennen.

Dieser Lernprozess ermöglicht es dem Computer-Vision-Modell, verschiedene Aufgaben auszuführen, darunter Objekterkennung, Instanzsegmentierung, semantische Segmentierung und Bildklassifizierung. Das letztendliche Ziel ist ein Modell, das sein Wissen auf neue, bisher ungesehene Bilder übertragen kann, sodass es visuelle Daten in realen Anwendungen zuverlässig versteht.

Nachdem wir nun wissen, was beim Training eines Modells im Hintergrund passiert, sehen wir uns an, welche Punkte du dabei berücksichtigen solltest.

Training mit großen Datensätzen#

Wenn du ein Modell mit einem großen Datensatz trainieren möchtest, solltest du verschiedene Aspekte berücksichtigen. Du kannst beispielsweise die Batch-Größe anpassen, die GPU-Auslastung steuern oder Training mit mehreren Maßstäben verwenden. Sehen wir uns diese Optionen im Detail an.

Batch-Größe und GPU-Auslastung#

Beim Training von Modellen mit großen Datensätzen ist die effiziente Nutzung deiner GPU entscheidend. Die Batch-Größe ist dabei ein wichtiger Faktor. Sie gibt an, wie viele Datenproben ein Machine-Learning-Modell in einer einzelnen Trainingsiteration verarbeitet. Wenn du die von deiner GPU unterstützte maximale Batch-Größe verwendest, kannst du ihre Möglichkeiten vollständig ausschöpfen und die Trainingszeit des Modells verkürzen. Du solltest jedoch vermeiden, dass der GPU-Speicher ausgeht. Wenn Speicherfehler auftreten, verringere die Batch-Größe schrittweise, bis das Modell reibungslos trainiert.

Für YOLO26 kannst du den Parameter batch in den Argumenten für den Trainingsmodus so festlegen, dass er der Kapazität deiner GPU entspricht. Bei einem einzelnen Beschleuniger erstellt batch=-1 ein Profil des Modells und wählt eine Batch-Größe, die auf eine Speicherauslastung von ungefähr 60 % abzielt; ein Bruchteil wie batch=0.70 zielt auf einen anderen Anteil ab. Ausführungen mit mehreren GPUs erfordern eine explizite globale Batch-Größe, die ein Vielfaches der Geräteanzahl ist. Auf der CPU und Apple-Silicon warnt AutoBatch und verwendet stattdessen batch=16.

Training mit Teilmengen#

Beim Training mit Teilmengen trainierst du dein Modell mit einer kleineren Datenmenge, die den größeren Datensatz repräsentiert. Das kann Zeit und Ressourcen sparen, insbesondere während der ersten Entwicklung und beim Testen des Modells. Wenn du wenig Zeit hast oder verschiedene Modellkonfigurationen ausprobierst, ist das Training mit einer Teilmenge eine gute Option.

Für YOLO26 kannst du das Training mit Teilmengen einfach mit dem Parameter fraction umsetzen. Verwende ein Verhältnis wie fraction=0.1 für 10 % der Trainingsdaten, eine Ganzzahl 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. Zwei-Element-Listen wie [300, 100] lassen den Test-Split vollständig. Bei NDJSON-Datensätzen werden Datensätze vor dem Herunterladen gleichmäßig ausgewählt, sodass bei wiederholten Ausführungen exakt dieselbe Teilmenge verwendet wird. Diese Technik ermöglicht schnelle Iterationen und Abstimmungen, bevor du dich auf den vollständigen Datensatz festlegst.

Training mit mehreren Maßstäben#

Training mit mehreren Maßstäben verbessert die Fähigkeit deines Modells zur Verallgemeinerung, indem es mit Bildern unterschiedlicher Größe trainiert wird. Dein Modell kann dadurch Objekte in verschiedenen Größen und Entfernungen erkennen und wird robuster.

Wenn du beispielsweise YOLO26 trainierst, kannst du die Skalierungsaugmentation aktivieren, indem du den Parameter scale festlegst. Dieser Parameter passt die Größe der Trainingsbilder um einen angegebenen Faktor an und simuliert Objekte in unterschiedlichen Entfernungen. Mit scale=0.5 werden Trainingsbilder während des Trainings beispielsweise zufällig um einen Faktor zwischen 0,5 und 1,5 vergrößert oder verkleinert. Durch die Konfiguration dieses Parameters sieht dein Modell eine Vielzahl von Bildmaßstäben und verbessert seine Erkennungsfähigkeiten für unterschiedliche Objektgrößen und Szenarien.

Ultralytics unterstützt außerdem Training mit mehreren Bildgrößen über den Parameter multi_scale. Anders als scale, das Bilder zoomt und anschließend auf imgsz auffüllt oder zuschneidet, ändert multi_scale imgsz selbst in jedem Batch, gerundet auf den Modell-Stride. Mit imgsz=640 und multi_scale=0.25 wird die Trainingsgröße beispielsweise in Stride-Schritten zwischen 480 und 800 ausgewählt (z. B. 480, 512, 544, ..., 800), während multi_scale=0.0 eine feste Größe beibehält.

Caching#

Caching ist eine wichtige Technik, um das Training von Machine-Learning-Modellen effizienter zu machen. Durch das Speichern vorverarbeiteter Bilder im Arbeitsspeicher verringert Caching die Zeit, in der die GPU auf das Laden von Daten von der Festplatte wartet. Das Modell kann kontinuierlich Daten empfangen, ohne durch Festplatten-E/A-Vorgänge verzögert zu werden.

Beim Training von YOLO26 lässt sich Caching über den Parameter cache steuern:

• cache=True: Speichert Datensatzbilder im RAM. Dadurch wird die schnellste Zugriffsgeschwindigkeit erreicht, allerdings steigt der Speicherbedarf.
• cache='disk': Speichert die Bilder auf der Festplatte. Das ist langsamer als RAM, aber schneller als das jedes Mal erneute Laden der Daten.
• cache=False: Deaktiviert Caching und verwendet ausschließlich Festplatten-E/A, was die langsamste Option ist.

Training mit gemischter Genauigkeit#

Beim Training mit gemischter Genauigkeit werden sowohl 16-Bit-(FP16)- als auch 32-Bit-(FP32)-Gleitkommatypen verwendet. Die Vorteile beider Formate werden genutzt, indem FP16 für schnellere Berechnungen und FP32 zur Aufrechterhaltung der Genauigkeit an den erforderlichen Stellen eingesetzt wird. Die meisten Operationen des neuronalen Netzes werden in FP16 ausgeführt, um von schnelleren Berechnungen und einem geringeren Speicherbedarf zu profitieren. Eine Masterkopie der Modellgewichte wird jedoch in FP32 gespeichert, um die Genauigkeit während der Aktualisierung der Gewichte sicherzustellen. So kannst du größere Modelle oder größere Batch-Größen innerhalb derselben Hardwarebeschränkungen verarbeiten.

Um Training mit gemischter Genauigkeit zu implementieren, musst du deine Trainingsskripte anpassen und sicherstellen, dass deine Hardware, etwa GPUs, dies unterstützt. Viele moderne Frameworks für Deep Learning, darunter PyTorch und TensorFlow, bieten integrierte Unterstützung für gemischte Genauigkeit.

Training mit gemischter Genauigkeit ist bei YOLO26 unkompliziert: AMP ist standardmäßig aktiviert (amp=True). Auf einer CUDA-GPU führt YOLO zu Beginn des Trainings einmalig eine Überprüfung der Fähigkeiten durch und wechselt bei einem Fehler auf vollständiges FP32; auf der CPU und Apple-Silicon wird AMP vollständig übersprungen. Setze amp=False, um FP32 zu erzwingen.

Vortrainierte Gewichte#

Die Verwendung vortrainierter Gewichte ist eine effektive Möglichkeit, den Trainingsprozess deines Modells zu beschleunigen. Vortrainierte Gewichte stammen aus Modellen, die bereits mit großen Datensätzen trainiert wurden, und verschaffen deinem Modell einen Vorsprung. Transferlernen passt vortrainierte Modelle an neue, verwandte Aufgaben an. Beim Feinabstimmen eines vortrainierten Modells beginnst du mit diesen Gewichten und setzt das Training anschließend mit deinem spezifischen Datensatz fort. Diese Trainingsmethode führt zu kürzeren Trainingszeiten und oft zu einer besseren Leistung, da das Modell bereits über ein solides Verständnis grundlegender Merkmale verfügt.

Vortrainierte Gewichte werden über das Argument model geladen, daher startet model=yolo26n.pt bereits mit COCO-Gewichten. Der Parameter pretrained steuert, ob diese Gewichte beibehalten (True, Standard), verworfen (False) oder durch einen anderen Checkpoint ersetzt werden (pretrained=path/to/best.pt). Wenn du pretrained=True bei einem *.yaml-Modell festlegst, werden nicht automatisch Gewichte abgerufen. Eine vollständige Beschreibung des Transferlern-Workflows findest du unter So stimmst du YOLO auf einen benutzerdefinierten Datensatz ab.

Weitere Techniken für die Arbeit mit großen Datensätzen#

Bei der Arbeit mit einem großen Datensatz solltest du noch einige weitere Techniken berücksichtigen:

• Lernraten-Scheduler: Lernraten-Scheduler passen 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 unterstützt der Parameter lrf die Steuerung der Lernrate, indem er die endgültige Lernrate als Bruchteil der anfänglichen Lernrate festlegt. Für Verhaltensweisen, die kein Argument bereitstellt, etwa Lernraten pro Schicht oder Gradienten-Clipping, erweiterst du den Trainer durch eine Unterklasse.
• Verteiltes Training: Für die Verarbeitung großer Datensätze kann verteiltes Training einen entscheidenden Unterschied machen. Du kannst die Trainingszeit verkürzen, indem du die Arbeitslast auf mehrere GPUs oder Rechner verteilst. Dieser Ansatz ist besonders wertvoll für Projekte im Unternehmensmaßstab mit umfangreichen Rechenressourcen.
• Channels-Last-Speicherformat: Das CUDA-Training verwendet in PyTorch 1.11 und neuer automatisch das schnellere NHWC-Speicherlayout, außer unter Windows, wo es langsamer war. Setze channels_last=True, um das Speicherformat zu erzwingen, oder channels_last=False, um NCHW beizubehalten; PyTorch 1.10 und älter, CPU und MPS bleiben standardmäßig auf NCHW.

Die Anzahl der Trainingsepochen#

Eine Epoche bezeichnet beim Training eines Modells einen vollständigen Durchlauf durch den gesamten Trainingsdatensatz. Während einer Epoche verarbeitet das Modell jedes Beispiel im Trainingssatz einmal und aktualisiert seine Parameter auf Grundlage des Lernalgorithmus. In der Regel sind mehrere Epochen erforderlich, damit das Modell seine Parameter im Laufe der Zeit lernen und verfeinern kann.

Eine häufige Frage ist, wie du die Anzahl der Trainingsepochen bestimmst. Ein guter Ausgangspunkt sind 300 Epochen. Wenn das Modell früh überangepasst wird, kannst du die Anzahl der Epochen reduzieren. Wenn nach 300 Epochen keine Überanpassung auftritt, kannst du das Training auf 600, 1200 oder mehr Epochen ausweiten.

Die ideale Anzahl der Epochen kann jedoch je nach Größe deines Datensatzes und den Zielen deines Projekts variieren. Bei größeren Datensätzen sind möglicherweise mehr Epochen erforderlich, damit das Modell effektiv lernt, während kleinere Datensätze möglicherweise weniger Epochen benötigen, um Überanpassung zu vermeiden. Für YOLO26 kannst du den Parameter epochs in deinem Trainingsskript festlegen.

Frühes Beenden#

Frühes Beenden ist eine wertvolle Technik zur Optimierung des Modelltrainings. Indem du die Validierungsleistung überwachst, kannst du das Training beenden, sobald sich das Modell nicht mehr verbessert. So sparst du Rechenressourcen und verhinderst Überanpassung.

Dazu wird ein Geduldsparameter festgelegt, der bestimmt, wie viele Epochen auf eine Verbesserung der Validierungsmetriken gewartet wird, bevor das Training beendet wird. Wenn sich die Leistung des Modells innerhalb dieser Epochen nicht verbessert, wird das Training beendet, um Zeit und Ressourcen nicht zu verschwenden.

Für YOLO26 kannst du frühes Beenden aktivieren, indem du den Geduldsparameter in deiner Trainingskonfiguration festlegst. patience=5 bedeutet beispielsweise, dass das Training beendet wird, wenn sich die Validierungsmetriken 5 aufeinanderfolgende Epochen lang nicht verbessern. Diese Methode sorgt dafür, dass der Trainingsprozess effizient bleibt und ohne übermäßigen Rechenaufwand eine optimale Leistung erreicht.

Training in der Cloud oder lokal#

Für das Training deines Modells gibt es zwei Optionen: Cloud-Training und lokales Training.

Cloud-Training bietet Skalierbarkeit und leistungsstarke Hardware und eignet sich ideal für große Datensätze und komplexe Modelle. Plattformen wie Google Cloud, AWS und Azure ermöglichen bei Bedarf den Zugriff auf leistungsstarke GPUs und TPUs. Dadurch werden Trainingszeiten verkürzt 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 zusätzliche Kosten und Verzögerungen verursachen.

Lokales Training bietet mehr Kontrolle und Anpassungsmöglichkeiten, sodass du deine Umgebung auf spezifische Anforderungen zuschneiden und laufende Cloud-Kosten vermeiden kannst. Für langfristige Projekte kann es kostengünstiger sein. Da deine Daten lokal bleiben, ist es außerdem sicherer. Lokale Hardware kann jedoch über begrenzte Ressourcen verfügen 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 Verlustfunktion zu minimieren. Diese misst, wie gut das Modell arbeitet. Vereinfacht gesagt unterstützt der Optimierer das Lernen des Modells, indem er seine Parameter so anpasst, dass die Fehler reduziert werden. Die Wahl des richtigen Optimierers wirkt sich direkt darauf aus, wie schnell und genau das Modell lernt.

Du kannst die Parameter des Optimierers außerdem feinabstimmen, um die Leistung des Modells zu verbessern. Durch die Anpassung der Lernrate legst du die Schrittgröße bei der Aktualisierung der Parameter fest. Für mehr Stabilität kannst du mit einer moderaten Lernrate beginnen und sie im Laufe der Zeit schrittweise verringern, um das langfristige Lernen zu verbessern. Zusätzlich bestimmt der Momentum-Wert, wie stark sich frühere Aktualisierungen auf aktuelle Aktualisierungen auswirken. Ein üblicher Momentum-Wert liegt bei etwa 0,9 und bietet in der Regel ein gutes Gleichgewicht.

Gängige Optimierer#

Verschiedene Optimierer haben unterschiedliche Stärken und Schwächen. Sehen wir uns einige gängige Optimierer kurz an.

• SGD (Stochastischer Gradientenabstieg):

  • Aktualisiert die Modellparameter mithilfe des Gradienten der Verlustfunktion in Bezug auf die Parameter.
  • Einfach und effizient, kann jedoch langsam konvergieren und in lokalen Minima stecken bleiben.

• Adam (Adaptive Momentenschätzung):

  • Kombiniert die Vorteile von SGD mit Momentum und RMSProp.
  • Passt die Lernrate für jeden Parameter anhand von Schätzungen des ersten und zweiten Moments der Gradienten an.
  • Besonders geeignet für verrauschte Daten und spärliche Gradienten.
  • Effizient und erfordert im Allgemeinen weniger Abstimmung. Für kürzere Trainingsläufe wählt optimizer=auto von YOLO26 den eng verwandten Optimierer AdamW anstelle von Adam selbst.

• RMSProp (Fortschreibung des quadratischen Mittelwerts):

  • Passt die Lernrate für jeden Parameter an, indem es den Gradienten durch einen gleitenden Durchschnitt der Beträge kürzlich berechneter Gradienten teilt.
  • Hilft beim Umgang mit dem Problem verschwindender Gradienten und eignet sich effektiv für rekurrente neuronale Netze.

• MuSGD (Muon- und SGD-Hybrid):

  • Kombiniert Aktualisierungen nach dem SGD-Prinzip mit von Muon inspiriertem Verhalten, um die Stabilität beim Training im großen Maßstab zu verbessern.
  • Eine gute Wahl, wenn du eine SGD-ähnliche Verallgemeinerung möchtest, aber eine gleichmäßigere Konvergenz als bei einfachem SGD benötigst.
  • Besonders relevant für YOLO26-Trainingsrezepte; wenn du unsicher bist, beginne mit optimizer=auto und vergleiche die Ergebnisse auf deinem Datensatz mit MuSGD.

Für YOLO26 kannst du mit dem Parameter optimizer aus verschiedenen Optimierern auswählen, darunter SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam und RMSProp. Alternativ kannst du auto festlegen, damit die Auswahl automatisch anhand der Anzahl der Trainingsiterationen erfolgt.

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

Mit der Community vernetzen#

Die Teilnahme an einer Community von Computer-Vision-Enthusiasten kann dir helfen, Probleme zu lösen und schneller zu lernen. Hier sind einige Möglichkeiten, dich zu vernetzen, Hilfe zu erhalten und Ideen auszutauschen.

Ressourcen der Community#

• GitHub-Issues: Besuche das YOLO26-GitHub-Repository und nutze den Tab „Issues“, um Fragen zu stellen, Fehler zu melden und neue Funktionen vorzuschlagen. Die Community und die Maintainer sind sehr aktiv und helfen dir gerne.
• 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-Dokumentation: In der offiziellen YOLO26-Dokumentation findest du ausführliche Anleitungen und hilfreiche Tipps für verschiedene Computer-Vision-Projekte.

Mit diesen Ressourcen kannst du Herausforderungen bewältigen und dich über die neuesten Trends und Vorgehensweisen in der Computer-Vision-Community auf dem Laufenden halten.

Wichtige Erkenntnisse#

Das Training von Computer-Vision-Modellen erfordert gute Vorgehensweisen, die Optimierung deiner Strategien und die Lösung auftretender Probleme. Techniken wie die Anpassung der Batch-Größe, Training mit gemischter Genauigkeit und der Einsatz vortrainierter Gewichte können die Leistung deiner Modelle verbessern und das Training beschleunigen. Methoden wie Training mit Teilmengen und frühes Beenden helfen dir, Zeit und Ressourcen zu sparen. Wenn du mit der Community verbunden bleibst und neue Trends verfolgst, kannst du deine Fähigkeiten im Modelltraining kontinuierlich verbessern.

FAQ#