Phase 00 - Lesson 05

Jupyter Notebooks

Notebooks são a bancada de laboratório da engenharia de IA. Você prototipa aqui e depois leva o que funciona para produção.

Tipo: Build Linguagens: Python Pré-requisitos: Fase 0, Lição 01 Tempo: ~30 minutos

Objetivos de Aprendizagem

• Instalar e iniciar o JupyterLab, o Jupyter Notebook ou o VS Code com a extensão Jupyter
• Usar comandos mágicos (%timeit, %%time, %matplotlib inline) para medir desempenho e visualizar inline
• Distinguir quando usar notebooks ou scripts e aplicar o fluxo "explore em notebooks, entregue em scripts"
• Identificar e evitar armadilhas comuns de notebooks: execução fora de ordem, estado oculto e vazamentos de memória

O Problema

Todo artigo de IA, tutorial e competição do Kaggle usa Jupyter notebooks. Eles permitem rodar código em partes, ver saídas inline, misturar código com explicações e iterar rápido. Se você tentar aprender IA sem notebooks, é como fazer dever de matemática sem papel de rascunho.

Mas notebooks têm armadilhas reais. As pessoas os usam para tudo, inclusive coisas em que eles são péssimos. Saber quando usar um notebook e quando usar um script vai te poupar de pesadelos de depuração mais tarde.

O Conceito

Um notebook é uma lista de células. Cada célula é código ou texto.

graph TD
    A["**Markdown Cell**
# My Experiment
Testing learning rate 0.01"] --> B["**Code Cell** ► Run
model.fit(X, y, lr=0.01)
---
Output: loss = 0.342"]
    B --> C["**Code Cell** ► Run
plt.plot(losses)
---
Output: inline plot"]

O kernel é um processo Python rodando em segundo plano. Quando você executa uma célula, ela envia o código para o kernel, que o executa e devolve o resultado. Todas as células compartilham o mesmo kernel, então as variáveis persistem entre as células.

graph LR
    A[Notebook UI] <--> B[Kernel
Python process]
    B --> C[Keeps variables in memory]
    B --> D[Runs cells in whatever order you click]
    B --> E[Dies when you restart it]

Essa parte de "qualquer ordem que você clicar" é ao mesmo tempo o superpoder e o tiro no pé.

Build It

Passo 1: Escolha sua interface

Três opções, um formato:

Os três leem e escrevem o mesmo arquivo .ipynb. Escolha o que você preferir. O JupyterLab é o mais comum no trabalho com IA.

pip install jupyterlab
jupyter lab

Passo 2: Atalhos de teclado que importam

Você opera em dois modos. Pressione Escape para o modo de comando (barra azul à esquerda), Enter para o modo de edição (barra verde).

Modo de comando (mais usado):

Modo de edição:

Shift+Enter é o que você vai usar mil vezes por dia. Aprenda esse primeiro.

Passo 3: Tipos de célula

Células de código executam Python e mostram a saída:

import numpy as np
data = np.random.randn(1000)
data.mean(), data.std()

Saída: (0.0032, 0.9987)

Células de markdown renderizam texto formatado. Use-as para documentar o que você está fazendo e por que. Suportam cabeçalhos, negrito, itálico, matemática LaTeX ($E = mc^2$), tabelas e imagens.

Passo 4: Comandos mágicos

Esses não são Python. São comandos específicos do Jupyter que começam com % (magia de linha) ou %% (magia de célula).

Cronometre seu código:

%timeit np.random.randn(10000)

Saída: 45.2 us +/- 1.3 us per loop

%%time
model.fit(X_train, y_train, epochs=10)

Saída: Wall time: 2.34 s

%timeit executa o código várias vezes e tira a média. %%time executa uma vez. Use %timeit para microbenchmarks e %%time para execuções de treinamento.

Habilite plots inline:

%matplotlib inline

Agora todo plt.plot() ou plt.show() renderiza diretamente no notebook.

Instale pacotes sem sair do notebook:

!pip install scikit-learn

O prefixo ! executa qualquer comando de shell.

Verifique variáveis de ambiente:

%env CUDA_VISIBLE_DEVICES

Passo 5: Exiba saída rica inline

Notebooks exibem automaticamente a última expressão de uma célula. Mas você pode controlar isso:

import pandas as pd

df = pd.DataFrame({
    "model": ["Linear", "Random Forest", "Neural Net"],
    "accuracy": [0.72, 0.89, 0.94],
    "training_time": [0.1, 2.3, 45.6]
})
df

Isso renderiza uma tabela HTML formatada, não um despejo de texto. O mesmo vale para plots:

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 4))
plt.plot([1, 2, 3, 4], [1, 4, 2, 3])
plt.title("Inline Plot")
plt.show()

O plot aparece logo abaixo da célula. É por isso que os notebooks dominam o trabalho com IA. Você vê os dados, o plot e o código juntos.

Para imagens:

from IPython.display import Image, display
display(Image(filename="architecture.png"))

Passo 6: Google Colab

O Colab é um Jupyter notebook gratuito na nuvem. Ele te dá uma GPU, bibliotecas pré-instaladas e integração com o Google Drive. Sem configuração necessária.

1. Acesse colab.research.google.com
2. Faça upload de qualquer arquivo .ipynb deste curso
3. Runtime > Change runtime type > T4 GPU (grátis)

Diferenças do Colab em relação ao Jupyter local:

• Os arquivos não persistem entre sessões (salve no Drive ou baixe)
• Pré-instalados: numpy, pandas, matplotlib, torch, tensorflow, sklearn
• from google.colab import files para enviar/baixar arquivos
• from google.colab import drive; drive.mount('/content/drive') para armazenamento persistente
• As sessões expiram após 90 minutos de inatividade (camada gratuita)

Use It

Notebooks vs Scripts: quando usar cada um

A regra: explore em notebooks, entregue em scripts.

Um fluxo comum em IA:

1. Explore os dados em um notebook
2. Prototipe seu modelo no notebook
3. Quando funcionar, mova o código para arquivos .py
4. Importe esses arquivos .py de volta no notebook para mais experimentos

Armadilhas comuns

Execução fora de ordem. Você executa a célula 5, depois a 2, depois a 7. O notebook funciona na sua máquina, mas quebra quando alguém o executa de cima para baixo. Correção: Kernel > Restart & Run All antes de compartilhar.

Estado oculto. Você apaga uma célula, mas a variável que ela criou ainda está na memória. O notebook parece limpo, mas depende de uma célula fantasma. Correção: reinicie o kernel regularmente.

Vazamentos de memória. Carregar um dataset de 4GB, treinar um modelo, carregar outro dataset. Nada é liberado. Correção: del variable_name e gc.collect(), ou reinicie o kernel.

Ship It

Esta lição produz:

• outputs/prompt-notebook-helper.md para depurar problemas de notebook

Exercícios

1. Abra o JupyterLab, crie um notebook e use %timeit para comparar list comprehension vs numpy na criação de um array de 100.000 números aleatórios
2. Crie um notebook com células de markdown e de código que carrega um CSV, exibe um dataframe e plota um gráfico. Depois execute Kernel > Restart & Run All para verificar se funciona de cima para baixo
3. Pegue o código de code/notebook_tips.py, cole em um notebook do Colab e execute com uma GPU gratuita

Termos-chave

Leitura Adicional

• JupyterLab Docs para o conjunto completo de recursos
• Google Colab FAQ para limites e recursos específicos do Colab
• 28 Jupyter Notebook Tips para atalhos de usuário avançado