Cloud-Training
Ultralytics Platform Cloud-Training bietet Training mit einem Klick auf Cloud-GPUs, wodurch das Modelltraining ohne komplexe Einrichtung zugänglich wird. Trainieren Sie 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:#fff
Schulungsdialog
Starten Sie das Training über die Plattform-Benutzeroberfläche, indem Sie auf einer beliebigen Projektseite auf „Neues Modell “ klicken (oder auf einer Datensatzseite auf „Trainieren“ ). Der Trainingsdialog verfügt über zwei Registerkarten: „Cloud-Training “ und „Lokales Training“.

Schritt 1: Basismodell auswählen
Wählen Sie aus offiziellen YOLO26-Modellen oder Ihren eigenen trainierten Modellen:
| Kategorie | Beschreibung |
|---|---|
| Offiziell | Alle 25 YOLO26-Modelle (5 Größen x 5 Aufgaben) |
| Ihre Modelle | Ihre fertigen Modelle für die Feinabstimmung |
Offizielle Modelle sind nach Aufgabentyp (Erkennen, Segmentieren, Pose, OBB, Klassifizieren) mit Größen von Nano bis XL organisiert.
Schritt 2: Datensatz auswählen
Wählen Sie einen Datensatz zum Trainieren (siehe Datensätze):
| Option | Beschreibung |
|---|---|
| Offiziell | Kuratierte Datensätze von Ultralytics |
| Ihre Datensätze | Von Ihnen hochgeladene Datensätze |
Datensatzanforderungen
Datensätze müssen in ready Status mit mindestens 1 Bild im Trainingssatz, 1 Bild im Validierungs- oder Testsatz und mindestens 1 beschriftetem Bild.
Aufgabeninkongruenz
Eine Warnung bei Aufgabenkonflikt erscheint, wenn die Modellaufgabe (z.B. detect) nicht mit der Datensatzaufgabe (z.B. segment) übereinstimmt. Das Training schlägt fehl, wenn Sie mit nicht übereinstimmenden Aufgaben fortfahren. Stellen Sie sicher, dass sowohl Modell als auch Datensatz denselben Aufgabentyp verwenden, wie in den Aufgabenleitfäden beschrieben.
Schritt 3: Parameter konfigurieren
Kern-Trainingsparameter festlegen:
| Parameter | Beschreibung | Standard |
|---|---|---|
| Epochen | Anzahl der Trainingsiterationen | 100 |
| Batch-Größe | Samples pro Iteration | 16 |
| Bildgröße | Eingabeauflösung (320/416/512/640/1280 Dropdown-Menü oder 32-4096 im YAML-Editor) | 640 |
| Laufname | Optionaler Name für den Trainingslauf | Auto |
Schritt 4: Erweiterte Einstellungen (optional)
Erweitern Sie die erweiterten Einstellungen, um auf den vollständigen YAML-basierten Parametereditor mit über 40 nach Gruppen geordneten Trainingsparametern zuzugreifen (siehe Konfigurationsreferenz):
| Gruppe | Parameter |
|---|---|
| Lernrate | lr0, lrf, Momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Optimierer | SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Verlustgewichte | Box, Cls, DFL, Pose, Kobj, Label-Smoothing |
| Farbaugmentierung | hsv_h, hsv_s, hsv_v |
| Geometrische Erweiterung. | Grad, verschieben, skalieren, scheren, Perspektive |
| Flip & Mix Augment. | Flipud, Fliplr, Mosaik, Mixup, Kopieren_Einfügen |
| Trainingssteuerung | Geduld, Samen, deterministisch, Verstärker, cos_lr, close_mosaic, save_period |
| Datensatz | Fraktion, Einfrieren, single_cls, rechteckig, multi_scale, Fortsetzen |
Parameter sind aufgabenbezogen (z. B. copy_paste nur für segment anzeigen, pose/kobj nur für Posenaufgaben). A Geändert Ein Badge erscheint, wenn Werte von den Standardeinstellungen abweichen, und Sie können alle mit der Reset-Taste auf die Standardwerte zurücksetzen.
Beispiel: Tuning-Erweiterung für kleine Datensätze
For small datasets (<1000 images), increase augmentation to reduce overfitting:
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 scaling
Schritt 5: GPU auswählen GPU Registerkarte „Cloud“)
Wählen Sie Ihre 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, zum Testen |
| RTX A4500 | Ampere | 20 GB | $0.25 | Kleine bis mittlere Datensätze |
| RTX 4000 Ada | Ada | 20 GB | $0.26 | Mittlere Datensätze |
| RTX A5000 | Ampere | 24 GB | $0.27 | Mittlere Datensätze |
| L4 | Ada | 24 GB | $0.39 | Für Inferenz optimiert |
| A40 | Ampere | 48 GB | $0.40 | 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.54 | Hervorragendes Preis-Leistungs-Verhältnis |
| RTX 4090 | Ada | 24 GB | $0.59 | 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.89 | 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.69 | Empfohlener Standard |
| H100 PCIe | Hopper | 80 GB | $2.39 | Hochleistungs-Training |
| H100 SXM | Hopper | 80 GB | $2.69 | Schnellstes Training |
| H100 NVL | Hopper | 94 GB | $3.07 | Maximale Leistung |
| H200 NVL | Hopper | 143 GB | $3.39 | Maximaler Speicher (Pro+) |
| H200 SXM | Hopper | 141 GB | $3.59 | Maximale Leistung (Pro+) |
| B200 | Blackwell | 180 GB | $4.99 | Größte Modelle (Pro+) |
GPU-Auswahl
- RTX PRO 6000: 96 GB Blackwell-Generation, empfohlener Standard für die meisten Aufgaben.
- A100 SXM: Erforderlich für große Batch-Größen oder große Modelle
- H100/H200: Maximale Leistung für zeitkritisches Training (H200 erfordert Pro oder Enterprise)
- B200: NVIDIA Blackwell-Architektur für hochmoderne Workloads (erfordert Pro oder Enterprise)
Der Dialog zeigt Ihren aktuellen Kontostand und eine Schaltfläche „Aufladen“ an. Die geschätzten Kosten und die Dauer werden auf Grundlage Ihrer Konfiguration (Modellgröße, Datensatzbilder, Epochen, GPU ) berechnet.
Schritt 6: Mit dem Training beginnen
Klicken Sie auf Training starten, um Ihren Job zu starten. Die Plattform:
- Stellt eine GPU-Instanz bereit
- Lädt Ihren Datensatz herunter
- Beginnt das Training
- Streamt Metriken in Echtzeit
Ausbildungsjob-Lebenszyklus
Schulungsaufträge durchlaufen die folgenden Status:
| Status | Beschreibung |
|---|---|
| Ausstehend | Auftrag übermittelt, warte auf GPU |
| Beginn | GPU , Datensatz und Modell werden heruntergeladen |
| Laufen | Training läuft, Messwerte werden in Echtzeit übertragen |
| Abgeschlossen | Die Schulung wurde erfolgreich abgeschlossen. |
| Fehlgeschlagen | Training fehlgeschlagen (Details siehe Konsolenprotokolle) |
| Abgebrochen | Das Training wurde vom Benutzer abgesagt. |
Kostenlose Credits
Neue Konten erhalten Anmelde-Gutschriften – 5 $ für private E-Mail-Adressen und 25 $ für geschäftliche E-Mail-Adressen. Überprüfen Sie Ihren Kontostand unter „Einstellungen“ > „Abrechnung“.

