Fehlerbehebung bei häufigen Problemen mit YOLO

Einführung

Dieser Leitfaden dient als umfassende Hilfestellung zur Behebung häufiger Probleme bei der Arbeit mit YOLO26 in deinen Ultralytics-Projekten. Mit der richtigen Anleitung ist die Lösung dieser Probleme ein Kinderspiel, sodass deine Projekte ohne unnötige Verzögerungen auf Kurs bleiben.

Häufige Probleme

Installationsfehler

Installationsfehler können aus verschiedenen Gründen auftreten, wie z. B. durch inkompatible Versionen, fehlende Abhängigkeiten oder fehlerhafte Umgebungskonfigurationen. Überprüfe zuerst, ob du Folgendes beachtest:

• Du verwendest Python 3.8 oder höher, wie empfohlen.
• Stelle sicher, dass die korrekte Version von PyTorch (1.8 oder höher) installiert ist.
• Erwäge die Verwendung virtueller Umgebungen, um Konflikte zu vermeiden.
• Befolge die offizielle Installationsanleitung Schritt für Schritt.

Hier sind zudem einige häufige Installationsprobleme, auf die Nutzer gestoßen sind, zusammen mit ihren jeweiligen Lösungen:

• Importfehler oder Abhängigkeitsprobleme - Wenn beim Import von YOLO26 Fehler auftreten oder du Probleme mit Abhängigkeiten hast, ziehe die folgenden Schritte zur Fehlerbehebung in Betracht:

  • Neuinstallation: Manchmal kann eine Neuinstallation unerwartete Probleme lösen. Besonders bei Bibliotheken wie Ultralytics, bei denen Updates Änderungen an der Struktur des Dateibaums oder an Funktionen einführen können.

  • Regelmäßige Updates: Stelle sicher, dass du die neueste Version der Bibliothek verwendest. Ältere Versionen sind möglicherweise nicht mit aktuellen Updates kompatibel, was zu potenziellen Konflikten oder Problemen führen kann.

  • Abhängigkeiten prüfen: Überprüfe, ob alle erforderlichen Abhängigkeiten korrekt installiert sind und die kompatiblen Versionen aufweisen.

  • Änderungen überprüfen: Wenn du eine ältere Version geklont oder installiert hast, sei dir bewusst, dass bedeutende Updates die Struktur oder Funktionen der Bibliothek beeinflussen könnten. Konsultiere immer die offizielle Dokumentation oder die Changelogs, um größere Änderungen zu verstehen.

  • Denk daran, dass die Aktualisierung deiner Bibliotheken und Abhängigkeiten entscheidend für eine reibungslose und fehlerfreie Erfahrung ist.

• Ausführen von YOLO26 auf der GPU - Wenn du Probleme beim Ausführen von YOLO26 auf der GPU hast, beachte die folgenden Schritte zur Fehlerbehebung:

  • CUDA-Kompatibilität und -Installation verifizieren: Stelle sicher, dass deine GPU CUDA-kompatibel ist und CUDA korrekt installiert wurde. Verwende den Befehl nvidia-smi, um den Status deiner NVIDIA GPU und die CUDA-Version zu überprüfen.

  • PyTorch- und CUDA-Integration prüfen: Stelle sicher, dass PyTorch CUDA nutzen kann, indem du import torch; print(torch.cuda.is_available()) in einem Python-Terminal ausführst. Wenn 'True' zurückgegeben wird, ist PyTorch für die Nutzung von CUDA eingerichtet.

  • GPU-Kompatibilität prüfen: Die Unterstützung für GPU-Architekturen vor Turing und eine Compute Capability (SM) < 7.5 wurde seit cuDNN 9.11.0 eingestellt. Wenn du also eine ältere GPU hast – wie eine 1080Ti –, musst du möglicherweise eine Version von PyTorch verwenden, die mit einer älteren CUDA/cuDNN-Version erstellt wurde. Du kannst dies überprüfen, indem du import torch; cap = torch.cuda.get_device_capability(0) if torch.cuda.is_available() else (0, 0); cudnn = torch.backends.cudnn.version() or 0; ok = "not compatible" if cudnn >= 91100 and (cap[0] < 7 or (cap[0] == 7 and cap[1] < 5)) else "should be ok"; print(f"Compute capability: SM {cap[0]}.{cap[1]}, cuDNN: {cudnn} => {ok}") ausführst.

  • Umgebungsaktivierung: Stelle sicher, dass du dich in der richtigen Umgebung befindest, in der alle notwendigen Pakete installiert sind.

  • Pakete aktualisieren: Veraltete Pakete sind möglicherweise nicht mit deiner GPU kompatibel. Halte sie auf dem neuesten Stand.

  • Programmkonfiguration: Prüfe, ob das Programm oder der Code die GPU-Nutzung spezifiziert. Bei YOLO26 kann dies in den Einstellungen oder der Konfiguration zu finden sein.

