Anleitung zum Training deiner YOLO26-Modelle mit JupyterLab
Das Erstellen von Deep-Learning-Modellen ist in einer interaktiven Umgebung einfacher, in der Code, Daten und Ergebnisse nebeneinander verfügbar sind. JupyterLab ist eine webbasierte Plattform, die das Programmieren flexibel und interaktiv macht. Du kannst damit große Datensätze verarbeiten, komplexe Modelle erstellen und mit anderen zusammenarbeiten – alles an einem Ort.
Mit JupyterLab kannst du an Projekten arbeiten, die sich auf Ultralytics YOLO26-Modelle beziehen. Damit kannst du direkt auf deinem Computer mit dem Experimentieren und dem Training von YOLO26-Modellen beginnen. Dieser Leitfaden behandelt JupyterLab, seine wichtigsten Funktionen und wie du damit YOLO26-Modelle trainieren kannst.
Was ist JupyterLab?#
JupyterLab ist eine quelloffene, webbasierte Plattform für die Arbeit mit Jupyter-Notebooks, Code und Daten. Als Schnittstelle der nächsten Generation von Project Jupyter erweitert sie das klassische Jupyter Notebook um eine flexiblere Arbeitsumgebung.
Mit JupyterLab kannst du an einem Ort mit Notebooks, Texteditoren, Terminals und weiteren Tools arbeiten. Dank des flexiblen Designs kannst du deinen Arbeitsbereich nach Bedarf organisieren und Aufgaben wie Datenanalyse, Visualisierung und maschinelles Lernen einfacher erledigen. JupyterLab unterstützt außerdem die Zusammenarbeit in Echtzeit, was bei Teamprojekten in Forschung und Datenwissenschaft hilfreich ist.
Wichtige Funktionen von JupyterLab#
Hier sind einige der wichtigsten Funktionen, die JupyterLab für die Modellentwicklung und das Experimentieren nützlich machen:
- Arbeitsumgebung für alles: 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, übersichtlichen Umgebung. Du kannst verschiedene Dateiformate, darunter JPEG, PDF und CSV, direkt in JupyterLab anzeigen und bearbeiten. So bleibt alles, was du brauchst, an einem Ort.
- Flexible Layouts: Du kannst Tabs verschieben und ihre Größe ändern, um ein persönliches Layout zu erstellen, mit dem du effizienter arbeiten kannst. Über die einklappbare linke Seitenleiste sind wichtige Tabs wie der Dateibrowser, laufende Kernel und die Befehlspalette schnell erreichbar. Du kannst mehrere Fenster gleichzeitig geöffnet haben und so mehrere Aufgaben parallel erledigen und deine Projekte effizienter 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 deine Markdown-Datei schreibst oder bearbeitest, siehst du die formatierte Ausgabe in Echtzeit. So kannst du leichter prüfen, ob deine Dokumentation korrekt dargestellt wird, ohne zwischen Bearbeitungs- und Vorschaumodus zu wechseln.
- Code aus Textdateien ausführen: Wenn du eine Textdatei mit Code teilst, kannst du den Code in JupyterLab ganz einfach direkt in der Plattform ausführen. Markiere den Code und drücke Umschalt + Eingabetaste, um ihn auszuführen. So kannst du Codeausschnitte schnell überprüfen und sicherstellen, dass der geteilte Code wie erwartet funktioniert.
Warum solltest du JupyterLab für deine YOLO26-Projekte verwenden?#
Es gibt verschiedene Plattformen für die Entwicklung und Auswertung von Modellen des maschinellen Lernens. Hier sind einige Aspekte von JupyterLab, die bei Projekten zum maschinellen Lernen hilfreich sind:
- Zellen einfach verwalten: Statt Zellen auszuschneiden und einzufügen, kannst du sie per Drag-and-drop verschieben, um ein Notebook neu anzuordnen.
- 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
/labin 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 bietet ein integriertes dunkles Design für Notebooks. Für Texteditor und Terminal stehen ebenfalls Designs zur Verfügung, sodass du das Erscheinungsbild deiner gesamten Arbeitsumgebung 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 verwalten, in der der Code ausgeführt wird. Wenn du ein Jupyter-Notebook schließt, läuft der Kernel auf dem Server weiter, sodass du später zu lang laufenden Aufgaben zurückkehren kannst. 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. Du kannst diese Pakete mit dem Befehl
python -m pip install package-namein deinem Home-Verzeichnis oder einer virtuellen Umgebung installieren. Mitpython -m pip listkannst 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, mit denen du den Funktionsumfang erweitern kannst. Du kannst diese Erweiterungen installieren und an deine Bedürfnisse anpassen.
- 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. Folge diesen Schritten, um loszulegen.
Schritt 1: JupyterLab installieren#
Installiere zunächst JupyterLab. Öffne das Terminal und führe den folgenden Befehl aus:
# Install the required package for JupyterLab
pip install jupyterlabSchritt 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:
jupyter labNachdem du diesen Befehl ausgeführt hast, wird JupyterLab wie unten gezeigt in deinem Standardbrowser 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.

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: Entdecke die Funktionen und Möglichkeiten von JupyterLab in der offiziellen Dokumentation.
- Mit Binder ausprobieren: Experimentiere mit JupyterLab, ohne etwas zu installieren. Mit Binder kannst du eine aktive JupyterLab-Instanz direkt im Browser starten.
- Installationsanleitung: Eine Schritt-für-Schritt-Anleitung zur Installation von JupyterLab auf deinem lokalen Rechner findest du in der Installationsanleitung.
- Ultralytics YOLO11 mit JupyterLab trainieren: Erfahre in diesem Blogbeitrag mehr über die praktische Verwendung von JupyterLab mit Ultralytics-YOLO-Modellen.
Zusammenfassung#
In diesem Leitfaden wurde gezeigt, wie du mit JupyterLab mit Ultralytics-YOLO26-Modellen experimentieren kannst. Du kannst JupyterLab auf deinem lokalen Computer einrichten und in wenigen Minuten mit YOLO26 loslegen. Mit JupyterLab kannst du deine Modelle ganz einfach an einem Ort trainieren und auswerten, Ausgaben visualisieren und deine Ergebnisse dokumentieren.
Anders als Cloud-Plattformen wie Google Colab läuft JupyterLab lokal auf deinem Computer. Dadurch hast du mehr Kontrolle über deine Rechenumgebung und kannst trotzdem interaktiv mit Notebooks arbeiten. Das ist besonders nützlich 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.
Häufig gestellte Fragen#
So trainierst du ein YOLO26-Modell mit JupyterLab:
-
Installiere JupyterLab und das Ultralytics-Paket:
pip install jupyterlab ultralytics -
Starte JupyterLab und öffne ein neues Notebook.
-
Importiere die YOLO-Klasse und lade ein vortrainiertes YOLO26n-Modell:
from ultralytics import YOLO model = YOLO("yolo26n.pt") -
Trainiere das Modell mit deinem benutzerdefinierten Datensatz:
results = model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640) -
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 Parameter ändern, Ergebnisse visualisieren und den Trainingsprozess deines Modells schrittweise verbessern.
-
JupyterLab bietet mehrere Funktionen, die sich für YOLO26-Projekte eignen:
- Interaktive Codeausführung: Teste und debugge YOLO26-Codeausschnitte in Echtzeit.
- Integrierter Dateibrowser: Verwalte ganz einfach Datensätze, Modellgewichte und Konfigurationsdateien.
- Flexibles Layout: Ordne mehrere Notebooks, Terminals und Ausgabefenster nebeneinander an, um effizient zu arbeiten.
- Umfangreiche Ausgabeanzeige: Visualisiere YOLO26-Erkennungsergebnisse, Trainingskurven und Modellleistungskennzahlen direkt im Notebook.
- Markdown-Unterstützung: Dokumentiere deine YOLO26-Experimente und Erkenntnisse mit formatiertem Text und Bildern.
- Erweiterungsökosystem: Ergänze Funktionen durch Erweiterungen für Versionsverwaltung, entferntes Rechnen und mehr.
Diese Funktionen ermöglichen einen reibungslosen Arbeitsablauf bei der Arbeit mit YOLO26-Modellen – von der Datenvorbereitung bis zur Modellbereitstellung.
So optimierst du die Leistung eines YOLO26-Modells in JupyterLab:
-
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) -
Führe eine Hyperparameteroptimierung mit Bibliotheken wie Ray Tune durch:
result_grid = model.tune(data="path/to/data.yaml", use_ray=True) -
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 -
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 Feedback in Echtzeit. Dadurch lassen sich YOLO26-Modelle einfacher optimieren.
-
Bei der Arbeit mit JupyterLab und YOLO26 können einige häufige Probleme auftreten. So gehst du damit um:
-
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.
- Verwende
-
Paketkonflikte:
- Erstelle für deine YOLO26-Projekte eine separate Conda-Umgebung, um Konflikte zu vermeiden.
- Führe
!pip install package_namein einer Notebook-Zelle aus, um fehlende Pakete zu installieren.
-
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.
-
Kommentare2
Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.
new-php
"This guide seems helpful, but there are a few things that could be improved. The steps for training YOLO11 models in JupyterLab are unclear in some parts, and it would be great to see more detailed explanations, especially for beginners. I also noticed that some important configurations for training weren’t mentioned, which could cause confusion for users trying to set up the environment correctly.
It would be really helpful to include sample images or screenshots to clarify key steps. Otherwise, new users might struggle with understanding the exact flow.
For more details, check out:
JupyterLab Installation GuideThis version should come across as more critical and focused on the potential issues. Feel free to adjust further!
Glenn JocherUltralytics@new-php thank you for your feedback! We'll review the guide to improve clarity in training steps and configurations. For detailed YOLO11 training examples in JupyterLab, see our FAQ section with code snippets and best practices. Visual enhancements are planned for future updates.