Dask
O Dask escala o Python. Ele se parece com Pandas/NumPy, mas é executado em clusters. As atualizações de 2025 focam em High Performance Shuffle e integração com GPU.
Quando Usar
- Computação Tabular Maior que a Memória: Processar conjuntos de dados CSV/Parquet de 10GB a 1TB em uma única máquina ou cluster multi-nó.
- Paralelização de Workflows Python Personalizados: Usar
dask.delayedpara paralelizar loops Python arbitrários e grafos de tarefas. - Aprendizado de Máquina Distribuído: Integração com Scikit-learn, XGBoost e LightGBM em nós de trabalho distribuídos.
- Escalonamento de NumPy & Pandas: APIs familiares prontas para uso em cálculos de arrays e DataFrames fora do núcleo.
Início Rápido
import dask.dataframe as dd
# Ler arquivos CSV particionados de vários gigabytes de forma lazy
df = dd.read_csv('data/transactions_*.csv')
# Calcular estatísticas agregadas em paralelo em todos os núcleos da CPU
resultado = df.groupby('category').amount.mean().compute()
print(resultado)
Conceitos Principais
#Processamento Fora do Núcleo com Dask DataFrame
Carregar arquivos Parquet particionados e calcular agregações de forma lazy:
import dask.dataframe as dd
from dask.distributed import Client
# Inicializar cluster local distribuído
cliente = Client(n_workers=4, threads_per_worker=2, memory_limit='4GB')
print(f"Painel Dask em: {cliente.dashboard_link}")
# Carregar dataset multi-arquivo de forma lazy
df = dd.read_parquet(
's3://analytics-bucket/transactions/*.parquet',
columns=['customer_id', 'amount', 'status', 'country'],
engine='pyarrow'
)
# Construir grafo computacional lazy
filtrado = df[df['status'] == 'completed']
metricas = filtrado.groupby('country')['amount'].agg(['mean', 'sum', 'count'])
# Executar o grafo e retornar um DataFrame Pandas concreto
df_resultado = metricas.compute()
print(df_resultado)
#Grafos de Tarefas Personalizados com dask.delayed
Paralelizar execuções de funções independentes:
from dask import delayed, compute
import time
@delayed
def buscar_dados_api(endpoint: str) -> dict:
time.sleep(0.5) # Simulando I/O
return {'endpoint': endpoint, 'status': 200, 'items': [1, 2, 3]}
@delayed
def transformar_payload(dados: dict) -> int:
return sum(dados['items'])
@delayed
def agregar_totais(totais: list[int]) -> int:
return sum(totais)
# Construir DAG de dependências
endpoints = ['users', 'orders', 'inventory', 'payments']
buscados = [buscar_dados_api(ep) for ep in endpoints]
transformados = [transformar_payload(b) for b in buscados]
total_final = agregar_totais(transformados)
# Executar todas as tarefas em paralelo no cluster
resultado_total = total_final.compute()
print("Total Geral:", resultado_total)
#Dask Array para Álgebra Linear Distribuída
Manipulando arrays multi-dimensionais massivos:
import dask.array as da
# Criar um array 50.000 x 50.000 dividido em chunks de 5.000 x 5.000
x = da.random.normal(10, 0.1, size=(50000, 50000), chunks=(5000, 5000))
# Realizar cálculos de forma lazy
y = x + x.T
z = y[::2, ::2].mean(axis=0)
# Calcular resultado
resultado = z.compute()
print("Forma média do array calculado:", resultado.shape)
Padrões Comuns
Futures Distribuídos para Grafos de Tarefas Irregulares
Problema: Computações paralelas personalizadas que não se encaixam perfeitamente em estruturas de linhas/colunas de DataFrame/Array.
Solução: Use o Cliente Distribuído Dask com futures assíncronos:
from dask.distributed import Client
cliente = Client(n_workers=4, threads_per_worker=2)
def treinar_particao(id_parte: int):
# Treinar sub-modelo local
return f"Modelo {id_parte} treinado"
futures = [cliente.submit(treinar_particao, i) for i in range(10)]
resultados = cliente.gather(futures)
print(resultados)
Melhores Práticas (2026)
- Faça verifique o Painel Web do Dask (normalmente na porta 8787) para monitorar pressão de memória, fluxo de tarefas e gargalos.
- Faça escolha tamanhos de chunk entre 100MB e 300MB em memória para eficiência paralela ideal.
- Faça persista DataFrames intermediários (
df = df.persist()) ao consultar os mesmos dados transformados repetidamente. - Faça filtre colunas e linhas cedo usando projeções de colunas e pushdown de predicados.
- Não chame
.compute()dentro de loops; construa o grafo de tarefas completo e chamecompute()uma única vez. - Não use Dask se os dados cabem confortavelmente na RAM; Pandas nativo e Polars são significativamente mais rápidos para tarefas em memória.
- Não crie milhões de tarefas atrasadas minúsculas; a sobrecarga excessiva de tarefas degrada o desempenho do escalonador.
Solução de Problemas
| Erro | Causa | Solução |
|---|---|---|
KilledWorker: Trabalhador excedeu orçamento de 95% de memória | Partição de tarefa muito grande para caber na RAM do trabalhador durante o cálculo. | Aumente o número de partições: df.repartition(npartitions=100). |
UserWarning: Enviando objeto grande para trabalhadores | Array NumPy grande ou DataFrame passado como argumento direto de função. | Espalhe os dados uma vez com client.scatter(data) antes de enviar tarefas. |
Slow compute: Muitas tarefas minúsculas | Milhares de micropartições causando sobrecarga de escalonamento de tarefas. | Mescle partições pequenas usando repartition(partition_size="100MB"). |