Ultralytics YOLO27:
Get Started

Anleitung zum Training deiner YOLO26-Modelle mit JupyterLab#

Das Erstellen von Deep-Learning-Modellen kann schwierig sein, besonders wenn dir die passenden Tools oder die richtige Arbeitsumgebung fehlen. Wenn du vor diesem Problem stehst, könnte JupyterLab die passende Lösung für dich sein. JupyterLab ist eine benutzerfreundliche, webbasierte Plattform, die das Programmieren flexibler und interaktiver macht. Damit kannst du große Datensätze verarbeiten, komplexe Modelle erstellen und sogar mit anderen zusammenarbeiten – alles an einem Ort.

Du kannst JupyterLab für Projekte rund um Ultralytics YOLO26-Modelle verwenden. JupyterLab eignet sich hervorragend für eine effiziente Modellentwicklung und Experimente. Damit kannst du ganz einfach direkt auf deinem Computer mit dem Experimentieren und dem Training von YOLO26-Modellen beginnen. Sehen wir uns JupyterLab, seine wichtigsten Funktionen und die Verwendung zum Training von YOLO26-Modellen genauer an.

Was ist JupyterLab?#

JupyterLab ist eine webbasierte Open-Source-Plattform für die Arbeit mit Jupyter-Notebooks, Code und Daten. Sie ist eine Weiterentwicklung der herkömmlichen Jupyter-Notebook-Oberfläche und bietet eine vielseitigere und leistungsfähigere Benutzererfahrung.

Mit JupyterLab kannst du an einem Ort mit Notebooks, Texteditoren, Terminals und anderen Tools arbeiten. Dank des flexiblen Designs kannst du deinen Arbeitsbereich an deine Bedürfnisse anpassen. So lassen sich Aufgaben wie Datenanalyse, Visualisierung und maschinelles Lernen leichter erledigen. JupyterLab unterstützt außerdem die Zusammenarbeit in Echtzeit und eignet sich damit ideal für gemeinsame Forschungs- und Data-Science-Projekte.

Wichtige Funktionen von JupyterLab#

Hier sind einige der wichtigsten Funktionen, die JupyterLab zu einer hervorragenden Option für die Modellentwicklung und das Experimentieren machen:

  • Alles an einem Ort: JupyterLab ist eine zentrale Anlaufstelle für alle deine Data-Science-Anforderungen. Anders als das klassische Jupyter Notebook, das separate Oberflächen für Textbearbeitung, Terminalzugriff und Notebooks bot, vereint JupyterLab all diese Funktionen in einer einzigen, einheitlichen Umgebung. Du kannst verschiedene Dateiformate, darunter JPEG, PDF und CSV, direkt in JupyterLab anzeigen und bearbeiten. In einem Arbeitsbereich hast du alles griffbereit, was deinen Arbeitsablauf vereinfacht und Zeit spart.
  • Flexible Layouts: Eine der herausragenden Funktionen von JupyterLab ist das flexible Layout. Du kannst Tabs verschieben, ablegen und in der Größe anpassen, um ein persönliches Layout zu erstellen, mit dem du effizienter arbeitest. Die einklappbare Seitenleiste links hält wichtige Tabs wie den Dateibrowser, laufende Kernel und die Befehlspalette stets griffbereit. Du kannst mehrere Fenster gleichzeitig geöffnet haben, um verschiedene Aufgaben parallel zu erledigen und deine Projekte besser zu verwalten.
  • Interaktive Code-Konsolen: Code-Konsolen in JupyterLab bieten einen interaktiven Bereich, in dem du Codefragmente oder Funktionen ausprobieren kannst. Sie dienen auch als Protokoll der Berechnungen in einem Notebook. Eine neue Konsole für ein Notebook zu erstellen und alle Kernel-Aktivitäten anzuzeigen, ist ganz einfach. Diese Funktion ist besonders nützlich, wenn du neue Ideen ausprobierst oder Probleme in deinem Code behebst.
  • Markdown-Vorschau: Dank der gleichzeitigen Vorschau kannst du in JupyterLab effizienter mit Markdown-Dateien arbeiten. Während du eine Markdown-Datei schreibst oder bearbeitest, siehst du die formatierte Ausgabe in Echtzeit. So kannst du die Darstellung deiner Dokumentation leichter überprüfen, ohne ständig zwischen Bearbeitungs- und Vorschauansicht wechseln zu müssen.
  • Code aus Textdateien ausführen: Wenn du eine Textdatei mit Code teilst, kannst du den Code mit JupyterLab ganz einfach direkt auf der Plattform ausführen. Markiere den Code und drücke Umschalt + Eingabetaste, um ihn auszuführen. So kannst du Codefragmente schnell überprüfen und sicherstellen, dass der geteilte Code funktioniert und fehlerfrei ist.

