Communitygithub.com

G1Joshi/Agent-Skills

Asistencia experta en computación distribuida con Dask, cubriendo DataFrames, Arrays, Futures y escalado de clústeres. Útil al analizar conjuntos de datos demasiado grandes para pandas en una sola máquina o clúster multi-nodo.

¿Qué es Agent-Skills?

Este skill proporciona asistencia experta para el uso de la biblioteca Dask en computación distribuida. Está diseñado para desarrolladores que necesitan procesar conjuntos de datos que exceden la memoria RAM de una sola máquina, o que desean paralelizar flujos de trabajo complejos en Python. Cubre desde operaciones básicas con DataFrames y Arrays (similares a Pandas y NumPy) hasta la creación de grafos de tareas personalizados con `dask.delayed` y el uso de Futures para tareas asíncronas. También incluye guías de mejores prácticas para optimizar el rendimiento, como el tamaño adecuado de particiones (100-300MB) y la importancia de persistir datos intermedios. Es compatible con clústeres locales y distribuidos, y se integra con herramientas de Machine Learning como Scikit-learn y XGBoost. Los usuarios se beneficiarán de ejemplos prácticos, diagnósticos de errores comunes y consejos para evitar cuellos de botella.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

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.delayed para 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 a compute() 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 delayed diminutas; la sobrecarga excesiva de tareas degrada el rendimiento del planificador.

Solución de problemas

ErrorCausaSolución
KilledWorker: Worker exceeded 95% memory budgetLa 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 workersUn 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 tasksMiles de micro-particiones causan sobrecarga de planificación de tareas.Fusione particiones pequeñas usando repartition(partition_size="100MB").

Referencias

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].

Skills relacionados