👸🏻 💮 🗜️ पंडों बिग डेटा विश्लेषण के लिए गाइड 🦐 🐼 👩‍❤️‍👩

छोटे डेटासेट का विश्लेषण करने के लिए पांडा लाइब्रेरी का उपयोग करते समय, जिसका आकार 100 मेगाबाइट से अधिक नहीं होता है, प्रदर्शन शायद ही कभी एक समस्या बन जाता है। लेकिन जब डेटा सेट के अध्ययन की बात आती है, जिसके आकार कई गीगाबाइट तक पहुंच सकते हैं, तो प्रदर्शन समस्याएं डेटा विश्लेषण की अवधि में उल्लेखनीय वृद्धि कर सकती हैं और स्मृति की कमी के कारण विश्लेषण करने में असमर्थता भी पैदा कर सकती हैं।

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

आज हम जिस सामग्री का अनुवाद कर रहे हैं, DataFrame का उपयोग करते समय मेमोरी के साथ काम करने की विशेषताओं के बारे में बात करेंगे, और DataFrame की तालिका डेटा संरचनाओं के कॉलम में संग्रहीत उचित डेटा प्रकारों का चयन करके मेमोरी की खपत को लगभग 90% तक कैसे कम करें।

बेसबॉल गेम पर डेटा के साथ काम करना

हम मेजर लीग के बेसबॉल खेल के आंकड़ों पर काम करेंगे, जो 130 साल से अधिक समय से एकत्र किया गया है और रेट्रोसेट से लिया गया है।

प्रारंभ में, इस डेटा को 127 CSV फ़ाइलों के रूप में प्रस्तुत किया गया था, लेकिन हमने उन्हें csvkit का उपयोग करते हुए एक डेटा सेट में जोड़ा और परिणामी तालिका की पहली पंक्ति के रूप में, स्तंभ नामों वाली एक पंक्ति के रूप में जोड़ा। यदि आप चाहें, तो आप इस डेटा के हमारे संस्करण को डाउनलोड कर सकते हैं और इसके साथ प्रयोग कर सकते हैं, लेख पढ़ सकते हैं।

चलो एक डेटासेट आयात करके शुरू करते हैं और इसकी पहली पांच लाइनों पर एक नज़र डालते हैं। आप इस तालिका में उन्हें शीट के पर पा सकते हैं।

 import pandas as pd gl = pd.read_csv('game_logs.csv') gl.head()

नीचे इस डेटा के साथ तालिका के सबसे महत्वपूर्ण स्तंभों के बारे में जानकारी दी गई है। यदि आप सभी स्तंभों के लिए स्पष्टीकरण पढ़ना चाहते हैं, तो यहां आप संपूर्ण डेटा सेट के लिए एक डेटा शब्दकोश पा सकते हैं।

date - खेल की तारीख।
v_name - अतिथि टीम का नाम।
v_league - मेहमान टीम की लीग।
h_name - होम टीम का नाम।
h_league - होम टीम लीग।
v_score - दूर टीम से अंक।
h_score - होम टीम के पॉइंट्स।
v_line_score - अतिथि टीम के अंकों का सारांश, उदाहरण के लिए - 010000(10)00 ।
h_line_score - उदाहरण के लिए, होम टीम के अंकों का सारांश - 010000(10)0X ।
park_id - उस क्षेत्र का पहचानकर्ता जिस पर खेल खेला गया था।
attendance - दर्शकों की संख्या।

DataFrame ऑब्जेक्ट के बारे में सामान्य जानकारी जानने के लिए, आप DataFrame.info () विधि का उपयोग कर सकते हैं। इस पद्धति के लिए धन्यवाद, आप किसी ऑब्जेक्ट के आकार, डेटा प्रकारों के बारे में, और मेमोरी उपयोग के बारे में जान सकते हैं।

डिफ़ॉल्ट रूप से, पांडा, समय की बचत के लिए, DataFrame द्वारा मेमोरी उपयोग के बारे में अनुमानित जानकारी DataFrame । हम सटीक जानकारी में रुचि रखते हैं, इसलिए हम memory_usage पैरामीटर को 'deep' सेट करेंगे।

 gl.info(memory_usage='deep')