Warum solltest du JupyterLab für deine YOLO26-Projekte verwenden?#

Für die Entwicklung und Bewertung von Modellen für maschinelles Lernen gibt es zahlreiche Plattformen. Was zeichnet also JupyterLab aus? Sehen wir uns einige der besonderen Funktionen an, die JupyterLab für deine Machine-Learning-Projekte bietet:

  • Zellen einfach verwalten: In JupyterLab lassen sich Zellen mühelos verwalten. Statt sie umständlich auszuschneiden und einzufügen, kannst du sie einfach per Drag-and-drop neu anordnen.
  • Zellen zwischen Notebooks kopieren: Mit JupyterLab kannst du Zellen ganz einfach zwischen verschiedenen Notebooks kopieren. Ziehe dazu Zellen per Drag-and-drop von einem Notebook in ein anderes.
  • Einfach zur klassischen Notebook-Ansicht wechseln: Wenn du die klassische Oberfläche von Jupyter Notebook bevorzugst, kannst du mit JupyterLab ganz einfach zurückwechseln. Ersetze einfach /lab in der URL durch /tree, um zur vertrauten Notebook-Ansicht zurückzukehren.
  • Mehrere Ansichten: JupyterLab unterstützt mehrere Ansichten desselben Notebooks, was besonders bei langen Notebooks nützlich ist. Du kannst verschiedene Abschnitte zum Vergleichen oder Erkunden nebeneinander öffnen. Änderungen in einer Ansicht werden auch in der anderen angezeigt.
  • Anpassbare Designs: JupyterLab enthält ein dunkles Design für Notebooks, das sich ideal für lange Programmiersitzungen am Abend eignet. Für den Texteditor und das Terminal stehen ebenfalls Designs zur Verfügung, mit denen du das Erscheinungsbild deines gesamten Arbeitsbereichs anpassen kannst.

Häufige Probleme bei der Arbeit mit JupyterLab#

Bei der Arbeit mit JupyterLab können einige häufige Probleme auftreten. Hier sind ein paar Tipps, damit du dich problemlos auf der Plattform zurechtfindest:

  • Kernel verwalten: Kernel sind wichtig, weil sie die Verbindung zwischen dem Code, den du in JupyterLab schreibst, und der Umgebung, in der er ausgeführt wird, verwalten. Sie können außerdem Daten zwischen Notebooks abrufen und gemeinsam nutzen. Wenn du ein Jupyter Notebook schließt, läuft der Kernel möglicherweise weiter, weil andere Notebooks ihn noch verwenden. Wenn du einen Kernel vollständig herunterfahren möchtest, wähle ihn aus, klicke mit der rechten Maustaste darauf und wähle im Kontextmenü „Kernel herunterfahren“.
  • Python-Pakete installieren: Manchmal benötigst du zusätzliche Python-Pakete, die nicht auf dem Server vorinstalliert sind. Mit dem Befehl python -m pip install package-name kannst du diese Pakete ganz einfach in deinem Home-Verzeichnis oder einer virtuellen Umgebung installieren. Mit python -m pip list kannst du alle installierten Pakete anzeigen.
  • Flask-/FastAPI-API auf Posit Connect bereitstellen: Du kannst deine Flask- und FastAPI-APIs über das Terminal mit dem Paket rsconnect-python auf Posit Connect bereitstellen. So lassen sich deine Webanwendungen leichter in JupyterLab integrieren und mit anderen teilen.
  • JupyterLab-Erweiterungen installieren: JupyterLab unterstützt verschiedene Erweiterungen, die den Funktionsumfang erweitern. Du kannst diese Erweiterungen installieren und an deine Bedürfnisse anpassen. Eine ausführliche Anleitung findest du im Handbuch zu JupyterLab-Erweiterungen.
  • Mehrere Python-Versionen verwenden: Wenn du mit verschiedenen Python-Versionen arbeiten musst, kannst du Jupyter-Kernel verwenden, die mit den jeweiligen Python-Versionen konfiguriert sind.

