Ultralytics YOLO27:

Eine Anleitung zur Verwendung von JupyterLab zum Trainieren deiner YOLO26-Modelle#

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

Du kannst JupyterLab nutzen, um an Projekten im Zusammenhang mit Ultralytics YOLO26-Modellen zu arbeiten. JupyterLab eignet sich hervorragend für die effiziente Modellentwicklung und das Experimentieren. Damit kannst du direkt auf deinem Computer einfach mit dem Experimentieren und Trainieren von YOLO26-Modellen beginnen. Sehen wir uns JupyterLab, seine wichtigsten Funktionen und die Verwendung zum Trainieren 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. Es ist eine Weiterentwicklung der herkömmlichen Jupyter-Notebook-Oberfläche und bietet eine vielseitigere und leistungsfähigere Benutzererfahrung.

Mit JupyterLab kannst du an Notebooks, Texteditoren, Terminals und anderen Werkzeugen an einem Ort arbeiten. Durch das flexible Design kannst du deinen Arbeitsbereich an deine Anforderungen anpassen. Dadurch werden Aufgaben wie Datenanalyse, Visualisierung und maschinelles Lernen erleichtert. JupyterLab unterstützt außerdem die Zusammenarbeit in Echtzeit und eignet sich daher ideal für Teamprojekte in Forschung und Datenwissenschaft.

Wichtige Funktionen von JupyterLab#

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

  • Arbeitsbereich für alles: JupyterLab ist eine zentrale Anlaufstelle für alle deine Anforderungen in der Datenwissenschaft. Im Gegensatz zum klassischen Jupyter Notebook, das separate Oberflächen für Textbearbeitung, Terminalzugriff und Notebooks bot, integriert JupyterLab all diese Funktionen in einer einheitlichen Umgebung. Du kannst verschiedene Dateiformate, darunter JPEG, PDF und CSV, direkt in JupyterLab anzeigen und bearbeiten. In einem zentralen Arbeitsbereich hast du alles Notwendige direkt zur Hand, optimierst deinen Arbeitsablauf und sparst Zeit.
  • Flexible Layouts: Eine der herausragenden Funktionen von JupyterLab ist das flexible Layout. Du kannst Tabs per Drag-and-drop verschieben und ihre Größe ändern, um ein personalisiertes Layout zu erstellen, mit dem du effizienter arbeitest. Die einklappbare Seitenleiste auf der linken Seite bietet schnellen Zugriff auf wichtige Tabs wie den Dateibrowser, laufende Kernel und die Befehlspalette. Du kannst mehrere Fenster gleichzeitig geöffnet haben und so effektiver mehrere Aufgaben erledigen und deine Projekte verwalten.
  • Interaktive Codekonsolen: Codekonsolen in JupyterLab bieten einen interaktiven Bereich zum Testen von Codeausschnitten oder Funktionen. Außerdem dienen sie als Protokoll der Berechnungen, die innerhalb eines Notebooks durchgeführt wurden. Eine neue Konsole für ein Notebook zu erstellen und alle Kernel-Aktivitäten anzuzeigen, ist unkompliziert. Diese Funktion ist besonders nützlich, wenn du neue Ideen ausprobierst oder Fehler in deinem Code suchst.
  • Markdown-Vorschau: Die Arbeit mit Markdown-Dateien ist in JupyterLab dank der Funktion zur gleichzeitigen Vorschau effizienter. Während du deine Markdown-Datei schreibst oder bearbeitest, kannst du die formatierte Ausgabe in Echtzeit sehen. So lässt sich leichter überprüfen, ob deine Dokumentation korrekt aussieht, ohne ständig zwischen Bearbeitungs- und Vorschaumodus wechseln zu müssen.
  • Code aus Textdateien ausführen: Wenn du eine Textdatei mit Code teilst, kannst du sie mit JupyterLab einfach direkt innerhalb der Plattform ausführen. Markiere den Code und drücke Umschalt + Eingabetaste, um ihn auszuführen. Das eignet sich hervorragend, um Codeausschnitte schnell zu überprüfen, und hilft sicherzustellen, dass der geteilte Code funktioniert und fehlerfrei ist.

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

Es gibt mehrere Plattformen zur Entwicklung und Bewertung von Modellen für maschinelles Lernen. Was hebt JupyterLab also hervor? Sehen wir uns einige der besonderen Aspekte an, die JupyterLab für deine Projekte im Bereich maschinelles Lernen bietet:

  • Einfache Zellverwaltung: Die Verwaltung von Zellen in JupyterLab ist unkompliziert. Statt der umständlichen Ausschneiden-und-Einfügen-Methode kannst du Zellen einfach per Drag-and-drop neu anordnen.
  • Zellen zwischen Notebooks kopieren: Mit JupyterLab kannst du Zellen problemlos zwischen verschiedenen Notebooks kopieren. Ziehe die Zellen einfach per Drag-and-drop von einem Notebook in ein anderes.
  • Einfach zum klassischen Notebook-Modus wechseln: Wenn du die klassische Jupyter-Notebook-Oberfläche vermisst, kannst du mit JupyterLab einfach zurückwechseln. Ersetze dazu /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 dabei in der anderen übernommen.
  • Anpassbare Designs: JupyterLab enthält ein integriertes dunkles Design für das Notebook, das sich ideal für nächtliche Programmiersitzungen eignet. Auch für den Texteditor und das Terminal sind Designs verfügbar, sodass 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 einige Tipps, die dir die Arbeit mit der Plattform erleichtern:

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

