Ultralytics YOLO27:
Get Started

Guia de uso do JupyterLab para treinar seus modelos YOLO26#

Criar modelos de aprendizado profundo pode ser difícil, especialmente quando você não tem as ferramentas ou o ambiente certos para trabalhar. Se você estiver enfrentando esse problema, o JupyterLab pode ser a solução ideal. O JupyterLab é uma plataforma baseada na Web, fácil de usar, que torna a programação mais flexível e interativa. Você pode usá-la para lidar com grandes conjuntos de dados, criar modelos complexos e até colaborar com outras pessoas, tudo em um só lugar.

Você pode usar o JupyterLab para trabalhar em projetos relacionados aos modelos Ultralytics YOLO26. O JupyterLab é uma ótima opção para desenvolver modelos e fazer experimentos com eficiência. Com ele, é fácil começar a experimentar e treinar modelos YOLO26 diretamente no seu computador. Vamos explorar mais a fundo o JupyterLab, seus principais recursos e como você pode usá-lo para treinar modelos YOLO26.

O que é o JupyterLab?#

O JupyterLab é uma plataforma de código aberto baseada na Web, desenvolvida para trabalhar com notebooks Jupyter, código e dados. É uma versão aprimorada da interface tradicional do Jupyter Notebook, que oferece uma experiência de uso mais versátil e poderosa.

O JupyterLab permite trabalhar com notebooks, editores de texto, terminais e outras ferramentas em um só lugar. Seu design flexível permite organizar o espaço de trabalho de acordo com suas necessidades e facilita tarefas como análise de dados, visualização e aprendizado de máquina. O JupyterLab também oferece suporte à colaboração em tempo real, sendo ideal para projetos de equipe em pesquisa e ciência de dados.

Principais recursos do JupyterLab#

Veja alguns dos principais recursos que fazem do JupyterLab uma ótima opção para desenvolver modelos e fazer experimentos:

  • Espaço de trabalho completo: o JupyterLab reúne tudo o que você precisa para ciência de dados. Ao contrário do Jupyter Notebook clássico, que tinha interfaces separadas para edição de texto, acesso ao terminal e notebooks, o JupyterLab integra todos esses recursos em um único ambiente coeso. Você pode visualizar e editar vários formatos de arquivo, incluindo JPEG, PDF e CSV, diretamente no JupyterLab. Um espaço de trabalho completo deixa tudo o que você precisa ao alcance dos dedos, simplifica seu fluxo de trabalho e economiza tempo.
  • Layouts flexíveis: um dos principais recursos do JupyterLab é o layout flexível. Você pode arrastar, soltar e redimensionar abas para criar um layout personalizado que ajuda a trabalhar com mais eficiência. A barra lateral esquerda recolhível mantém abas essenciais, como o navegador de arquivos, os kernels em execução e a paleta de comandos, sempre à mão. Você pode deixar várias janelas abertas ao mesmo tempo, o que permite realizar várias tarefas e gerenciar seus projetos com mais eficiência.
  • Consoles de código interativos: os consoles de código do JupyterLab oferecem um espaço interativo para testar trechos de código ou funções. Eles também registram os cálculos realizados em um notebook. É simples criar um novo console para um notebook e visualizar toda a atividade do kernel. Esse recurso é especialmente útil quando você está experimentando novas ideias ou solucionando problemas no código.
  • Pré-visualização de Markdown: trabalhar com arquivos Markdown é mais eficiente no JupyterLab, graças ao recurso de pré-visualização simultânea. Enquanto escreve ou edita seu arquivo Markdown, você pode ver o resultado formatado em tempo real. Assim, fica mais fácil conferir se a documentação está perfeita, sem precisar alternar entre os modos de edição e pré-visualização.
  • Executar código de arquivos de texto: se você estiver compartilhando um arquivo de texto com código, o JupyterLab facilita a execução direta na plataforma. Basta selecionar o código e pressionar Shift + Enter para executá-lo. Isso é ótimo para verificar rapidamente trechos de código e ajuda a garantir que o código compartilhado funcione e não tenha erros.

Por que usar o JupyterLab nos seus projetos YOLO26?#

Existem várias plataformas para desenvolver e avaliar modelos de aprendizado de máquina. Então, o que diferencia o JupyterLab? Vamos explorar alguns dos recursos exclusivos que ele oferece para seus projetos de aprendizado de máquina:

  • Gerenciamento fácil de células: gerenciar células no JupyterLab é muito simples. Em vez de usar o incômodo método de recortar e colar, basta arrastar e soltar as células para reorganizá-las.
  • Copiar células entre notebooks: o JupyterLab facilita a cópia de células entre diferentes notebooks. Você pode arrastar e soltar células de um notebook para outro.
  • Alternar facilmente para a visualização clássica do Notebook: se você sente falta da interface clássica do Jupyter Notebook, o JupyterLab oferece uma maneira simples de voltar a ela. Basta substituir /lab na URL por /tree para voltar à visualização familiar do notebook.
  • Várias visualizações: o JupyterLab oferece várias visualizações do mesmo notebook, um recurso especialmente útil para notebooks longos. Você pode abrir diferentes seções lado a lado para compará-las ou explorá-las, e as alterações feitas em uma visualização aparecem na outra.
  • Temas personalizáveis: o JupyterLab inclui um tema escuro para o notebook, perfeito para programar até tarde da noite. Também há temas para o editor de texto e o terminal, permitindo personalizar a aparência de todo o espaço de trabalho.

