Dask
Dask escala Python. Se parece a Pandas/NumPy pero funciona en clústeres. Las actualizaciones de 2025 se centran en High Performance Shuffle e integración con GPU.
Cuándo usar
- Computación tabular que excede la memoria: Procesar conjuntos de datos CSV/Parquet de 10 GB a 1 TB en una sola máquina o clúster multi-nodo.
- Paralelizar flujos de trabajo Python personalizados: Usar
dask.delayedpara paralelizar bucles Python arbitrarios y grafos de tareas. - Aprendizaje automático distribuido: Integración con Scikit-learn, XGBoost y LightGBM en nodos workers distribuidos.
- Escalado de NumPy y Pandas: APIs familiares para cálculos de arrays y DataFrames que no caben en memoria.
Inicio rápido
import dask.dataframe as dd
# Leer de forma diferida archivos CSV particionados de varios gigabytes
df = dd.read_csv('data/transactions_*.csv')
# Calcular estadísticas agregadas en paralelo en todos los núcleos de CPU
result = df.groupby('category').amount.mean().compute()
print(result)
Conceptos centrales
#Procesamiento fuera de núcleo con Dask DataFrame
Cargar archivos Parquet particionados y calcular agregaciones de forma diferida:
import dask.dataframe as dd
from dask.distributed import Client
# Inicializar clúster distribuido local
client = Client(n_workers=4, threads_per_worker=2, memory_limit='4GB')
print(f"Dask Dashboard corriendo en: {client.dashboard_link}")
# Carga diferida de un conjunto de datos multi-archivo
df = dd.read_parquet(
's3://analytics-bucket/transactions/*.parquet',
columns=['customer_id', 'amount', 'status', 'country'],
engine='pyarrow'
)
# Construir grafo computacional de forma diferida
filtered = df[df['status'] == 'completed']
metrics = filtered.groupby('country')['amount'].agg(['mean', 'sum', 'count'])
# Ejecutar el grafo y devolver un DataFrame de Pandas concreto
result_df = metrics.compute()
print(result_df)
#Grafos de tareas personalizados con dask.delayed
Paralelizar ejecuciones de funciones independientes:
from dask import delayed, compute
import time
@delayed
def fetch_api_data(endpoint: str) -> dict:
time.sleep(0.5) # Simulando E/S
return {'endpoint': endpoint, 'status': 200, 'items': [1, 2, 3]}
@delayed
def transform_payload(data: dict) -> int:
return sum(data['items'])
@delayed
def aggregate_totals(totals: list[int]) -> int:
return sum(totals)
# Construir DAG de dependencias
endpoints = ['users', 'orders', 'inventory', 'payments']
fetched = [fetch_api_data(ep) for ep in endpoints]
transformed = [transform_payload(f) for f in fetched]
final_total = aggregate_totals(transformed)
# Ejecutar todas las tareas en paralelo en el clúster
total_result = final_total.compute()
print("Gran Total:", total_result)
#Dask Array para álgebra lineal distribuida
Manipular arrays multidimensionales masivos:
import dask.array as da
# Crear un array de 50,000 x 50,000 dividido en fragmentos de 5,000 x 5,000
x = da.random.normal(10, 0.1, size=(50000, 50000), chunks=(5000, 5000))
# Realizar cálculos de forma diferida
y = x + x.T
z = y[::2, ::2].mean(axis=0)
# Calcular resultado
result = z.compute()
print("Forma media del array calculado:", result.shape)
Patrones comunes
Futures distribuidos para grafos de tareas irregulares
Problema: Computaciones paralelas personalizadas que no encajan fácilmente en estructuras de filas/columnas de DataFrame/Array.
Solución: Usar el Cliente Dask Distribuido con futures asíncronos:
from dask.distributed import Client
client = Client(n_workers=4, threads_per_worker=2)
def train_partition(part_id: int):
# Entrenar sub-modelo local
return f"Modelo {part_id} entrenado"
futures = [client.submit(train_partition, i) for i in range(10)]
results = client.gather(futures)
print(results)
Mejores prácticas (2026)
- Use el Dask Web Dashboard (típicamente en el puerto 8787) para monitorear presión de memoria, flujos de tareas y cuellos de botella.
- Seleccione tamaños de fragmento entre 100 MB y 300 MB en memoria para una eficiencia paralela óptima.
- Persista DataFrames intermedios (
df = df.persist()) cuando consulte los mismos datos transformados repetidamente. - Filtre columnas y filas de forma temprana usando proyecciones de columnas y empuje de predicados.
- No llame a
.compute()dentro de bucles; construya el grafo de tareas completo y llame acompute()una sola vez. - No use Dask si los datos caben cómodamente en RAM; Pandas nativo y Polars son significativamente más rápidos para tareas en memoria.
- No cree millones de tareas
delayeddiminutas; la sobrecarga excesiva de tareas degrada el rendimiento del planificador.
Solución de problemas
| Error | Causa | Solución |
|---|---|---|
KilledWorker: Worker exceeded 95% memory budget | La partición de la tarea es demasiado grande para caber en la RAM del worker durante el cálculo. | Aumente el número de particiones: df.repartition(npartitions=100). |
UserWarning: Sending large object to workers | Un array de NumPy o DataFrame grande se pasa como argumento directo de la función. | Disemine los datos una vez con client.scatter(data) antes de enviar las tareas. |
Slow compute: Too many tiny tasks | Miles de micro-particiones causan sobrecarga de planificación de tareas. | Fusione particiones pequeñas usando repartition(partition_size="100MB"). |