Modifier la page sur GitHub (EN)

Guide sur l'utilisation de JupyterLab pour entraîner tes modèles YOLO26

Construire des modèles de deep learning peut être difficile, surtout si tu n'as pas les bons outils ou le bon environnement. Si tu rencontres ce problème, JupyterLab pourrait être la solution idéale. JupyterLab est une plateforme web conviviale qui rend le codage plus flexible et interactif. Tu peux l'utiliser pour gérer de grands jeux de données, créer des modèles complexes et même collaborer avec d'autres personnes, le tout au même endroit.

Tu peux utiliser JupyterLab pour travailler sur des projets liés aux modèles Ultralytics YOLO26. JupyterLab est une excellente option pour le développement et l'expérimentation efficaces de modèles. Il facilite le démarrage de tes expériences et l'entraînement de modèles YOLO26 directement depuis ton ordinateur. Plongeons dans JupyterLab, ses fonctionnalités clés et la manière dont tu peux l'utiliser pour entraîner des modèles YOLO26.

Qu'est-ce que JupyterLab ?

JupyterLab est une plateforme web open-source conçue pour travailler avec des notebooks Jupyter, du code et des données. C'est une mise à jour de l'interface traditionnelle Jupyter Notebook qui offre une expérience utilisateur plus polyvalente et puissante.

JupyterLab te permet de travailler avec des notebooks, des éditeurs de texte, des terminaux et d'autres outils au même endroit. Sa conception flexible te permet d'organiser ton espace de travail selon tes besoins et facilite l'exécution de tâches comme l'analyse de données, la visualisation et le machine learning. JupyterLab prend également en charge la collaboration en temps réel, ce qui le rend idéal pour les projets d'équipe en recherche et en science des données.

Fonctionnalités clés de JupyterLab

Voici quelques-unes des fonctionnalités clés qui font de JupyterLab une excellente option pour le développement et l'expérimentation de modèles :

  • Espace de travail tout-en-un : JupyterLab est une solution centralisée pour tous tes besoins en science des données. Contrairement au Jupyter Notebook classique, qui avait des interfaces séparées pour l'édition de texte, l'accès au terminal et les notebooks, JupyterLab intègre toutes ces fonctionnalités dans un environnement unique et cohérent. Tu peux afficher et modifier divers formats de fichiers, y compris JPEG, PDF et CSV, directement dans JupyterLab. Un espace de travail tout-en-un te permet d'accéder à tout ce dont tu as besoin, rationalisant ton flux de travail et te faisant gagner du temps.
  • Mises en page flexibles : L'une des fonctionnalités remarquables de JupyterLab est sa mise en page flexible. Tu peux glisser, déposer et redimensionner des onglets pour créer une disposition personnalisée qui t'aide à travailler plus efficacement. La barre latérale gauche pliable garde les onglets essentiels comme le navigateur de fichiers, les noyaux actifs et la palette de commandes à portée de main. Tu peux ouvrir plusieurs fenêtres à la fois, ce qui te permet d'effectuer plusieurs tâches et de gérer tes projets plus efficacement.
  • Consoles de code interactives : Les consoles de code dans JupyterLab offrent un espace interactif pour tester des extraits de code ou des fonctions. Elles servent également de journal des calculs effectués dans un notebook. Créer une nouvelle console pour un notebook et visualiser toute l'activité du noyau est simple. Cette fonctionnalité est particulièrement utile lorsque tu expérimentes de nouvelles idées ou que tu corriges des problèmes dans ton code.
  • Aperçu Markdown : Travailler avec des fichiers Markdown est plus efficace dans JupyterLab, grâce à sa fonctionnalité d'aperçu simultané. Au fur et à mesure que tu écris ou modifies ton fichier Markdown, tu peux voir le résultat formaté en temps réel. Il est ainsi plus facile de vérifier que ta documentation est parfaite, t'évitant de faire des allers-retours entre les modes édition et prévisualisation.
  • Exécuter du code à partir de fichiers texte : Si tu partages un fichier texte contenant du code, JupyterLab permet de l'exécuter facilement directement dans la plateforme. Tu peux mettre le code en surbrillance et appuyer sur Shift + Enter pour l'exécuter. C'est idéal pour vérifier rapidement des extraits de code et garantir que le code que tu partages est fonctionnel et sans erreur.