YOLO26 mit JupyterLab ausprobieren#

Mit JupyterLab kannst du ganz einfach mit YOLO26 experimentieren. Führe zunächst die folgenden einfachen Schritte aus.

Schritt 1: JupyterLab installieren#

Installiere zunächst JupyterLab. Öffne das Terminal und führe den folgenden Befehl aus:

Installation
# Install the required package for JupyterLab
pip install jupyterlab

Schritt 2: YOLO26-Tutorial-Notebook herunterladen#

Lade als Nächstes die Datei tutorial.ipynb aus dem GitHub-Repository von Ultralytics herunter. Speichere die Datei in einem beliebigen Verzeichnis auf deinem lokalen Computer.

Schritt 3: JupyterLab starten#

Wechsle im Terminal in das Verzeichnis, in dem du die Notebook-Datei gespeichert hast. Führe dann den folgenden Befehl aus, um JupyterLab zu starten:

Verwendung
jupyter lab

Nachdem du diesen Befehl ausgeführt hast, wird JupyterLab wie unten gezeigt in deinem Standardbrowser geöffnet.

Abbildung: JupyterLab wird im Browser geöffnet

Schritt 4: Mit dem Experimentieren beginnen#

Öffne in JupyterLab das Notebook tutorial.ipynb. Jetzt kannst du die Zellen ausführen, um YOLO26 zu erkunden und damit zu experimentieren.

Abbildung: Geöffnetes YOLO26-Notebook in JupyterLab

In der interaktiven Umgebung von JupyterLab kannst du Code ändern, Ausgaben visualisieren und deine Erkenntnisse an einem Ort dokumentieren. Du kannst verschiedene Konfigurationen ausprobieren und nachvollziehen, wie YOLO26 funktioniert.

Ausführliche Informationen zum Modelltraining und zu bewährten Vorgehensweisen findest du in der Anleitung zum Training von YOLO26-Modellen. Diese Anleitung hilft dir, das Beste aus deinen Experimenten herauszuholen und YOLO26 effektiv einzusetzen.

Mehr über JupyterLab erfahren#

Wenn du mehr über JupyterLab erfahren möchtest, findest du hier einige Ressourcen für den Einstieg:

  • JupyterLab-Dokumentation: Sieh dir die offizielle JupyterLab-Dokumentation an, um die Funktionen und Möglichkeiten kennenzulernen. So erfährst du, wie du dieses leistungsstarke Tool optimal nutzen kannst.
  • Mit Binder ausprobieren: Probiere JupyterLab ohne Installation aus: Mit Binder kannst du direkt im Browser eine laufende JupyterLab-Instanz starten. So kannst du sofort mit dem Experimentieren beginnen.
  • Installationsanleitung: Eine Schritt-für-Schritt-Anleitung zur Installation von JupyterLab auf deinem lokalen Rechner findest du in der Installationsanleitung.
  • Ultralytics YOLO26 mit JupyterLab trainieren: In diesem ausführlichen Blogbeitrag erfährst du mehr über die praktischen Einsatzmöglichkeiten von JupyterLab mit YOLO26-Modellen.

Zusammenfassung#

Wir haben uns angesehen, wie JupyterLab ein leistungsstarkes Tool zum Experimentieren mit Ultralytics YOLO26-Modellen sein kann. Dank der flexiblen und interaktiven Umgebung kannst du JupyterLab ganz einfach auf deinem lokalen Rechner einrichten und mit YOLO26 arbeiten. Mit JupyterLab kannst du deine Modelle ganz einfach trainieren und auswerten, Ausgaben visualisieren und deine Erkenntnisse dokumentieren – alles an einem Ort.

Anders als andere Plattformen wie Google Colab wird JupyterLab lokal auf deinem Rechner ausgeführt. So hast du mehr Kontrolle über deine Rechenumgebung und kannst trotzdem interaktiv mit Notebooks arbeiten. Das ist besonders wertvoll für Entwickler, die zuverlässig auf ihre Entwicklungsumgebung zugreifen müssen, ohne auf Cloud-Ressourcen angewiesen zu sein.

Weitere Informationen findest du auf der JupyterLab-FAQ-Seite.

Du interessierst dich für weitere YOLO26-Integrationen? In der Ultralytics-Integrationsanleitung findest du zusätzliche Tools und Möglichkeiten für deine Machine-Learning-Projekte.

