Link to this sectionCloud-Training#
Das Ultralytics Platform Cloud-Training bietet Training mit 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 (oder auf einer Datensatzseite auf Trainieren) klickst. Der Trainingsdialog hat zwei Reiter: 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 fertiggestellten Modelle für das Fine-Tuning |
Offizielle Modelle sind nach Aufgabentyp (Detect, Segment, Semantic, Pose, OBB, Classify) mit Größen von nano bis xlarge organisiert.
Link to this sectionSchritt 2: Datensatz auswählen#
Wähle einen Datensatz für das Training 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 vor einem Aufgaben-Konflikt erscheint, wenn die Modellaufgabe (z. B. detect) nicht mit der Datensatzaufgabe (z. B. segment) übereinstimmt. Das Training schlägt fehl, wenn du mit unterschiedlichen Aufgaben fortfährst. Stelle sicher, dass sowohl Modell als auch Datensatz denselben Aufgabentyp verwenden, wie in den Aufgabenleitfäden beschrieben.
Link to this sectionSchritt 3: Parameter konfigurieren#
Lege die wichtigsten Trainingsparameter fest:
| Parameter | Beschreibung | Standard |
|---|---|---|
| Epochen | Anzahl der Trainingsiterationen | 100 |
| Batch-Größe | Stichproben pro Iteration | -1 (auto) |
| Bildgröße | Eingabeauflösung (320/416/512/640/1280 Dropdown, jedes Vielfache von 32 zwischen 32-4096 im YAML-Editor) | 640 |
| Run-Name | Optionaler Name für den Trainingslauf | auto |
Link to this sectionSchritt 4: Erweiterte Einstellungen (Optional)#
Klappe die Erweiterten Einstellungen aus, 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 |
| Optimierer | auto (Standard), SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Verlustgewichtungen | box, cls, dfl, pose, kobj, label_smoothing |
| Farb-Augmentierung | 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 aufgabenbezogen (z. B. copy_paste wird nur für Segment-Aufgaben angezeigt, pose/kobj nur für Pose-Aufgaben). Ein Geändert-Badge erscheint, wenn Werte von den Standards abweichen, und du kannst alle mit dem Zurücksetzen-Button auf die Standardwerte zurücksetzen.
Beispiel: Optimierung der Augmentierung für kleine Datensätze
Erhöhe bei kleinen Datensätzen (<1000 Bilder) 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-Reiter)#
Wähle deine GPU aus der Ultralytics Cloud:

| GPU | Generation | VRAM | Kosten/Stunde | Am besten für |
|---|---|---|---|---|
| RTX 2000 Ada | Ada | 16 GB | $0.24 | Kleine Datensätze, Tests |
| 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 | 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 | Großartiges 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 zeitkritisches Training (verfügbar in allen Plänen)
- H200 NVL / H200 SXM: 141–143 GB Hopper für speicherintensive Workloads (verfügbar in allen Plänen)
- B200 / B300: 180–288 GB NVIDIA Blackwell für modernste Workloads – erfordert Pro oder Enterprise
Der Dialog zeigt dein aktuelles Guthaben und einen Aufladen-Button. Basierend auf deiner Konfiguration (Modellgröße, Datensatzbilder, Epochen, GPU-Geschwindigkeit) werden geschätzte Kosten und Dauer berechnet.
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 mit dem Training
- Streamt Metriken in Echtzeit
Link to this sectionTrainingsjob-Lebenszyklus#
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 läuft, Metriken werden in Echtzeit gestreamt |
| Abgeschlossen | Training erfolgreich beendet |
| Fehlgeschlagen | Training fehlgeschlagen (siehe Konsolenprotokolle für Details) |
| Abgebrochen | Training wurde vom Benutzer abgebrochen |
Neue Konten erhalten Anmelde-Guthaben – 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#
Verfolge den Trainingsfortschritt in Echtzeit auf dem Reiter Trainieren der Modellseite:
Link to this sectionCharts-Unter-Tab#

