📩 😳 🧔🏾 मोटे डेटा के लिए पंडों और अन्य 👩🏼‍🤝‍👨🏾 🖇️ 🈚️

इस लेख में, मैं उन कुछ सरल ट्रिक्स के बारे में बात करूंगा जो डेटा के साथ काम करते समय उपयोगी होते हैं जो स्थानीय मशीन में फिट नहीं होते हैं, लेकिन बड़े कहलाने के लिए अभी भी बहुत छोटा है। अंग्रेजी भाषा की उपमा (बड़ी लेकिन बड़ी नहीं) के बाद हम इस डेटा को मोटा कहेंगे। हम इकाइयों के आकार और गीगाबाइट के दसियों के बारे में बात कर रहे हैं।

[डिस्क्लेमर] यदि आप एसक्यूएल से प्यार करते हैं, तो नीचे लिखी गई सभी चीजें आपको उज्ज्वल, सबसे अधिक नकारात्मक भावनाओं का कारण बन सकती हैं, नीदरलैंड में ४ ९ २६२ टेस्ला हैं, उनमें से ४२ better टैक्सी हैं, बेहतर नहीं आगे पढ़ें [/ अस्वीकृति]।

शुरुआती बिंदु एक दिलचस्प डेटा सेट के विवरण के साथ हब पर एक लेख था - नीदरलैंड में पंजीकृत वाहनों की एक पूरी सूची, 14 मिलियन लाइनें, ट्रक ट्रैक्टर से इलेक्ट्रिक बाइक तक सब कुछ 25 किमी / घंटा से ऊपर की गति पर।

सेट दिलचस्प है, 7 जीबी लेता है, आप इसे जिम्मेदार संगठन की वेबसाइट पर डाउनलोड कर सकते हैं।

डेटा को ड्राइव करने का प्रयास जैसा कि पंडों में होता है फ़िल्टर करने के लिए और इसे साफ करने के लिए एक फ़ाइस्को में समाप्त हो गया (एसक्यूएल हुसर्स के सज्जन, मैंने चेतावनी दी!)। पंडों को डेस्कटॉप पर 8 जीबी के साथ स्मृति की कमी से गिर गया। थोड़े रक्तपात के साथ, प्रश्न हल किया जा सकता है यदि आप याद करते हैं कि पांडा मध्यम आकार के टुकड़ों में सीएसवी फाइलें पढ़ सकते हैं। पंक्तियों में टुकड़े का आकार हिस्सा पैरामीटर द्वारा निर्धारित किया जाता है।

कार्य का वर्णन करने के लिए, हम एक सरल कार्य लिखेंगे जो एक अनुरोध करता है और यह निर्धारित करता है कि कुल मिलाकर टेस्ला कार कितनी हैं और उनमें से किस अनुपात में टैक्सी काम करती हैं। विखंडन पढ़ने के साथ चाल के बिना, ऐसा अनुरोध पहले सभी मेमोरी को खा जाता है, फिर लंबे समय तक पीड़ित होता है, और अंत में रैंप बंद हो जाता है।

टुकड़ा पढ़ने के साथ, हमारा कार्य कुछ इस तरह दिखेगा:

def pandas_chunky_query():
    print('reading csv file with pandas in chunks')
    filtered_chunk_list=[]
    for chunk in pd.read_csv('C:\Open_data\RDW_full.CSV', chunksize=1E+6):
        filtered_chunk=chunk[chunk['Merk'].isin(['TESLA MOTORS','TESLA'])]
        filtered_chunk_list.append(filtered_chunk)
    model_df = pd.concat(filtered_chunk_list)
    print(model_df['Taxi indicator'].value_counts())

पूरी तरह से उचित मिलियन लाइनों को निर्दिष्ट करके, आप 1:46 में क्वेरी को निष्पादित कर सकते हैं और अपने चरम पर 1965 एम मेमोरी का उपयोग कर सकते हैं। कुछ प्राचीन, आठ-कोर के बारे में 8 जीबी मेमोरी के साथ और सातवें विंडोज के तहत एक डंब डेस्कटॉप के लिए सभी नंबर।

यदि आप विखंडू को बदलते हैं, तो शिखर मेमोरी की खपत काफी शाब्दिक रूप से इसका पालन करती है, निष्पादन का समय बहुत अधिक नहीं बदलता है। 0.5 एम लाइनों के लिए, अनुरोध 244 1:53 और 3762 एमबी के लिए, 1:44 और 1063 एमबी लेता है।

