Ultralytics YOLO27:

Guía sobre cómo usar JupyterLab para entrenar tus modelos YOLO26#

Crear modelos de aprendizaje profundo puede ser complicado, especialmente si no tienes las herramientas o el entorno adecuados para trabajar. Si te encuentras con este problema, JupyterLab podría ser la solución adecuada para ti. JupyterLab es una plataforma web intuitiva que hace que programar sea más flexible e interactivo. Puedes usarla para gestionar grandes conjuntos de datos, crear modelos complejos e incluso colaborar con otras personas, todo en un mismo lugar.

Puedes usar JupyterLab para trabajar en proyectos relacionados con modelos YOLO26 de Ultralytics. JupyterLab es una opción excelente para desarrollar modelos y realizar experimentos de forma eficiente. Te permite empezar fácilmente a experimentar con el entrenamiento de modelos YOLO26 directamente desde tu ordenador. Vamos a profundizar en JupyterLab, sus funciones principales y cómo puedes usarlo para entrenar modelos YOLO26.

¿Qué es JupyterLab?#

JupyterLab es una plataforma web de código abierto diseñada para trabajar con notebooks, código y datos de Jupyter. Es una evolución de la interfaz tradicional de Jupyter Notebook que ofrece una experiencia de usuario más versátil y potente.

JupyterLab te permite trabajar con notebooks, editores de texto, terminales y otras herramientas en un mismo lugar. Su diseño flexible te permite organizar el espacio de trabajo según tus necesidades y facilita tareas como el análisis de datos, la visualización y el aprendizaje automático. JupyterLab también admite la colaboración en tiempo real, por lo que es ideal para proyectos de equipo en investigación y ciencia de datos.

Funciones principales de JupyterLab#

Estas son algunas de las funciones principales que hacen de JupyterLab una excelente opción para desarrollar modelos y experimentar con ellos:

  • Espacio de trabajo todo en uno: JupyterLab es una solución integral para todas tus necesidades de ciencia de datos. A diferencia de Jupyter Notebook clásico, que tenía interfaces independientes para editar texto, acceder al terminal y trabajar con notebooks, JupyterLab integra todas estas funciones en un único entorno cohesionado. Puedes ver y editar distintos formatos de archivo, incluidos JPEG, PDF y CSV, directamente desde JupyterLab. Un espacio de trabajo todo en uno te permite acceder a todo lo que necesitas al instante, agilizando tu flujo de trabajo y ahorrándote tiempo.
  • Diseños flexibles: Una de las funciones más destacadas de JupyterLab es su diseño flexible. Puedes arrastrar, soltar y cambiar el tamaño de las pestañas para crear un diseño personalizado que te ayude a trabajar de forma más eficiente. La barra lateral izquierda plegable mantiene al alcance pestañas esenciales como el explorador de archivos, los kernels en ejecución y la paleta de comandos. Puedes tener varias ventanas abiertas a la vez, lo que te permite realizar varias tareas y gestionar tus proyectos de forma más eficaz.
  • Consolas de código interactivas: Las consolas de código de JupyterLab proporcionan un espacio interactivo para probar fragmentos de código o funciones. También sirven como registro de los cálculos realizados en un notebook. Crear una consola nueva para un notebook y consultar toda la actividad del kernel es muy sencillo. Esta función resulta especialmente útil cuando experimentas con ideas nuevas o solucionas problemas en tu código.
  • Vista previa de Markdown: Trabajar con archivos Markdown es más eficiente en JupyterLab gracias a su función de vista previa simultánea. Mientras escribes o editas tu archivo Markdown, puedes ver el resultado con formato en tiempo real. Esto facilita comprobar que tu documentación tiene el aspecto adecuado y evita tener que alternar entre los modos de edición y vista previa.
  • Ejecutar código desde archivos de texto: Si compartes un archivo de texto con código, JupyterLab facilita su ejecución directa dentro de la plataforma. Puedes seleccionar el código y pulsar Shift + Enter para ejecutarlo. Esto resulta ideal para verificar rápidamente fragmentos de código y ayuda a garantizar que el código que compartes funciona y no contiene errores.

¿Por qué deberías usar JupyterLab para tus proyectos YOLO26?#

Existen varias plataformas para desarrollar y evaluar modelos de aprendizaje automático, así que ¿qué hace destacar a JupyterLab? Exploremos algunos de los aspectos únicos que JupyterLab ofrece para tus proyectos de aprendizaje automático:

  • Gestión sencilla de celdas: Gestionar celdas en JupyterLab es muy fácil. En lugar del engorroso método de cortar y pegar, solo tienes que arrastrar y soltar las celdas para reorganizarlas.
  • Copiar celdas entre notebooks: JupyterLab facilita copiar celdas entre distintos notebooks. Puedes arrastrar y soltar celdas de un notebook a otro.
  • Cambio sencillo a la vista clásica de Notebook: Si echas de menos la interfaz clásica de Jupyter Notebook, JupyterLab te permite volver a ella fácilmente. Solo tienes que sustituir /lab en la URL por /tree para volver a la vista de notebook que conoces.
  • Varias vistas: JupyterLab admite varias vistas del mismo notebook, algo especialmente útil para notebooks largos. Puedes abrir distintas secciones una junto a otra para compararlas o explorarlas, y los cambios realizados en una vista se reflejan en la otra.
  • Temas personalizables: JupyterLab incluye un tema oscuro integrado para el notebook, perfecto para programar hasta tarde. También hay temas para el editor de texto y el terminal, lo que te permite personalizar el aspecto de todo tu espacio de trabajo.