यहां वे जानकारी दी गई हैं जिन्हें हम प्राप्त करने में कामयाब रहे:

 <class 'pandas.core.frame.DataFrame'> RangeIndex: 171907 entries, 0 to 171906 Columns: 161 entries, date to acquisition_info dtypes: float64(77), int64(6), object(78) memory usage: 861.6 MB

जैसा कि यह निकला, हमारे पास 171,907 पंक्तियाँ और 161 स्तंभ हैं। पांडा लाइब्रेरी ने स्वचालित रूप से डेटा प्रकारों का पता लगाया। संख्यात्मक डेटा के साथ 83 कॉलम हैं और ऑब्जेक्ट्स के साथ 78 कॉलम हैं। ऑब्जेक्ट कॉलम का उपयोग स्ट्रिंग डेटा को संग्रहीत करने के लिए किया जाता है, और ऐसे मामलों में जहां कॉलम में विभिन्न प्रकार के डेटा होते हैं।

अब, यह समझने के लिए कि आप इस DataFrame साथ मेमोरी उपयोग को कैसे अनुकूलित कर सकते हैं, आइए बात करते हैं कि पांडा मेमोरी में डेटा कैसे स्टोर करते हैं।

किसी DataFrame का आंतरिक दृश्य

पंडों के अंदर, डेटा कॉलम को एक ही प्रकार के मूल्यों के साथ ब्लॉक में वर्गीकृत किया जाता है। यहाँ एक उदाहरण है कि कैसे एक DataFrame के पहले 12 कॉलम पांडा में संग्रहीत किए DataFrame हैं।

पांडा में विभिन्न प्रकार के डेटा का आंतरिक प्रतिनिधित्व

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

प्रत्येक डेटा प्रकार में pandas.core.internals मॉड्यूल में एक विशेष वर्ग होता है। उदाहरण के लिए, पांडा स्ट्रिंग कॉलम वाले ब्लॉक का प्रतिनिधित्व करने के लिए ObjectBlock क्लास का उपयोग करता है, और FloatBlock वर्ग उन कॉलम को ब्लॉक करने के लिए प्रतिनिधित्व करता है जो फ्लोटिंग-पॉइंट नंबर रखते हैं। पूर्णांक या फ़्लोटिंग पॉइंट नंबरों की तरह दिखने वाले संख्यात्मक मानों को दर्शाने वाले ब्लॉक के लिए, पंडास कॉलम को जोड़ती है और उन्हें न्यूपी लाइब्रेरी के डेटारी ndarray रूप में संग्रहीत करती है। यह डेटा संरचना सरणी C पर आधारित है, मानों को स्मृति के निरंतर ब्लॉक में संग्रहीत किया जाता है। इस डेटा स्टोरेज स्कीम की बदौलत डेटा के टुकड़ों तक पहुंच बहुत तेज है।

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

 for dtype in ['float','int','object']:   selected_dtype = gl.select_dtypes(include=[dtype])   mean_usage_b = selected_dtype.memory_usage(deep=True).mean()   mean_usage_mb = mean_usage_b / 1024 ** 2   print("Average memory usage for {} columns: {:03.2f} MB".format(dtype,mean_usage_mb))

नतीजतन, यह पता चला है कि विभिन्न प्रकारों के डेटा के लिए मेमोरी उपयोग के औसत संकेतक इस तरह दिखते हैं:

 Average memory usage for float columns: 1.29 MB Average memory usage for int columns: 1.12 MB Average memory usage for object columns: 9.53 MB

यह जानकारी हमें यह समझाती है कि अधिकांश मेमोरी 78 कॉलम पर ऑब्जेक्ट वैल्यू को स्टोर करने पर खर्च की जाती है। हम इस बारे में बाद में बात करेंगे, लेकिन अब इस बारे में सोचें कि क्या हम संख्यात्मक डेटा स्टोर करने वाले स्तंभों के साथ मेमोरी उपयोग में सुधार कर सकते हैं।

उपप्रकार

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

पंडों में कई डेटा प्रकारों में कई उपप्रकार होते हैं जो प्रत्येक मूल्य का प्रतिनिधित्व करने के लिए कम बाइट्स का उपयोग कर सकते हैं। उदाहरण के लिए, float प्रकार में float16 , float और float float64 । प्रकार नाम में संख्या बिट्स की संख्या को इंगित करता है जो उप-प्रकार मानों का प्रतिनिधित्व करने के लिए उपयोग करता है। उदाहरण के लिए, डेटा संग्रहण के लिए क्रमशः सूचीबद्ध उप-वर्गों में 2, 4, 8 और 16 बाइट्स का उपयोग किया जाता है। निम्न तालिका पंडों में सबसे अधिक इस्तेमाल किए जाने वाले डेटा प्रकारों के उपप्रकारों को दिखाती है।