Probleme beim Modelltraining

Dieser Abschnitt behandelt häufige Probleme beim Training sowie deren Erklärungen und Lösungen.

Überprüfung der Konfigurationseinstellungen

Problem: Du bist dir unsicher, ob die Konfigurationseinstellungen in der .yaml-Datei während des Modelltrainings korrekt angewendet werden.

Lösung: Die Konfigurationseinstellungen in der .yaml-Datei sollten angewendet werden, wenn die Funktion model.train() verwendet wird. Um sicherzustellen, dass diese Einstellungen korrekt übernommen werden, befolge diese Schritte:

• Bestätige, dass der Pfad zu deiner .yaml-Konfigurationsdatei korrekt ist.

• Stelle sicher, dass du den Pfad zu deiner .yaml-Datei als data-Argument übergibst, wenn du model.train() aufrufst, wie unten gezeigt:

  model.train(data="/path/to/your/data.yaml", batch=4)

Training mit mehreren GPUs beschleunigen

Problem: Das Training auf einer einzelnen GPU ist langsam und du möchtest den Prozess mit mehreren GPUs beschleunigen.

Lösung: Eine Erhöhung der batch size kann das Training beschleunigen, es ist jedoch wichtig, die Speicherkapazität der GPU zu berücksichtigen. Um das Training mit mehreren GPUs zu beschleunigen, befolge diese Schritte:

• Stelle sicher, dass mehrere GPUs verfügbar sind.

• Ändere deine .yaml-Konfigurationsdatei, um die Anzahl der zu verwendenden GPUs anzugeben, z. B. gpus: 4.

• Erhöhe die Batch-Größe entsprechend, um die mehreren GPUs voll auszunutzen, ohne die Speichergrenzen zu überschreiten.

• Ändere deinen Trainingsbefehl, um mehrere GPUs zu nutzen:

  # Adjust the batch size and other settings as needed to optimize training speed
  model.train(data="/path/to/your/data.yaml", batch=32)

Kontinuierliche Überwachungsparameter

Problem: Du möchtest wissen, welche Parameter neben dem Loss während des Trainings kontinuierlich überwacht werden sollten.

Lösung: Während der Loss eine entscheidende Metrik zur Überwachung ist, ist es auch wichtig, andere Metriken für die Optimierung der Modellleistung zu verfolgen. Einige wichtige Metriken, die während des Trainings überwacht werden sollten, sind:

• Präzision
• Abruf
• Mean Average Precision (mAP)

Du kannst diese Metriken über die Trainingsprotokolle oder durch die Verwendung von Tools wie TensorBoard oder wandb zur Visualisierung abrufen. Die Implementierung von Early Stopping basierend auf diesen Metriken kann dir helfen, bessere Ergebnisse zu erzielen.

Tools zur Verfolgung des Trainingsfortschritts

Problem: Du suchst nach Empfehlungen für Tools, um den Trainingsfortschritt zu verfolgen.

Lösung: Um den Trainingsfortschritt zu verfolgen und zu visualisieren, kannst du die folgenden Tools in Betracht ziehen:

• TensorBoard: TensorBoard ist eine beliebte Wahl für die Visualisierung von Trainingsmetriken, einschließlich Loss, accuracy und mehr. Du kannst es in deinen YOLO26-Trainingsprozess integrieren.
• Comet: Comet bietet ein umfangreiches Toolkit für die Verfolgung und den Vergleich von Experimenten. Es ermöglicht dir, Metriken, Hyperparameter und sogar Modellgewichte zu verfolgen. Die Integration mit YOLO-Modellen ist ebenfalls unkompliziert und bietet dir einen vollständigen Überblick über deinen Experimentierzyklus.
• Ultralytics Platform: Die Ultralytics Platform bietet eine spezialisierte Umgebung für die Verfolgung von YOLO-Modellen und stellt eine zentrale Anlaufstelle dar, um Metriken und Datensätze zu verwalten und sogar mit deinem Team zusammenzuarbeiten. Da sie speziell auf YOLO zugeschnitten ist, bietet sie individuellere Optionen zur Verfolgung.

