Link to this sectionCloud-Training#
Ultralytics Platform Cloud-Training bietet Training mit nur einem Klick auf Cloud-GPUs, wodurch das Modelltraining ohne komplexe Einrichtung zugänglich wird. Trainiere YOLO-Modelle mit Echtzeit-Metrik-Streaming und automatischer Checkpoint-Speicherung.
graph LR
A[Configure] --> B[Start Training]
B --> C[Provision GPU]
C --> D[Download Dataset]
D --> E[Train]
E --> F[Stream Metrics]
F --> G[Save Checkpoints]
G --> H[Complete]
style A fill:#2196F3,color:#fff
style B fill:#FF9800,color:#fff
style E fill:#9C27B0,color:#fff
style H fill:#4CAF50,color:#fffLink to this sectionTrainingsdialog#
Starte das Training über die Plattform-UI, indem du auf jeder Projektseite auf Neues Modell klickst (oder auf einer Datensatzseite auf Trainieren). Der Trainingsdialog hat zwei Tabs: Cloud-Training und Lokales Training.

Link to this sectionSchritt 1: Basismodell auswählen#
Wähle aus offiziellen YOLO26-Modellen oder deinen eigenen trainierten Modellen:
| Kategorie | Beschreibung |
|---|---|
| Offiziell | Alle 30 YOLO26-Modelle (5 Größen x 6 Aufgaben) |
| Deine Modelle | Deine abgeschlossenen Modelle zum Fine-Tuning |
Offizielle Modelle sind nach Aufgabentyp organisiert (Detect, Segment, Semantic, Pose, OBB, Classify) mit Größen von nano bis xlarge.
Link to this sectionSchritt 2: Datensatz auswählen#
Wähle einen Datensatz zum Trainieren aus (siehe Datasets):
| Option | Beschreibung |
|---|---|
| Offiziell | Kuratierte Datensätze von Ultralytics |
| Deine Datensätze | Datensätze, die du hochgeladen hast |
Datensätze müssen den Status ready haben und mindestens 1 Bild im Trainings-Split, 1 Bild im Validierungs- oder Test-Split sowie mindestens 1 beschriftetes Bild enthalten.
Eine Warnung bei Aufgaben-Konflikten erscheint, wenn die Modellaufgabe (z. B. detect) nicht mit der Datensatzaufgabe (z. B. segment) übereinstimmt. Das Training schlägt fehl, wenn du mit nicht übereinstimmenden Aufgaben fortfährst. Stelle sicher, dass sowohl Modell als auch Datensatz denselben Aufgabentyp verwenden, wie in den Aufgaben-Anleitungen beschrieben.
Link to this sectionSchritt 3: Parameter konfigurieren#
Lege die grundlegenden Trainingsparameter fest:
| Parameter | Beschreibung | Standard |
|---|---|---|
| Epochen | Anzahl der Trainingsiterationen | 100 |
| Batch-Größe | Stichproben pro Iteration | -1 (auto) |
| Bildgröße | Eingabeauflösung (Dropdown 320/416/512/640/1280, jedes Vielfache von 32 von 32-4096 im YAML-Editor) | 640 |
| Name des Laufs | Optionaler Name für den Trainingslauf | auto |
Link to this sectionSchritt 4: Erweiterte Einstellungen (Optional)#
Erweitere Erweiterte Einstellungen, um auf den vollständigen YAML-basierten Parameter-Editor mit über 40 Trainingsparametern zuzugreifen, die nach Gruppen organisiert sind (siehe Konfigurationsreferenz):
| Gruppe | Parameter |
|---|---|
| Lernrate | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Optimizer | auto (Standard), SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Verlustgewichtung | box, cls, dfl, pose, kobj, label_smoothing |
| Farbaugmentation | hsv_h, hsv_s, hsv_v |
| Geometrische Augment. | degrees, translate, scale, shear, perspective |
| Flip & Mix Augment. | flipud, fliplr, mosaic, mixup, copy_paste |
| Trainingssteuerung | patience, seed, deterministic, amp, cos_lr, close_mosaic, save_period |
| Datensatz | fraction, freeze, single_cls, rect, multi_scale, resume |
Die Parameter sind aufgabenabhängig (z. B. copy_paste wird nur bei Segmentierungsaufgaben angezeigt, pose/kobj nur bei Pose-Aufgaben). Ein Modifiziert-Abzeichen erscheint, wenn Werte von den Standardwerten abweichen, und du kannst alles mit der Reset-Taste auf die Standardwerte zurücksetzen.
Beispiel: Optimierung der Augmentierung für kleine Datensätze
Für kleine Datensätze (<1000 Bilder), erhöhe die Augmentierung, um Overfitting zu reduzieren:
mosaic: 1.0 # Keep mosaic on
mixup: 0.3 # Add mixup blending
copy_paste: 0.3 # Add copy-paste (segment only)
fliplr: 0.5 # Horizontal flip
degrees: 10.0 # Slight rotation
scale: 0.9 # Aggressive scalingLink to this sectionSchritt 5: GPU auswählen (Cloud-Tab)#
Wähle deine GPU aus der Ultralytics Cloud:

