Communitygithub.com

Dask - Assistência em Computação Distribuída

Assistência especializada em computação distribuída com Dask, cobrindo DataFrames, Arrays, Futures e escalonamento de clusters. Use ao analisar conjuntos de dados muito grandes para o pandas em uma única máquina ou cluster multi-nó.

O que é Dask - Assistência em Computação Distribuída?

Este skill fornece assistência especializada para o uso da biblioteca Dask, que escala o Python para computação distribuída em clusters, mantendo APIs familiares como Pandas e NumPy. Ele é essencial para desenvolvedores e engenheiros de dados que precisam processar conjuntos de dados tabulares de 10GB a 1TB, paralelizar workflows personalizados com loops Python arbitrários via `dask.delayed`, ou realizar aprendizado de máquina distribuído com Scikit-learn, XGBoost e LightGBM. O skill inclui exemplos práticos de código para Dask DataFrame, Array e Futures, além de melhores práticas para otimização de desempenho (como monitoramento via Dashboard, escolha de tamanho de chunks e persistência de dados). Também oferece uma tabela de solução de problemas para erros comuns, como `KilledWorker` e `UserWarning`, e orientações sobre quando NÃO usar Dask (dados cabem na RAM). Suporta as últimas atualizações de 2025, incluindo High Performance Shuffle e integração com GPU.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/G1Joshi/Agent-Skills/tree/HEAD/skills/ai-ml/dask

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

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.delayed para 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 chame compute() 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

ErroCausaSolução
KilledWorker: Trabalhador excedeu orçamento de 95% de memóriaPartiçã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 trabalhadoresArray 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úsculasMilhares de micropartições causando sobrecarga de escalonamento de tarefas.Mescle partições pequenas usando repartition(partition_size="100MB").

Referências

Individual skills in this repo

This repo contains 11 individual skills — each has its own dedicated page.

G1Joshi/Agent-Skills

Expert dbt (data build tool) assistance covering SQL modeling, Jinja macros, tests, documentation, and semantic layer. Use when building analytics engineering pipelines on BigQuery, Snowflake, or PostgreSQL.

G1Joshi/Agent-Skills

Expert JAX assistance covering Autograd, XLA compilation (`jit`), vectorization (`vmap`), and parallelization (`pmap`). Use when building high-performance numerical computing and cutting-edge deep learning research.

G1Joshi/Agent-Skills

Expert Ray distributed computing assistance covering Ray Core (actors, tasks), Ray Train, Ray Tune, and Ray Serve. Use when scaling Python compute and ML training across multi-node clusters.

G1Joshi/Agent-Skills

Expert Git version control assistance covering branching, interactive rebase, cherry-pick, submodules, worktrees, and conflict resolution. Use when managing source code history and collaboration workflows.

G1Joshi/Agent-Skills

Expert K9s CLI assistance covering terminal Kubernetes cluster navigation, real-time log streaming, port forwarding, and pod debugging. Use when managing and troubleshooting Kubernetes clusters with speed.

G1Joshi/Agent-Skills

Expert SWC assistance covering high-performance Rust-based JavaScript/TypeScript compilation, .swcrc configuration, Jest testing via @swc/jest, and minification. Use when replacing Babel with SWC for faster builds, accelerating test execution, or compiling modern ECMAScript features.

G1Joshi/Agent-Skills

Expert Tig assistance covering text-mode interface for Git, interactive staging, commit graph visualization, diff exploration, and blame navigation. Use when navigating Git commit history in the terminal, staging hunks interactively, browsing file changes, or reviewing revisions.

G1Joshi/Agent-Skills

Expert Vim assistance covering modal editing, .vimrc configuration, registers, macros, search/replace, and plugin management via vim-plug. Use when editing text efficiently in terminal environments, writing Vimscript, recording macros, or configuring core Vim settings.

G1Joshi/Agent-Skills

Expert Zed editor assistance covering high-performance Rust-based text editing, multi-buffer editing, language server protocols (LSP), and AI assistant integrations. Use when configuring Zed settings.json, setting up language extensions, collaborating in real-time channels, or optimizing editor startup speed.

G1Joshi/Agent-Skills

Expert Zsh assistance covering shell customization, Oh My Zsh plugins, Zinit plugin manager, prompt engineering (Starship/Powerlevel10k), and shell scripting. Use when configuring .zshrc, writing Zsh automation scripts, optimizing shell startup time, or configuring tab-completion.

G1Joshi/Agent-Skills

Expert [skill-name] assistance covering [feature 1], [feature 2], and [feature 3]. Use when [working with X], [debugging Y], or [implementing Z].

Habilidades Relacionadas