Jedes dieser Tools bietet eigene Vorteile; daher solltest du bei deiner Wahl die spezifischen Anforderungen deines Projekts berücksichtigen.

So prüfst du, ob das Training auf der GPU stattfindet

Problem: Der 'device'-Wert in den Trainingsprotokollen ist 'null' und du bist dir unsicher, ob das Training auf der GPU stattfindet.

Lösung: Ein 'null'-Wert bei 'device' bedeutet normalerweise, dass der Trainingsprozess so eingestellt ist, dass er automatisch eine verfügbare GPU verwendet, was das Standardverhalten ist. Um sicherzustellen, dass das Training auf einer spezifischen GPU erfolgt, kannst du den 'device'-Wert in deiner .yaml-Konfigurationsdatei manuell auf den GPU-Index setzen (z. B. '0' für die erste GPU):

device: 0

Dies weist den Trainingsprozess explizit der angegebenen GPU zu. Wenn du auf der CPU trainieren möchtest, setze 'device' auf 'cpu'.

Behalte den 'runs'-Ordner für Protokolle und Metriken im Auge, um den Trainingsfortschritt effektiv zu überwachen.

Wichtige Überlegungen für ein effektives Modelltraining

Hier sind einige Punkte, die du beachten solltest, wenn du Probleme beim Modelltraining hast.

Datenformat und Labels

• Bedeutung: Das Fundament jedes machine learning-Modells liegt in der Qualität und dem Format der Daten, mit denen es trainiert wird.
• Empfehlung: Stelle sicher, dass dein benutzerdefinierter Datensatz und die zugehörigen Labels dem erwarteten Format entsprechen. Es ist entscheidend zu überprüfen, ob die Annotationen präzise sind und eine hohe Qualität aufweisen. Falsche oder mangelhafte Annotationen können den Lernprozess des Modells stören und zu unvorhersehbaren Ergebnissen führen.

Modellkonvergenz

• Bedeutung: Das Erreichen der Modellkonvergenz stellt sicher, dass das Modell ausreichend aus den training data gelernt hat.
• Empfehlung: Wenn du ein Modell 'von Grund auf neu' trainierst, ist es wichtig sicherzustellen, dass das Modell einen zufriedenstellenden Grad an Konvergenz erreicht. Dies kann eine längere Trainingsdauer mit mehr epochs erfordern, als wenn du ein bestehendes Modell feinabstimmst.

Learning Rate und Batch-Größe

• Bedeutung: Diese Hyperparameter spielen eine entscheidende Rolle dabei, wie das Modell während des Trainings seine Gewichte aktualisiert.
• Empfehlung: Evaluiere regelmäßig, ob die gewählte Lernrate und Batch-Größe für deinen spezifischen Datensatz optimal sind. Parameter, die nicht mit den Eigenschaften des Datensatzes harmonieren, können die Leistung des Modells beeinträchtigen.

Klassenverteilung

• Bedeutung: Die Verteilung der Klassen in deinem Datensatz kann die Vorhersagetendenzen des Modells beeinflussen.
• Empfehlung: Überprüfe regelmäßig die Verteilung der Klassen in deinem Datensatz. Wenn ein Klassenungleichgewicht vorliegt, besteht das Risiko, dass das Modell eine Tendenz zur häufiger vorkommenden Klasse entwickelt. Diese Verzerrung kann in der Konfusionsmatrix deutlich werden, in der das Modell möglicherweise vorwiegend die Mehrheitsklasse vorhersagt.

Abgleich mit vortrainierten Gewichten

• Bedeutung: Die Nutzung vortrainierter Gewichte kann einen soliden Ausgangspunkt für das Modelltraining bieten, insbesondere wenn nur begrenzte Daten verfügbar sind.
• Empfehlung: Erwäge als Diagnoseschritt, dein Modell mit denselben Daten zu trainieren, es aber mit vortrainierten Gewichten zu initialisieren. Wenn dieser Ansatz eine gut strukturierte Konfusionsmatrix liefert, könnte dies darauf hindeuten, dass das Modell, das 'von Grund auf' trainiert wurde, weitere Trainingsschritte oder Anpassungen benötigt.