Häufig gestellte Fragen#

  • So trainierst du ein YOLO26-Modell mit JupyterLab:

    1. Installiere JupyterLab und das Ultralytics-Paket:

      pip install jupyterlab ultralytics

    2. Starte JupyterLab und öffne ein neues Notebook.

    3. Importiere das YOLO-Modell und lade ein vortrainiertes Modell:

      from ultralytics import YOLO

model = YOLO("yolo26n.pt")

    4. Trainiere das Modell mit deinem benutzerdefinierten Datensatz:

      results = model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

    5. Visualisiere die Trainingsergebnisse mit den integrierten Plot-Funktionen von JupyterLab:

      from ultralytics.utils.plotting import plot_results

plot_results("runs/detect/train/results.csv")  # speichert results.png neben results.csv

    In der interaktiven Umgebung von JupyterLab kannst du ganz einfach Parameter ändern, Ergebnisse visualisieren und deinen Modelltrainingsprozess schrittweise verbessern.

  • JupyterLab bietet mehrere Funktionen, die es ideal für YOLO26-Projekte machen:

    1. Interaktive Codeausführung: Teste und debugge YOLO26-Codeausschnitte in Echtzeit.
    2. Integrierter Dateibrowser: Verwalte ganz einfach Datensätze, Modellgewichte und Konfigurationsdateien.
    3. Flexible Anordnung: Ordne mehrere Notebooks, Terminals und Ausgabefenster nebeneinander an, um effizient zu arbeiten.
    4. Umfangreiche Ausgabeanzeige: Visualisiere YOLO26-Erkennungsergebnisse, Trainingskurven und Modellleistungskennzahlen direkt im Notebook.
    5. Markdown-Unterstützung: Dokumentiere deine YOLO26-Experimente und Erkenntnisse mit formatiertem Text und Bildern.
    6. Erweiterungsökosystem: Ergänze Funktionen durch Erweiterungen für Versionsverwaltung, entferntes Rechnen und mehr.

    Diese Funktionen ermöglichen eine nahtlose Entwicklung mit YOLO26-Modellen – von der Datenaufbereitung bis zur Bereitstellung des Modells.

  • So optimierst du die Leistung eines YOLO26-Modells in JupyterLab:

    1. Verwende AutoBatch, um die größte Stapelgröße zu ermitteln, die in den GPU-Speicher passt:

      results = model.train(data="path/to/data.yaml", batch=-1)

    2. Führe eine Hyperparameteroptimierung mit Bibliotheken wie Ray Tune durch:

      result_grid = model.tune(data="path/to/data.yaml", use_ray=True)

    3. Visualisiere und analysiere Modellkennzahlen mit den Plot-Funktionen von JupyterLab:

      from ultralytics.utils.plotting import plot_results

plot_results("runs/detect/train/results.csv")  # speichert results.png neben results.csv

    4. Experimentiere mit verschiedenen Modellarchitekturen und Exportformaten, um für deinen konkreten Anwendungsfall das beste Verhältnis zwischen Geschwindigkeit und Genauigkeit zu finden.

    Die interaktive Umgebung von JupyterLab ermöglicht schnelle Iterationen und sofortiges Feedback. So kannst du deine YOLO26-Modelle einfacher und effizienter optimieren.

  • Bei der Arbeit mit JupyterLab und YOLO26 können einige häufige Probleme auftreten. So gehst du damit um:

    1. Probleme mit dem GPU-Speicher:

      • Verwende torch.cuda.empty_cache(), um den GPU-Speicher zwischen den Durchläufen freizugeben.
      • Passe die Stapelgröße oder die Bildgröße so an, dass sie in den GPU-Speicher passt.

    2. Paketkonflikte:

      • Erstelle für deine YOLO26-Projekte eine separate Conda-Umgebung, um Konflikte zu vermeiden.
      • Führe !pip install package_name in einer Notebook-Zelle aus, um fehlende Pakete zu installieren.

    3. Abstürze des Kernels:

      • Starte den Kernel neu und führe die Zellen einzeln aus, um den problematischen Code zu ermitteln.
      • Prüfe deinen Code auf Speicherlecks, insbesondere bei der Verarbeitung großer Datensätze.
Mitwirkende
GLglenn-jocher12RAraimbekovm2RIRizwanMunawar2LALaughing-q2Y-Y-T-G1WIWillieMaddox1MAMatthewNoyce1AMambitious-octopus1ABabirami-vina1

Kommentare