Problemas habituales al trabajar con JupyterLab#

Al trabajar con JupyterLab, es posible que te encuentres con algunos problemas habituales. Estos consejos te ayudarán a desenvolverte por la plataforma sin complicaciones:

  • Gestión de kernels: Los kernels son fundamentales porque gestionan la conexión entre el código que escribes en JupyterLab y el entorno donde se ejecuta. También pueden acceder a datos y compartirlos entre notebooks. Cuando cierras un Jupyter Notebook, es posible que el kernel siga ejecutándose porque otros notebooks podrían estar utilizándolo. Si quieres apagar un kernel por completo, selecciónalo, haz clic derecho y elige "Shut Down Kernel" en el menú emergente.
  • Instalar paquetes de Python: A veces puedes necesitar paquetes de Python adicionales que no estén preinstalados en el servidor. Puedes instalar fácilmente estos paquetes en tu directorio personal o en un entorno virtual mediante el comando python -m pip install package-name. Para ver todos los paquetes instalados, usa python -m pip list.
  • Implementar una API de Flask/FastAPI en Posit Connect: Puedes implementar tus API de Flask y FastAPI en Posit Connect usando el paquete rsconnect-python desde el terminal. Esto facilita la integración de tus aplicaciones web con JupyterLab y su uso compartido con otras personas.
  • Instalar extensiones de JupyterLab: JupyterLab admite diversas extensiones para ampliar sus funciones. Puedes instalar y personalizar estas extensiones según tus necesidades. Para obtener instrucciones detalladas, consulta la guía de extensiones de JupyterLab.
  • Usar varias versiones de Python: Si necesitas trabajar con distintas versiones de Python, puedes usar kernels de Jupyter configurados con diferentes versiones de Python.

Cómo usar JupyterLab para probar YOLO26#

JupyterLab facilita experimentar con YOLO26. Para empezar, sigue estos sencillos pasos.

Paso 1: Instala JupyterLab#

Primero tienes que instalar JupyterLab. Abre el terminal y ejecuta el comando:

Instalación
# Install the required package for JupyterLab
pip install jupyterlab

Paso 2: Descarga el notebook del tutorial de YOLO26#

A continuación, descarga el archivo tutorial.ipynb del repositorio de Ultralytics en GitHub. Guarda este archivo en cualquier directorio de tu máquina local.

Paso 3: Inicia JupyterLab#

Ve al directorio donde has guardado el archivo del notebook usando el terminal. Después, ejecuta el siguiente comando para iniciar JupyterLab:

Uso
jupyter lab

Cuando hayas ejecutado este comando, JupyterLab se abrirá en tu navegador web predeterminado, como se muestra a continuación.

Imagen que muestra cómo se abre JupyterLab en el navegador

Paso 4: Empieza a experimentar#

En JupyterLab, abre el notebook tutorial.ipynb. Ya puedes empezar a ejecutar las celdas para explorar y experimentar con YOLO26.

Imagen que muestra el notebook de YOLO26 abierto en JupyterLab

El entorno interactivo de JupyterLab te permite modificar código, visualizar resultados y documentar tus conclusiones en un mismo lugar. Puedes probar distintas configuraciones y entender cómo funciona YOLO26.

Para comprender en detalle el proceso de entrenamiento de modelos y las prácticas recomendadas, consulta la guía de entrenamiento de modelos YOLO26. Esta guía te ayudará a sacar el máximo partido a tus experimentos y a asegurarte de que usas YOLO26 de forma eficaz.

Sigue aprendiendo sobre JupyterLab#

Si quieres obtener más información sobre JupyterLab, estos recursos te ayudarán a empezar:

  • Documentación de JupyterLab: Consulta la documentación oficial de JupyterLab para explorar sus funciones y capacidades. Es una excelente forma de entender cómo utilizar al máximo esta potente herramienta.
  • Pruébalo con Binder: Experimenta con JupyterLab sin instalar nada usando Binder, que te permite iniciar una instancia activa de JupyterLab directamente en el navegador. Es una excelente forma de empezar a experimentar de inmediato.
  • Guía de instalación: Para consultar una guía paso a paso sobre cómo instalar JupyterLab en tu máquina local, echa un vistazo a la guía de instalación.
  • Entrena Ultralytics YOLO26 con JupyterLab: Descubre más sobre las aplicaciones prácticas de usar JupyterLab con modelos YOLO26 en esta entrada de blog detallada.