Probleme im Zusammenhang mit Modellvorhersagen

Dieser Abschnitt behandelt häufige Probleme bei der Modellvorhersage.

Erhalten von Bounding-Box-Vorhersagen mit deinem benutzerdefinierten YOLO26-Modell

Problem: Bei der Ausführung von Vorhersagen mit einem benutzerdefinierten YOLO26-Modell gibt es Herausforderungen beim Format und der Visualisierung der Bounding-Box-Koordinaten.

Lösung:

• Koordinatenformat: YOLO26 liefert Bounding-Box-Koordinaten in absoluten Pixelwerten. Um diese in relative Koordinaten (im Bereich von 0 bis 1) umzurechnen, musst du sie durch die Bildabmessungen teilen. Nehmen wir beispielsweise an, deine Bildgröße beträgt 640x640. Dann gehst du wie folgt vor:

  # Convert absolute coordinates to relative coordinates
  x1 = x1 / 640  # Divide x-coordinates by image width
  x2 = x2 / 640
  y1 = y1 / 640  # Divide y-coordinates by image height
  y2 = y2 / 640

• Dateiname: Um den Dateinamen des Bildes zu erhalten, für das du Vorhersagen triffst, greife innerhalb deiner Vorhersageschleife direkt vom Ergebnisobjekt auf den Bilddateipfad zu.

Filtern von Objekten in YOLO26-Vorhersagen

Problem: Es gibt Schwierigkeiten beim Filtern und Anzeigen nur spezifischer Objekte in den Vorhersageergebnissen bei der Verwendung von YOLO26 mit der Ultralytics-Bibliothek.

Lösung: Um spezifische Klassen zu erkennen, verwende das Argument 'classes', um die Klassen anzugeben, die du in die Ausgabe aufnehmen möchtest. Um zum Beispiel nur Autos zu erkennen (unter der Annahme, dass 'Autos' den Klassenindex 2 haben):

yolo task=detect mode=segment model=yolo26n-seg.pt source='path/to/car.mp4' show=True classes=2

Verständnis von Präzisionsmetriken in YOLO26

Problem: Unklarheiten bezüglich des Unterschieds zwischen Box-Präzision, Masken-Präzision und der Präzision der confusion matrix in YOLO26.

Lösung: Die Box-Präzision misst die Genauigkeit vorhergesagter Bounding-Boxen im Vergleich zu den tatsächlichen Ground-Truth-Boxen unter Verwendung von IoU (Intersection over Union) als Metrik. Die Masken-Präzision bewertet die Übereinstimmung zwischen vorhergesagten Segmentierungsmasken und Ground-Truth-Masken bei der pixelweisen Objektklassifizierung. Die Präzision der Konfusionsmatrix hingegen konzentriert sich auf die allgemeine Klassifizierungsgenauigkeit über alle Klassen hinweg und berücksichtigt nicht die geometrische Genauigkeit von Vorhersagen. Es ist wichtig zu beachten, dass eine bounding box geometrisch korrekt (True Positive) sein kann, selbst wenn die Klassenvorhersage falsch ist, was zu Unterschieden zwischen Box-Präzision und Konfusionsmatrix-Präzision führt. Diese Metriken bewerten unterschiedliche Aspekte der Leistung eines Modells, was die Notwendigkeit für verschiedene Bewertungsmetriken in verschiedenen Aufgaben widerspiegelt.

Extrahieren von Objektmaßen in YOLO26

Problem: Schwierigkeiten beim Abrufen von Länge und Höhe erkannter Objekte in YOLO26, insbesondere wenn mehrere Objekte in einem Bild erkannt werden.

Lösung: Um die Bounding-Box-Maße abzurufen, verwende zuerst das Ultralytics YOLO26-Modell, um Objekte in einem Bild vorherzusagen. Extrahiere dann die Breiten- und Höheninformationen der Bounding-Boxen aus den Vorhersageergebnissen.

from ultralytics import YOLO

# Load a pretrained YOLO26 model
model = YOLO("yolo26n.pt")

# Specify the source image
source = "https://ultralytics.com/images/bus.jpg"

