¿Hacer que Pandas DataFrame aplique () use todos los núcleos?

A partir de agosto de 2017, Pandas DataFame.apply () lamentablemente todavía está limitado a trabajar con un solo núcleo, lo que significa que una máquina de múltiples núcleos desperdiciará la mayor parte de su tiempo de cómputo cuando ejecute df.apply(myfunc, axis=1).

¿Cómo puede usar todos sus núcleos para ejecutar la aplicación en un marco de datos en paralelo?

Puede utilizar el swifterpaquete:

pip install swifter

Funciona como un complemento para pandas, lo que le permite reutilizar la applyfunción:

import swifter

def some_function(data):
    return data * 10

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

Descubrirá automáticamente la forma más eficiente de paralelizar la función, sin importar si está vectorizada (como en el ejemplo anterior) o no.

Más ejemplos y una comparación de rendimiento están disponibles en GitHub. Tenga en cuenta que el paquete está en desarrollo activo, por lo que la API puede cambiar.

También tenga en cuenta que esto no funcionará automáticamente para columnas de cadena. Al usar cadenas, Swifter recurrirá a Pandas "simples" apply, que no serán paralelos. En este caso, incluso forzar su uso daskno creará mejoras de rendimiento, y sería mejor dividir su conjunto de datos manualmente y paralelizarlo usandomultiprocessing .

La forma más sencilla es utilizar map_partitions de Dask . Necesita estas importaciones (las necesitará pip install dask):

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

y la sintaxis es

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)  

(Creo que 30 es un número adecuado de particiones si tiene 16 núcleos). Solo para completar, cronometré la diferencia en mi máquina (16 núcleos):

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

Dando un factor de 10 aceleración desde pandas aplicar a dask aplicar en particiones. Por supuesto, si tiene una función que puede vectorizar, debería hacerlo; en este caso, la función ( y*(x**2+1)) está vectorizada trivialmente, pero hay muchas cosas que son imposibles de vectorizar.

puede probar en su pandarallellugar: una herramienta simple y eficiente para paralelizar sus operaciones de pandas en todas sus CPU (en Linux y macOS)

• La paralelización tiene un costo (instanciar nuevos procesos, enviar datos a través de memoria compartida, etc.), por lo que la paralelización es eficiente solo si la cantidad de cálculo para paralelizar es lo suficientemente alta. Para muy poca cantidad de datos, el uso de paralelismo no siempre vale la pena.
• Las funciones aplicadas NO deben ser funciones 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)

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

Si desea permanecer en Python nativo:

import multiprocessing as mp

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

aplicará la función fde forma paralela a la columna coldel marco de datosdf

Aquí hay un ejemplo de transformador base sklearn, en el que la aplicación de pandas está en paralelo

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

para obtener más información, consulte https://towardsdatascience.com/4-easy-steps-to-improve-your-machine-learning-code-performance-88a0b0eeffa8

Para utilizar todos los núcleos (físicos o lógicos), puede probar mapplycomo alternativa a swiftery pandarallel.

Puede establecer la cantidad de núcleos (y el comportamiento de fragmentación) al iniciar:

import pandas as pd
import mapply

mapply.init(n_workers=-1)

...

df.mapply(myfunc, axis=1)

De forma predeterminada ( n_workers=-1), el paquete utiliza todas las CPU físicas disponibles en el sistema. Si su sistema usa Hyper-Threading (por lo general, aparecería el doble de la cantidad de CPU físicas), mapplygenerará un trabajador adicional para priorizar el grupo de multiprocesamiento sobre otros procesos en el sistema.

Dependiendo de su definición de all your cores, también podría usar todos los núcleos lógicos en su lugar (tenga en cuenta que, de esta manera, los procesos vinculados a la CPU lucharán por las CPU físicas, lo que podría ralentizar su operación):

import multiprocessing
n_workers = multiprocessing.cpu_count()

# or more explicit
import psutil
n_workers = psutil.cpu_count(logical=True)