| Metrik | Beschreibung |
|---|---|
| Verlust | Trainings- und Validierungsverlust |
| mAP | Mean Average Precision |
| Genauigkeit | Korrekte positive Vorhersagen |
| Recall | Erkannte Ground Truths |
Link to this sectionKonsole-Unter-Tab#
Live-Konsolenausgabe mit ANSI-Farbunterstützung, Fortschrittsbalken und Fehlererkennung.
Link to this sectionSystem-Unter-Tab#
GPU-Auslastung in Echtzeit, Arbeitsspeicher, 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 zum Download, Export und Deployment bereit.
Link to this sectionTraining abbrechen#
Klicke auf der Modellseite auf Training abbrechen, um einen laufenden Job zu stoppen:
- Die Compute-Instanz wird beendet
- Die Berechnung der Credits wird gestoppt
- Der beste Checkpoint bleibt verfügbar, wenn 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 du Metriken an die Plattform streamst.
Die Plattform-Integration erfordert ultralytics>=8.4.60. Niedrigere Versionen funktionieren NICHT mit der Plattform.
pip install -U ultralyticsLink to this sectionAPI-Schlüssel einrichten#
- Gehe zu
Settings > API Keys - Erstelle einen neuen Schlüssel (oder die Plattform erstellt automatisch einen, wenn du den Tab Local 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-1Der Local Training-Tab im Trainingsdialog zeigt einen vorkonfigurierten Befehl mit deinem API-Schlüssel, ausgewählten Parametern und erweiterten Argumenten an.
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 Using Platform Datasets).
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, Batchgröße und GPU-Geschwindigkeit
- Berechnung der gesamten Trainingszeit durch Multiplikation der Sekunden pro Epoche mit der Anzahl der Epochen, plus Start-Overhead
- Berechnung der geschätzten Kosten aus der gesamten Trainingszeit in Stunden 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 den Rechenaufwand: 320px=~0.3x, 640px=1.0x (Basislinie), 1280px=~3.5x |
| Batch-Größe | Größere Batches sind effizienter (Batch 32 = ~0.85x Zeit, Batch 8 = ~1.2x Zeit im Vergleich zur Batch 16-Basislinie) |
| GPU-Geschwindigkeit | Schnellere GPUs reduzieren 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 geprüft
- Training: Der Job läuft auf der ausgewählten Rechenleistung
- Abrechnung: Die Endkosten basieren auf der tatsächlichen Laufzeit
Die Abrechnung erfasst die tatsächliche Rechennutzung, einschließlich abgebrochener Teildurchläufe. Du wirst niemals für fehlgeschlagene Trainingsläufe zur Kasse gebeten.
Link to this sectionAbrechnung nach Jobstatus#
| Status | Berechnet? |
|---|---|
| Abgeschlossen | Ja — tatsächliche GPU-Nutzungszeit |
| Abgebrochen | Ja — GPU-Zeit vom Start bis zum Abbruch |
| Fehlgeschlagen | Nein — fehlgeschlagene Läufe werden nicht berechnet |
| Festgefahren | Teilweise — nur tatsächliche Trainingszeit wird berechnet |
Wenn ein Trainingslauf aufgrund eines Konfigurationsfehlers, eines Speicherproblems oder eines anderen Fehlers fehlschlägt, wirst du nicht zur Kasse gebeten. Nur erfolgreiche Rechenzeit wird abgerechnet. Festgefahrene Jobs (keine Aktivität für mehr als 4 Stunden) werden automatisch beendet und nur für die Zeit berechnet, in der die GPU aktiv trainierte, nicht für die Leerlaufzeit.
Link to this sectionZahlungsmethoden#
| Methode | Beschreibung |
|---|---|
| Kontostand | Vorab geladene Credits |
| Zahlung pro Job | Belastung bei Abschluss des Jobs |
Der Trainingsstart erfordert ein positives verfügbares Guthaben und ausreichend Credits für die geschätzten Jobkosten.
Link to this sectionTrainingskosten anzeigen#
Nach dem Training kannst du detaillierte Kosten im Billing-Tab einsehen:
- Kostenaufschlüsselung pro Epoche
- Gesamte GPU-Zeit
- Kostenbericht herunterladen