# Make predictions
results = model.predict(source, save=True, imgsz=320, conf=0.25)

# Extract bounding box dimensions
boxes = results[0].boxes.xywh.cpu()
for box in boxes:
    x, y, w, h = box
    print(f"Width of Box: {w}, Height of Box: {h}")

Herausforderungen bei der Bereitstellung

Probleme bei der GPU-Bereitstellung

Problem: Die Bereitstellung von Modellen in einer Umgebung mit mehreren GPUs kann manchmal zu unerwartetem Verhalten führen, wie z. B. ungewöhnlichem Speicherverbrauch, inkonsistenten Ergebnissen über GPUs hinweg usw.

Lösung: Prüfe die Standard-GPU-Initialisierung. Einige Frameworks, wie PyTorch, könnten CUDA-Operationen auf einer Standard-GPU initialisieren, bevor sie auf die zugewiesenen GPUs übergehen. Um unerwartete Standard-Initialisierungen zu umgehen, gib die GPU während der Bereitstellung und Vorhersage direkt an. Verwende dann Tools, um die GPU-Auslastung und den Speicherverbrauch zu überwachen, um Anomalien in Echtzeit zu identifizieren. Stelle zudem sicher, dass du die neueste Version des Frameworks oder der Bibliothek verwendest.

Probleme bei der Modellkonvertierung/-exportierung

Problem: Während des Prozesses der Konvertierung oder des Exports von Modellen für maschinelles Lernen in verschiedene Formate oder Plattformen können Benutzer auf Fehler oder unerwartetes Verhalten stoßen.

Lösung:

• Kompatibilitätsprüfung: Stelle sicher, dass du Versionen von Bibliotheken und Frameworks verwendest, die miteinander kompatibel sind. Nicht übereinstimmende Versionen können während der Konvertierung zu unerwarteten Fehlern führen.
• Umgebungs-Reset: Wenn du eine interaktive Umgebung wie Jupyter oder Colab verwendest, erwäge einen Neustart der Umgebung, nachdem du wesentliche Änderungen oder Installationen vorgenommen hast. Ein frischer Start kann manchmal zugrunde liegende Probleme lösen.
• Offizielle Dokumentation: Konsultiere immer die offizielle Dokumentation des Tools oder der Bibliothek, die du für die Konvertierung verwendest. Sie enthält häufig spezifische Richtlinien und bewährte Verfahren für den Export von Modellen.
• Community-Unterstützung: Überprüfe das offizielle Repository der Bibliothek oder des Frameworks auf ähnliche Probleme, die von anderen Benutzern gemeldet wurden. Die Betreuer oder die Community könnten in Diskussionsthreads Lösungen oder Workarounds bereitgestellt haben.
• Regelmäßige Updates: Stelle sicher, dass du die neueste Version des Tools oder der Bibliothek verwendest. Entwickler veröffentlichen häufig Updates, die bekannte Fehler beheben oder die Funktionalität verbessern.
• Inkrementelles Testen: Bevor du eine vollständige Konvertierung durchführst, teste den Prozess mit einem kleineren Modell oder Datensatz, um potenzielle Probleme frühzeitig zu identifizieren.

Community und Support

Die Interaktion mit einer Community Gleichgesinnter kann deine Erfahrung und deinen Erfolg bei der Arbeit mit YOLO26 erheblich verbessern. Nachfolgend findest du einige Kanäle und Ressourcen, die dir hilfreich sein könnten.

Foren und Kanäle, um Hilfe zu erhalten

GitHub Issues: Das YOLO26-Repository auf GitHub hat einen Issues-Tab, in dem du Fragen stellen, Bugs melden und neue Funktionen vorschlagen kannst. Die Community und die Maintainer sind hier aktiv, und es ist ein großartiger Ort, um Hilfe bei spezifischen Problemen zu bekommen.

Ultralytics Discord-Server: Ultralytics hat einen Discord-Server, auf dem du dich mit anderen Nutzern und den Entwicklern austauschen kannst.

Offizielle Dokumentation und Ressourcen

Ultralytics YOLO26-Doku: Die offizielle Dokumentation bietet einen umfassenden Überblick über YOLO26 sowie Anleitungen zu Installation, Nutzung und Fehlerbehebung.