| GPU | Generation | VRAM | Kosten/Stunde | Am besten geeignet für |
|---|---|---|---|---|
| RTX 2000 Ada | Ada | 16 GB | $0.24 | Kleine Datensätze, Tests |
| RTX A4500 | Ampere | 20 GB | $0.25 | Kleine bis mittelgroße Datensätze |
| RTX 4000 Ada | Ada | 20 GB | $0.26 | Mittelgroße Datensätze |
| RTX A5000 | Ampere | 24 GB | $0.27 | Mittelgroße Datensätze |
| L4 | Ada | 24 GB | $0.39 | Optimiert für Inferenz |
| A40 | Ampere | 48 GB | $0.44 | Größere Batch-Größen |
| RTX 3090 | Ampere | 24 GB | $0.46 | Allgemeines Training |
| RTX A6000 | Ampere | 48 GB | $0.49 | Große Modelle |
| RTX PRO 4500 | Blackwell | 32 GB | $0.64 | Hervorragendes Preis-Leistungs-Verhältnis |
| RTX 4090 | Ada | 24 GB | $0.69 | Bestes Preis-Leistungs-Verhältnis |
| RTX 6000 Ada | Ada | 48 GB | $0.77 | Training mit großen Batches |
| L40S | Ada | 48 GB | $0.86 | Training mit großen Batches |
| RTX 5090 | Blackwell | 32 GB | $0.99 | Neueste Consumer-Generation |
| L40 | Ada | 48 GB | $0.99 | Große Modelle |
| A100 PCIe | Ampere | 80 GB | $1.39 | Produktionstraining |
| A100 SXM | Ampere | 80 GB | $1.49 | Produktionstraining |
| RTX PRO 6000 | Blackwell | 96 GB | $1.89 | Empfohlener Standard |
| H100 PCIe | Hopper | 80 GB | $2.39 | Hochleistungstraining |
| H100 SXM | Hopper | 80 GB | $2.99 | Schnellstes Training |
| H100 NVL | Hopper | 94 GB | $3.07 | Maximale Leistung |
| H200 NVL | Hopper | 143 GB | $3.39 | Maximaler Speicher |
| H200 SXM | Hopper | 141 GB | $3.99 | Maximale Leistung |
| B200 | Blackwell | 180 GB | $5.49 | Große Modelle (Pro+) |
| B300 | Blackwell | 288 GB | $7.39 | Größte Modelle (Pro+) |
- RTX PRO 6000: 96 GB Blackwell, empfohlener Standard für die meisten Jobs
- A100 SXM: 80 GB HBM2e – starke Wahl für große Batch-Größen oder größere Modelle
- H100 PCIe / H100 SXM / H100 NVL: 80–94 GB Hopper für zeitkritische Trainings (verfügbar in allen Tarifen)
- H200 NVL / H200 SXM: 141–143 GB Hopper für speicherintensive Workloads (verfügbar in allen Tarifen)
- B200 / B300: 180–288 GB NVIDIA Blackwell für modernste Workloads – erfordert Pro oder Enterprise
Der Dialog zeigt dein aktuelles Guthaben und eine Aufladen-Schaltfläche an. Geschätzte Kosten und Dauer werden basierend auf deiner Konfiguration berechnet (Modellgröße, Datensatzbilder, Epochen, GPU-Geschwindigkeit).
Link to this sectionSchritt 6: Training starten#
Klicke auf Training starten, um deinen Job zu starten. Die Plattform:
- Stellt eine GPU-Instanz bereit
- Lädt deinen Datensatz herunter
- Beginnt das Training
- Streamt Metriken in Echtzeit
Link to this sectionLebenszyklus eines Trainingsjobs#
Trainingsjobs durchlaufen die folgenden Status:
| Status | Beschreibung |
|---|---|
| Ausstehend | Job übermittelt, wartet auf GPU-Zuweisung |
| Startend | GPU bereitgestellt, Datensatz und Modell werden heruntergeladen |
| Läuft | Training in Bearbeitung, Metriken streamen in Echtzeit |
| Abgeschlossen | Training erfolgreich beendet |
| Fehlgeschlagen | Training fehlgeschlagen (siehe Konsolen-Logs für Details) |
| Abgebrochen | Training wurde vom Benutzer abgebrochen |
Neue Konten erhalten ein Startguthaben – 5 $ für persönliche E-Mails und 25 $ für Firmen-E-Mails. Überprüfe dein Guthaben unter Einstellungen > Abrechnung.