^{मेमोरी उपयोग, बाइट्स}	^{फ्लोटिंग पॉइंट नंबर}	^{पूर्णांक}	^{निरुपित पूर्णांक}	^{तारीख और समय}	^{बूलियन मूल्य}	^{वस्तु}
¹		^int8	^uint8		^bool
²	^float16	^int16	^uint16
⁴	^float32	^int32	^uint32
⁸	^float64	^int64	^uint64	^datetime64
^{चर स्मृति क्षमता}						^{वस्तु}

एक संख्या को स्टोर करने के लिए टाइप int8 का मान 1 बाइट (8 बिट) का उपयोग करता है और 256 बाइनरी मान (2 से 8 शक्ति) का प्रतिनिधित्व कर सकता है। इसका मतलब यह है कि इस उपप्रकार का उपयोग -128 से लेकर 127 (0 सहित) में मानों को संग्रहीत करने के लिए किया जा सकता है।

प्रत्येक पूर्णांक उपप्रकार का उपयोग करके भंडारण के लिए उपयुक्त न्यूनतम और अधिकतम मूल्यों की जांच करने के लिए, आप numpy.iinfo() विधि का उपयोग कर सकते हैं। एक उदाहरण पर विचार करें:

 import numpy as np int_types = ["uint8", "int8", "int16"] for it in int_types:   print(np.iinfo(it))

इस कोड को निष्पादित करने से, हमें निम्नलिखित डेटा मिलते हैं:

 Machine parameters for uint8 --------------------------------------------------------------- min = 0 max = 255 --------------------------------------------------------------- Machine parameters for int8 --------------------------------------------------------------- min = -128 max = 127 --------------------------------------------------------------- Machine parameters for int16 --------------------------------------------------------------- min = -32768 max = 32767 ---------------------------------------------------------------

यहां आप प्रकार uint (अहस्ताक्षरित पूर्णांक) और int (हस्ताक्षरित पूर्णांक) के बीच अंतर पर ध्यान दे सकते हैं। दोनों प्रकारों में समान क्षमता है, लेकिन जब स्तंभों में केवल सकारात्मक मान संग्रहीत होते हैं, तो अहस्ताक्षरित प्रकार स्मृति के अधिक कुशल उपयोग की अनुमति देते हैं।

उपप्रकारों का उपयोग करके संख्यात्मक डेटा के भंडारण का अनुकूलन

pd.to_numeric() फ़ंक्शन का उपयोग संख्यात्मक प्रकारों को pd.to_numeric() करने के लिए किया जा सकता है। पूर्णांक स्तंभों का चयन करने के लिए, हम DataFrame.select_dtypes() विधि का उपयोग करते हैं, फिर हम उनका अनुकूलन करते हैं और अनुकूलन से पहले और बाद में मेमोरी उपयोग की तुलना करते हैं।

 #     ,   , #   ,      . def mem_usage(pandas_obj):   if isinstance(pandas_obj,pd.DataFrame):       usage_b = pandas_obj.memory_usage(deep=True).sum()   else: #     ,     DataFrame,   Series       usage_b = pandas_obj.memory_usage(deep=True)   usage_mb = usage_b / 1024 ** 2 #       return "{:03.2f} MB".format(usage_mb) gl_int = gl.select_dtypes(include=['int']) converted_int = gl_int.apply(pd.to_numeric,downcast='unsigned') print(mem_usage(gl_int)) print(mem_usage(converted_int)) compare_ints = pd.concat([gl_int.dtypes,converted_int.dtypes],axis=1) compare_ints.columns = ['before','after'] compare_ints.apply(pd.Series.value_counts)

यहाँ स्मृति खपत के एक अध्ययन का परिणाम है:

7.87 MB
1.48 MB

	को	के बाद
uint8	NaN	5.0
uint32	NaN	1.0
int64	6.0	NaN