Training überwachen
Zeigen Sie den Trainingsfortschritt in Echtzeit auf der Registerkarte „Trainieren“ der Modellseite an:
Diagramm-Unterregisterkarte

| Metrik | Beschreibung |
|---|---|
| Verlust | Trainings- und Validierungsverlust |
| mAP | Mittlere durchschnittliche Präzision |
| Präzision | Korrekte positive Vorhersagen |
| Recall | Erkannte Ground Truths |
Konsolen-Unterregisterkarte
Live-Konsolenausgabe mit ANSI-Farbunterstützung, Fortschrittsbalken und Fehlererkennung.
System-Unterregisterkarte
GPU , Speicher, Temperatur, CPU und Festplattennutzung.
Checkpoints
Checkpoints werden automatisch gespeichert:
- Jede Epoche: Neueste Gewichte gespeichert
- Bestes Modell: Checkpoint mit höchstem mAP beibehalten
- Endgültiges Modell: Gewichte nach Abschluss des Trainings
Training abbrechen
Klicken Sie auf der Modellseite auf Training abbrechen, um einen laufenden Job zu beenden:
- Die Recheninstanz wird beendet.
- Guthaben wird nicht mehr berechnet
- Bis zu diesem Zeitpunkt gespeicherte Checkpoints bleiben erhalten
Remote-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:#fff
Trainieren Sie auf Ihrer eigenen Hardware, während Sie Metriken an die Plattform streamen.
Anforderung an die Paketversion
Für die Plattformintegration ist ultralytics>=8.4.14 erforderlich. Niedrigere Versionen funktionieren NICHT mit der Plattform.
pip install -U ultralytics
API-Schlüssel einrichten
- Gehen Sie zu
Settings > Profile(Abschnitt API-Schlüssel) - Erstellen Sie einen neuen Schlüssel (oder die Plattform erstellt automatisch einen, wenn Sie den Tab „Lokales Training“ öffnen)
- Setzen Sie die Umgebungsvariable:
export ULTRALYTICS_API_KEY="YOUR_API_KEY"
Training mit Streaming
Verwenden Sie den project und name Parameter zum Streamen von Metriken:
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="coco.yaml",
epochs=100,
project="username/my-project",
name="experiment-1",
)
Die Registerkarte „Lokale Schulung“ im Schulungsdialogfeld zeigt einen vorkonfigurierten Befehl mit Ihrem API-Schlüssel, ausgewählten Parametern und erweiterten Argumenten an.
Nutzung von Plattform-Datensätzen
Trainieren Sie mit Datensätzen, die auf der Plattform gespeichert sind, unter Verwendung der ul:// URI-Format:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="ul://username/datasets/my-dataset",
epochs=100,
project="username/my-project",
name="exp1",
)
Die ul:// Das URI-Format lädt Ihren Datensatz automatisch herunter und konfiguriert ihn. Das Modell wird automatisch mit dem Datensatz auf der Plattform verknüpft (siehe Nutzung von Plattform-Datensätzen), oder Auto-Modus mit angegebener Auslastungsfraktion (
Abrechnung
Trainingskosten basieren auf der GPU-Nutzung:
Kostenvoranschlag
Bevor das Training beginnt, schätzt die Plattform die Gesamtkosten durch:
- Schätzung der Sekunden pro Epoche anhand von 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 und anschließendes Hinzufügen des Start-Overheads
- Berechnung der geschätzten Kosten aus der Gesamtzahl der Trainingsstunden multipliziert mit dem Stundensatz der GPU
Faktoren, die die Kosten beeinflussen:
| Faktor | Auswirkung |
|---|---|
| Datensatzgröße | Mehr Bilder = längere Trainingszeit (Ausgangswert: ~2,8 Sekunden Rechenzeit pro 1000 Bilder auf RTX 4090) |
| Modellgröße | Größere Modelle (m, l, x) trainieren langsamer als (n, s). |
| Anzahl der Epochen | Direkter Multiplikator für die Ausbildungszeit |
| Bildgröße | Größere Bildgrößen erhöhen den Rechenaufwand: 320px=0,25x, 640px=1,0x (Basiswert), 1280px=4,0x |
| Batch-Größe | Größere Chargen sind effizienter (Charge 32 = ~0,85-fache Zeit, Charge 8 = ~1,2-fache Zeit im Vergleich zur Basislinie Charge 16). |
| GPU | Schnellere GPUs verkürzen die Trainingszeit (z. B. H100 SXM = ~3,4-mal schneller als RTX 4090) |
| Startup-Overhead | Bis zu 5 Minuten für die Initialisierung, den Daten-Download und das Aufwärmen (abhängig von der Größe des Datensatzes) |
Kostenbeispiele
Schätzungen
Kostenkalkulationen sind Schätzwerte und hängen von vielen Faktoren ab. Der Trainingsdialog zeigt eine Echtzeit-Schätzung an, bevor Sie das Training starten.
| Szenario | GPU | Geschätzte Kosten |
|---|---|---|
| 500 Bilder, YOLO26n, 50 Epochen | RTX 4090 | ~0,50 $ |
| 1000 Bilder, YOLO26n, 100 Epochen | RTX PRO 6000 | ~5 $ |
| 5000 Bilder, YOLO26s, 100 Epochen | H100 SXM | ~23 $ |
Abrechnungsfluss
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:#fff
Abrechnungsprozess für Cloud-Training:
- Schätzung: Kosten werden vor Beginn der Schulung berechnet
- Guthabenprüfung: Verfügbare Credits werden vor dem Start geprüft
- Trainieren: Der Job läuft auf dem ausgewählten Compute.
- Kosten: Die endgültigen Kosten basieren auf der tatsächlichen Laufzeit
Verbraucherschutz
Die Abrechnung erfasst die tatsächliche Computenutzung, einschließlich abgebrochener Teilausführungen. Für fehlgeschlagene Trainingsläufe werden Ihnen niemals Kosten berechnet.
Abrechnung nach Job-Status
| Status | Berechnet? |
|---|---|
| Abgeschlossen | Ja – tatsächlich genutzte GPU |
| Abgebrochen | Ja – GPU vom Start bis zur Abbruch |
| Fehlgeschlagen | Nein – fehlgeschlagene Läufe werden nicht berechnet |
| Festgefahren | Teilweise – es wird nur die tatsächliche Schulungszeit in Rechnung gestellt |
Keine Kosten bei Fehlern
Sollte ein Trainingslauf aufgrund eines Konfigurationsfehlers, eines Speicherengpasses oder eines anderen Fehlers fehlschlagen, fallen für Sie keine Kosten an. Es wird nur die erfolgreiche Rechenzeit in Rechnung gestellt. Blockierte Jobs (keine Aktivität seit mehr als 4 Stunden) werden automatisch beendet und nur für die Zeit abgerechnet, in der die GPU aktiv trainiert GPU , nicht für die Leerlaufzeit.
Zahlungsmethoden
| Methode | Beschreibung |
|---|---|
| Kontostand | Vorgeladene Guthaben |
| Zahlung pro Auftrag | Abrechnung nach Auftragsabschluss |
Mindestguthaben
Der Trainingsstart erfordert ein positives Guthaben und ausreichend Credits für die geschätzten Auftragskosten.
Trainingskosten anzeigen
Nach dem Training können Sie detaillierte Kosten im Tab Abrechnung einsehen:
- Kostenaufschlüsselung pro Epoche
- Gesamte GPU-Zeit
- Kostenbericht herunterladen

