Cloud-Training#
Ultralytics Platform Cloud-Training ermöglicht das Training mit Cloud-GPUs per Mausklick und macht das Modelltraining ohne komplexe Einrichtung zugänglich. Trainiere YOLO-Modelle mit Metriken in Echtzeit und automatischer Speicherung von Checkpoints.
Trainingsdialog#
Starte das Training über die Benutzeroberfläche der Platform, indem du auf einer beliebigen Projekt- oder Datensatzseite auf Neues Modell klickst. Der Trainingsdialog enthält zwei Tabs: Cloud-Training und Lokales Training. Befindet sich der ausgewählte Datensatz auf einem On-Premise-Host, heißt der erste Tab On-Premise und der Tab „Lokales Training“ wird ausgeblendet. Dieser Datensatz kann nur auf seinem eigenen Host trainiert werden. Dafür ist ein Enterprise-Tarif sowie ein verbundener, aktiver Worker erforderlich.

Der Dialog merkt sich für jede Datensatzaufgabe und jeden Workspace im aktuellen Browser das Basismodell und alle Parameter, die nicht den Standardwerten entsprechen und beim letzten Schließen eingestellt waren. Beim nächsten Öffnen für dieselbe Aufgabe werden diese Einstellungen wiederhergestellt. Die GPU-Auswahl wird nicht gespeichert. Bei Training wiederholen für einen fehlgeschlagenen Lauf werden stattdessen die Argumente dieses Laufs wiederhergestellt.
Schritt 1: Basismodell auswählen#
Wähle ein offizielles Ultralytics-Modell oder eines deiner eigenen abgeschlossenen Modelle aus:
| Tab | Beschreibung |
|---|---|
| Offiziell | Projektmodelle von YOLO26 (empfohlen), YOLO11, YOLOv8 und YOLOv5 |
| Meine Modelle | Deine abgeschlossenen oder hochgeladenen Modelle, nach Projekt gruppiert, für die Feinabstimmung |
In jedem Tab sind die Modelle nach Aufgabe in kanonischer Reihenfolge gruppiert und nach Größe sortiert. Beide Tabs zeigen nur Modelle an, deren Aufgabe mit dem ausgewählten Datensatz trainiert werden kann. YOLO26 umfasst Varianten für Objekterkennung, Segmentierung, semantische Segmentierung, Tiefenschätzung, Klassifizierung, Posenschätzung und OBB in Größen von Nano bis Xlarge.
Tiefendatensätze lassen sich mit Float-NPY-Zielwerten in Metern oder mit uint16-PNG-Zielwerten über das depth_scale des Datensatzes hochladen. Siehe das Format für Tiefendatensätze. Für Tiefenmodelle gilt standardmäßig ein Feinabstimmungsrezept (optimizer: AdamW, lr0: 0.0001, warmup_bias_lr: 0.0001), sofern du diese Parameter nicht selbst festlegst.
Schritt 2: Datensatz auswählen#
Wähle einen Datensatz für das Training aus (siehe Datensätze):
| Option | Beschreibung |
|---|---|
| Offiziell | Kuratierte Datensätze von Ultralytics |
| Meine Datensätze | Datensätze in deinem Workspace |
Datensätze müssen den Status ready haben und mindestens 1 Bild im Trainingssplit, 1 Bild im Validierungs- oder Testsplit, 1 beschriftetes Bild sowie mindestens einen Klassennamen enthalten. Bei Klassifizierungsdatensätzen muss außerdem das Bild im Trainingssplit beschriftet sein, und Posendatensätze müssen eine Keypoint-Form definieren. Tiefendatensätze benötigen stattdessen eine gepaarte Karte in train und zwei in val; nicht zugeordnete Bilder werden ausgeschlossen.
Wenn das ausgewählte Modell nicht für die Aufgabe des Datensatzes trainiert werden kann, erscheint eine Warnung wegen nicht übereinstimmender Aufgaben. Training starten bleibt deaktiviert, bis du ein kompatibles Modell auswählst. Ein Segmentierungsdatensatz kann mit einem Segmentierungs- oder semantischen Segmentierungsmodell verwendet werden; für andere Datensatzaufgaben ist ein Modell mit der jeweils passenden Aufgabe erforderlich. Siehe die Anleitungen zu den Aufgaben.
Schritt 3: Parameter konfigurieren#
Lege die wichtigsten Trainingsparameter fest:
| Parameter | Beschreibung | Standard |
|---|---|---|
| Epochen | Anzahl der Trainingsiterationen (1–10000) | 100 |
| Batch-Größe | Stichproben pro Iteration (-1 passt sich automatisch an den verfügbaren VRAM an, oder eine feste Anzahl von Bildern) | -1 (automatisch) |
| Bildgröße | Schieberegler für die Eingabeauflösung, 32–1280 in Schritten von 32 | 640 |
| Name | Optionaler Name für den Trainingslauf | automatisch |
Werte außerhalb des zulässigen Parameterbereichs werden begrenzt, sobald das Feld den Fokus verliert.
Der Schieberegler reicht bis 1280, der YAML-Editor akzeptiert jedoch Bildgrößen bis 4096. Bei Werten über 1280 erscheint eine Warnung, da höhere Auflösungen den GPU-Speicherbedarf, die Trainingsdauer und die Kosten deutlich erhöhen.
Schritt 4: Erweiterte Einstellungen (optional)#
Klappe Erweiterte Einstellungen aus, um auf den YAML-basierten Parametereditor mit über 50 Trainingsparametern in den Bereichen Trainingseinstellungen und Bildveränderungen zuzugreifen (siehe Referenz zur Konfiguration):
| Gruppe | Parameter |
|---|---|
| Lernrate | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Optimierer | auto (Standard), SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Gewichtungen der Verlustfunktionen | box, cls, cls_pw, dfl, pose, kobj, rle, angle, dlog, dgrad, dlam |
| Farbveränderungen | hsv_h, hsv_s, hsv_v |
| Geometrische Veränderungen | degrees, translate, scale, shear, perspective |
| Spiegelungs- und Mischveränderungen | flipud, fliplr, mosaic, mixup, copy_paste, bgr, cutmix, copy_paste_mode, auto_augment, erasing |
| Trainingssteuerung | epochs, batch, imgsz, pretrained, patience, seed, deterministic, amp, cos_lr, compile, close_mosaic, save_period, nbs, cls_remap, channels_last, profile, overlap_mask, mask_ratio |
| Datensatz | fraction, freeze, single_cls, rect, multi_scale, resume |
| Validierung | max_det |
Die Parameter richten sich nach der jeweiligen Aufgabe (z. B. wird copy_paste nur bei Segmentierungs-, semantischen und OBB-Aufgaben angezeigt, pose/kobj nur bei Pose-Aufgaben und auto_augment/erasing nur bei Klassifizierungsaufgaben). Der Editor blendet device, cache, workers, iou, dropout, val und time aus und ignoriert diese Parameter in eingefügten oder abgelegten Konfigurationen. Lege sie in deinem eigenen yolo train-Befehl fest, wenn du lokal trainierst. Ein Geändert-Abzeichen erscheint, wenn Werte von den Standardwerten abweichen. Mit der Schaltfläche zum Zurücksetzen kannst du alle Werte auf die Standardwerte zurücksetzen. An den Trainingsjob werden nur erweiterte Werte übermittelt, die von den Standardwerten abweichen (die grundlegenden Parameter für epochs, batch und Bildgröße sind immer enthalten). So bleibt der resultierende Befehl übersichtlich.
Beispiel: Augmentierung für kleine Datensätze optimieren
Erhöhe bei kleinen Datensätzen (<1000 Bilder) die Augmentierung, um Overfitting zu verringern:
mosaic: 1.0 # Keep mosaic on
mixup: 0.3 # Add mixup blending
copy_paste: 0.3 # Add copy-paste (segment, semantic, OBB)
fliplr: 0.5 # Horizontal flip
degrees: 10.0 # Slight rotation
scale: 0.9 # Aggressive scalingDatensatzversion speichern (optional)#
Aktiviere Datensatzversion speichern, um das Modell mit einer unveränderlichen Version eines auf der Plattform gehosteten Datensatzes zu verknüpfen. Die Plattform prüft, ob sich die Inhalte des Datensatzes geändert haben, verwendet eine übereinstimmende Version erneut, wenn sie unverändert sind, und erstellt nur bei Bedarf eine neue nummerierte Version. Das Training verwendet dann genau diesen NDJSON-Snapshot und speichert dessen Versionsnummer und Inhalts-Hash im Modell.
So bleiben die für den Trainingslauf verwendeten Daten erhalten, auch wenn du später Bilder hinzufügst oder entfernst, Annotationen bearbeitest oder die Aufteilung des Datensatzes änderst. Die verknüpfte Version findest du in den Tabs Modelle und Versionen des Datensatzes.
Datensatzversion speichern ist für verbundene Cloud-Speicher und On-Premise-Datensätze nicht verfügbar. Du kannst Snapshots auch manuell über den Tab Versionen erstellen.
Schritt 5: GPU auswählen (Cloud-Tab)#
Wähle deine GPU in Ultralytics Cloud aus:

