Зробити Pandas DataFrame apply () використовувати всі ядра?

Починаючи з серпня 2017 року, Pandas DataFame.apply () , на жаль, все ще обмежений роботою з одним ядром, що означає, що багатоядерна машина витратить більшу частину свого обчислювального часу під час роботи df.apply(myfunc, axis=1).

Як ви можете використовувати всі свої ядра для паралельного запуску застосування у фреймі даних?

Ви можете використовувати swifterпакет:

pip install swifter

Він працює як плагін для панд, що дозволяє повторно використовувати applyфункцію:

import swifter

def some_function(data):
    return data * 10

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

Він автоматично визначить найефективніший спосіб розпаралелювати функцію, незалежно від того, векторизована вона (як у наведеному вище прикладі) чи ні.

Інші приклади та порівняння продуктивності доступні на GitHub. Зверніть увагу, що пакет знаходиться в стадії активної розробки, тому API може змінюватися.

Також зауважте, що це не буде працювати автоматично для стовпців рядків. При використанні рядків Swifter повернеться до "простих" панд apply, які не будуть паралельними. У цьому випадку навіть примушування до використання daskне призведе до покращення продуктивності, і вам було б краще просто розділити свій набір даних вручну та розпаралелювати використанняmultiprocessing .

Найпростіший спосіб - використовувати map_partitions Dask . Вам потрібні такі імпорти (вам потрібно pip install dask):

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

а синтаксис такий

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)  

(Я вважаю, що 30 - це відповідна кількість розділів, якщо у вас 16 ядер). Просто для повноти, я приурочив різницю на моїй машині (16 ядер):

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

Даючи коефіцієнт 10 прискорення, переходячи від панд, застосовується до тиску, що застосовується до розділів. Звичайно, якщо у вас є функція, яку ви можете векторизувати, вам слід - у цьому випадку функція ( y*(x**2+1)) тривіально векторизується, але є багато речей, які неможливо векторизувати.

Ви можете спробувати pandarallelзамість цього: простий та ефективний інструмент для розпаралелювання ваших операцій панд на всіх процесорах (у Linux та macOS)

• Паралелізація має свої витрати (ініціація нових процесів, надсилання даних через спільну пам’ять тощо), тому паралелізація є ефективною лише в тому випадку, якщо обсяг обчислення для паралелізації достатньо високий. Для дуже невеликого обсягу даних використання паралелізації не завжди варто.
• Застосовувані функції НЕ повинні бути лямбда-функціями.

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)

див. https://github.com/nalepae/pandarallel

Якщо ви хочете залишитися в рідному python:

import multiprocessing as mp

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

застосовуватиме функцію fпаралельно до стовпця colфрейму данихdf

Ось приклад базового трансформатора sklearn, в якому застосовуються панди, паралелізований

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

для отримання додаткової інформації див. https://towardsdatascience.com/4-easy-steps-to-improve-your-machine-learning-code-performance-88a0b0eeffa8

Щоб використовувати всі (фізичні чи логічні) ядра, ви можете спробувати mapplyяк альтернативу swifterі pandarallel.

Ви можете встановити кількість ядер (і поведінку порцій) на init:

import pandas as pd
import mapply

mapply.init(n_workers=-1)

...

df.mapply(myfunc, axis=1)

За замовчуванням ( n_workers=-1), пакет використовує всі фізичні процесори, доступні в системі. Якщо у вашій системі використовується гіперпотік (зазвичай у два рази перевищує кількість фізичних процесорів), mapplyз’явиться один зайвий працівник , який надасть пріоритет багатопроцесорному пулу над іншими процесами в системі.

Залежно від вашого визначення all your coresви можете замість цього використовувати всі логічні ядра (будьте уважні, що подібні процеси, пов'язані з процесором, будуть боротися за фізичні процесори, що може уповільнити вашу роботу):

import multiprocessing
n_workers = multiprocessing.cpu_count()

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