गति बहुत सुखदायक नहीं है, यहां तक कि कम मनभावन यह है कि टुकड़ों में फ़ाइल को पढ़ना आपको इस फ़ंक्शन के लिए अनुकूलित लिखने के लिए मजबूर करता है, टुकड़ों की सूचियों के साथ काम करना जो तब डेटा फ्रेम में एकत्र किया जाना चाहिए। इसके अलावा, सीएसवी प्रारूप स्वयं बहुत खुश नहीं है, जो बहुत अधिक स्थान लेता है और धीरे-धीरे पढ़ा जाता है।

चूंकि हम डेटा को रैंप में चला सकते हैं, इसलिए भंडारण के लिए बहुत अधिक कॉम्पैक्ट अपाचेव प्रारूप का उपयोग किया जा सकता हैलकड़ी की छत जहां संपीड़न है, और, डेटा योजना के लिए धन्यवाद, यह पढ़ने के लिए पढ़ने के लिए बहुत तेज है। और रैंप उनके साथ काम करने में काफी सक्षम है। केवल अब उन्हें टुकड़ों में नहीं पढ़ा जा सकता है। क्या करें?

- चलो मज़ा है, Dask ~~बटन accordion~~ ले लो और गति!

Dask! बॉक्स से बाहर रैंप के लिए एक विकल्प, बड़ी फ़ाइलों को पढ़ने में सक्षम, कई कोर पर समानांतर में काम करने में सक्षम, और आलसी गणनाओं का उपयोग कर। Habré पर Dask के बारे में मेरे आश्चर्य के लिए केवल 4 प्रकाशन हैं ।

तो, हम डस्क लेते हैं, हम मूल सीएसवी को इसमें डालते हैं और न्यूनतम रूपांतरण के साथ, हम इसे फर्श पर चलाते हैं। पढ़ते समय, कुछ स्तंभों में डेटा प्रकारों की अस्पष्टता पर शपथ ग्रहण करते हैं, इसलिए हमने उन्हें स्पष्ट रूप से निर्धारित किया है (स्पष्टता के लिए, यही बात रैंप के लिए की गई थी, परिचालन समय इस कारक को ध्यान में रखते हुए अधिक है, dtypes वाला शब्दकोश स्पष्टता के लिए सभी प्रश्नों के लिए काट दिया गया है), बाकी खुद के लिए है। । इसके अलावा, सत्यापन के लिए, हम फ़्लोरिंग में छोटे सुधार करते हैं, अर्थात्, हम डेटा प्रकारों को सबसे कॉम्पैक्ट लोगों को कम करने की कोशिश करते हैं, कॉलम की एक जोड़ी को टेक्स्ट हाँ / नहीं के साथ बूलियन वाले के साथ बदलें, और अन्य डेटा को सबसे किफायती प्रकारों में परिवर्तित करें (इंजन सिलेंडरों की संख्या के लिए, uint8 निश्चित रूप से पर्याप्त है)। हम अलग से अनुकूलित फर्श को बचाते हैं और देखते हैं कि हमें क्या मिलता है।

पहली बात जो डैस्क के साथ काम करते समय प्रसन्न होती है, वह यह है कि हमें मोटे तौर पर कुछ भी लिखने की आवश्यकता नहीं है क्योंकि हमारे पास मोटा डेटा है। यदि आप इस तथ्य पर ध्यान नहीं देते हैं कि डस्क आयात किया गया है, और रैंप नहीं है, तो सब कुछ रैंप में सौ लाइनों (प्लस प्रोफाइलिंग के लिए सजावटी सीटी की एक जोड़ी) के साथ एक फ़ाइल को संसाधित करने के समान दिखता है।

def dask_query():
    print('reading CSV file with dask')
    with ProgressBar(), ResourceProfiler(dt=0.25) as rprof:
        raw_data=dd.read_csv('C:\Open_data\RDW_full.CSV')
        model_df=raw_data[raw_data['Merk'].isin(['TESLA MOTORS','TESLA'])]
        print(model_df['Taxi indicator'].value_counts().compute())
    rprof.visualize()

अब डस्सो के साथ काम करने पर प्रदर्शन पर स्रोत फ़ाइल के प्रभाव की तुलना करें। सबसे पहले हमने उसी csv फाइल को पढ़ा, जब रैंप के साथ काम कर रहे थे। लगभग दो मिनट और दो गीगाबाइट मेमोरी (1:38 2096 एमबी)। यह प्रतीत होता है, यह इसके लायक झाड़ियों में चुंबन करना था?