Link to this sectionTraining überwachen#
Sieh dir den Trainingsfortschritt in Echtzeit auf dem Tab Trainieren der Modellseite an:
Link to this sectionDiagramm-Subtab#

| Metrik | Beschreibung |
|---|---|
| Verlust | Trainings- und Validierungsverlust |
| mAP | Mittlere durchschnittliche Präzision |
| Präzision | Korrekte positive Vorhersagen |
| Recall | Erkannte Ground-Truth-Daten |
Link to this sectionKonsolen-Unterregisterkarte#
Live-Konsolenausgabe mit ANSI-Farbunterstützung, Fortschrittsbalken und Fehlererkennung.
Link to this sectionSystem-Unterregisterkarte#
GPU-Auslastung in Echtzeit, Speicher, Temperatur, CPU- und Festplattennutzung.
Link to this sectionCheckpoints#
Nach Abschluss des Trainings wird das beste Modell (best.pt, der Checkpoint mit der höchsten mAP) auf die Plattform hochgeladen und steht für Download, Export und Bereitstellung zur Verfügung.
Link to this sectionTraining abbrechen#
Klicke auf der Modellseite auf Training abbrechen, um einen laufenden Job zu stoppen:
- Die Compute-Instanz wird beendet
- Credits werden nicht mehr abgerechnet
- Der beste Checkpoint bleibt verfügbar, falls er vor dem Abbruch erreicht wurde
Link to this sectionRemote-Training#
graph LR
A[Local GPU] --> B[Train]
B --> C[ultralytics Package]
C --> D[Stream Metrics]
D --> E[Platform Dashboard]
style A fill:#FF9800,color:#fff
style C fill:#2196F3,color:#fff
style E fill:#4CAF50,color:#fffTrainiere auf deiner eigenen Hardware, während Metriken an die Plattform gestreamt werden.
Die Plattform-Integration erfordert ultralytics>=8.4.60. Ältere Versionen funktionieren NICHT mit der Plattform.
pip install -U ultralyticsLink to this sectionAPI-Schlüssel einrichten#
- Go to
Settings > API Keys - Erstelle einen neuen Schlüssel (oder die Plattform erstellt automatisch einen, wenn du die Registerkarte für lokales Training öffnest)
- Setze die Umgebungsvariable:
export ULTRALYTICS_API_KEY="YOUR_API_KEY"Link to this sectionTraining mit Streaming#
Verwende die Parameter project und name, um Metriken zu streamen:
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1Die Registerkarte Lokales Training im Trainingsdialog zeigt einen vorkonfigurierten Befehl mit deinem API-Schlüssel, ausgewählten Parametern und enthaltenen erweiterten Argumenten.
Link to this sectionPlattform-Datensätze verwenden#
Trainiere mit Datensätzen, die auf der Plattform gespeichert sind, unter Verwendung des ul:// URI-Formats:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1Das ul:// URI-Format lädt deinen Datensatz automatisch herunter und konfiguriert ihn. Das Modell wird automatisch mit dem Datensatz auf der Plattform verknüpft (siehe Plattform-Datensätze verwenden).
Link to this sectionAbrechnung#
Die Trainingskosten basieren auf der GPU-Nutzung:
Link to this sectionKostenschätzung#
Vor Beginn des Trainings schätzt die Plattform die Gesamtkosten durch:
- Schätzung der Sekunden pro Epoche basierend auf Datensatzgröße, Modellkomplexität, Bildgröße, Batch-Größe und GPU-Geschwindigkeit
- Berechnung der gesamten Trainingszeit durch Multiplikation der Sekunden pro Epoche mit der Anzahl der Epochen, zuzüglich Start-Overhead
- Berechnung der geschätzten Kosten aus den gesamten Trainingsstunden multipliziert mit dem Stundensatz der GPU
Faktoren, die die Kosten beeinflussen:
| Faktor | Auswirkung |
|---|---|
| Datensatzgröße | Mehr Bilder = längere Trainingszeit (Rechenaufwand skaliert ungefähr linear mit der Datensatzgröße) |
| Modellgröße | Größere Modelle (m, l, x) trainieren langsamer als (n, s) |
| Anzahl der Epochen | Direkter Multiplikator für die Trainingszeit |
| Bildgröße | Größere imgsz erhöht die Berechnung: 320px=0,25x, 640px=1,0x (Basislinie), 1280px=4,0x |
| Batch-Größe | Größere Batches sind effizienter (Batch 32 = ~0,85x Zeit, Batch 8 = ~1,2x Zeit im Vergleich zur 16er Batch-Basislinie) |
| GPU-Geschwindigkeit | Schnellere GPUs verkürzen die Trainingszeit (z. B. H100 SXM = ~3,4x schneller als RTX 4090) |
| Start-Overhead | Bis zu 5 Minuten für Instanzinitialisierung, Datendownload und Warmup (skaliert mit der Datensatzgröße) |
Link to this sectionKostenbeispiele#
Kostenschätzungen sind annähernd und hängen von vielen Faktoren ab. Der Trainingsdialog zeigt eine Echtzeitschätzung, bevor du mit dem Training beginnst.
| Szenario | GPU | Geschätzte Kosten |
|---|---|---|
| 500 Bilder, YOLO26n, 50 Epochen | RTX 4090 | ~$0,03 |
| 1000 Bilder, YOLO26n, 100 Epochen | RTX PRO 6000 | ~$0,27 |
| 5000 Bilder, YOLO26s, 100 Epochen | H100 SXM | ~$1,75 |
Link to this sectionAbrechnungsablauf#
graph LR
A[Estimate Cost] --> B[Balance Check]
B --> C[Train]
C --> D[Charge Actual Runtime]
style A fill:#2196F3,color:#fff
style B fill:#FF9800,color:#fff
style C fill:#9C27B0,color:#fff
style D fill:#4CAF50,color:#fffAbrechnungsablauf für Cloud-Training:
- Schätzung: Kosten werden vor Trainingsbeginn berechnet
- Guthabenprüfung: Verfügbare Credits werden vor dem Start überprüft
- Training: Job läuft auf der ausgewählten Compute-Instanz
- Abrechnung: Endgültige Kosten basieren auf der tatsächlichen Laufzeit
Die Abrechnung verfolgt die tatsächliche Compute-Nutzung, einschließlich abgebrochener Teilausführungen. Fehlgeschlagene Trainingsläufe werden dir niemals berechnet.
Link to this sectionAbrechnung nach Jobstatus#
| Status | Berechnet? |
|---|---|
| Abgeschlossen | Ja — tatsächlich genutzte GPU-Zeit |
| Abgebrochen | Ja — GPU-Zeit vom Start bis zum Abbruch |
| Fehlgeschlagen | Nein — fehlgeschlagene Läufe werden nicht berechnet |
| Feststeckend | Teilweise — nur die tatsächliche Trainingszeit wird berechnet |
Wenn ein Trainingslauf aufgrund eines Konfigurationsfehlers, eines Speicherproblems oder eines anderen Fehlers fehlschlägt, werden dir keine Kosten berechnet. Nur die erfolgreiche Rechenzeit wird in Rechnung gestellt. Feststeckende Jobs (keine Aktivität für 4+ Stunden) werden automatisch beendet und nur für die Zeit berechnet, in der die GPU tatsächlich trainiert hat, nicht für die Leerlaufzeit.
Link to this sectionZahlungsmethoden#
| Methode | Beschreibung |
|---|---|
| Kontostand | Vorausbezahlte Credits |
| Bezahlung pro Job | Abrechnung bei Abschluss des Jobs |
Der Start des Trainings erfordert ein positives Guthaben und ausreichend Credits für die geschätzten Jobkosten.
Link to this sectionTrainingskosten einsehen#
Nach dem Training kannst du die detaillierten Kosten in der Registerkarte Abrechnung einsehen:
- Kostenaufschlüsselung pro Epoche
- Gesamte GPU-Zeit
- Kostenbericht herunterladen

Link to this sectionTipps für das Training#
Link to this sectionWähle die richtige Modellgröße#
| Modell | Parameter | Am besten geeignet für |
|---|---|---|
| YOLO26n | 2,4M | Echtzeit, Edge-Geräte |
| YOLO26s | 9,5M | Ausgewogenes Verhältnis von Geschwindigkeit/Genauigkeit |
| YOLO26m | 20,4M | Höhere Genauigkeit |
| YOLO26l | 24,8 Mio. | Produktionsgenauigkeit |
| YOLO26x | 55,7 Mio. | Maximale Genauigkeit |
Link to this sectionTrainingszeit optimieren#
- Klein anfangen: Teste mit 10-20 Epochen auf einer kostengünstigen GPU, um zu überprüfen, ob dein Datensatz und deine Konfiguration funktionieren.
- Geeignete GPU verwenden: Die RTX PRO 6000 bewältigt die meisten Arbeitslasten gut.
- Datensatz validieren: Behebe Kennzeichnungsprobleme, bevor du Geld für das Training ausgibst.
- Frühzeitig überwachen: Brich das Training ab, wenn der Verlust stagniert – du zahlst nur für die tatsächlich genutzte Rechenzeit.
Link to this sectionFehlerbehebung#
| Problem | Lösung |
|---|---|
| Training bei 0 % hängen geblieben | Datensatzformat prüfen, erneut versuchen |
| Arbeitsspeicher voll | Batch-Größe reduzieren oder größere GPU verwenden |
| Geringe Genauigkeit | Epochen erhöhen, Datenqualität prüfen |
| Training langsam | Schnellere GPU in Betracht ziehen |
| Fehler bei der Aufgaben-Zuordnung | Stelle sicher, dass Modell- und Datensatzaufgaben übereinstimmen |
Link to this sectionFAQ#
Link to this sectionWie lange dauert das Training?#
Die Trainingsdauer hängt ab von:
- Datensatzgröße
- Modellgröße
- Anzahl der Epochen
- Ausgewählte GPU
Typische Zeiten (1000 Bilder, 100 Epochen):
| Modell | RTX PRO 6000 | A100 SXM |
|---|---|---|
| YOLO26n | ~8 Min. | ~7 Min. |
| YOLO26m | ~16 Min. | ~13 Min. |
| YOLO26x | ~27 Min. | ~22 Min. |
Trainingszeiten sind Näherungswerte und variieren je nach Komplexität des Datensatzes, Augmentierungseinstellungen und Batch-Größe. Verwende die Kostenschätzung im Trainingsdialog für genauere Prognosen.
Link to this sectionKann ich über Nacht trainieren?#
Ja, das Training läuft bis zum Abschluss weiter. Du erhältst eine Benachrichtigung, wenn das Training beendet ist. Stelle sicher, dass dein Konto über ausreichend Guthaben für das epochenbasierte Training verfügt.
Link to this sectionWas passiert, wenn mein Guthaben aufgebraucht ist?#
Wenn dein Guthaben während eines Trainingslaufs auf null fällt, läuft das Training bis zum Abschluss weiter und dein Kontostand wird negativ. Dies stellt sicher, dass dein Trainingsauftrag nicht mittendrin unterbrochen wird.
Nach Abschluss des Trainings musst du Guthaben aufladen, um dein Konto wieder auf einen positiven Stand zu bringen, bevor du neue Trainingsaufträge startest. Dein fertiggestelltes Modell, die Checkpoints und alle Trainingsartefakte bleiben unabhängig vom Kontostand vollständig erhalten.
Ein negativer Kontostand verhindert lediglich den Start neuer Trainingsaufträge. Bestehende Deployments und andere Plattformfunktionen funktionieren weiterhin normal. Lade Guthaben über Einstellungen > Abrechnung auf oder aktiviere automatische Aufladung, um Unterbrechungen zu vermeiden.
Link to this sectionWas passiert, wenn mein Training mehr kostet als geschätzt?#
Kostenschätzungen sind Richtwerte – die tatsächliche Trainingszeit kann aufgrund von Faktoren wie Datenladegeschwindigkeit, GPU-Aufwärmphase und Modellkonvergenzverhalten variieren. Wenn die tatsächlichen Kosten die Schätzung übersteigen, kann dein Kontostand negativ werden (siehe oben). Die Plattform stoppt das Training nicht basierend auf der Schätzung.
So verwaltest du die Kosten:
- Überwache den Trainingsfortschritt in Echtzeit und brich bei Bedarf frühzeitig ab
- Aktiviere automatische Aufladung, um Guthaben automatisch aufzufüllen
- Starte mit kürzeren Läufen (weniger Epochen), um die Erwartungen zu kalibrieren
Link to this sectionKann ich benutzerdefinierte Trainingsargumente verwenden?#
Ja, erweitere den Bereich Erweiterte Einstellungen im Trainingsdialog, um auf einen YAML-Editor mit über 40 konfigurierbaren Parametern zuzugreifen. Nicht-Standardwerte werden sowohl in Cloud- als auch in lokalen Trainingsbefehlen berücksichtigt.
Der YAML-Editor unterstützt auch den Import von Konfigurationen aus früheren Trainingsläufen:
- Von vorhandenem Modell kopieren: Auf der Seite jedes abgeschlossenen Modells befindet sich auf der Karte "Trainingskonfiguration" eine Schaltfläche Als JSON kopieren. Kopiere das JSON und füge es direkt in den YAML-Editor ein – das Format wird automatisch erkannt und alle Parameter werden importiert.
- YAML oder JSON einfügen: Füge eine beliebige gültige YAML- oder JSON-Trainingskonfiguration in den Editor ein. Die Parameter werden automatisch validiert, Werte außerhalb des Bereichs werden korrigiert und Warnungen werden angezeigt.
- Dateien per Drag-and-Drop: Ziehe eine
.yaml- oder.json-Datei direkt in den Editor, um deren Parameter zu importieren.

Dies macht es einfach, frühere Trainingskonfigurationen zu reproduzieren oder zu iterieren, ohne jeden Parameter manuell neu eingeben zu müssen.
Link to this sectionKann ich von einer Datensatzseite aus trainieren?#
Ja, die Schaltfläche Trainieren auf Datensatzseiten öffnet den Trainingsdialog, wobei der Datensatz vorausgewählt und gesperrt ist. Du wählst dann ein Projekt und ein Modell aus, um das Training zu starten.
Link to this sectionReferenz der Trainingsparameter#
| Parameter | Typ | Standard | Bereich | Beschreibung |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Anzahl der Trainingsepochen |
batch | int | -1 (auto) | -1 bis 512 | Batch-Größe (-1 = automatische Anpassung an verfügbaren VRAM) |
imgsz | int | 640 | 32-4096 | Eingabebildgröße |
patience | int | 100 | 1-1000 | Patience für frühzeitigen Abbruch |
seed | int | 0 | 0-2147483647 | Zufälliger Startwert für Reproduzierbarkeit |
deterministic | bool | True | - | Deterministischer Trainingsmodus |
amp | bool | True | - | Automatische gemischte Präzision |
close_mosaic | int | 10 | 0-50 | Deaktiviere Mosaic in den letzten N Epochen |
save_period | int | -1 | -1-100 | Speichere Checkpoint alle N Epochen |
workers | int | 8 | 0-64 | Dataloader-Worker |
cache | auswählen | false | ram/disk/false | Bilder zwischenspeichern |
Einige Parameter gelten nur für spezifische Aufgaben:
- Nur für Erkennungsaufgaben (detect, segment, pose, OBB — nicht classify):
box,dfl,degrees,translate,shear,perspective,mosaic,mixup,close_mosaic - Nur für Segmentierung:
copy_paste - Nur für Pose:
pose(Verlustgewichtung),kobj(Keypoint-Objekthaftigkeit)