अगस्त 2017 तक, पंडस डेटाफैम.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 पर उपलब्ध है। ध्यान दें कि पैकेज सक्रिय विकास के तहत है, इसलिए एपीआई बदल सकता है।
यह भी ध्यान दें कि यह स्ट्रिंग कॉलम के लिए स्वचालित रूप से काम नहीं करेगा । स्ट्रिंग्स का उपयोग करते समय, स्विफ्ट "सरल" पंडों में वापस आ जाएगी apply, जो समानांतर नहीं होगी। इस स्थिति में, इसका उपयोग करने के लिए मजबूर करने से भी daskप्रदर्शन में सुधार नहीं होगा, और आप अपने डेटासेट को मैन्युअल रूप से विभाजित करने और उपयोग करने के लिए समानांतरmultiprocessing करना बेहतर होगा ।
allow_dask_on_strings(enable=True)इस तरह जोड़ें : df.swifter.allow_dask_on_strings(enable=True).apply(some_function) स्रोत: github.com/jmcarpenter2/swifter/issues/45
Dask के map_partitions का उपयोग करने का सबसे सरल तरीका है । आपको इन आयातों की आवश्यकता है (आपको इसकी आवश्यकता होगी 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)
(मेरा मानना है कि यदि आपके पास 16 कोर हैं तो 30 उपयुक्त विभाजन है)। पूर्णता के लिए, मैंने अपनी मशीन (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))
.010668013244867325
पांडा से जाने वाले 10 स्पीडअप का एक कारक देते हुए विभाजन पर डस्क लागू होते हैं। बेशक, यदि आपके पास एक फ़ंक्शन है जिसे आप वेक्टर कर सकते हैं, तो आपको चाहिए - इस मामले में फ़ंक्शन ( y*(x**2+1)) तुच्छ रूप से वेक्टरीकृत है, लेकिन ऐसी बहुत सी चीजें हैं जो वेक्टर करना असंभव हैं।
The get= keyword has been deprecated. Please use the scheduler= keyword instead with the name of the desired scheduler like 'threads' or 'processes'
ValueError: cannot reindex from a duplicate axis। उसके चारों ओर जाने के लिए, या तो आपको डुप्लिकेट इंडेक्स को हटा देना चाहिए df = df[~df.index.duplicated()]या अपने इंडेक्स को रीसेट करना होगा df.reset_index(inplace=True)।
आप pandarallelइसके बजाय कोशिश कर सकते हैं : अपने सभी सीपीयू (लिनक्स और मैकओएस पर) अपने पंडों के संचालन को समानांतर करने के लिए एक सरल और कुशल उपकरण
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)
यदि आप देशी अजगर में रहना चाहते हैं:
import multiprocessing as mp
with mp.Pool(mp.cpu_count()) as pool:
df['newcol'] = pool.map(f, df['col'])
डेटाफ़्रेम के fस्तंभ colके समानांतर फैशन में फ़ंक्शन लागू करेगाdf
ValueError: Length of values does not match length of indexसे __setitem__में pandas/core/frame.py। सुनिश्चित नहीं है कि मैंने कुछ गलत किया है, या यदि असाइन करना df['newcol']थ्रेडसेफ़ नहीं है।
यहां स्केलेर बेस ट्रांसफार्मर का एक उदाहरण दिया गया है, जिसमें पांडा लागू होते हैं
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विकल्प के रूप में प्रयास कर सकते हैं ।swifterpandarallel
आप कोर की राशि (और चंचल व्यवहार) को 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)