| 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 | 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.44 | Größere Batchgrößen |
| RTX 3090 | Ampere | 24 GB | $0.46 | Allgemeines Training |
| RTX A6000 | Ampere | 48 GB | $0.49 | Große Modelle |
| RTX PRO 4000 | Blackwell | 24 GB | $0.57 | Preisgünstiges Blackwell |
| RTX PRO 4500 | Blackwell | 32 GB | $0.64 | Gutes 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 Batchgrößen |
| L40S | Ada | 48 GB | $0.86 | Training mit großen Batchgrößen |
| RTX PRO 5000 | Blackwell | 48 GB | $0.96 | Training mit großen Batchgrößen |
| RTX 5090 | Blackwell | 32 GB | $0.99 | Neueste Generation für Endverbraucher |
| L40 | Ada | 48 GB | $0.99 | Große Modelle |
| A100 PCIe | Ampere | 80 GB | $1.39 | Training für den Produktiveinsatz |
| A100 SXM | Ampere | 80 GB | $1.49 | Training für den Produktiveinsatz |
| RTX PRO 6000 | Blackwell | 96 GB | $2.09 | Empfohlene Standardeinstellung |
| H100 PCIe | Hopper | 80 GB | $2.89 | Hochleistungstraining |
| H100 NVL | Hopper | 94 GB | $3.19 | Maximale Leistung |
| H100 SXM | Hopper | 80 GB | $3.29 | Schnellstes Training |
| H200 NVL | Hopper | 143 GB | $3.39 | Maximaler Speicher |
| H200 SXM | Hopper | 141 GB | $4.39 | Maximale Leistung |
| B200 | Blackwell | 180 GB | $5.89 | Große Modelle (Pro+) |
| B300 | Blackwell | 288 GB | $7.39 | Größte Modelle (Pro+) |
- RTX PRO 6000: 96 GB Blackwell, als Standard für die meisten Jobs empfohlen
- A100 SXM: 80 GB HBM2e – eine gute Wahl für große Batch-Größen oder größere Modelle
- H100 PCIe / H100 SXM / H100 NVL: 80–94 GB Hopper für zeitkritisches Training (in allen Tarifen verfügbar)
- H200 NVL / H200 SXM: 141–143 GB Hopper für speicherintensive Arbeitslasten (in allen Tarifen verfügbar)
- B200 / B300: 180–288 GB NVIDIA Blackwell für anspruchsvolle Arbeitslasten – erfordert Pro oder Enterprise
Im Dialog werden dein aktuelles Guthaben und eine Schaltfläche Aufladen angezeigt. Die Kostenkarte schätzt die Gesamtdauer und den Preis für deine Konfiguration (Modellgröße, Anzahl der Datensatzbilder, epochs, Bildgröße, Batch-Größe, Optimierer und GPU-Geschwindigkeit) und zeigt außerdem die geschätzte Dauer pro Epoche sowie die Anzahl der Datensatzbilder an.
Die GPU-Auswahl zeigt die aktuelle Kapazität der Cloud an und kennzeichnet daher Optionen, für die derzeit keine Kapazität verfügbar ist. Falls ein Job trotzdem nicht auf der von dir ausgewählten GPU starten kann, meldet die Plattform den Engpass und stellt deine Auswahl auf die ähnlichste verfügbare GPU um – zuerst nach VRAM, dann nach Geschwindigkeit und anschließend nach Preis. Die Plattform teilt dir den neuen VRAM-Wert und Stundensatz mit, damit du sofort starten oder eine andere GPU auswählen kannst.
Wenn du eine günstigere GPU als die RTX PRO 6000 auswählst, kann dein Job auf der von Ultralytics verwalteten Infrastruktur ausgeführt werden. Ist dort Kapazität frei, läuft der Trainingslauf auf einer RTX PRO 6000, wird aber weiterhin zum Tarif der von dir ausgewählten GPU abgerechnet. So kann ein Trainingslauf schneller abgeschlossen werden und weniger kosten, als wenn er auf der von dir ausgewählten GPU ausgeführt würde – das Upgrade selbst macht einen Trainingslauf niemals langsamer oder teurer.
Schritt 6: Training starten#
Klicke auf Training starten, um deinen Job zu starten. Die Plattform:
- Ermittelt die unveränderliche Datensatzversion, wenn Datensatzversion speichern aktiviert ist
- Stellt eine GPU-Instanz bereit
- Lädt deinen Datensatz herunter
- Startet das Training
- Überträgt Metriken in Echtzeit
Beim erneuten Training eines vorhandenen Modells wird dieselbe Modellseite verwendet. Sobald der neue Job erstellt wurde, werden die Diagramme, die Konsolenausgabe, die Systemmetriken und der Fehlerstatus des vorherigen Trainingslaufs gelöscht. Bei einem Trainingslauf, der fehlschlägt, bevor Rechenressourcen bereitgestellt wurden, bleiben die vorherigen Ergebnisse unverändert.
Lebenszyklus eines Trainingsjobs#
Trainingsjobs durchlaufen die folgenden Status:
| Status | Beschreibung |
|---|---|
| Wird gestartet | Job eingereicht; GPU wird bereitgestellt; Datensatz und Modell werden heruntergeladen |
| Wird ausgeführt | Training läuft; Metriken werden in Echtzeit übertragen |
| Abgeschlossen | Training erfolgreich abgeschlossen |
| Fehlgeschlagen | Training fehlgeschlagen (Details findest du in den Konsolenprotokollen) |
| Abgebrochen | Training vom Benutzer abgebrochen |
Ein schwerwiegender Python-Fehler im Konsolenstream – etwa ein Traceback, ein CUDA-Fehler wegen unzureichenden Speichers oder eine fehlgeschlagene CUDA-Initialisierung – beendet den Trainingslauf sofort, statt auf eine Zeitüberschreitung zu warten. Die ausgelesene Meldung erscheint auf der Modellseite in einem Fehlerbanner mit den Aktionen Vollständige Konsolenprotokolle anzeigen und Training erneut versuchen. Trainingsläufe, bei denen vier Stunden lang keine Aktivität gemeldet wird, werden automatisch als fehlgeschlagen markiert und ihre Rechenressourcen freigegeben.
Um Ergebnisse abgeschlossener und fehlgeschlagener Trainingsläufe zu erhalten, ohne diese Seite geöffnet zu lassen, richte Slack-Benachrichtigungen ein.
Neue Konten erhalten ein Startguthaben – 5 $ bei privaten E-Mail-Adressen und 25 $ bei geschäftlichen E-Mail-Adressen. Prüfe dein Guthaben unter Einstellungen > Abrechnung.

