Phase 00 - Lesson 05

Jupyter Notebooks

Los notebooks son el banco de laboratorio de la ingeniería de IA. Aquí prototipas y luego llevas lo que funciona a producción.

Tipo: Build Lenguajes: Python Requisitos previos: Fase 0, Lección 01 Tiempo: ~30 minutos

Objetivos de Aprendizaje

• Instalar y ejecutar JupyterLab, Jupyter Notebook o VS Code con la extensión de Jupyter
• Usar comandos mágicos (%timeit, %%time, %matplotlib inline) para medir el rendimiento y visualizar inline
• Distinguir cuándo usar notebooks o scripts y aplicar el flujo "explora en notebooks, entrega en scripts"
• Identificar y evitar trampas comunes de los notebooks: ejecución fuera de orden, estado oculto y fugas de memoria

El Problema

Todo artículo de IA, tutorial y competencia de Kaggle usa Jupyter notebooks. Te permiten ejecutar código por partes, ver salidas inline, mezclar código con explicaciones e iterar rápido. Si intentas aprender IA sin notebooks, es como hacer la tarea de matemáticas sin papel borrador.

Pero los notebooks tienen trampas reales. La gente los usa para todo, incluso para cosas en las que son pésimos. Saber cuándo usar un notebook y cuándo usar un script te ahorrará pesadillas de depuración más adelante.

El Concepto

Un notebook es una lista de celdas. Cada celda es código o texto.

graph TD
    A["**Markdown Cell**\n# My Experiment\nTesting learning rate 0.01"] --> B["**Code Cell** ► Run\nmodel.fit(X, y, lr=0.01)\n---\nOutput: loss = 0.342"]
    B --> C["**Code Cell** ► Run\nplt.plot(losses)\n---\nOutput: inline plot"]

El kernel es un proceso de Python que se ejecuta en segundo plano. Cuando ejecutas una celda, envía el código al kernel, que lo ejecuta y devuelve el resultado. Todas las celdas comparten el mismo kernel, así que las variables persisten entre celdas.

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

Esa parte de "en el orden que hagas clic" es a la vez el superpoder y el tiro en el pie.

Build It

Paso 1: Elige tu interfaz

Tres opciones, un formato:

Las tres leen y escriben el mismo archivo .ipynb. Elige la que prefieras. JupyterLab es la más común en el trabajo con IA.

pip install jupyterlab
jupyter lab

Paso 2: Atajos de teclado que importan

Operas en dos modos. Presiona Escape para el modo de comando (barra azul a la izquierda), Enter para el modo de edición (barra verde).

Modo de comando (el más usado):

Modo de edición:

Shift+Enter es el que usarás mil veces al día. Apréndelo primero.

Paso 3: Tipos de celda

Las celdas de código ejecutan Python y muestran la salida:

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

Salida: (0.0032, 0.9987)

Las celdas de markdown renderizan texto con formato. Úsalas para documentar lo que haces y por qué. Soportan encabezados, negrita, cursiva, matemática LaTeX ($E = mc^2$), tablas e imágenes.

Paso 4: Comandos mágicos

Estos no son Python. Son comandos específicos de Jupyter que comienzan con % (magia de línea) o %% (magia de celda).

Cronometra tu código:

%timeit np.random.randn(10000)

Salida: 45.2 us +/- 1.3 us per loop

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

Salida: Wall time: 2.34 s

%timeit ejecuta el código muchas veces y promedia. %%time lo ejecuta una vez. Usa %timeit para microbenchmarks y %%time para ejecuciones de entrenamiento.

Habilita los plots inline:

%matplotlib inline

Ahora cada plt.plot() o plt.show() se renderiza directamente en el notebook.

Instala paquetes sin salir del notebook:

!pip install scikit-learn

El prefijo ! ejecuta cualquier comando de shell.

Revisa las variables de entorno:

%env CUDA_VISIBLE_DEVICES

Paso 5: Muestra salida enriquecida inline

Los notebooks muestran automáticamente la última expresión de una celda. Pero puedes controlarlo:

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

Esto renderiza una tabla HTML con formato, no un volcado de texto. Lo mismo con los 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()

El plot aparece justo debajo de la celda. Por esto los notebooks dominan el trabajo con IA. Ves los datos, el plot y el código juntos.

Para imágenes:

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

Paso 6: Google Colab

Colab es un Jupyter notebook gratuito en la nube. Te da una GPU, bibliotecas preinstaladas e integración con Google Drive. Sin configuración necesaria.

1. Ve a colab.research.google.com
2. Sube cualquier archivo .ipynb de este curso
3. Runtime > Change runtime type > T4 GPU (gratis)

Diferencias de Colab respecto a Jupyter local:

• Los archivos no persisten entre sesiones (guarda en Drive o descarga)
• Preinstalados: numpy, pandas, matplotlib, torch, tensorflow, sklearn
• from google.colab import files para subir/descargar archivos
• from google.colab import drive; drive.mount('/content/drive') para almacenamiento persistente
• Las sesiones expiran tras 90 minutos de inactividad (nivel gratuito)

Use It

Notebooks vs Scripts: cuándo usar cada uno

La regla: explora en notebooks, entrega en scripts.

Un flujo común en IA:

1. Explora los datos en un notebook
2. Prototipa tu modelo en el notebook
3. Una vez que funcione, mueve el código a archivos .py
4. Importa esos archivos .py de vuelta al notebook para más experimentos

Trampas comunes

Ejecución fuera de orden. Ejecutas la celda 5, luego la 2, luego la 7. El notebook funciona en tu máquina, pero falla cuando alguien lo ejecuta de arriba a abajo. Solución: Kernel > Restart & Run All antes de compartir.

Estado oculto. Eliminas una celda, pero la variable que creó sigue en memoria. El notebook se ve limpio, pero depende de una celda fantasma. Solución: reinicia el kernel con regularidad.

Fugas de memoria. Cargar un dataset de 4GB, entrenar un modelo, cargar otro dataset. Nada se libera. Solución: del variable_name y gc.collect(), o reinicia el kernel.

Ship It

Esta lección produce:

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

Ejercicios

1. Abre JupyterLab, crea un notebook y usa %timeit para comparar list comprehension vs numpy al crear un array de 100.000 números aleatorios
2. Crea un notebook con celdas de markdown y de código que cargue un CSV, muestre un dataframe y dibuje un gráfico. Luego ejecuta Kernel > Restart & Run All para verificar que funcione de arriba a abajo
3. Toma el código de code/notebook_tips.py, pégalo en un notebook de Colab y ejecútalo con una GPU gratuita

Términos Clave

Lectura Adicional

• JupyterLab Docs para el conjunto completo de funciones
• Google Colab FAQ para límites y funciones específicas de Colab
• 28 Jupyter Notebook Tips para atajos de usuario avanzado