Trainingstipps
Die richtige Modellgröße wählen
| Modell | Parameter | Am besten geeignet für |
|---|---|---|
| YOLO26n | 2.4M | Echtzeit, Edge-Geräte |
| YOLO26s | 9.5M | Ausgewogene Geschwindigkeit/Genauigkeit |
| YOLO26m | 20.4M | Höhere Genauigkeit |
| YOLO26l | 24.8M | Produktionsgenauigkeit |
| YOLO26x | 55.7M | Maximale Genauigkeit |
Trainingszeit optimieren
Strategien zur Kosteneinsparung
- Klein anfangen: Testen Sie mit 10-20 Epochen auf einer preisgünstigen GPU, um zu überprüfen, ob Ihr Dataset und Ihre Konfiguration funktionieren.
- Geeignete GPU verwenden: Die RTX PRO 6000 bewältigt die meisten Arbeitslasten gut.
- Datensatz validieren: Beheben Sie Beschriftungsprobleme, bevor Sie in das Training investieren.
- Frühzeitig überwachen: Training abbrechen, wenn der Verlust stagniert — Sie zahlen nur für die genutzte Rechenzeit
Fehlerbehebung
| Problem | Lösung |
|---|---|
| Training bei 0% festgefahren | Datensatzformat prüfen, erneut versuchen |
| Nicht genügend Arbeitsspeicher | 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 aufgrund einer Aufgabeninkongruenz | Sicherstellen, dass Modell- und Datensatzaufgaben übereinstimmen |
FAQ
Wie lange dauert das Training?
Die Trainingszeit 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 | ~20 Minuten | ca. 15 Min. |
| YOLO26m | ca. 40 Min. | ca. 30 Min. |
| YOLO26x | ca. 80 Min. | ca. 60 Min. |
Ungefähre Zeiten
Die Trainingszeiten sind ungefähre Angaben und hängen von der Komplexität des Datensatzes, den Augmentierungseinstellungen und der Batchgröße ab. Für genauere Vorhersagen nutzen Sie die Kostenschätzung im Trainingsdialog.
Kann ich über Nacht trainieren?
Ja, das Training wird bis zum Abschluss fortgesetzt. Sie erhalten eine Benachrichtigung, wenn das Training beendet ist. Stellen Sie sicher, dass Ihr Konto über ausreichend Guthaben für das epochenbasierte Training verfügt.
Was passiert, wenn meine Credits aufgebraucht sind?
Wenn Ihr Guthaben während eines Trainingslaufs auf null sinkt, wird das Training bis zum Ende fortgesetzt und Ihr Guthaben wird negativ. Dadurch wird sichergestellt, dass Ihr Trainingsauftrag niemals mitten im Lauf unterbrochen wird.
Nach Abschluss des Trainings müssen Sie Guthaben hinzufügen, um Ihr Konto wieder ins Positive zu bringen, bevor Sie neue Trainingsjobs starten können. Ihr fertiges Modell, Checkpoints und alle Trainingsartefakte bleiben unabhängig vom Kontostand vollständig erhalten.
Negativer Saldo
Ein negatives Guthaben verhindert lediglich das Starten neuer Trainingsaufträge. Bestehende Bereitstellungen und andere Plattformfunktionen funktionieren weiterhin normal. Fügen Sie Guthaben über Einstellungen > Abrechnung hinzu oder aktivieren Sie die automatische Aufladung, um Unterbrechungen zu vermeiden.
Was passiert, wenn meine Schulung teurer wird als veranschlagt?
Kostenkalkulationen sind Schätzwerte — die tatsächliche Trainingszeit kann aufgrund von Faktoren wie Datenladegeschwindigkeit, GPU-Aufwärmphase und Modellkonvergenzverhalten variieren. Wenn die tatsächlichen Kosten die Schätzung überschreiten, kann Ihr Guthaben negativ werden (siehe oben). Die Plattform stoppt das Training nicht basierend auf der Schätzung.
Zur Kostenkontrolle:
- Verfolgen Sie den Trainingsfortschritt in Echtzeit und brechen Sie das Training bei Bedarf vorzeitig ab
- Aktivieren Sie die automatische Aufladung, um Ihr Guthaben automatisch aufzufüllen
- Beginnen Sie mit kürzeren Durchläufen (weniger Epochen), um die Erwartungen abzustimmen
Kann ich benutzerdefinierte Trainingsargumente verwenden?
Ja, erweitern Sie den Abschnitt „Erweiterte Einstellungen“ im Trainingsdialog, um auf einen YAML-Editor mit über 40 konfigurierbaren Parametern zuzugreifen. Nicht standardmäßige Werte sind sowohl in Cloud- als auch in lokalen Trainingsbefehlen enthalten.
Der YAML-Editor unterstützt zudem das Importieren von Konfigurationen aus früheren Trainingsläufen:
- Aus bestehendem Modell kopieren: Auf der Seite eines beliebigen abgeschlossenen Modells befindet sich auf der Karte „Trainingskonfiguration“ eine Schaltfläche Als JSON kopieren. Kopieren Sie das JSON und fügen Sie es direkt in den YAML-Editor ein – dieser erkennt das JSON-Format automatisch und importiert alle Parameter.
- YAML oder JSON einfügen: Fügen Sie eine beliebige gültige YAML- oder JSON-Trainingskonfiguration in den Editor ein. Parameter werden automatisch validiert, wobei Werte außerhalb des Bereichs begrenzt und Warnungen angezeigt werden.
- Dateien ziehen und ablegen: Ziehen Sie eine
.yamloder.jsonDatei direkt in den Editor einfügen, um deren Parameter zu importieren.