Problemas comuns ao trabalhar com o JupyterLab#

Ao trabalhar com o JupyterLab, você pode se deparar com alguns problemas comuns. Veja algumas dicas para usar a plataforma sem complicações:

  • Gerenciamento de kernels: os kernels são fundamentais porque gerenciam a conexão entre o código que você escreve no JupyterLab e o ambiente em que ele é executado. Eles também podem acessar e compartilhar dados entre notebooks. Quando você fecha um Jupyter Notebook, o kernel pode continuar em execução porque outros notebooks podem estar usando-o. Para desligar completamente um kernel, selecione-o, clique com o botão direito e escolha "Shut Down Kernel" no menu pop-up.
  • Instalação de pacotes Python: às vezes, você pode precisar de pacotes Python adicionais que não vêm pré-instalados no servidor. É fácil instalá-los no diretório pessoal ou em um ambiente virtual usando o comando python -m pip install package-name. Para ver todos os pacotes instalados, use python -m pip list.
  • Implantação de API Flask/FastAPI no Posit Connect: você pode implantar suas APIs Flask e FastAPI no Posit Connect usando o pacote rsconnect-python pelo terminal. Isso facilita a integração dos seus aplicativos Web com o JupyterLab e o compartilhamento deles com outras pessoas.
  • Instalação de extensões do JupyterLab: o JupyterLab oferece suporte a várias extensões que ampliam sua funcionalidade. Você pode instalar e personalizar essas extensões para atender às suas necessidades. Para ver instruções detalhadas, consulte o guia de extensões do JupyterLab.
  • Uso de várias versões do Python: se você precisar trabalhar com diferentes versões do Python, poderá usar kernels do Jupyter configurados com versões distintas do Python.

Como usar o JupyterLab para testar o YOLO26#

O JupyterLab facilita a experimentação com o YOLO26. Para começar, siga estas etapas simples.

Etapa 1: instalar o JupyterLab#

Primeiro, você precisa instalar o JupyterLab. Abra o terminal e execute o comando:

Instalação
# Install the required package for JupyterLab
pip install jupyterlab

Etapa 2: baixar o notebook do tutorial do YOLO26#

Em seguida, baixe o arquivo tutorial.ipynb do repositório da Ultralytics no GitHub. Salve o arquivo em qualquer diretório do seu computador local.

Etapa 3: iniciar o JupyterLab#

No terminal, navegue até o diretório em que você salvou o arquivo do notebook. Em seguida, execute o seguinte comando para iniciar o JupyterLab:

Uso
jupyter lab

Depois de executar este comando, o JupyterLab será aberto no navegador padrão, conforme mostrado abaixo.

Imagem mostrando como o JupyterLab é aberto no navegador

Etapa 4: Começa a experimentar#

No JupyterLab, abre o notebook tutorial.ipynb. Agora podes começar a executar as células para explorar e experimentar o YOLO26.

Imagem do notebook do YOLO26 aberto no JupyterLab

O ambiente interativo do JupyterLab permite-te modificar código, visualizar resultados e documentar as tuas descobertas, tudo num só lugar. Podes experimentar diferentes configurações e perceber como o YOLO26 funciona.

Para entender detalhadamente o processo de treinamento do modelo e conhecer as práticas recomendadas, consulte o guia de treinamento de modelos YOLO26. Este guia vai ajudar você a aproveitar ao máximo seus experimentos e garantir o uso eficaz do YOLO26.

Continua a aprender sobre o JupyterLab#

Se quiseres saber mais sobre o JupyterLab, estes recursos ajudam-te a começar:

  • Documentação do JupyterLab: Explora a documentação oficial do JupyterLab para conhecer as funcionalidades e capacidades da ferramenta. É uma ótima forma de perceber como tirar o máximo partido desta poderosa ferramenta.
  • Experimenta com o Binder: Experimenta o JupyterLab sem instalar nada, usando o Binder, que te permite iniciar uma instância ativa do JupyterLab diretamente no browser. É uma ótima forma de começares a experimentar de imediato.
  • Guia de instalação: Consulta o guia de instalação para obter instruções passo a passo sobre como instalar o JupyterLab na tua máquina local.
  • Treina o Ultralytics YOLO26 com o JupyterLab: Sabe mais sobre as aplicações práticas do JupyterLab com modelos YOLO26 nesta publicação detalhada do blogue.