अब बोर्ड को अनपॉइंटाइज्ड पेर्केट फाइल खिलाएं। अनुरोध को लगभग 54 सेकंड में संसाधित किया गया था, जिसमें 1388 एमबी मेमोरी का उपभोग किया गया था, और अनुरोध के लिए फ़ाइल स्वयं अब 10 गुना छोटी है (लगभग 700 मिलियन)। यहाँ बोनस पहले से ही उत्तल दिखाई दे रहे हैं। सैकड़ों प्रतिशत का सीपीयू उपयोग कई कोर में समानांतर है।

संपीड़ित रूप में थोड़ा संशोधित डेटा प्रकारों के साथ पहले से अनुकूलित अनुकूलित लकड़ी का छत केवल 1 एमबी कम है, जिसका अर्थ है कि संकेत के बिना सब कुछ काफी कुशलता से संकुचित होता है। उत्पादकता में वृद्धि भी विशेष रूप से महत्वपूर्ण नहीं है। अनुरोध समान 53 सेकंड लेता है और थोड़ी कम मेमोरी खाता है - 1332 एमबी।

हमारे अभ्यास के परिणामों के आधार पर, हम निम्नलिखित कह सकते हैं:

यदि आपका डेटा "मोटा" है और आप रैंप के लिए उपयोग किए जाते हैं - चंक्साइज़ इस वॉल्यूम को पचाने के लिए रैंप की मदद करेगा, तो गति सहने योग्य होगी।
यदि आप अधिक गति को निचोड़ना चाहते हैं, तो भंडारण के दौरान स्थान बचाएं और आप सिर्फ रैंप का उपयोग करके वापस नहीं रख रहे हैं, तो लकड़ी की छत के साथ शाम को एक अच्छा संयोजन है।

अंत में, आलसी कंप्यूटिंग के बारे में। नकाब की एक विशेषता यह है कि यह आलसी गणनाओं का उपयोग करता है, अर्थात, गणना तुरंत नहीं की जाती है क्योंकि वे कोड में पाए जाते हैं, लेकिन जब उन्हें वास्तव में जरूरत होती है या जब आप स्पष्ट रूप से गणना पद्धति का उपयोग करके अनुरोध करते हैं। उदाहरण के लिए, हमारे फ़ंक्शन में, जब हम फ़ाइल को पढ़ने के लिए संकेत करते हैं तो डैस्क मेमोरी में सभी डेटा को नहीं पढ़ता है। वह उन्हें बाद में पढ़ता है, और केवल वे कॉलम जो अनुरोध से संबंधित हैं।

यह निम्नलिखित उदाहरण में आसानी से देखा जाता है। हम एक पूर्व-फ़िल्टर की गई फ़ाइल लेते हैं जिसमें हमने प्रारंभिक 64 में से केवल 12 कॉलम छोड़ दिए, संपीड़ित लकड़ी की छत में 203 एमबी लगता है। यदि आप इस पर हमारा नियमित अनुरोध चलाते हैं, तो यह 8.8 सेकंड में पूरा हो जाएगा, और पीक मेमोरी का उपयोग लगभग 300 एमबी होगा, जो कि एक सरल सीएसएसवी में ओवरटेक करने पर संपीड़ित फ़ाइल के दसवें से मेल खाती है।

यदि हमें स्पष्ट रूप से आपको फ़ाइल पढ़ने की आवश्यकता है, और फिर अनुरोध निष्पादित करें, तो मेमोरी की खपत लगभग 10 गुना अधिक होगी। हम फ़ाइल को स्पष्ट रूप से पढ़कर अपने फ़ंक्शन को थोड़ा संशोधित करते हैं:

def dask_query():
    print('reading parquet file with dask')
    with ProgressBar(), ResourceProfiler(dt=0.25) as rprof:
        raw_data=dd.read_parquet('C:\Open_data\RDW_filtered.parquet' ).compute()
        model_df=raw_data[raw_data['Merk'].isin(['TESLA MOTORS','TESLA'])]
        #print(model_df.head())
        print(model_df['Taxi indicator'].value_counts())
    rprof.visualize()

और यहाँ हम क्या प्राप्त करते हैं, 10.5 सेकंड और 3568 एमबी मेमोरी (!)

एक बार फिर हम आश्वस्त हैं कि डस्क - यह अपने कार्यों से निपटने के लिए सक्षम है, और एक बार फिर माइक्रो-प्रबंधन के साथ इसमें चढ़ने का कोई मतलब नहीं है।

मोटे डेटा के लिए पंडों और अन्य

More articles: