Capitulo 05
Pipelines y optimización de datos
De un script ETL monolítico a un flujo modular, vectorizado y medible
Diseño de pipelines reproducibles, procesamiento vectorizado con Pandas, optimización en memoria con Polars y uso responsable de asistentes de IA para escribir y revisar código de datos. Incluye la arquitectura de la pre-entrega ETL modular.
Un pipeline de datos es un sistema: tiene fuentes, contratos, transformaciones, validaciones, salidas y una forma de repetir la ejecución. La optimización empieza cuando puedes medir dónde se consume memoria y tiempo, no cuando agregas una librería porque está de moda.
Primero haz que el flujo sea correcto y reproducible; después haz que sea rápido sin volverlo imposible de explicar.
— Principio de diseño de pipelines
5.1 Mapa de aprendizaje
Al finalizar este capítulo podrás:
- Explicar qué problema resuelve un pipeline y diferenciar ETL, ELT, batch, streaming y microbatch.
- Separar extracción, transformación y carga en funciones con responsabilidades claras.
- Usar procesamiento vectorizado en Pandas en lugar de recorrer filas sin necesidad.
- Elegir tipos de datos que reduzcan memoria sin destruir la información necesaria.
- Reconocer cuándo conviene usar Polars en modo eager o lazy y cómo evitar materializar datos demasiado pronto.
- Diseñar ejecuciones idempotentes, observables y fáciles de probar.
- Usar un asistente de IA para explorar alternativas sin delegarle la validación ni la responsabilidad técnica.
- Defender la arquitectura de la pre-entrega 5: fuentes sucias, limpieza modular, merge validado y salida Parquet.
💡 Piensa en repetibilidad, entradas y salidas.
5.2 Arquitectura de pipelines y tipos de flujo
Un pipeline transforma una entrada en una salida mediante una secuencia de operaciones. En Data Science, esa salida puede ser un archivo limpio, una tabla analítica, un conjunto de features o directamente la entrada de un modelo.
fuentes → extracción → validación → transformación → control de calidad → carga
CSV leer tipos limpiar nulos Parquet
XLSX registrar esquema unir duplicados tabla
API origen contrato calcular métricas dataset ML
ETL y ELT
En ETL (Extract, Transform, Load) se transforma antes de cargar el resultado en el destino. En ELT (Extract, Load, Transform) se carga primero el dato crudo y se transforma dentro del motor analítico. Ninguno es universalmente superior: la decisión depende del volumen, el costo del almacenamiento, la gobernanza y la capacidad del destino.
| Concepto | Descripcion |
|---|---|
| ETL | Extraer, limpiar y transformar antes de entregar al destino. Útil cuando el destino debe recibir solo datos validados o cuando hay restricciones de almacenamiento. |
| ELT | Extraer, conservar la fuente y transformar dentro del warehouse o motor analítico. Útil cuando se necesita trazabilidad del dato crudo y el destino tiene capacidad de cómputo. |
| Híbrido | Validar lo mínimo en la entrada, conservar raw y aplicar transformaciones analíticas después. Suele ser una opción práctica para crecer sin perder auditabilidad. |
La pre-entrega 5 usa un ETL pequeño y explícito: lee un CSV y un Excel, corrige tipos, elimina problemas conocidos, hace un merge, calcula total_venta y carga el resultado en Parquet. La elección es correcta para el alcance: el dataset es pequeño, la consigna pide demostrar limpieza y el flujo se puede defender función por función.
Pipeline de datos
M5Secuencia reproducible de etapas que extrae, transforma, valida y entrega datos a un consumidor, manteniendo contratos y evidencia de lo ocurrido.
Ej: leer_fuentes() → corregir_tipos() → eliminar_duplicados() → manejar_nulos() → hacer_merge() → exportar_parquet()
Batch, streaming y microbatch
El tipo de flujo expresa cuándo se procesa el dato. No es una etiqueta decorativa: cambia el diseño, el estado que debes conservar y la forma de manejar errores.
| Concepto | Descripcion |
|---|---|
| Batch | Procesa un conjunto completo en horarios o ejecuciones definidas. Simple de probar y adecuado para cierres diarios, archivos y reportes. |
| Streaming | Procesa eventos a medida que llegan y mantiene baja latencia. Requiere particiones, offsets, reintentos y manejo de eventos fuera de orden. |
| Microbatch | Acumula eventos durante un intervalo corto y los procesa juntos. Equilibra latencia y simplicidad; es común cuando el tiempo real estricto no es necesario. |
Para decidir, pregunta:
- ¿Qué latencia necesita el consumidor: segundos, minutos o un día?
- ¿La fuente entrega archivos completos o eventos individuales?
- ¿Qué ocurre si el proceso falla a mitad de camino?
- ¿Puedes volver a procesar el mismo intervalo sin duplicar resultados?
Contratos, idempotencia y observabilidad
Un contrato de datos describe lo mínimo que una etapa puede esperar y lo que garantiza al entregar su resultado. Por ejemplo:
| Frontera | Contrato mínimo |
|---|---|
| CSV → extracción | Existe id_producto, cantidad y fecha; el header puede normalizarse. |
| Transformación → merge | Las llaves son string, están sin espacios y el catálogo es único por id_producto. |
| Merge → carga | No hay nulos en campos críticos y total_venta es numérico. |
Una ejecución es idempotente cuando repetirla con las mismas entradas produce el mismo resultado sin duplicar efectos. Leer fuentes inmutables, usar drop_duplicates, escribir una salida determinista y no hacer append ciego son decisiones que acercan el pipeline a la idempotencia.
La observabilidad no significa imprimir cada línea. Significa registrar información suficiente para responder qué ocurrió:
EXTRACCIÓN CSV 129 filas | Excel 17 filas
LIMPIEZA duplicados: -3 transacciones | -1 producto
NULOS filas descartadas: -3 transacciones | -1 producto
MERGE 123 filas | 0 sin match
CARGA ventas_procesadas.parquet | 123 x 6 | round-trip OK
Eliminar nulos o duplicados puede ser correcto, pero si no informas cuántas filas se descartaron, el pipeline pierde auditabilidad. Una transformación silenciosa es difícil de defender y más difícil de depurar.
5.3 De un monolito a un ETL modular
Un archivo que lee, limpia, une y exporta puede funcionar. El problema aparece cuando necesitas cambiar una etapa, probarla aislada o explicar por qué una fila desapareció. Separar responsabilidades no es crear archivos por estética: es reducir el área de cambio.
La estructura de la pre-entrega 5 es:
pre-entrega5/
├── main.py # orquesta, no concentra la lógica de pandas
├── src/
│ ├── extract.py # leer fuentes y normalizar el borde de entrada
│ ├── transform.py # tipos, duplicados, nulos, merge y cálculo
│ └── load.py # exportar y verificar Parquet
└── data/
├── transacciones.csv
├── catalogo_productos.xlsx
└── ventas_procesadas.parquet
main.py tiene una sola responsabilidad: ordenar el flujo.
from src.extract import leer_fuentes
from src.transform import (
corregir_tipos,
eliminar_duplicados,
manejar_nulos,
hacer_merge,
crear_columna_total_venta,
)
from src.load import exportar_parquet
df_trans, df_prod = leer_fuentes(CSV_PATH, XLSX_PATH)
df_trans, df_prod = corregir_tipos(df_trans, df_prod)
df_trans, df_prod = eliminar_duplicados(df_trans, df_prod)
df_trans, df_prod = manejar_nulos(df_trans, df_prod)
df_final = hacer_merge(df_trans, df_prod)
df_final = crear_columna_total_venta(df_final)
exportar_parquet(df_final, PARQUET_PATH)
La orquestación permite leer la historia del proceso de arriba hacia abajo. La lógica vive en módulos que pueden probarse con DataFrames pequeños y controlados.
Extraer con tipos conscientes
La extracción es la frontera del sistema. Conviene leer primero como texto cuando los archivos son poco confiables, normalizar los nombres y después aplicar tipos explícitos.
import pandas as pd
df_trans = pd.read_csv(csv_path, dtype=str)
df_trans.columns = (
df_trans.columns.astype(str)
.str.strip()
.str.lower()
.str.replace(r"\s+", "_", regex=True)
)
df_trans["id_producto"] = df_trans["id_producto"].astype("string")
df_trans["cantidad"] = pd.to_numeric(
df_trans["cantidad"], errors="coerce"
).astype("Int32")
errors="coerce" no arregla datos inválidos: los convierte en valores ausentes para que una etapa posterior los detecte. Esa diferencia importa. Ocultar un error de conversión sería peor que detenerse.
Transformar con funciones pequeñas
Cada función de transform.py tiene una decisión defendible:
corregir_tipos: fechas adatetime, llaves astringystrippara eliminar espacios invisibles.eliminar_duplicados: exactos en transacciones y por llave en el catálogo.manejar_nulos: elimina campos críticos porque imputar una venta sin cantidad inventaría información.hacer_merge:inneryvalidate="many_to_one"para evitar un catálogo duplicado que multiplique ventas.crear_columna_total_venta: cálculo explícito y validación de nulos finales.
Abre Modulo 5/pre-entrega5/main.py y sigue una fila desde transacciones.csv hasta ventas_procesadas.parquet. Identifica qué función toca id_producto, en qué momento se descarta un nulo y dónde se garantiza que el catálogo sea único. Luego agrega un log que informe el porcentaje de filas conservadas en cada etapa.
5.4 Procesamiento vectorial para datos de ML
El procesamiento vectorizado aplica una operación sobre una columna o un bloque completo usando operaciones optimizadas internamente. No significa que toda operación sea mágicamente rápida; significa que evitas pedirle al intérprete de Python que ejecute una instrucción por cada fila cuando la biblioteca ya puede operar sobre el bloque.
El costo de recorrer filas sin necesidad
# Funciona, pero ejecuta lógica Python fila por fila.
for indice, fila in df.iterrows():
df.loc[indice, "total"] = fila["cantidad"] * fila["precio"]
# Preferible: operación sobre columnas completas.
df["total"] = df["cantidad"] * df["precio"]
La segunda versión expresa mejor la intención y suele aprovechar implementaciones optimizadas. La regla no es “nunca uses un loop”: un loop puede ser válido cuando existe una dependencia secuencial, una llamada externa por registro o una lógica que no tiene equivalente vectorizado. La regla es no usarlo por costumbre.
Patrones vectorizados frecuentes
import pandas as pd
df["fecha"] = pd.to_datetime(df["fecha"], errors="coerce")
df["cantidad"] = pd.to_numeric(df["cantidad"], errors="coerce")
df["id_producto"] = df["id_producto"].astype("string").str.strip()
df["es_grande"] = df["cantidad"].ge(10)
df["mes"] = df["fecha"].dt.month
ventas_por_producto = (
df.groupby("id_producto", as_index=False)
.agg(unidades=("cantidad", "sum"), ingresos=("total", "sum"))
)
map, where, clip, fillna, groupby, merge y las operaciones .str y .dt resuelven muchos casos sin bajar al nivel de fila.
Memoria: tipos que expresan intención
El tipo por defecto no siempre es el tipo correcto. Un identificador no debe convertirse en entero solo porque parece numérico: P001 y P1 no son la misma clave. En cambio, una cantidad que admite nulos puede usar Int32, y un precio con precisión suficiente puede usar float32.
| Concepto | Descripcion |
|---|---|
| string | Conserva códigos, ceros iniciales y valores ausentes. Adecuado para P001, P007 y llaves de negocio. |
| Int32 | Entero nullable de menor ancho que int64. Útil para cantidad cuando todavía puede existir un nulo. |
| float32 | Decimal de menor ancho para cálculos donde la precisión requerida lo permite. Validar el dominio antes de usarlo en dinero de alta precisión. |
| datetime64 | Permite filtrar, ordenar y extraer componentes temporales. Convertir con errors="coerce" y luego controlar los NaT. |
Mide antes de afirmar que optimizaste:
memoria_kb = df.memory_usage(deep=True).sum() / 1024
print(f"Filas: {len(df):,} | Memoria: {memoria_kb:.1f} KB")
print(df.dtypes)
Vectorización
M5Aplicación de una operación sobre una serie o bloque de datos mediante primitivas optimizadas, evitando recorrer filas con Python cuando no es necesario.
Ej: df['total_venta'] = df['cantidad'] * df['precio_unitario'] en lugar de calcular cada fila con iterrows().
Preparar features sin contaminar la evaluación
Optimizar el procesamiento no autoriza a mezclar entrenamiento y evaluación. Si calculas una mediana, escalas una variable o codificas categorías usando todo el dataset antes del train_test_split, el conjunto de prueba influye en el entrenamiento.
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=123
)
imputer = SimpleImputer(strategy="median")
X_train = imputer.fit_transform(X_train)
X_test = imputer.transform(X_test)
El pipeline de datos debe entregar features reproducibles, pero la transformación que aprende parámetros debe ajustarse solo con train.
5.5 Optimización en memoria con Polars
Polars es una biblioteca de DataFrames escrita en Rust, con ejecución paralela y un motor orientado a expresiones. No reemplaza automáticamente a Pandas: ofrece otra implementación y otro modelo mental para ciertas cargas tabulares.
pip install polars
Eager y lazy
En modo eager, cada operación se ejecuta inmediatamente y devuelve un DataFrame. En modo lazy, construyes un LazyFrame; Polars puede optimizar el plan antes de ejecutar cuando llamas a collect().
| Concepto | Descripcion |
|---|---|
| DataFrame | Lee y ejecuta cada operación al instante. Cómodo para explorar y para resultados pequeños que caben en memoria. |
| LazyFrame | Construye un plan y lo ejecuta al llamar a collect(). Permite projection pushdown, predicate pushdown y optimización del orden de operaciones. |
| scan_* | Describe la lectura sin materializar todos los datos. scan_csv y scan_parquet son preferibles para pipelines que filtran y seleccionan columnas. |
El patrón central es: seleccionar temprano, filtrar temprano y materializar tarde.
import polars as pl
ventas = (
pl.scan_csv("data/transacciones.csv")
.select(["ID_Producto", "Cantidad", "FECHA"])
.rename({
"ID_Producto": "id_producto",
"Cantidad": "cantidad",
"FECHA": "fecha",
})
.with_columns([
pl.col("id_producto").cast(pl.String).str.strip_chars(),
pl.col("cantidad").cast(pl.Int32, strict=False),
pl.col("fecha").str.to_date(strict=False),
])
.drop_nulls(["id_producto", "cantidad", "fecha"])
.collect()
)
Para Parquet, la lectura puede conservar el flujo lazy:
resumen = (
pl.scan_parquet("data/ventas_procesadas.parquet")
.filter(pl.col("total_venta") > 1000)
.group_by("id_producto")
.agg([
pl.len().alias("transacciones"),
pl.col("total_venta").sum().alias("ingresos"),
])
.sort("ingresos", descending=True)
.collect()
)
El motor puede leer solo las columnas usadas por el plan y filtrar antes de construir el resultado completo. Esa es una optimización concreta: reducir I/O y memoria sin cambiar el significado del análisis.
¿Pandas o Polars?
| Pregunta | Pandas | Polars |
|---|---|---|
| ¿El equipo ya conoce la API y el dataset es pequeño? | Elección pragmática. | Puede añadir una dependencia innecesaria. |
| ¿Necesitas un ecosistema científico muy amplio? | Tiene integración madura. | Puede requerir convertir a Pandas para algunas librerías. |
| ¿Lees Parquet grande y haces filtros/selecciones? | Funciona con cuidado y tipos adecuados. | Lazy + expresiones puede reducir materialización. |
| ¿Quieres comparar rendimiento? | Mide con tus datos. | No asumas que el benchmark de otra persona aplica a tu caso. |
Evaluación lazy
M5Modelo en el que las operaciones se acumulan como un plan y se ejecutan después, permitiendo optimizar lecturas, filtros y columnas antes de materializar el resultado.
Ej: pl.scan_parquet(...).filter(...).select(...).collect() ejecuta el plan solo al final.
Construye la misma agregación con Pandas y Polars sobre ventas_procesadas.parquet. Mide tiempo de ejecución, memoria y forma del resultado. Documenta el tamaño del archivo, las columnas seleccionadas y si cada herramienta tuvo que materializar la tabla completa. El objetivo no es declarar un ganador: es aprender a justificar una elección.
5.6 Asistentes de IA para escribir y revisar código de datos
Un asistente puede acelerar la exploración de una API, proponer un test o explicar un error. No puede confirmar por sí solo que un cálculo represente correctamente el negocio, que una fuente sea confiable o que no hayas filtrado un secreto.
Un pedido útil tiene contexto y límites
Un prompt técnico debería declarar:
- Contexto: tamaño, formato, columnas y versión de Python o biblioteca.
- Objetivo: qué resultado necesitas y cómo sabrás que está bien.
- Restricciones: memoria, dependencias permitidas, estilo y seguridad.
- Evidencia: datos de ejemplo, error exacto o contrato esperado.
- Salida solicitada: plan, código, tests, supuestos y riesgos separados.
Estoy construyendo un pipeline ETL educativo con Python y pandas.
La entrada tiene id_producto, cantidad y fecha; el catálogo tiene
id_producto, nombre_producto y precio_unitario. Hay duplicados y nulos
intencionales. Propón funciones separadas para tipos, duplicados, nulos,
merge y total_venta. No inventes columnas. Incluye tres tests de contrato,
explica los supuestos y señala qué debo verificar manualmente.
Este pedido es mejor que “hazme un pipeline” porque obliga al asistente a trabajar dentro de un contrato.
Revisión en cuatro pasadas
| Concepto | Descripcion |
|---|---|
| 1 | ¿La métrica y el filtro responden la pregunta real? Un código que corre puede seguir calculando una métrica equivocada. |
| 2 | ¿Qué ocurre con nulos, duplicados, zonas horarias, encoding y tipos? Probar casos borde, no solo la fila feliz. |
| 3 | ¿Lee columnas innecesarias o recorre filas sin motivo? Medir memoria y tiempo con datos representativos. |
| 4 | ¿Expone tokens, datos personales o rutas locales? Nunca pegues secretos reales en una conversación. |
La IA es especialmente útil como revisor, no solo como generador. Puedes pedirle que encuentre casos borde, proponga una matriz de tests, explique un plan de ejecución o compare una implementación vectorizada con un loop. La decisión final sigue siendo tuya y debe apoyarse en evidencia.
Q: ¿Usar IA para escribir una función de limpieza reemplaza entender el pipeline?
No. La función puede ser sintácticamente correcta y semánticamente peligrosa: podría eliminar demasiadas filas, imputar una variable que no debe imputarse o introducir leakage. El profesional define el contrato, revisa el código, prueba casos borde y explica la decisión.
🪤 Confundir velocidad para producir código con comprensión del dato5.7 Recursos recomendados
5.8 Test Yourself
Responde sin mirar el código y después comprueba cada respuesta con un ejemplo mínimo.
💡 Piensa en el destino y en la privacidad del dato.
💡 ¿Qué representa el catálogo?
💡 Observa quién ejecuta la operación.
💡 La clave está en collect().
Usa la pre-entrega 5 como laboratorio. Ejecuta el pipeline, registra las filas de cada etapa y escribe una breve defensa técnica con: por qué se separaron los módulos, por qué se eliminaron los nulos críticos, por qué se usaron Int32 y float32, por qué Parquet es una salida adecuada y qué revisarías antes de llevar el flujo a datos de producción.
Para continuar
El siguiente paso es consultar y resumir datos directamente sobre archivos con SQL y DuckDB. El pipeline de este capítulo prepara una salida limpia; el M6 enseña a formular preguntas analíticas sobre volúmenes mayores sin cargar innecesariamente todo en memoria.
Tu espacio de estudio
Notas privadas
Se guardan solo en este navegador y no se publican.