Jupyter y Google Colab

El cuaderno de laboratorio del ingeniero de IA: pruebas rápidas y resultados a la vista.

Qué vas a aprender

• Instalar y abrir JupyterLab, Jupyter Notebook o VS Code con la extensión de Jupyter
• Usar comandos mágicos (%timeit, %%time, %matplotlib inline) para medir y visualizar dentro del notebook
• Saber cuándo usar notebooks y cuándo scripts, y aplicar el flujo «explora en notebooks, publica en scripts»
• Reconocer y evitar las trampas típicas: ejecución desordenada, estado oculto y fugas de memoria

Por qué importa

Todos los papers, tutoriales y competiciones de Kaggle usan notebooks de Jupyter. Te permiten ejecutar el código por partes, ver los resultados al momento, mezclar código con explicaciones e iterar rápido. Aprender IA sin notebooks es como hacer los deberes de matemáticas sin papel de borrador.

Pero los notebooks tienen trampas de verdad. Mucha gente los usa para todo, incluso para lo que se les da fatal. Saber cuándo usar un notebook y cuándo un script te ahorrará pesadillas de depuración.

La idea clave

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

graph TD
    A["Celda Markdown\nMi experimento: learning rate 0.01"] --> B["Celda de código ► Ejecutar\nmodel.fit(X, y, lr=0.01)\nSalida: loss = 0.342"]
    B --> C["Celda de código ► Ejecutar\nplt.plot(losses)\nSalida: gráfico en línea"]

El kernel es un proceso de Python que se ejecuta en segundo plano. Cuando ejecutas una celda, el notebook le 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 de una celda a otra.

graph LR
    A[Interfaz del notebook] <--> B[Kernel\nproceso de Python]
    B --> C[Guarda las variables en memoria]
    B --> D[Ejecuta las celdas en el orden en que hagas clic]
    B --> E[Muere cuando lo reinicias]

Eso de «en el orden en que hagas clic» es a la vez su superpoder y la forma más fácil de pegarte un tiro en el pie.

Paso a paso

Paso 1: elige tu interfaz

Tres opciones, un mismo formato:

Las tres leen y escriben el mismo archivo .ipynb. Elige la que prefieras; JupyterLab es la más habitual en IA.

pip install jupyterlab
jupyter lab

Paso 2: los atajos de teclado que importan

Trabajas en dos modos. Pulsa Escape para el modo comando (barra azul a la izquierda) y Enter para el modo edición (barra verde).

Modo comando (los más usados):

Modo edición:

Shift+Enter lo usarás mil veces al día. Apréndete ese 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 Markdown muestran texto con formato. Úsalas para documentar qué haces y por qué. Admiten títulos, negrita, cursiva, fórmulas LaTeX ($E = mc^2$), tablas e imágenes.

Paso 4: comandos mágicos

No son Python: son comandos propios de Jupyter que empiezan por % (mágico de línea) o %% (mágico de celda).

Mide el tiempo de 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 hace la media. %%time lo ejecuta una sola vez. Usa %timeit para microbenchmarks y %%time para entrenamientos.

Activa los gráficos en línea:

%matplotlib inline

A partir de ahí, cada plt.plot() o plt.show() se dibuja directamente en el notebook.

Instala paquetes sin salir del notebook:

!pip install scikit-learn

El prefijo ! ejecuta cualquier comando de la shell. (Dentro de un entorno con uv, mejor %pip install ..., que instala en el mismo Python que usa el kernel.)

Consulta variables de entorno:

%env CUDA_VISIBLE_DEVICES

Paso 5: salida enriquecida

El notebook muestra automáticamente la última expresión de cada celda, pero puedes controlarlo:

Pruébalo aquí mismo: estos dos bloques se ejecutan en tu navegador como si fueran celdas (aquí la tabla sale como texto; en Jupyter la verás con formato). La primera vez tarda unos segundos en cargar pandas y matplotlib.

import pandas as pd

df = pd.DataFrame({
    "modelo": ["Lineal", "Random Forest", "Red neuronal"],
    "accuracy": [0.72, 0.89, 0.94],
    "tiempo_entrenamiento": [0.1, 2.3, 45.6]
})
df