So verwendest du JupyterLab, um YOLO26 auszuprobieren#

Mit JupyterLab kannst du einfach mit YOLO26 experimentieren. Befolge zum Einstieg diese einfachen Schritte.

Schritt 1: JupyterLab installieren#

Zuerst musst du JupyterLab installieren. Öffne dein Terminal und führe den folgenden Befehl aus:

Installation
# Install the required package for JupyterLab
pip install jupyterlab

Schritt 2: Das YOLO26-Tutorial-Notebook herunterladen#

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

Schritt 3: JupyterLab starten#

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

Verwendung
jupyter lab

Nachdem du diesen Befehl ausgeführt hast, wird JupyterLab in deinem Standard-Webbrowser geöffnet, wie unten dargestellt.

Abbildung zum Öffnen von JupyterLab im Browser

Schritt 4: Mit dem Experimentieren beginnen#

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

Abbildung des geöffneten YOLO26-Notebooks in JupyterLab

Die interaktive Umgebung von JupyterLab ermöglicht es dir, Code zu ändern, Ausgaben zu visualisieren und deine Ergebnisse an einem Ort zu dokumentieren. Du kannst verschiedene Konfigurationen ausprobieren und verstehen, wie YOLO26 funktioniert.

Eine ausführliche Beschreibung des Modelltrainingsprozesses und bewährter 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.

Weiterführende Informationen zu JupyterLab#

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

  • JupyterLab-Dokumentation: In der offiziellen JupyterLab-Dokumentation kannst du die Funktionen und Möglichkeiten der Plattform erkunden. Sie hilft dir dabei, die vielseitige Plattform optimal zu nutzen.
  • Mit Binder ausprobieren: Experimentiere mit JupyterLab, ohne etwas zu installieren. Mit Binder kannst du direkt in deinem Browser eine aktive JupyterLab-Instanz starten. So kannst du sofort mit dem Experimentieren beginnen.
  • Installationsanleitung: Eine schrittweise Anleitung zur Installation von JupyterLab auf deinem lokalen Computer findest du in der Installationsanleitung.
  • Ultralytics YOLO26 mit JupyterLab trainieren: In diesem ausführlichen Blogbeitrag erfährst du mehr über die praktische Verwendung von JupyterLab mit YOLO26-Modellen.

Zusammenfassung#

Wir haben untersucht, wie JupyterLab ein leistungsfähiges Werkzeug zum Experimentieren mit Ultralytics YOLO26-Modellen sein kann. Dank der flexiblen und interaktiven Umgebung kannst du JupyterLab einfach auf deinem lokalen Computer einrichten und mit YOLO26 arbeiten. Mit JupyterLab kannst du deine Modelle an einem Ort einfach trainieren und bewerten, Ausgaben visualisieren und deine Ergebnisse dokumentieren.

Im Gegensatz zu anderen 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 wertvoll für Entwickler, die dauerhaft auf ihre Entwicklungsumgebung zugreifen müssen, ohne auf Cloud-Ressourcen angewiesen zu sein.

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

Interessierst du dich für weitere YOLO26-Integrationen? Sieh dir den Ultralytics-Integrationsleitfaden an, um zusätzliche Werkzeuge und Funktionen für deine Projekte im Bereich maschinelles Lernen zu entdecken.

FAQ#

  • 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 Darstellungsfunktionen von JupyterLab:

      from ultralytics.utils.plotting import plot_results

plot_results("runs/detect/train/results.csv")

    Die interaktive Umgebung von JupyterLab ermöglicht es dir, Parameter einfach zu ändern, Ergebnisse zu visualisieren und deinen Modelltrainingsprozess schrittweise zu verbessern.

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

    1. Interaktive Codeausführung: Teste und debugge YOLO26-Codeausschnitte in Echtzeit.
    2. Integrierter Dateibrowser: Verwalte Datensätze, Modellgewichte und Konfigurationsdateien einfach.
    3. Flexibles Layout: Ordne mehrere Notebooks, Terminals und Ausgabefenster für einen effizienten Arbeitsablauf nebeneinander an.
    4. Umfangreiche Ausgabeanzeige: Visualisiere YOLO26-Erkennungsergebnisse, Trainingskurven und Kennzahlen zur Modellleistung direkt im Notebook.
    5. Markdown-Unterstützung: Dokumentiere deine YOLO26-Experimente und Ergebnisse mit formatiertem Text und Bildern.
    6. Erweiterungsökosystem: Erweitere den Funktionsumfang mit Erweiterungen für Versionsverwaltung, Remote-Rechenressourcen 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 Batch-Größe zu wählen, die in den GPU-Speicher passt:

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

    2. Führe Hyperparameter-Optimierung 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 Darstellungsfunktionen von JupyterLab:

      from ultralytics.utils.plotting import plot_results

plot_results("runs/detect/train/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 Feedback in Echtzeit. Dadurch kannst du deine YOLO26-Modelle 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 Ausführungen zu leeren.
      • Passe die Batch-Größe oder die Bildgröße an den verfügbaren GPU-Speicher an.

    2. Paketkonflikte:

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

    3. Kernel-Abstürze:

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

Kommentare