Link to this sectionTrainingstipps#
Link to this sectionWähle die richtige Modellgröße#
| Modell | Parameter | Am besten 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 |
Link to this sectionOptimierung der Trainingszeit#
- Klein anfangen: Teste mit 10-20 Epochen auf einer günstigen GPU, um zu überprüfen, ob dein Datensatz und deine Konfiguration funktionieren
- Geeignete GPU verwenden: 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 genutzte Rechenzeit
Link to this sectionFehlerbehebung#
| Problem | Lösung |
|---|---|
| Training hängt bei 0% | Datensatzformat prüfen, erneut versuchen |
| Speichermangel (Out of Memory) | Batchgröße reduzieren oder größere GPU verwenden |
| Geringe Genauigkeit | Epochen erhöhen, Datenqualität prüfen |
| Training langsam | Erwäge eine schnellere GPU |
| Fehler durch Aufgaben-Nichtübereinstimmung | 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
- Gewä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 Datensatzkomplexität, Augmentierungseinstellungen und Batchgröße. Nutze die Kostenschätzung im Trainingsdialog für genauere Vorhersagen.
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 genügend Guthaben für das epochenbasierte Training verfügt.
Link to this sectionWas passiert, wenn meine Credits aufgebraucht sind?#
Wenn dein Guthaben während eines Trainingslaufs auf Null sinkt, läuft das Training bis zum Abschluss weiter und dein Kontostand wird negativ. Dies stellt sicher, dass dein Trainingsauftrag niemals mittendrin unterbrochen wird.
Nach Abschluss des Trainings musst du Credits hinzufügen, um deinen Kontostand wieder ins Positive zu bringen, bevor du neue Trainingsaufträge startest. Dein fertiges Modell, Checkpoints und alle Trainingsartefakte bleiben unabhängig vom Kontostand vollständig erhalten.
Ein negativer Kontostand verhindert lediglich das Starten neuer Trainingsaufträge. Bestehende Deployments und andere Plattformfunktionen funktionieren weiterhin normal. Füge Credits über Einstellungen > Abrechnung hinzu oder aktiviere automatisches Aufladen, um Unterbrechungen zu vermeiden.
Link to this sectionWas passiert, wenn mein Training mehr als geschätzt kostet?#
Kostenschätzungen sind Näherungswerte — die tatsächliche Trainingszeit kann aufgrund von Faktoren wie Datenladegeschwindigkeit, GPU-Warmup 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.
Um Kosten zu verwalten:
- Überwache den Trainingsfortschritt in Echtzeit und brich bei Bedarf vorzeitig ab
- Aktiviere automatisches Aufladen, um Credits automatisch aufzufüllen
- Starte mit kürzeren Läufen (weniger Epochen), um 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-standardmäßige Werte werden sowohl in Cloud- als auch in lokalen Trainingsbefehlen berücksichtigt.
Der YAML-Editor unterstützt auch das Importieren von Konfigurationen aus früheren Trainingsläufen:
- Von bestehendem Modell kopieren: Auf der Seite jedes abgeschlossenen Modells findest du in der Karte Trainingskonfiguration eine Schaltfläche Als JSON kopieren. Kopiere das JSON und füge es direkt in den YAML-Editor ein — er erkennt das JSON-Format automatisch und importiert alle Parameter.
- YAML oder JSON einfügen: Füge eine beliebige gültige YAML- oder JSON-Trainingskonfiguration in den Editor ein. Parameter werden automatisch validiert, Werte außerhalb des Bereichs werden begrenzt und Warnungen angezeigt.
- Dateien per Drag & Drop ziehen: Ziehe eine
.yaml- oder.json-Datei direkt in den Editor, um deren Parameter zu importieren.

Dies macht es einfach, vorherige 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 Trainieren-Schaltfläche auf Datensatzseiten öffnet den Trainingsdialog, bei dem der Datensatz bereits vorausgewählt und gesperrt ist. Du wählst dann ein Projekt und ein Modell aus, um mit dem Training zu beginnen.
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 | Batchgröße (-1 = automatische Anpassung an verfügbaren VRAM) |
imgsz | int | 640 | 32-4096 | Eingabebildgröße |
patience | int | 100 | 1-1000 | Patience für Early Stopping |
seed | int | 0 | 0-2147483647 | Zufälliger Seed für Reproduzierbarkeit |
deterministic | bool | True | - | Deterministischer Trainingsmodus |
amp | bool | True | - | Automatische gemischte Präzision |
close_mosaic | int | 10 | 0-50 | Mosaic in den letzten N Epochen deaktivieren |
save_period | int | -1 | -1-100 | Checkpoint alle N Epochen speichern |
workers | int | 8 | 0-64 | Dataloader-Worker |
cache | auswählen | false | ram/disk/false | Bilder zwischenspeichern |
Einige Parameter gelten nur für bestimmte Aufgaben:
- Nur Detection-Aufgaben (detect, segment, pose, OBB — nicht classify):
box,dfl,degrees,translate,shear,perspective,mosaic,mixup,close_mosaic - Nur Segmentierung:
copy_paste - Nur Pose:
pose(Verlustgewicht),kobj(Keypoint-Objekthaftigkeit)