1.3 · Convenciones y reproducibilidad¶

Objetivos. Al terminar este capítulo podrás: usar el vocabulario común del curso (observación, característica, objetivo, X, y); separar las características del objetivo en un DataFrame; y aplicar las reglas mínimas para que un cuaderno sea reproducible.

Evidencia de logro. Dado un DataFrame, separarás correctamente X e y y explicarás qué haría falta para que otra persona pueda repetir tu resultado.

Contexto y motivación¶

"En mi ordenador funciona" es la frase que queremos erradicar del curso. En ciencia de datos, un resultado solo vale si otra persona (o tú, dentro de dos semanas) puede repetirlo. Si tu análisis no se puede reproducir, no es ciencia: es una anécdota.

Este capítulo fija las reglas que usaremos en todos los ejemplos y prácticas. Son pocas, pero te ahorrarán horas de "¿por qué ayer esto daba otro número?".

Prerrequisitos¶

Haber leído 1.1 · IA y Aprendizaje Automático y 1.2 · Data Science y ciclo de vida, y tener preparado el entorno del curso.

Vocabulario común¶

Usamos siempre las mismas palabras para hablar de una tabla de datos. Tener un vocabulario fijo evita malentendidos y te permite leer cualquier tutorial o documentación sin traducir mentalmente cada término.

Separar X e y¶

La separación X / y es la convención universal del ML: X es lo que el modelo ve (las entradas) e y es lo que queremos que aprenda a predecir (la salida). En un problema supervisado siempre tendrás estas dos piezas, y separarlas bien es el primer gesto de todo proyecto.

import pandas as pd

datos = pd.DataFrame({
    "superficie_m2": [80, 150, 220],
    "empleados": [3, 6, 9],
    "ventas_mensuales": [12000, 25000, 41000],
})

# X: características (entrada). y: objetivo (lo que queremos predecir).
X = datos[["superficie_m2", "empleados"]]
y = datos["ventas_mensuales"]

print("Forma de X:", X.shape, "· Forma de y:", y.shape)

Salida esperada:

Forma de X: (3, 2) · Forma de y: (3,)

Cómo leer la salida: shape («forma») devuelve el tamaño de la tabla como (filas, columnas). X tiene 3 observaciones y 2 características; y tiene los 3 objetivos. Fíjate en la diferencia: X es bidimensional (3 filas × 2 columnas) e y es unidimensional (3 valores). La coma de (3,) indica que solo hay una dimensión. Esa diferencia de forma es la que esperan las librerías de ML.

Observa también los corchetes: datos[["superficie_m2", "empleados"]] usa doble corchete porque le pasamos una lista de columnas y devuelve una tabla; datos["ventas_mensuales"] usa corchete simple y devuelve una sola columna.

Reproducibilidad: las cinco reglas¶

Un resultado es reproducible si cualquier persona, siguiendo tus pasos, llega al mismo resultado. No es un capricho académico: es lo que permite corregir errores, comparar experimentos y confiar en tus propias conclusiones.

1. Versión de Python fijada. El curso usa Python 3.14 con uv. Distintas versiones pueden comportarse distinto; fijarla elimina esa fuente de sorpresas.
2. Dependencias fijadas en pyproject.toml y bloqueadas en uv.lock. Así, cuando alguien descargue tu proyecto, instalará exactamente las mismas versiones de las librerías (pandas, numpy…), no "la última que toque".
3. Semillas fijadas para todo lo aleatorio. Cada vez que generes datos o entrenes con algo aleatorio, fija la semilla (lo verás en NumPy) para que el azar no cambie tus conclusiones entre ejecuciones.
4. Datos de entrada identificados. Qué archivo usaste, de dónde salió y en qué estado estaba. Sin esto, nadie puede repetir tu análisis.
5. Resultado esperado y decisiones registradas. Anota qué esperabas ver y por qué elegiste cada paso (¿por qué borraste esos valores? ¿por qué esta métrica?). Un cuaderno que solo tiene código es ilegible dos semanas después.

# En un proyecto gestionado por uv, el lockfile congela las versiones exactas:
uv sync --locked

No se muestra la salida: uv sync --locked imprime una línea por cada paquete del entorno, y la lista depende de lo que tengas instalado. Lo que importa no es el texto, sino lo que garantiza: instala exactamente las versiones declaradas en uv.lock, así que el entorno de quien repite tu cuaderno es idéntico al tuyo.

Una forma sencilla de comprobarlo es volver a ejecutar cualquier bloque de este capítulo: si da exactamente la salida esperada, tu entorno se comporta como el del curso. Si algún día da otra cosa y no has cambiado el código, sospecha primero de las versiones: comprueba que ejecutas con uv run y que tu uv.lock es el del proyecto.

Formato de entrega¶

Todo lo que entregues en el módulo será un cuaderno marimo con esta estructura mínima:

1. Título y una frase que diga qué resuelve el cuaderno.
2. Celdas ejecutables que cargan los datos y calculan el resultado.
3. Una sección "Salida esperada" (o una celda Markdown) con lo que debería verse.
4. Interpretación: qué significa el resultado, no solo el número.
5. Conclusión final: qué se ha aprendido o decidido.

¿Por qué marimo y no Jupyter? En Jupyter puedes ejecutar las celdas en cualquier orden y el "estado oculto" (una variable que definiste y borraste, una celda que ejecutaste dos veces) hace que el cuaderno no sea reproducible. marimo ejecuta como un grafo reactivo: cada celda depende de sus variables y se recalcula sola cuando algo cambia, así el estado siempre es coherente. Por eso es nuestro formato de entrega.

El historial lo guarda Git: cada versión del cuaderno queda registrada y se puede recuperar. Si algo se rompe, puedes ver qué cambió y cuándo.

Errores frecuentes¶

• Mezclar los nombres: llamar "columna" a la fila o "modelo" al algoritmo.
• Poner el objetivo dentro de X (fuga de información).
• No fijar la semilla y sorprenderse de que el resultado cambie.
• Entregar código sin interpretación: los números sin conclusión no sirven.
• Ejecutar las celdas en cualquier orden y confiar en un estado que ya no existe (el problema clásico de Jupyter).

Práctica de transferencia¶

Con este DataFrame:

import pandas as pd

datos = pd.DataFrame({
    "horas_estudio": [2, 4, 6, 8],
    "asistencia": [0.5, 0.7, 0.9, 1.0],
    "nota_final": [4, 6, 7, 9],
})

1. Identifica cuáles son las observaciones, las características y el objetivo.
2. Escribe el código que separa X e y.
3. Explica en una frase qué significa que "el cuaderno sea reproducible" y qué dos cosas harías para garantizarlo.
4. Comprueba las formas: X debe ser (4, 2) e y, (4,). Si X sale (4, 3), has dejado el objetivo dentro de las características.

Producto evaluable¶

Completa el cuaderno 01_tipos_aprendizaje.py con una última celda:

1. Separa X e y del ejercicio anterior.
2. Añade una celda Markdown que resuma, con tus palabras, las cinco reglas de reproducibilidad.

Formato de entrega: cuaderno marimo ejecutado, con conclusiones al final.

Resumen y referencia rápida¶

Siguiente: 1.4 · NumPy, donde empezamos a programar en serio.