Esto se muestra como una tabla HTML con formato, no como texto plano. Lo mismo con los gráficos:

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 4))
plt.plot([1, 2, 3, 4], [1, 4, 2, 3])
plt.title("Gráfico en línea")
plt.show()

El gráfico aparece justo debajo de la celda. Por eso los notebooks dominan el trabajo en IA: ves los datos, el gráfico 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 notebook de Jupyter gratuito en la nube: te da GPU, librerías preinstaladas e integración con Google Drive, sin configurar nada.

1. Entra en colab.research.google.com
2. Crea un notebook nuevo o sube uno tuyo (.ipynb)
3. Entorno de ejecución › Cambiar tipo de entorno de ejecución › GPU T4 (gratis)

Diferencias de Colab con Jupyter local: - Los archivos no persisten entre sesiones (guárdalos en Drive o descárgalos) - Vienen preinstalados numpy, pandas, matplotlib, torch, tensorflow y sklearn - from google.colab import files para subir y descargar archivos - from google.colab import drive; drive.mount('/content/drive') para almacenamiento persistente - En el plan gratuito, las sesiones se cierran tras un rato de inactividad

En la práctica

Notebooks frente a scripts: cuándo usar cada uno

La regla: explora en notebooks, publica en scripts.

El flujo habitual en IA: 1. Explora los datos en un notebook 2. Prototipa tu modelo en el notebook 3. Cuando funcione, mueve el código a archivos .py 4. Importa esos .py desde el notebook para seguir experimentando

Trampas habituales

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

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

Fugas de memoria. Cargas un dataset de 4 GB, entrenas un modelo, cargas otro dataset… y no se libera nada. Solución: del nombre_variable y gc.collect(), o reinicia el kernel.

Pista: los números entre corchetes a la izquierda de cada celda ([1], [2]…) indican el orden en que se ejecutaron. Si al bajar por el notebook no van en orden creciente, desconfía.

Tu caja de herramientas

Un prompt para que un asistente de IA te ayude cuando un notebook se porte raro. Cópialo, pégalo y describe lo que te pasa:

Eres un experto en Jupyter y Google Colab para proyectos de IA. Ayúdame a resolver un problema
con mi notebook. Ten en cuenta las causas más habituales:

- El kernel se muere o se reinicia: casi siempre es falta de memoria (RAM o VRAM). Propón cargar
  menos datos, liberar variables con `del` y `gc.collect()`, usar `torch.cuda.empty_cache()` o
  reducir el tamaño de lote.
- No se ven los gráficos o las tablas: revisa `%matplotlib inline`, que la última línea de la celda
  devuelva el objeto, o `display()`.
- Resultados distintos al ejecutar de arriba abajo: ejecución desordenada o estado oculto.
  Recomienda Kernel › Restart & Run All.
- ModuleNotFoundError en el notebook pero no en la terminal: el kernel usa otro Python.
  Comprobar con `import sys; print(sys.executable)` y registrar el kernel del entorno virtual con
  `python -m ipykernel install --user --name mi-entorno`.
- Colab: la sesión se desconecta, se pierden los archivos (montar Google Drive) o no hay GPU
  (Entorno de ejecución › Cambiar tipo de entorno de ejecución).

Pregúntame lo que necesites saber y dame la solución con el código exacto.

Mi problema:

Retos para tu ordenador

1. Abre JupyterLab, crea un notebook y usa %timeit para comparar una list comprehension con numpy al crear un array de 100.000 números aleatorios
2. Crea un notebook con celdas Markdown y de código que cargue un CSV, muestre un dataframe y dibuje un gráfico. Después ejecuta Kernel › Restart & Run All para comprobar que funciona de arriba abajo
3. Copia en un notebook de Colab los ejemplos de esta lección, activa la GPU gratuita (Entorno de ejecución › Cambiar tipo de entorno de ejecución) y comprueba con !nvidia-smi que la tienes

Glosario de la lección

Para saber más

• Documentación de JupyterLab
• Preguntas frecuentes de Google Colab, con sus límites y funciones