আগস্ট 2017 পর্যন্ত, পান্ডাস ডেটাফেম.এপ্লি () দুর্ভাগ্যক্রমে এখনও একটি একক কোর নিয়ে কাজ করার মধ্যে সীমাবদ্ধ, যার অর্থ আপনি যখন রান করবেন তখন একটি মাল্টি-কোর মেশিনটি তার সংখ্যাগরিষ্ঠ সময়কে নষ্ট করবে 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)
এটি স্বয়ংক্রিয়ভাবে ফাংশনটিকে সমান্তরাল করার সবচেয়ে কার্যকর উপায়টি নির্ধারণ করবে, এটি ভেক্টরাইজড (উপরের উদাহরণ হিসাবে যেমন) হোক না কেন।
আরও উদাহরণ এবং একটি পারফরম্যান্স তুলনা গিটহাব এ উপলব্ধ। নোট করুন যে প্যাকেজটি সক্রিয় বিকাশের অধীনে রয়েছে, সুতরাং API পরিবর্তন হতে পারে।
এছাড়াও মনে রাখবেন যে স্ট্রিং কলামগুলির জন্য এটি স্বয়ংক্রিয়ভাবে কাজ করবে না । স্ট্রিংগুলি ব্যবহার করার সময়, সোয়েটার একটি "সরল" পান্ডায় ফ্যালব্যাক 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
সবচেয়ে সহজ উপায় হ'ল দাস্কের মানচিত্র_ বিভাগগুলি ব্যবহার করা । আপনার এই আমদানিগুলি প্রয়োজন (আপনার প্রয়োজন হবে 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)
(আমি বিশ্বাস করি যে আপনার কাছে ১ c টি কোর থাকলে 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))
0.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কলামে সমান্তরাল ফ্যাশনে ফাংশন প্রয়োগ করবেcoldf
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: //towardsdatas ज्ञान.com/4- easy-steps- to- improve-your- machine-learning- code-performance- 88a0b0eeffa8
সমস্ত (শারীরিক বা যৌক্তিক) কোর ব্যবহার করতে, আপনি এবং এর mapplyবিকল্প হিসাবে চেষ্টা করতে পারেন ।swifterpandarallel
আপনি আর ডি (সি) উপর পরিমাণের পরিমাণ (এবং মজাদার আচরণ) নির্ধারণ করতে পারেন:
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)