नतीजतन, आप स्मृति उपयोग में 7.9 से 1.5 मेगाबाइट तक की गिरावट देख सकते हैं, अर्थात् - हमने मेमोरी की खपत 80% से अधिक घटा दी है। मूल DataFrame पर इस अनुकूलन का समग्र प्रभाव, विशेष रूप से मजबूत नहीं है क्योंकि इसमें बहुत कम पूर्णांक स्तंभ हैं।

आइए फ्लोटिंग पॉइंट नंबर वाले कॉलम के साथ भी ऐसा ही करें।

 gl_float = gl.select_dtypes(include=['float']) converted_float = gl_float.apply(pd.to_numeric,downcast='float') print(mem_usage(gl_float)) print(mem_usage(converted_float)) compare_floats = pd.concat([gl_float.dtypes,converted_float.dtypes],axis=1) compare_floats.columns = ['before','after'] compare_floats.apply(pd.Series.value_counts)

परिणाम निम्नलिखित है:

100.99 MB
50.49 MB

	को	के बाद
float32	NaN	77.0
float64	77.0	NaN

नतीजतन, सभी कॉलम जो डेटा टाइप float64 साथ फ्लोटिंग पॉइंट नंबर संग्रहीत float64 हैं, अब टाइप float64 की संख्या स्टोर float32 , जिससे हमें मेमोरी उपयोग में 50% की कमी हुई।

मूल DataFrame की एक प्रति बनाएँ, जो कि इसमें मूल रूप से मौजूद थे, के बजाय इन अनुकूलित संख्यात्मक स्तंभों का उपयोग करें और अनुकूलन के बाद समग्र मेमोरी उपयोग को देखें।

 optimized_gl = gl.copy() optimized_gl[converted_int.columns] = converted_int optimized_gl[converted_float.columns] = converted_float print(mem_usage(gl)) print(mem_usage(optimized_gl))

यहाँ हमें क्या मिला है:

861.57 MB
804.69 MB

हालाँकि, हमने पूरे DataFrame में सामान्य रूप से, संख्यात्मक डेटा संग्रहीत करने वाले स्तंभों द्वारा मेमोरी की खपत को काफी कम कर दिया है, लेकिन मेमोरी की खपत में 7% की कमी आई है। वस्तु प्रकारों के भंडारण का अनुकूलन किसी स्थिति के अधिक गंभीर सुधार का स्रोत बन सकता है।

इससे पहले कि हम इस अनुकूलन को करें, हम इस बात पर करीब से नज़र डालेंगे कि पंडों में तार कैसे संग्रहीत किए जाते हैं, और इसकी तुलना यहाँ कैसे संग्रहीत की जाती है।

संख्या और तारों के भंडारण के लिए तंत्र की तुलना

object प्रकार पायथन स्ट्रिंग ऑब्जेक्ट्स का उपयोग करके मूल्यों का प्रतिनिधित्व करता है। यह आंशिक रूप से है क्योंकि NumPy गायब स्ट्रिंग मानों के प्रतिनिधित्व का समर्थन नहीं करता है। चूंकि पायथन एक उच्च-स्तरीय व्याख्या वाली भाषा है, यह प्रोग्रामर को ठीक-ट्यूनिंग के लिए उपकरण प्रदान नहीं करता है कि डेटा को मेमोरी में कैसे संग्रहीत किया जाता है।

यह सीमा इस तथ्य की ओर ले जाती है कि तार स्मृति के सन्निहित टुकड़ों में जमा नहीं होते हैं, स्मृति में उनका प्रतिनिधित्व खंडित है। यह स्मृति की खपत में वृद्धि और स्ट्रिंग मूल्यों के साथ काम करने की गति में मंदी की ओर जाता है। कॉलम में प्रत्येक तत्व ऑब्जेक्ट डेटा प्रकार को संग्रहीत करता है, वास्तव में, एक संकेतक है जिसमें "पता" होता है, जिस पर वास्तविक मूल्य स्मृति में स्थित होता है।

निम्नलिखित इस सामग्री पर आधारित एक आरेख है जो न्यूमपी डेटा प्रकारों का उपयोग करके संख्यात्मक डेटा को संग्रहीत करने और पायथन के अंतर्निहित डेटा प्रकारों का उपयोग करके तारों को संग्रहीत करने की तुलना करता है।

संख्यात्मक और स्ट्रिंग डेटा संग्रहीत करना

यहां आप याद कर सकते हैं कि ऊपर दी गई एक तालिका में यह दिखाया गया था कि मेमोरी की एक चर राशि का उपयोग ऑब्जेक्ट प्रकारों के डेटा को संग्रहीत करने के लिए किया जाता है। हालाँकि, प्रत्येक पॉइंटर 1 बाइट की मेमोरी पर कब्जा कर लेता है, प्रत्येक विशेष स्ट्रिंग मान में मेमोरी की समान मात्रा होती है, जिसका उपयोग पायथन में एक स्ट्रिंग को स्टोर करने के लिए किया जाएगा। इसकी पुष्टि करने के लिए, हम sys.getsizeof() विधि का उपयोग करेंगे। सबसे पहले, व्यक्तिगत रेखाओं पर एक नज़र डालें, और फिर Series पांडा ऑब्जेक्ट में जो स्ट्रिंग डेटा संग्रहीत करता है।

तो, पहले हम सामान्य लाइनों की जाँच करते हैं:

 from sys import getsizeof s1 = 'working out' s2 = 'memory usage for' s3 = 'strings in python is fun!' s4 = 'strings in python is fun!' for s in [s1, s2, s3, s4]:   print(getsizeof(s))

यहाँ, मेमोरी उपयोग डेटा इस तरह दिखता है:

अब देखते हैं कि Series वस्तु में तारों का उपयोग कैसे दिखता है:

 obj_series = pd.Series(['working out',                         'memory usage for',                         'strings in python is fun!',                         'strings in python is fun!']) obj_series.apply(getsizeof)

यहाँ हम निम्नलिखित हैं:

 0    60 1    65 2    74 3    74 dtype: int64

यहाँ आप देख सकते हैं कि Series पांडा वस्तुओं में संग्रहीत लाइनों के आकार उनके आकार के समान हैं जब पायथन में उनके साथ काम करते हैं और जब उन्हें अलग-अलग संस्थाओं के रूप में प्रतिनिधित्व करते हैं।

श्रेणीगत चर का उपयोग करके ऑब्जेक्ट प्रकार डेटा के भंडारण का अनुकूलन

श्रेणी संस्करण 0.15 पांडा संस्करण में दिखाई दिए। तालिका स्तंभों में संग्रहीत मूल मानों के बजाय संबंधित प्रकार, category , अपने आंतरिक तंत्र में पूर्णांक मानों का उपयोग करता है। पंडों ने एक अलग शब्दकोश का उपयोग किया है जो पूर्णांक और प्रारंभिक मूल्यों के पत्राचार को निर्धारित करता है। जब स्तंभ सीमित सेट से मान सम्‍मिलित करता है तो यह दृष्टिकोण उपयोगी होता है। जब किसी कॉलम में संग्रहीत डेटा को category प्रकार में बदल दिया जाता है, तो पंडास int उपप्रकार का उपयोग करता है, जो मेमोरी के सबसे कुशल उपयोग की अनुमति देता है और कॉलम में पाए जाने वाले सभी अद्वितीय मूल्यों का प्रतिनिधित्व करने में सक्षम है।

Int8 उपप्रकार का उपयोग करके स्रोत डेटा और श्रेणीबद्ध डेटा

यह समझने के लिए कि स्मृति उपभोग को कम करने के लिए हम श्रेणीबद्ध डेटा का उपयोग कहां कर सकते हैं, हम उन स्तंभों में अद्वितीय मानों की संख्या का पता लगाते हैं जो ऑब्जेक्ट प्रकारों के मूल्यों को संग्रहीत करते हैं:

 gl_obj = gl.select_dtypes(include=['object']).copy() gl_obj.describe()

आप पा सकते हैं कि हमारे पास इस तालिका में, की शीट पर क्या है।

उदाहरण के लिए, day_of_week कॉलम में, जिस दिन खेल खेला गया था, उस दिन 171907 मूल्य हैं। उनमें से, केवल 7 अद्वितीय हैं। कुल मिलाकर, इस रिपोर्ट पर एक नज़र यह समझने के लिए पर्याप्त है कि लगभग 172,000 खेलों के डेटा का प्रतिनिधित्व करने के लिए कई स्तंभों में कुछ अद्वितीय मूल्यों का उपयोग किया जाता है।

इससे पहले कि हम पूर्ण पैमाने पर अनुकूलन करें, एक ऐसा कॉलम चुनें जो ऑब्जेक्ट डेटा, कम से कम day_of_week , और देखें कि प्रोग्राम के अंदर क्या होता है जब यह एक श्रेणीबद्ध प्रकार में परिवर्तित हो जाता है।

जैसा कि पहले ही उल्लेख किया गया है, इस स्तंभ में केवल 7 अद्वितीय मूल्य हैं। इसे एक .astype() प्रकार में बदलने के लिए, हम .astype() विधि का उपयोग करते हैं।

 dow = gl_obj.day_of_week print(dow.head()) dow_cat = dow.astype('category') print(dow_cat.head())

यहाँ हमें क्या मिला है:

 0    Thu 1    Fri 2    Sat 3    Mon 4    Tue Name: day_of_week, dtype: object 0    Thu 1    Fri 2    Sat 3    Mon 4    Tue Name: day_of_week, dtype: category Categories (7, object): [Fri, Mon, Sat, Sun, Thu, Tue, Wed]

जैसा कि आप देख सकते हैं, हालांकि स्तंभ का प्रकार बदल गया है, इसमें संग्रहीत डेटा पहले की तरह ही दिखता है। अब आइए देखें कि कार्यक्रम के अंदर क्या हो रहा है।

निम्नलिखित कोड में, हम यह पता लगाने के लिए Series.cat.codes विशेषता का उपयोग करते हैं कि सप्ताह के प्रत्येक दिन का प्रतिनिधित्व करने के लिए कौन से पूर्णांक category प्रकार का उपयोग करता है:

 dow_cat.head().cat.codes

हम निम्नलिखित का पता लगाने का प्रबंधन करते हैं:

 0    4 1    0 2    2 3    1 4    5 dtype: int8

यहां आप देख सकते हैं कि प्रत्येक अद्वितीय मान को एक पूर्णांक मान असाइन किया गया है, और यह कि स्तंभ अब प्रकार int8 । लापता मान नहीं हैं, लेकिन अगर ऐसा होता तो -1 का इस्तेमाल ऐसे मूल्यों को इंगित करने के लिए किया जाता।

अब चलो day_of_week कॉलम को category प्रकार में परिवर्तित करने से पहले और बाद में मेमोरी खपत की तुलना करें।

 print(mem_usage(dow)) print(mem_usage(dow_cat))

यहाँ परिणाम है:

9.84 MB
0.16 MB

जैसा कि आप देख सकते हैं, पहले 9.84 मेगाबाइट मेमोरी का उपभोग किया गया था, और केवल 0.16 मेगाबाइट के अनुकूलन के बाद, जिसका अर्थ है कि इस सूचक में 98% सुधार हुआ है। कृपया ध्यान दें कि इस स्तंभ के साथ काम करना संभवतः सबसे लाभदायक अनुकूलन परिदृश्यों में से एक को प्रदर्शित करता है, जब लगभग 17,000,000 तत्वों वाले स्तंभ में केवल 7 अद्वितीय मानों का उपयोग किया जाता है।

यद्यपि इस डेटा प्रकार में सभी कॉलम को परिवर्तित करने का विचार आकर्षक लगता है, ऐसा करने से पहले, इस तरह के रूपांतरण के नकारात्मक दुष्प्रभावों पर विचार करें। इसलिए, इस परिवर्तन का सबसे गंभीर ऋणात्मक डेटा पर अंकगणितीय संचालन करने की असंभवता है। यह साधारण अंकगणितीय परिचालनों पर भी लागू होता है, और पहले डेटा को वास्तविक संख्या प्रकार में परिवर्तित किए बिना Series.min() और Series.max() जैसे तरीकों का उपयोग होता है।

हमें category प्रकार के उपयोग को मुख्य रूप से उन स्तंभों तक सीमित करना चाहिए जो टाइप object डेटा को स्टोर करते हैं, जिसमें 50% से कम मूल्य अद्वितीय हैं। यदि किसी कॉलम के सभी मूल्य अद्वितीय हैं, तो category प्रकार का उपयोग करके मेमोरी के उपयोग के स्तर में वृद्धि होगी। यह इस तथ्य के कारण है कि मेमोरी में आपको संख्यात्मक श्रेणी कोड के अलावा, मूल स्ट्रिंग मानों को संग्रहीत करना होगा। category प्रकार प्रतिबंधों पर विवरण पांडा प्रलेखन में पाया जा सकता है।