Pourquoi devrais-tu utiliser JupyterLab pour tes projets YOLO26 ?

Il existe de multiples plateformes pour développer et évaluer des modèles de machine learning, alors qu'est-ce qui rend JupyterLab unique ? Explorons certains des aspects uniques que JupyterLab offre pour tes projets de machine learning :

  • Gestion facile des cellules : Gérer des cellules dans JupyterLab est un jeu d'enfant. Au lieu de la méthode fastidieuse de couper-coller, tu peux simplement glisser et déposer les cellules pour les réorganiser.
  • Copie de cellules entre notebooks : JupyterLab simplifie la copie de cellules entre différents notebooks. Tu peux glisser et déposer des cellules d'un notebook à un autre.
  • Basculement facile vers la vue classique : Pour ceux qui regrettent l'interface classique de Jupyter Notebook, JupyterLab offre une option pour y revenir facilement. Remplace simplement /lab dans l'URL par /tree pour retourner à la vue familière.
  • Vues multiples : JupyterLab prend en charge plusieurs vues du même notebook, ce qui est particulièrement utile pour les longs notebooks. Tu peux ouvrir différentes sections côte à côte pour comparaison ou exploration, et tout changement effectué dans une vue est répercuté dans l'autre.
  • Thèmes personnalisables : JupyterLab inclut un thème sombre intégré pour le notebook, parfait pour les sessions de codage tardives. Il existe également des thèmes disponibles pour l'éditeur de texte et le terminal, te permettant de personnaliser l'apparence de tout ton espace de travail.

Problèmes courants lors de l'utilisation de JupyterLab

En travaillant avec JupyterLab, tu pourrais rencontrer certains problèmes courants. Voici quelques conseils pour t'aider à naviguer facilement sur la plateforme :

  • Gestion des noyaux (Kernels) : Les noyaux sont cruciaux car ils gèrent la connexion entre le code que tu écris dans JupyterLab et l'environnement où il s'exécute. Ils peuvent également accéder à des données et les partager entre les notebooks. Lorsque tu fermes un Jupyter Notebook, le noyau peut continuer à tourner car d'autres notebooks pourraient l'utiliser. Si tu souhaites arrêter complètement un noyau, tu peux le sélectionner, faire un clic droit et choisir "Shut Down Kernel" dans le menu contextuel.
  • Installation de packages Python : Parfois, tu pourrais avoir besoin de packages Python supplémentaires qui ne sont pas pré-installés sur le serveur. Tu peux facilement installer ces packages dans ton répertoire personnel ou dans un environnement virtuel en utilisant la commande python -m pip install package-name. Pour voir tous les packages installés, utilise python -m pip list.
  • Déploiement d'API Flask/FastAPI sur Posit Connect : Tu peux déployer tes API Flask et FastAPI sur Posit Connect en utilisant le package rsconnect-python depuis le terminal. Cela facilite l'intégration de tes applications web avec JupyterLab et leur partage avec d'autres.
  • Installation d'extensions JupyterLab : JupyterLab prend en charge diverses extensions pour améliorer ses fonctionnalités. Tu peux installer et personnaliser ces extensions selon tes besoins. Pour des instructions détaillées, consulte le JupyterLab Extensions Guide pour plus d'informations.
  • Utilisation de plusieurs versions de Python : Si tu dois travailler avec différentes versions de Python, tu peux utiliser des noyaux Jupyter configurés avec différentes versions de Python.

Comment utiliser JupyterLab pour essayer YOLO26

JupyterLab facilite l'expérimentation avec YOLO26. Pour commencer, suis ces étapes simples.

Étape 1 : Installer JupyterLab

Tout d'abord, tu dois installer JupyterLab. Ouvre ton terminal et exécute la commande :

Installation
# Install the required package for JupyterLab
pip install jupyterlab

Étape 2 : Télécharger le notebook de tutoriel YOLO26

Ensuite, télécharge le fichier tutorial.ipynb depuis le dépôt GitHub d'Ultralytics. Enregistre ce fichier dans n'importe quel répertoire sur ta machine locale.

Étape 3 : Lancer JupyterLab

Navigue vers le répertoire où tu as enregistré le fichier de notebook en utilisant ton terminal. Ensuite, exécute la commande suivante pour lancer JupyterLab :

Utilisation
jupyter lab

Une fois cette commande exécutée, JupyterLab s'ouvrira dans ton navigateur web par défaut, comme indiqué ci-dessous.

Image montrant comment JupyterLab s'ouvre dans le navigateur

Étape 4 : Commencer l'expérimentation

Dans JupyterLab, ouvre le notebook tutorial.ipynb. Tu peux maintenant commencer à exécuter les cellules pour explorer et expérimenter avec YOLO26.

Image montrant le notebook YOLO26 ouvert dans JupyterLab

L'environnement interactif de JupyterLab te permet de modifier le code, de visualiser les résultats et de documenter tes découvertes au même endroit. Tu peux essayer différentes configurations et comprendre comment YOLO26 fonctionne.

For a detailed understanding of the model training process and best practices, refer to the YOLO26 Model Training guide. This guide will help you get the most out of your experiments and ensure you're using YOLO26 effectively.

Continuer à apprendre sur JupyterLab

Si tu veux en savoir plus sur JupyterLab, voici des ressources pour t'aider à démarrer :

  • Documentation JupyterLab : Plonge dans la documentation officielle de JupyterLab pour explorer ses fonctionnalités et ses capacités. C'est un excellent moyen de comprendre comment utiliser cet outil puissant à son plein potentiel.
  • Essaie avec Binder : Expérimente avec JupyterLab sans rien installer en utilisant Binder, qui te permet de lancer une instance JupyterLab en direct directement dans ton navigateur. C'est un excellent moyen de commencer à expérimenter immédiatement.
  • Guide d'installation : Pour un guide étape par étape sur l'installation de JupyterLab sur ta machine locale, consulte le guide d'installation.
  • Entraîner Ultralytics YOLO26 avec JupyterLab : Apprends-en plus sur les applications pratiques de l'utilisation de JupyterLab avec les modèles YOLO26 dans cet article de blog détaillé.

Résumé

Nous avons exploré comment JupyterLab peut être un outil puissant pour expérimenter avec les modèles Ultralytics YOLO26. En utilisant son environnement flexible et interactif, tu peux facilement configurer JupyterLab sur ta machine locale et commencer à travailler avec YOLO26. JupyterLab rend simple l'entraînement entraîner et l'évaluation évaluer de tes modèles, la visualisation des résultats et la documentation de tes découvertes le tout au même endroit.

Contrairement à d'autres plateformes comme Google Colab, JupyterLab s'exécute localement sur ta machine, te donnant plus de contrôle sur ton environnement de calcul tout en offrant une expérience de notebook interactif. Cela le rend particulièrement précieux pour les développeurs qui ont besoin d'un accès constant à leur environnement de développement sans dépendre de ressources cloud.

Pour plus de détails, visite la page FAQ de JupyterLab.

Intéressé par plus d'intégrations YOLO26 ? Consulte le guide d'intégration d'Ultralytics pour explorer des outils et capacités supplémentaires pour tes projets de machine learning.

FAQ

Comment puis-je utiliser JupyterLab pour entraîner un modèle YOLO26 ?

Pour entraîner un modèle YOLO26 en utilisant JupyterLab :

  1. Installe JupyterLab et le package Ultralytics :

    pip install jupyterlab ultralytics

  2. Lance JupyterLab et ouvre un nouveau notebook.

  3. Importe le modèle YOLO et charge un modèle pré-entraîné :

    from ultralytics import YOLO