Diese Ressourcen sollten eine solide Grundlage für die Fehlerbehebung und Verbesserung deiner YOLO26-Projekte bieten sowie dazu dienen, dich mit anderen aus der YOLO26-Community zu vernetzen.

Fazit

Fehlerbehebung ist ein wesentlicher Teil jedes Entwicklungsprozesses, und mit dem richtigen Wissen ausgestattet zu sein, kann den Zeit- und Arbeitsaufwand bei der Lösung von Problemen erheblich reduzieren. Dieser Leitfaden zielt darauf ab, die häufigsten Herausforderungen anzugehen, denen Nutzer des YOLO26-Modells innerhalb des Ultralytics-Ökosystems gegenüberstehen. Indem du diese häufigen Probleme verstehst und angehst, kannst du einen reibungsloseren Projektfortschritt sicherstellen und bessere Ergebnisse bei deinen Computer Vision-Aufgaben erzielen.

Denk daran, dass die Ultralytics-Community eine wertvolle Ressource ist. Der Austausch mit anderen Entwicklern und Experten kann zusätzliche Erkenntnisse und Lösungen liefern, die möglicherweise nicht in der Standarddokumentation abgedeckt sind. Lerne, experimentiere und teile weiterhin deine Erfahrungen, um zum kollektiven Wissen der Community beizutragen.

FAQ

Wie löse ich Installationsfehler bei YOLO26?

Installationsfehler beruhen oft auf Kompatibilitätsproblemen oder fehlenden Abhängigkeiten. Stelle sicher, dass du Python 3.8 oder neuer verwendest und PyTorch 1.8 oder neuer installiert hast. Es ist vorteilhaft, virtuelle Umgebungen zu nutzen, um Konflikte zu vermeiden. Für eine Schritt-für-Schritt-Installationsanleitung befolge unseren offiziellen Installationsleitfaden. Wenn du Importfehler feststellst, versuche eine Neuinstallation oder aktualisiere die Bibliothek auf die neueste Version.

Warum ist das Training meines YOLO26-Modells auf einer einzelnen GPU langsam?

Das Training auf einer einzelnen GPU kann aufgrund großer Batch-Größen oder unzureichendem Speicher langsam sein. Um das Training zu beschleunigen, verwende mehrere GPUs. Stelle sicher, dass dein System über mehrere GPUs verfügt, und passe deine .yaml-Konfigurationsdatei an, um die Anzahl der GPUs anzugeben, z. B. gpus: 4. Erhöhe die Batch-Größe entsprechend, um die GPUs vollständig auszulasten, ohne die Speichergrenzen zu überschreiten. Beispielbefehl:

model.train(data="/path/to/your/data.yaml", batch=32)

Wie kann ich sicherstellen, dass mein YOLO26-Modell auf der GPU trainiert?

Wenn der 'device'-Wert in den Trainingsprotokollen 'null' anzeigt, bedeutet das im Allgemeinen, dass der Trainingsprozess so eingestellt ist, dass er automatisch eine verfügbare GPU verwendet. Um explizit eine bestimmte GPU zuzuweisen, setze den 'device'-Wert in deiner .yaml-Konfigurationsdatei. Zum Beispiel:

device: 0

Dies setzt den Trainingsprozess auf die erste GPU. Konsultiere den nvidia-smi-Befehl, um dein CUDA-Setup zu bestätigen.

Wie kann ich meinen YOLO26-Modell-Trainingsfortschritt überwachen und verfolgen?

Die Nachverfolgung und Visualisierung des Trainingsfortschritts kann effizient über Tools wie TensorBoard, Comet und Ultralytics Platform verwaltet werden. Diese Tools ermöglichen es dir, Metriken wie Loss, Precision, Recall und mAP zu protokollieren und zu visualisieren. Die Implementierung von Early Stopping auf Basis dieser Metriken kann ebenfalls dazu beitragen, bessere Trainingsergebnisse zu erzielen.

Was soll ich tun, wenn YOLO26 mein Dataset-Format nicht erkennt?

Stelle sicher, dass dein Dataset und deine Labels dem erwarteten Format entsprechen. Überprüfe, ob die Annotationen korrekt sind und eine hohe Qualität aufweisen. Wenn du auf Probleme stößt, beziehe dich auf den Leitfaden zur Datensammlung und Annotation für Best Practices. Für weitere datasetspezifische Anleitungen prüfe den Bereich Datasets in der Dokumentation.