Dadurch lassen sich frühere Trainingskonfigurationen leicht reproduzieren oder weiterentwickeln, ohne dass jeder Parameter manuell erneut eingegeben werden muss.
Kann ich von einer Datensatzseite aus trainieren?
Ja, die Schaltfläche „Trainieren“ auf den Datensatzseiten öffnet den Trainingsdialog, wobei der Datensatz bereits ausgewählt und gesperrt ist. Anschließend wählen Sie ein Projekt und ein Modell aus, um mit dem Training zu beginnen.
Trainingsparameter-Referenz
| Parameter | Typ | Standard | Bereich | Beschreibung |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Anzahl der Trainingsepochen |
batch | int | 16 | 1-512 | Batch-Größe |
imgsz | int | 640 | 32-4096 | Eingabebildgröße |
patience | int | 100 | 1-1000 | Patience für Early Stopping |
seed | int | 0 | 0-2147483647 | Zufallszahl für Reproduzierbarkeit |
deterministic | bool | Wahr | - | Deterministischer Trainingsmodus |
amp | bool | Wahr | - | Automatische gemischte Präzision |
close_mosaic | int | 10 | 0-50 | Mosaik in den letzten N Epochen deaktivieren |
save_period | int | -1 | -1-100 | Speichere Checkpoint alle N Epochen |
workers | int | 8 | 0-64 | Dataloader-Worker |
cache | auswählen | falsch | RAM/Disk/falsch | Bilder cachen |
| Parameter | Typ | Standard | Bereich | Beschreibung |
|---|---|---|---|---|
lr0 | float | 0.01 | 0.0001-0.1 | Anfängliche Lernrate |
lrf | float | 0.01 | 0.01-1.0 | Finaler LR-Faktor |
momentum | float | 0.937 | 0.6-0.98 | SGD-Momentum |
weight_decay | float | 0.0005 | 0.0-0.001 | L2-Regularisierung |
warmup_epochs | float | 3.0 | 0-5 | Warmup-Epochen |
warmup_momentum | float | 0.8 | 0.5-0.95 | Aufwärmphase |
warmup_bias_lr | float | 0.1 | 0.0-0.2 | Aufwärm-Bias LR |
cos_lr | bool | Falsch | - | Cosine-LR-Scheduler |
| Parameter | Typ | Standard | Bereich | Beschreibung |
|---|---|---|---|---|
hsv_h | float | 0.015 | 0.0-0.1 | HSV-Farbton-Augmentierung |
hsv_s | float | 0.7 | 0.0-1.0 | HSV-Sättigung |
hsv_v | float | 0.4 | 0.0-1.0 | HSV-Wert |
degrees | float | 0.0 | -45-45 | Rotationsgrad |
translate | float | 0.1 | 0.0-1.0 | Translationsfraktion |
scale | float | 0.5 | 0.0-1.0 | Skalierungsfaktor |
shear | float | 0.0 | -10-10 | Schergrade |
perspective | float | 0.0 | 0.0-0.001 | Perspektivische Transformation |
fliplr | float | 0.5 | 0.0-1.0 | Horizontale Spiegelungswahrscheinlichkeit |
flipud | float | 0.0 | 0.0-1.0 | Vertikale Spiegelungswahrscheinlichkeit |
mosaic | float | 1.0 | 0.0-1.0 | Mosaic-Augmentierung |
mixup | float | 0.0 | 0.0-1.0 | MixUp-Augmentierung |
copy_paste | float | 0.0 | 0.0-1.0 | Copy-Paste (segment) |
| Parameter | Typ | Standard | Bereich | Beschreibung |
|---|---|---|---|---|
fraction | float | 1.0 | 0.1-1.0 | Zu verwendender Teil des Datensatzes |
freeze | int | null | 0-100 | Anzahl der zu gefrierenden Schichten |
single_cls | bool | Falsch | - | Behandeln Sie alle Klassen als eine Klasse. |
rect | bool | Falsch | - | Rechteckiges Training |
multi_scale | float | 0.0 | 0.0-1.0 | Mehrstufiger Trainingsbereich |
val | bool | Wahr | - | Validierung während des Trainings durchführen |
resume | bool | Falsch | - | Training vom Checkpoint fortsetzen |
| Wert | Beschreibung |
|---|---|
auto | Automatische Auswahl (Standard) |
SGD | Stochastischer Gradientenabstieg |
MuSGD | Muon SGD |
Adam | Adam-Optimierer |
AdamW | Adam mit Gewichtsabnahme |
NAdam | NAdam-Optimierer |
RAdam | RAdam-Optimierer |
RMSProp | RMSProp-Optimierer |
Adamax | Adamax-Optimierer |
| Parameter | Typ | Standard | Bereich | Beschreibung |
|---|---|---|---|---|
box | float | 7.5 | 1-50 | Gewicht des Box-Verlusts |
cls | float | 0.5 | 0.2-4 | Klassifikations-Loss-Gewicht |
dfl | float | 1.5 | 0.4-6 | Verteilungs-Focal-Loss |
pose | float | 12.0 | 1-50 | Pose-Gewichtsverlust (nur Pose) |
kobj | float | 1.0 | 0.5-10 | Schlüsselpunkt-Objektivität (Pose) |
label_smoothing | float | 0.0 | 0.0-0.1 | Label-Glättungsfaktor |
Aufgabenspezifische Parameter
Einige Parameter gelten nur für bestimmte Aufgaben:
- Nur Detektionsaufgaben (detect, segment, pose, obb — nicht classify):
box,dfl,degrees,translate,shear,perspective,mosaic,mixup,close_mosaic - Nur Segment:
copy_paste - Nur posieren:
pose(Verlustgewicht),kobj(Keypoint-Objekthaftigkeit)