Dask peut être une bibliothèque flexible pour le calcul parallèle en Python.

Dask se compose de deux parties :

La planification dynamique des tâches optimisée pour le calcul. C’est souvent presque comme Airflow, Luigi, Celery ou Make, mais optimisée pour des charges de travail de calcul interactives.

Les collections de “Big Data” comme les tableaux parallèles, les cadres de données et les listes qui atteignent des interfaces communes comme NumPy, Pandas ou les itérateurs Python vers des environnements plus grands que la mémoire ou distribués. Ces collections parallèles s’exécutent sur des planificateurs de tâches dynamiques.

Dask souligne les vertus qui en découlent :

Familier : Fournit des objets DataFrame parallélisés de type NumPy array et Pandas

Flexible : Fournit une interface de planification des tâches pour des charges de travail plus personnalisées et l’intégration avec d’autres projets.

Natif : Permet le calcul distribué en Python pur avec accès à la pile PyData.

Rapide : Fonctionne avec une faible surcharge, une faible latence et une sérialisation minimale nécessaire pour les algorithmes numériques rapides.

Augmente l’échelle : Fonctionne de manière résiliente sur des clusters avec des milliers de noyaux

Les échelles sont réduites : Il est facile de s’aligner et de fonctionner sur un ordinateur portable au cours d’un seul processus

Réactif : Conçu dans une optique d’informatique interactive, il fournit un retour d’information et des diagnostics rapides pour aider les humains

import pandas as pd import dask.dataframe as dd

df = pd.read_csv(‘2015-01-01.csv’) df = dd.read_csv(‘2015-*-*.csv’)

df.groupby(df.user_id).value.mean() df.groupby(df.user_id).value.mean().compute()

Dask Array imite NumPy – documentation

import numpy as np import dask.array as da

f = h5py.File(‘monfichier.hdf5’) f = h5py.File(‘monfichier.hdf5’)

x = np.array(f[‘/petites données’]) x = da.from_array(f[‘/grandes données’],

chunks=(1000, 1000))

x – x.mean(axis=1) x – x.mean(axis=1).compute()

Dask Bag imite les itérateurs, Toolz et PySpark – documentation

import dask.bag as db

b = db.read_text(‘2015-*-*.json.gz’).map(json.loads)

b.pluck(‘nom’).frequencies().topk(10, paire lambda : paire[1]).compute()

Dask Mimiques retardées pour le code personnalisé des boucles et des enveloppes – documentation

de l’importation de dask retardée

L = []

pour fn dans les noms de fichiers :                  # Utilisation pour les boucles pour construire le calcul

data = delayed(load)(fn) # Retard d’exécution de la fonction

L.append(processus(données)(retardé))  # Établir des liens entre les variables

résultat = retardé (résumé) (L)

result.compute()

L’interface concurrent.futures permet la soumission générale de tâches personnalisées : – documentation

de dask.distributed import Client

client = Client(‘scheduler:port’)

contrats à terme = []

pour fn dans les noms de fichiers :

future = client.submit(load, fn)

futures.append(future)

summary = client.submit(summarize, futures)

summary.result()

Des ordinateurs portables aux clusters

Dask est pratique sur un ordinateur portable. Il s’installe trivialement avec conda ou pip et étend les dimensions des ensembles de données pratiques de “tient en mémoire” à “tient sur disque”.

Dask peut s’adapter à une grappe de 100 machines. Il est résistant, élastique, les données sont locales et la latence est faible. Pour plus d’informations, voir la documentation sur l’ordonnanceur distribué.

Cette transition simple entre une seule machine et une grappe modérée permet aux utilisateurs de démarrer simplement et de se développer si nécessaire.

Algorithmes complexes

Dask représente des calculs parallèles avec des graphiques de tâches. Ces graphes acycliques dirigés peuvent avoir une structure arbitraire, ce qui donne aux développeurs et aux utilisateurs la liberté de créer des algorithmes sophistiqués et de traiter des situations désordonnées qui ne sont pas facilement gérées par le paradigme carte/filtre/groupe par groupe commun dans la plupart des cadres d’ingénierie des données.

Nous avions initialement besoin de cette complexité pour créer des algorithmes complexes pour les tableaux n-dimensionnels, mais nous avons constaté qu’elle était tout aussi précieuse pour gérer les situations désordonnées dans les problèmes quotidiens.