Faire appliquer Pandas DataFrame () utiliser tous les cœurs?

Depuis août 2017, Pandas DataFame.apply () est malheureusement encore limité à travailler avec un seul cœur, ce qui signifie qu'une machine multicœur perdra la majorité de son temps de calcul lorsque vous exécutez df.apply(myfunc, axis=1).

Comment pouvez-vous utiliser tous vos cœurs pour exécuter Apply sur un dataframe en parallèle?

Vous pouvez utiliser le swifterpackage:

pip install swifter

Il fonctionne comme un plugin pour les pandas, vous permettant de réutiliser la applyfonction:

import swifter

def some_function(data):
    return data * 10

data['out'] = data['in'].swifter.apply(some_function)

Il trouvera automatiquement le moyen le plus efficace de paralléliser la fonction, qu'elle soit vectorisée (comme dans l'exemple ci-dessus) ou non.

Plus d'exemples et une comparaison des performances sont disponibles sur GitHub. Notez que le package est en cours de développement actif, donc l'API peut changer.

Notez également que cela ne fonctionnera pas automatiquement pour les colonnes de chaîne. Lors de l'utilisation de chaînes, Swifter se repliera sur un Pandas «simple» apply, qui ne sera pas parallèle. Dans ce cas, même le forcer à l'utiliser daskne créera pas d'améliorations des performances, et vous feriez mieux de simplement diviser votre ensemble de données manuellement et paralléliser à l'aide demultiprocessing .

Le moyen le plus simple est d'utiliser les map_partitions de Dask . Vous avez besoin de ces importations (vous en aurez besoin pip install dask):

import pandas as pd
import dask.dataframe as dd
from dask.multiprocessing import get

et la syntaxe est

data = <your_pandas_dataframe>
ddata = dd.from_pandas(data, npartitions=30)

def myfunc(x,y,z, ...): return <whatever>

res = ddata.map_partitions(lambda df: df.apply((lambda row: myfunc(*row)), axis=1)).compute(get=get)  

(Je crois que 30 est un nombre approprié de partitions si vous avez 16 cœurs). Juste pour être complet, j'ai chronométré la différence sur ma machine (16 cœurs):

data = pd.DataFrame()
data['col1'] = np.random.normal(size = 1500000)
data['col2'] = np.random.normal(size = 1500000)

ddata = dd.from_pandas(data, npartitions=30)
def myfunc(x,y): return y*(x**2+1)
def apply_myfunc_to_DF(df): return df.apply((lambda row: myfunc(*row)), axis=1)
def pandas_apply(): return apply_myfunc_to_DF(data)
def dask_apply(): return ddata.map_partitions(apply_myfunc_to_DF).compute(get=get)  
def vectorized(): return myfunc(data['col1'], data['col2']  )

t_pds = timeit.Timer(lambda: pandas_apply())
print(t_pds.timeit(number=1))

28,16970546543598

t_dsk = timeit.Timer(lambda: dask_apply())
print(t_dsk.timeit(number=1))

2,708152851089835

t_vec = timeit.Timer(lambda: vectorized())
print(t_vec.timeit(number=1))

0,010668013244867325

Donner un facteur 10 d'accélération depuis les pandas s'applique à dask s'applique aux partitions. Bien sûr, si vous avez une fonction que vous pouvez vectoriser, vous devriez - dans ce cas, la fonction ( y*(x**2+1)) est trivialement vectorisée, mais il y a beaucoup de choses qui sont impossibles à vectoriser.

vous pouvez essayer à la pandarallelplace: Un outil simple et efficace pour paralléliser vos opérations pandas sur tous vos processeurs (sous Linux et macOS)

• La parallélisation a un coût (instanciation de nouveaux processus, envoi de données via mémoire partagée, etc ...), donc la parallélisation n'est efficace que si la quantité de calcul à paralléliser est suffisamment élevée. Pour très peu de données, l'utilisation de la parallez ne vaut pas toujours la peine.
• Les fonctions appliquées ne doivent PAS être des fonctions lambda.

from pandarallel import pandarallel
from math import sin

pandarallel.initialize()

# FORBIDDEN
df.parallel_apply(lambda x: sin(x**2), axis=1)

# ALLOWED
def func(x):
    return sin(x**2)

df.parallel_apply(func, axis=1)

voir https://github.com/nalepae/pandarallel

Si vous souhaitez rester en python natif:

import multiprocessing as mp

with mp.Pool(mp.cpu_count()) as pool:
    df['newcol'] = pool.map(f, df['col'])

appliquera la fonction fde manière parallèle à la colonne coldu dataframedf

Voici un exemple de transformateur de base sklearn, dans lequel les pandas s'appliquent est parallélisé

import multiprocessing as mp
from sklearn.base import TransformerMixin, BaseEstimator

class ParllelTransformer(BaseEstimator, TransformerMixin):
    def __init__(self,
                 n_jobs=1):
        """
        n_jobs - parallel jobs to run
        """
        self.variety = variety
        self.user_abbrevs = user_abbrevs
        self.n_jobs = n_jobs
    def fit(self, X, y=None):
        return self
    def transform(self, X, *_):
        X_copy = X.copy()
        cores = mp.cpu_count()
        partitions = 1

        if self.n_jobs <= -1:
            partitions = cores
        elif self.n_jobs <= 0:
            partitions = 1
        else:
            partitions = min(self.n_jobs, cores)

        if partitions == 1:
            # transform sequentially
            return X_copy.apply(self._transform_one)

        # splitting data into batches
        data_split = np.array_split(X_copy, partitions)

        pool = mp.Pool(cores)

        # Here reduce function - concationation of transformed batches
        data = pd.concat(
            pool.map(self._preprocess_part, data_split)
        )

        pool.close()
        pool.join()
        return data
    def _transform_part(self, df_part):
        return df_part.apply(self._transform_one)
    def _transform_one(self, line):
        # some kind of transformations here
        return line

pour plus d'informations, voir https://towardsdatascience.com/4-easy-steps-to-improve-your-machine-learning-code-performance-88a0b0eeffa8