Training überwachen#
Sieh dir den Trainingsfortschritt in Echtzeit im Tab Trainieren der Modellseite an:
Untertab „Charts“#

Die Diagramme sind nach Metrikgruppen geordnet. Welche Gruppen angezeigt werden, hängt davon ab, welche Metriken der Trainingslauf meldet:
| Gruppe | Inhalt |
|---|---|
| Messwerte | Aufgabenmetriken – mAP50, mAP50-95, Präzision und Recall für die Objekterkennung; Informationen zu anderen Aufgaben findest du unter Modelle |
| Verlust | Ein Diagramm pro Verlustkomponente, mit durchgezogener Linie für die Trainingsreihe und gestrichelter Linie für die Validierungsreihe |
| Lernrate | lr/pg0, lr/pg1, lr/pg2 |
Du kannst jede Gruppe einklappen, einzelne Diagramme über das Gruppenmenü ein- oder ausblenden sowie Diagramme verschieben und ihre Größe anpassen. Das Layout wird für das nächste Mal gespeichert.
Untertab „Konsole“#
Live-Konsolenausgabe mit Unterstützung für ANSI-Farben, Fortschrittsbalken und Erkennung schwerwiegender Fehler. Die letzten 2000 Zeilen werden gespeichert, Zeitstempel lassen sich einblenden und das gesamte Protokoll kann als Klartext kopiert werden.
Untertab „System“#
Eine Live-Übersicht des Hosts (Hostname, CPU, GPU, RAM und gesamte Festplattenkapazität) sowie Diagramme pro Epoche zur CPU- und RAM-Auslastung, GPU-Auslastung und -Speicherbelegung, GPU-Temperatur, Netzwerk-I/O und Festplatten-I/O.
Checkpoints#
Der beste Checkpoint (best.pt) wird während des Trainings regelmäßig und erneut am Ende des Trainingslaufs auf die Plattform hochgeladen. So werden beim Herunterladen, Exportieren und Bereitstellen immer die Ergebnisse der bis dahin besten Epoche verwendet. Wird der Trainingslauf abgebrochen, bleibt der vor dem Abbruch hochgeladene Checkpoint erhalten.
Training abbrechen#
Klicke in der Karte mit den Laufdetails auf der Modellseite auf Abbrechen und bestätige die Aktion. Beim Cloud-Training stoppt die Plattform den Job, gibt dessen Rechenressourcen frei und berechnet die bis zum Abbruch angefallene GPU-Zeit. Beim lokalen Training wird dem Prozess signalisiert, an der nächsten Epochengrenze anzuhalten, und Teilergebnisse bleiben erhalten – vor dem Beenden lädt der Trainingslauf alle bis dahin vorhandenen Ergebnisse hoch.
Remote-Training#
Trainiere auf deiner eigenen Hardware und übertrage dabei Metriken an die Plattform.
Für die Integration mit der Plattform sind Python>=3.11 und ultralytics>=8.4.120 erforderlich. Ältere Versionen funktionieren nicht mit der Plattform.
pip install -U ultralyticsAPI-Schlüssel einrichten#
- Gehe zu
Settings > API Keys - Erstelle einen neuen Schlüssel (oder lass die Plattform automatisch einen erstellen, wenn du den Tab „Lokales Training“ öffnest)
- Lege die Umgebungsvariable fest:
export ULTRALYTICS_API_KEY="YOUR_API_KEY"Mit Streaming trainieren#
Verwende die Parameter project und name, um Metriken zu übertragen:
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1Der Tab Lokales Training im Trainingsdialog zeigt einen vorkonfigurierten Befehl mit deinem API-Schlüssel, den ausgewählten Parametern und den erweiterten Argumenten.
Datensätze auf der Plattform verwenden#
Trainiere mit Datensätzen, die auf der Plattform gespeichert sind, und verwende dafür das ul://-URI-Format:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1Das URI-Format ul:// lädt deinen Datensatz automatisch herunter und konfiguriert ihn. Das Modell wird automatisch mit dem Datensatz auf der Plattform verknüpft (siehe Datensätze auf der Plattform verwenden).
Abrechnung#
Die Trainingskosten richten sich nach der GPU-Nutzung:
Kostenschätzung#
Vor Trainingsbeginn schätzt die Plattform anhand der Datensatzgröße, der Modellgröße, der Bildgröße, der Batch-Größe, der Anzahl der Epochen und der ausgewählten GPU die Gesamtdauer und die Kosten. Die Schätzungen sind Näherungswerte; abgerechnet wird die tatsächliche Nutzung.
Kostenfaktoren:
| Faktor | Auswirkung |
|---|---|
| Datensatzgröße | Mehr Bilder = längere Trainingszeit (der Rechenaufwand wächst 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 Trainingsdauer |
| Bildgröße | Eine größere imgsz erhöht den Rechenaufwand erheblich – 1280 px kosten ein Mehrfaches von 640 px |
| Batch-Größe | Mit größeren Batches lässt sich effizienter trainieren als mit kleinen |
| GPU-Geschwindigkeit | Schnellere GPUs verkürzen die Trainingszeit und gleichen ihren höheren Stundensatz teilweise aus |
| Optimierer | MuSGD dauert ungefähr doppelt so lange wie die anderen Optimierer |
| Startaufwand | Bis zu 5 Minuten für die Initialisierung der Instanz, den Datendownload und das Aufwärmen (abhängig von der Datensatzgröße) |
Die Schätzungen basieren auf tatsächlichen Cloud-Trainingsläufen und verwenden immer die von dir ausgewählte GPU. Daher wird ein Job, der auf schnellere Ultralytics-Infrastruktur umgeleitet wird, früher als geschätzt abgeschlossen.
Kostenbeispiele#
Kostenschätzungen sind Näherungswerte und hängen von vielen Faktoren ab. Im Trainingsdialog wird vor Trainingsbeginn eine aktuelle Schätzung angezeigt.
| Szenario | GPU | Geschätzte Kosten |
|---|---|---|
| 500 Bilder, YOLO26n, 50 Epochen | RTX 4090 | ~$0.03 |
| 1000 Bilder, YOLO26n, 100 Epochen | RTX PRO 6000 | ~$0.23 |
| 5000 Bilder, YOLO26s, 100 Epochen | H100 SXM | ~$1.56 |
Abrechnungsablauf#
Abrechnungsablauf für Cloud-Training:
- Schätzung: Kostenberechnung vor Trainingsbeginn
- Guthabenprüfung: Das verfügbare Guthaben wird vor dem Start geprüft
- Training und Erfassung: Der Auftrag läuft auf der ausgewählten Rechenleistung. Währenddessen wird die angefallene GPU-Zeit schrittweise von deinem Guthaben abgezogen.
- Abrechnung: Beim Erreichen des Endstatus wird die verbleibende Restzeit abgezogen und eine einzelne Training-Transaktion für den gesamten Lauf verbucht.
Die Abrechnung erfasst die tatsächlich genutzte GPU-Zeit, auch bei abgebrochenen oder fehlgeschlagenen Teilläufen, nachdem eine Cloud-GPU gestartet wurde.
Abrechnung nach Auftragsstatus#
| Status | Wird abgerechnet? |
|---|---|
| Abgeschlossen | Ja – tatsächlich genutzte GPU-Zeit |
| Abgebrochen | Ja – GPU-Zeit vom Start bis zum Abbruch |
| Fehlgeschlagen | Ja, wenn die Cloud-Rechenleistung gestartet wurde – verstrichene GPU-Zeit |
| Hängt fest | Ja – verstrichene GPU-Zeit bis zur automatischen Beendigung |
Ein Lauf, der 4 Stunden lang keine Aktivität meldet, wird automatisch als fehlgeschlagen markiert; die Instanz wird beendet und die verstrichene GPU-Zeit abgerechnet. Remote-Läufe auf deiner eigenen Hardware werden lediglich als fehlgeschlagen markiert; es fallen keine Kosten an.
Bei einem Validierungs- oder Startfehler, bevor eine Cloud-GPU gestartet wird, fallen keine Kosten für die Rechenleistung an. Sobald eine GPU läuft, werden abgeschlossene, abgebrochene, fehlgeschlagene und automatisch beendete Aufträge anhand der verstrichenen GPU-Laufzeit abgerechnet.
Zahlungsmethoden#
Cloud-Training wird über dein Plattformguthaben bezahlt.
Zum Starten eines Trainings ist ein positives verfügbares Guthaben erforderlich, das mindestens die geschätzten Auftragskosten abdeckt. Für jede Schätzung werden mindestens 15 Minuten GPU-Zeit reserviert. Bei mehreren gleichzeitig aktiven Läufen berücksichtigt die Prüfung außerdem deren noch nicht abgerechnete Restzeit.
Trainingskosten anzeigen#
Vor dem Start eines Cloud-Auftrags zeigt der Trainingsdialog dein aktuelles Guthaben an und schätzt Dauer und Kosten des Auftrags anhand des ausgewählten Modells, Datensatzes, der Epochen, Bildgröße und GPU. Die Schätzung dient nur zur Orientierung; tatsächlich berechnet wird die verbrauchte GPU-Zeit. Prüfe anschließend die daraus entstandene Guthabentransaktion unter Einstellungen > Abrechnung.

Trainingstipps#
Die passende Modellgröße auswählen#
| Modell | Parameter | Am besten geeignet für |
|---|---|---|
| YOLO26n | 2.4M | Echtzeit, Edge-Geräte |
| YOLO26s | 9.5M | Ausgewogenes Verhältnis von Geschwindigkeit und Genauigkeit |
| YOLO26m | 20.4M | Höhere Genauigkeit |
| YOLO26l | 24.8M | Genauigkeit für den Produktiveinsatz |
| YOLO26x | 55.7M | Maximale Genauigkeit |
Trainingszeit optimieren#
- Klein anfangen: Teste mit 10–20 Epochen auf einer kostengünstigen GPU, ob dein Datensatz und deine Konfiguration funktionieren.
- Geeignete GPU verwenden: Die RTX PRO 6000 bewältigt die meisten Workloads problemlos.
- Datensatz validieren: Behebe Probleme bei der Beschriftung, 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.
Fehlerbehebung#
| Problem | Lösung |
|---|---|
| Training bleibt bei 0 % hängen | Datensatzformat prüfen und erneut versuchen |
| Nicht genügend Arbeitsspeicher | Batch-Größe verringern oder eine größere GPU verwenden |
| Geringe Genauigkeit | Epochenzahl erhöhen und Datenqualität prüfen |
| Training dauert zu lange | Eine schnellere GPU in Betracht ziehen |
| Fehler wegen nicht übereinstimmender Aufgabe | Sicherstellen, dass Modell und Datensatz dieselbe Aufgabe verwenden |
Referenz der Trainingsparameter#
| Parameter | Typ | Standard | Bereich | Beschreibung |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Anzahl der Trainingsepochen |
batch | int/float | -1 (automatisch) | -1, 0-1 oder >=1 | Batch-Größe (-1 = automatische Anpassung an den verfügbaren VRAM, 0-1 = GPU-Speicheranteil) |
imgsz | int | 640 | 32-4096 | Eingabebildgröße |
pretrained | bool | True | - | Mit vortrainierten Gewichten statt mit zufälliger Initialisierung starten |
patience | int | 100 | 0-1000 | Geduld beim vorzeitigen Abbruch (0 deaktiviert ihn) |
time | float | null | 0.1-720 | Zeitlimit für das Training in Stunden; hat Vorrang vor der Epochenzahl |
seed | int | 0 | 0-2147483647 | Zufallsstartwert für reproduzierbare Ergebnisse |
deterministic | bool | True | - | Deterministischer Trainingsmodus |
amp | bool/str | True | true/false/fp16/bf16/fp32 | Trainingspräzision |
compile | bool | False | - | Mit torch.compile kompilieren (erste Epoche langsamer) |
close_mosaic | int | 10 | >=0 | Mosaik-Augmentierung in den letzten N Epochen deaktivieren |
save_period | int | -1 | >=-1 | Prüfpunkt alle N Epochen speichern |
device | Auswählen | automatisch | auto/0/cpu/mps | Trainingsgerät |
workers | int | 8 | 0-64 | Dataloader-Worker |
cache | Auswählen | false | ram/disk/false | Bilder zwischenspeichern |
dropout | float | 0.0 | 0.0-1.0 | Dropout im Klassifikationskopf (nur für Klassifikation) |
iou | float | 0.7 | 0.1-0.9 | IoU-Schwellenwert für NMS während der Validierung |
max_det | int | 300 | 1-10000 | Maximale Anzahl von Erkennungen pro Bild |
Einige Parameter gelten nur für bestimmte Aufgaben:
- Erkennung, Segmentierung, Pose und OBB:
box,cls,dfl,single_cls,iou,max_det - Alle Aufgaben außer Tiefe und Klassifizierung (Erkennung, Segmentierung, semantisch, Pose, OBB):
mosaic,mixup,close_mosaic - Alle Aufgaben außer Klassifizierung (Erkennung, Segmentierung, semantisch, Tiefe, Pose, OBB):
degrees,translate,shear,perspective - Segmentierung, semantisch und OBB:
copy_paste - Nur Tiefe:
dlog,dgrad,dlam - Nur Klassifizierung:
dropout - Nur Pose:
pose(Verlustgewicht),kobj(Keypoint-Objekterkennung),rle - Nur OBB:
angle
Häufig gestellte Fragen#
Die Trainingsdauer hängt von Folgendem ab:
- Datensatzgröße
- Modellgröße
- Anzahl der Epochen
- Ausgewählte GPU
Typische Dauer (1000 Bilder, 100 Epochen):
Modell RTX PRO 6000 A100 SXM YOLO26n ~6 Min. ~5 Min. YOLO26m ~15 Min. ~12 Min. YOLO26x ~30 Min. ~25 Min. Ungefähre DauerDie Trainingsdauer ist ein Näherungswert und hängt von der Komplexität des Datensatzes, den Augmentierungseinstellungen und der Batchgröße ab. Eine genauere Einschätzung erhältst du über die Kostenschätzung im Trainingsdialog.
Ja. Das Training kann unbeaufsichtigt laufen, solange es finanziert ist, und die Plattform protokolliert den Abschluss oder einen Fehler. Sinkt das Guthaben durch die Abrechnung unter null, werden aktive, kostenpflichtige Cloud-Läufe beendet und die bereits genutzte GPU-Zeit abgerechnet.
Die Cloud-Nutzung wird während des Trainings abgerechnet. Sinkt dein Guthaben durch eine Abbuchung unter null, werden aktive, kostenpflichtige Cloud-Trainingsläufe beendet und die bereits genutzte GPU-Zeit abgerechnet. Lade Guthaben auf oder aktiviere die automatische Aufladung, damit auch lange laufende Jobs finanziert bleiben.
Negatives GuthabenBei einem Guthaben von null oder darunter kannst du keine neuen kostenpflichtigen Cloud-Trainingsjobs starten. Ein negatives, nutzungsbasiert abgerechnetes Guthaben führt außerdem dazu, dass aktive, kostenpflichtige Cloud-Trainingsläufe beendet werden.
Kostenschätzungen sind Näherungswerte — die tatsächliche Trainingsdauer kann sich beispielsweise aufgrund der Ladegeschwindigkeit der Daten, des GPU-Aufwärmens und des Konvergenzverhaltens des Modells unterscheiden. Wenn die tatsächliche Nutzung das verfügbare Guthaben aufbraucht, beendet die Plattform aktive, kostenpflichtige Cloud-Läufe, sobald das Guthaben negativ wird.
So behältst du die Kosten im Griff:
- Überwache den Trainingsfortschritt in Echtzeit und brich den Lauf bei Bedarf frühzeitig ab
- Aktiviere die automatische Aufladung, damit Guthaben automatisch nachgeladen wird
- Beginne mit kürzeren Läufen (weniger Epochen), um die Erwartungen abzustimmen
Ja, klappe im Trainingsdialog den Abschnitt Erweiterte Einstellungen auf, um auf einen YAML-Editor mit mehr als 50 konfigurierbaren Parametern zuzugreifen. Werte, die nicht den Standardeinstellungen entsprechen, werden sowohl in Cloud- als auch in lokale Trainingsbefehle übernommen.
Der YAML-Editor unterstützt auch den Import von Konfigurationen aus früheren Trainingsläufen:
- Aus vorhandenem Modell kopieren: Auf der Seite eines abgeschlossenen Modells findest du in der Karte „Trainingskonfiguration“ das Menü Daten exportieren mit der Option JSON kopieren. Füge den JSON-Text direkt in den YAML-Editor ein — das Format wird automatisch erkannt und alle Parameter werden importiert. Über dasselbe Menü kannst du die Konfiguration als CSV- oder JSON-Datei herunterladen.
- 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 zulässigen Bereichs begrenzt und Warnungen angezeigt.
- Dateien per Drag-and-drop hinzufügen: Ziehe eine
.yaml- oder.json-Datei direkt in den Editor, um ihre Parameter zu importieren.

So kannst du frühere Trainingskonfigurationen ganz einfach reproduzieren oder weiterentwickeln, ohne jeden Parameter manuell erneut einzugeben.
Ja. Bei einem fehlgeschlagenen Modell wird ein Fehlerbanner mit der Aktion Training erneut versuchen angezeigt. Damit öffnest du den Trainingsdialog erneut, der dasselbe Basismodell, denselben Datensatz und dieselben Parameter vorauswählt. Du kannst also einen Wert anpassen und erneut starten. Beim erneuten Versuch wird dieselbe Modellseite verwendet: Die Diagramme, Konsolenausgabe, Systemmetriken und der Fehler des vorherigen Laufs werden gelöscht, sobald der neue Job erstellt wurde. Die Gewichte werden ersetzt, wenn der neue Lauf einen besseren Checkpoint erzeugt.
Ja, die Schaltfläche Neues Modell auf Datensatzseiten öffnet den Trainingsdialog, in dem der Datensatz bereits ausgewählt und gesperrt ist. Wähle dann ein Projekt und ein Modell aus, um das Training zu starten.