model = YOLO("yolo26n.pt")

  4. Entraîne le modèle sur ton propre jeu de données :

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

  5. Visualise les résultats de l'entraînement en utilisant les capacités de traçage intégrées de JupyterLab :

    import matplotlib

from ultralytics.utils.plotting import plot_results

matplotlib.use("inline")  # or 'notebook' for interactive
plot_results(results)

L'environnement interactif de JupyterLab te permet de modifier facilement les paramètres, de visualiser les résultats et d'itérer sur ton processus d'entraînement de modèle.

Quelles sont les fonctionnalités clés de JupyterLab qui le rendent adapté aux projets YOLO26 ?

JupyterLab offre plusieurs fonctionnalités qui le rendent idéal pour les projets YOLO26 :

  1. Exécution de code interactive : Teste et débogue des extraits de code YOLO26 en temps réel.
  2. Navigateur de fichiers intégré : Gère facilement les jeux de données, les poids des modèles et les fichiers de configuration.
  3. Mise en page flexible : Organise plusieurs notebooks, terminaux et fenêtres de sortie côte à côte pour un flux de travail efficace.
  4. Affichage de sortie riche : Visualise les résultats de détection YOLO26, les courbes d'entraînement et les métriques de performance du modèle en ligne.
  5. Prise en charge Markdown : Documente tes expériences et découvertes YOLO26 avec du texte riche et des images.
  6. Écosystème d'extensions : Améliore les fonctionnalités avec des extensions pour le contrôle de version, le calcul distant, et plus encore.

Ces fonctionnalités permettent une expérience de développement fluide lorsque tu travailles avec des modèles YOLO26, de la préparation des données au déploiement de modèles.

Comment puis-je optimiser la performance d'un modèle YOLO26 en utilisant JupyterLab ?

Pour optimiser la performance du modèle YOLO26 dans JupyterLab :

  1. Utilise la fonctionnalité autobatch pour déterminer la taille de lot (batch size) optimale :

    from ultralytics.utils.autobatch import autobatch

optimal_batch_size = autobatch(model)

  2. Implémente l'optimisation des hyperparamètres en utilisant des bibliothèques comme Ray Tune :

    from ultralytics.utils.tuner import run_ray_tune

best_results = run_ray_tune(model, data="path/to/data.yaml")

  3. Visualise et analyse les métriques du modèle en utilisant les capacités de traçage de JupyterLab :

    from ultralytics.utils.plotting import plot_results

plot_results(results.results_dict)

  4. Expérimente avec différentes architectures de modèle et formats d'exportation pour trouver le meilleur équilibre entre vitesse et précision pour ton cas d'utilisation spécifique.

L'environnement interactif de JupyterLab permet des itérations rapides et des retours en temps réel, rendant plus facile l'optimisation efficace de tes modèles YOLO26.

Comment gérer les problèmes courants lors de l'utilisation de JupyterLab et YOLO26 ?

Lorsque tu travailles avec JupyterLab et YOLO26, tu peux rencontrer certains problèmes courants. Voici comment les gérer :

  1. Problèmes de mémoire GPU :

    • Utilise torch.cuda.empty_cache() pour libérer la mémoire GPU entre les exécutions.
    • Ajuste la taille de lot ou la taille de l'image pour l'adapter à la mémoire de ton GPU.

  2. Conflits de packages :

    • Crée un environnement conda séparé pour tes projets YOLO26 afin d'éviter les conflits.
    • Utilise !pip install package_name dans une cellule de notebook pour installer les packages manquants.

  3. Plantages du noyau :

    • Redémarre le noyau et exécute les cellules une par une pour identifier le code problématique.
    • Vérifie les fuites de mémoire dans ton code, surtout lors du traitement de grands jeux de données.
Contributors
Modifier la page sur GitHub (EN)
GLglenn-jocher8RIRizwanMunawar2LALaughing-q2Y-Y-T-G1WIWillie Maddox1MAMatthewNoyce1AMambitious-octopus1ABabirami-vina1

Commentaires