आइए एक लूप बनाएं जो टाइप object डेटा को संग्रहीत करने वाले सभी स्तंभों पर प्रसारित करता है, यह पता लगाता है कि क्या स्तंभों में अद्वितीय मानों की संख्या 50% से अधिक है, और यदि ऐसा है, तो उन्हें टाइप category परिवर्तित करता है।

 converted_obj = pd.DataFrame() for col in gl_obj.columns:   num_unique_values = len(gl_obj[col].unique())   num_total_values = len(gl_obj[col])   if num_unique_values / num_total_values < 0.5:       converted_obj.loc[:,col] = gl_obj[col].astype('category')   else:       converted_obj.loc[:,col] = gl_obj[col]

अब तुलना करें कि पहले जो हुआ उसके साथ अनुकूलन के बाद क्या हुआ:

 print(mem_usage(gl_obj)) print(mem_usage(converted_obj)) compare_obj = pd.concat([gl_obj.dtypes,converted_obj.dtypes],axis=1) compare_obj.columns = ['before','after'] compare_obj.apply(pd.Series.value_counts)

हम निम्नलिखित प्राप्त करते हैं:

752.72 MB
51.67 MB

	को	के बाद
वस्तु	78.0	NaN
श्रेणी	NaN	78.0

category , , , , , , , , .

, , , object , 752 52 , 93%. , . , , , , 891 .

 optimized_gl[converted_obj.columns] = converted_obj mem_usage(optimized_gl)

:

'103.64 MB'

. - . , datetime , , , .

 date = optimized_gl.date print(mem_usage(date)) date.head()

:

0.66 MB

:

 0    18710504 1    18710505 2    18710506 3    18710508 4    18710509 Name: date, dtype: uint32

, uint32 . - datetime , 64 . datetime , , , .

to_datetime() , format , YYYY-MM-DD .

 optimized_gl['date'] = pd.to_datetime(date,format='%Y%m%d') print(mem_usage(optimized_gl)) optimized_gl.date.head()

:

104.29 MB

:

 0   1871-05-04 1   1871-05-05 2   1871-05-06 3   1871-05-08 4   1871-05-09 Name: date, dtype: datetime64[ns]

DataFrame . , , , , , , , . , . , , , . , , DataFrame , .

, . pandas.read_csv() , . , dtype , , , , — NumPy.

, , . , .

 dtypes = optimized_gl.drop('date',axis=1).dtypes dtypes_col = dtypes.index dtypes_type = [i.name for i in dtypes.values] column_types = dict(zip(dtypes_col, dtypes_type)) #    161 ,  #  10  /   #     preview = first2pairs = {key:value for key,value in list(column_types.items())[:10]} import pprint pp = pp = pprint.PrettyPrinter(indent=4) pp.pprint(preview)     : {   'acquisition_info': 'category',   'h_caught_stealing': 'float32',   'h_player_1_name': 'category',   'h_player_9_name': 'category',   'v_assists': 'float32',   'v_first_catcher_interference': 'float32',   'v_grounded_into_double': 'float32',   'v_player_1_id': 'category',   'v_player_3_id': 'category',   'v_player_5_id': 'category'}

, , .

- :

 read_and_optimized = pd.read_csv('game_logs.csv',dtype=column_types,parse_dates=['date'],infer_datetime_format=True) print(mem_usage(read_and_optimized)) read_and_optimized.head()

:

104.28 MB

, .

, , , , . pandas 861.6 104.28 , 88% .

, , , . .

 optimized_gl['year'] = optimized_gl.date.dt.year games_per_day = optimized_gl.pivot_table(index='year',columns='day_of_week',values='date',aggfunc=len) games_per_day = games_per_day.divide(games_per_day.sum(axis=1),axis=0) ax = games_per_day.plot(kind='area',stacked='true') ax.legend(loc='upper right') ax.set_ylim(0,1) plt.show()

,

, 1920- , , 50 , .

, , , 50 , .

, .

 game_lengths = optimized_gl.pivot_table(index='year', values='length_minutes') game_lengths.reset_index().plot.scatter('year','length_minutes') plt.show()

, 1940- .

परिणाम

pandas, , DataFrame , 90%. :

, , , , .
.

, , , , , , pandas, , .

प्रिय पाठकों! eugene_bb . - , — .

पंडों बिग डेटा विश्लेषण के लिए गाइड