Resumen#

Hemos visto cómo JupyterLab puede ser una herramienta potente para experimentar con modelos Ultralytics YOLO26. Gracias a su entorno flexible e interactivo, puedes configurar fácilmente JupyterLab en tu máquina local y empezar a trabajar con YOLO26. JupyterLab facilita entrenar y evaluar tus modelos, visualizar resultados y documentar tus conclusiones en un mismo lugar.

A diferencia de otras plataformas como Google Colab, JupyterLab se ejecuta localmente en tu máquina, lo que te proporciona un mayor control sobre tu entorno informático sin dejar de ofrecer una experiencia de notebook interactiva. Esto resulta especialmente valioso para desarrolladores que necesitan acceder de forma constante a su entorno de desarrollo sin depender de recursos en la nube.

Para obtener más información, visita la página de preguntas frecuentes de JupyterLab.

¿Te interesan más integraciones de YOLO26? Consulta la guía de integraciones de Ultralytics para explorar herramientas y funciones adicionales para tus proyectos de aprendizaje automático.

Preguntas frecuentes#

  • Para entrenar un modelo YOLO26 con JupyterLab:

    1. Instala JupyterLab y el paquete de Ultralytics:

      pip install jupyterlab ultralytics

    2. Inicia JupyterLab y abre un notebook nuevo.

    3. Importa el modelo YOLO y carga un modelo preentrenado:

      from ultralytics import YOLO

model = YOLO("yolo26n.pt")

    4. Entrena el modelo con tu conjunto de datos personalizado:

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

    5. Visualiza los resultados del entrenamiento con las funciones de representación integradas de JupyterLab:

      from ultralytics.utils.plotting import plot_results

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

    El entorno interactivo de JupyterLab te permite modificar parámetros fácilmente, visualizar resultados y repetir el proceso de entrenamiento de tu modelo.

  • JupyterLab ofrece varias funciones que lo hacen ideal para proyectos YOLO26:

    1. Ejecución de código interactiva: Prueba y depura fragmentos de código de YOLO26 en tiempo real.
    2. Explorador de archivos integrado: Gestiona fácilmente conjuntos de datos, pesos de modelos y archivos de configuración.
    3. Diseño flexible: Organiza varios notebooks, terminales y ventanas de resultados uno junto a otro para trabajar de forma eficiente.
    4. Visualización avanzada de resultados: Visualiza en línea los resultados de detección de YOLO26, las curvas de entrenamiento y las métricas de rendimiento del modelo.
    5. Compatibilidad con Markdown: Documenta tus experimentos y conclusiones de YOLO26 con texto enriquecido e imágenes.
    6. Ecosistema de extensiones: Amplía las funciones con extensiones para el control de versiones, la computación remota y mucho más.

    Estas funciones permiten disfrutar de una experiencia de desarrollo fluida al trabajar con modelos YOLO26, desde la preparación de datos hasta la implementación del modelo.

  • Para optimizar el rendimiento de un modelo YOLO26 en JupyterLab:

    1. Utiliza AutoBatch para elegir el tamaño de lote más grande que quepa en la memoria de la GPU:

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

    2. Implementa el ajuste de hiperparámetros con bibliotecas como Ray Tune:

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

    3. Visualiza y analiza las métricas del modelo mediante las funciones de representación de JupyterLab:

      from ultralytics.utils.plotting import plot_results

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

    4. Experimenta con distintas arquitecturas de modelos y formatos de exportación para encontrar el mejor equilibrio entre velocidad y precisión para tu caso de uso específico.

    El entorno interactivo de JupyterLab permite iteraciones rápidas y recibir comentarios en tiempo real, lo que facilita optimizar tus modelos YOLO26 de forma eficiente.

  • Al trabajar con JupyterLab y YOLO26, es posible que te encuentres con algunos problemas habituales. Así puedes gestionarlos:

    1. Problemas de memoria de la GPU:

      • Usa torch.cuda.empty_cache() para liberar la memoria de la GPU entre ejecuciones.
      • Ajusta el tamaño de lote o el tamaño de la imagen para adaptarlos a la memoria de tu GPU.

    2. Conflictos entre paquetes:

      • Crea un entorno de conda independiente para tus proyectos YOLO26 y evita conflictos.
      • Usa !pip install package_name en una celda del notebook para instalar los paquetes que falten.

    3. Bloqueos del kernel:

      • Reinicia el kernel y ejecuta las celdas una por una para identificar el código problemático.
      • Comprueba si hay fugas de memoria en tu código, especialmente al procesar grandes conjuntos de datos.
Colaboradores
GLglenn-jocher11RAraimbekovm2RIRizwanMunawar2LALaughing-q2Y-Y-T-G1WIWillieMaddox1MAMatthewNoyce1AMambitious-octopus1ABabirami-vina1

Comentarios