Resumo#

Explorámos como o JupyterLab pode ser uma ferramenta poderosa para experimentar modelos Ultralytics YOLO26. Com o seu ambiente flexível e interativo, podes configurar facilmente o JupyterLab na tua máquina local e começar a trabalhar com o YOLO26. O JupyterLab facilita o treino e a avaliação dos teus modelos, a visualização dos resultados e a documentação das tuas descobertas, tudo num só lugar.

Ao contrário de outras plataformas, como o Google Colab, o JupyterLab é executado localmente na tua máquina, dando-te mais controlo sobre o ambiente computacional e mantendo a experiência de utilização de notebooks interativos. Isto torna-o particularmente valioso para programadores que precisam de acesso consistente ao ambiente de desenvolvimento sem depender de recursos na nuvem.

Para mais detalhes, visita a página de perguntas frequentes do JupyterLab.

Queres conhecer mais integrações do YOLO26? Consulta o guia de integração da Ultralytics para explorar ferramentas e capacidades adicionais para os teus projetos de aprendizagem automática.

Perguntas frequentes#

  • Para treinar um modelo YOLO26 com o JupyterLab:

    1. Instala o JupyterLab e o pacote Ultralytics:

      pip install jupyterlab ultralytics

    2. Inicia o JupyterLab e abre um notebook novo.

    3. Importa o modelo YOLO e carrega um modelo pré-treinado:

      from ultralytics import YOLO

model = YOLO("yolo26n.pt")

    4. Treina o modelo com o teu conjunto de dados personalizado:

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

    5. Visualiza os resultados do treino com as funcionalidades de gráficos integradas no JupyterLab:

      from ultralytics.utils.plotting import plot_results

plot_results("runs/detect/train/results.csv")  # guarda results.png junto de results.csv

    O ambiente interativo do JupyterLab permite-te modificar parâmetros, visualizar resultados e iterar facilmente no processo de treino do modelo.

  • O JupyterLab oferece várias funcionalidades que o tornam ideal para projetos com YOLO26:

    1. Execução interativa de código: testa e depura trechos de código YOLO26 em tempo real.
    2. Explorador de ficheiros integrado: gere facilmente conjuntos de dados, pesos de modelos e ficheiros de configuração.
    3. Disposição flexível: organiza vários notebooks, terminais e janelas de saída lado a lado para um fluxo de trabalho eficiente.
    4. Apresentação avançada de resultados: visualiza em linha os resultados de deteção do YOLO26, as curvas de treino e as métricas de desempenho do modelo.
    5. Suporte para Markdown: documenta as tuas experiências e descobertas com o YOLO26 usando texto formatado e imagens.
    6. Ecossistema de extensões: amplia as funcionalidades com extensões para controlo de versões, computação remota e muito mais.

    Estas funcionalidades permitem um desenvolvimento fluido ao trabalhar com modelos YOLO26, desde a preparação dos dados até à implementação do modelo.

  • Para otimizar o desempenho do modelo YOLO26 no JupyterLab:

    1. Usa o AutoBatch para escolher o maior tamanho de lote que cabe na memória da GPU:

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

    2. Implementa o ajuste de hiperparâmetros com bibliotecas como o Ray Tune:

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

    3. Visualiza e analisa as métricas do modelo com as funcionalidades de gráficos do JupyterLab:

      from ultralytics.utils.plotting import plot_results

plot_results("runs/detect/train/results.csv")  # guarda results.png junto de results.csv

    4. Experimenta diferentes arquiteturas de modelos e formatos de exportação para encontrar o melhor equilíbrio entre velocidade e precisão para o teu caso de uso específico.

    O ambiente interativo do JupyterLab permite iterar rapidamente e obter feedback em tempo real, facilitando a otimização eficiente dos teus modelos YOLO26.

  • Ao trabalhar com o JupyterLab e o YOLO26, podes encontrar alguns problemas comuns. Eis como os resolver:

    1. Problemas de memória da GPU:

      • Usa torch.cuda.empty_cache() para libertar memória da GPU entre execuções.
      • Ajusta o tamanho do lote ou o tamanho da imagem para que caiba na memória da GPU.

    2. Conflitos entre pacotes:

      • Cria um ambiente conda separado para os teus projetos YOLO26 para evitar conflitos.
      • Usa !pip install package_name numa célula do notebook para instalar os pacotes em falta.

    3. Falhas do kernel:

      • Reinicia o kernel e executa as células uma a uma para identificar o código problemático.
      • Verifica se há fugas de memória no teu código, especialmente ao processar conjuntos de dados grandes.
Colaboradores
GLglenn-jocher12RAraimbekovm2RIRizwanMunawar2LALaughing-q2Y-Y-T-G1WIWillieMaddox1MAMatthewNoyce1AMambitious-octopus1ABabirami-vina1

Comentários