7 पांडा प्रदर्शन युक्तियाँ हर डेटा वैज्ञानिक को पता होनी चाहिए

संपूर्ण विचार डेटा पेशेवरों को यह एहसास दिलाना था कि “आधुनिक डेटाफ़्रेम” कैसा दिखता है और ये उपकरण डेटा के साथ हमारे काम करने के तरीके को कैसे नया आकार दे सकते हैं।

लेकिन कुछ दिलचस्प हुआ: मुझे जो फीडबैक मिला, उससे मुझे एहसास हुआ कि बहुत सारे डेटा वैज्ञानिक अभी भी अपने अधिकांश दैनिक कार्यों के लिए पांडा पर बहुत अधिक निर्भर हैं।

और मैं पूरी तरह से समझता हूं क्यों।

यहां तक ​​कि सभी नए विकल्पों के साथ भी, पांडा पायथन डेटा विज्ञान की रीढ़ बने हुए हैं।

और यह केवल कुछ टिप्पणियों पर आधारित भी नहीं है।

एक ताज़ा डेटा विज्ञान की स्थिति सर्वेक्षण रिपोर्ट करता है कि 77% अभ्यासकर्ता डेटा अन्वेषण और प्रसंस्करण के लिए पांडा का उपयोग करें।

मैं पंडों को उस विश्वसनीय पुराने मित्र के रूप में सोचना पसंद करता हूं जिसे आप बुलाते रहते हैं: शायद सबसे आकर्षक नहीं, लेकिन आप जानते हैं कि यह हमेशा काम पूरा करता है।

इसलिए, जबकि नए उपकरणों में निश्चित रूप से अपनी ताकत है, यह स्पष्ट है कि पांडा जल्द ही कहीं नहीं जा रहे हैं।

और हम में से कई लोगों के लिए, असली चुनौती पांडा को प्रतिस्थापित करना नहीं है, बल्कि जब हम बड़े डेटासेट के साथ काम कर रहे हैं तो इसे और अधिक कुशल बनाना और थोड़ा कम दर्दनाक बनाना है।

इस लेख में, मैं आपको आपके पांडा वर्कफ़्लो को तेज़ करने के सात व्यावहारिक तरीकों के बारे में बताऊंगा। इन्हें लागू करना आसान है फिर भी ये आपके कोड को काफ़ी तेज़ बनाने में सक्षम हैं।

सेटअप और पूर्वावश्यकताएँ

इससे पहले कि हम इसमें शामिल हों, यहां वह चीज़ दी गई है जिसकी आपको आवश्यकता होगी। मैं इस ट्यूटोरियल में Python 3.10+ और Pandas 2.x का उपयोग कर रहा हूं। यदि आप पुराने संस्करण पर हैं, तो आप इसे तुरंत अपग्रेड कर सकते हैं:

pip install --upgrade pandas

वास्तव में आपको बस यही चाहिए। एक मानक वातावरण, जैसे ज्यूपिटर नोटबुक, वीएस कोड, या Google Colab, ठीक काम करता है।

यदि आपके पास पहले से ही NumPy इंस्टॉल है, जैसा कि अधिकांश लोग करते हैं, तो इस ट्यूटोरियल में बाकी सब कुछ बिना किसी अतिरिक्त सेटअप के चलना चाहिए।

1. गति बढ़ाओ read_csv स्मार्टर डिफॉल्ट्स के साथ

मुझे याद है कि मैंने पहली बार 2GB CSV फ़ाइल के साथ काम किया था।

मेरे लैपटॉप के पंखे चिल्ला रहे थे, नोटबुक ठंडी होती जा रही थी, और मैं प्रगति पट्टी को घूर रहा था, सोच रहा था कि क्या यह कभी खत्म होगा।

मुझे बाद में एहसास हुआ कि मंदी पंडों के कारण नहीं थी, बल्कि इसलिए थी क्योंकि मैं इसे हर चीज़ का स्वतः पता लगाने दे रहा था और सभी 30 कॉलम लोड कर रहा था जब मुझे केवल 6 की आवश्यकता थी।

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

जिन कार्यों में मुझे आमतौर पर एक जमे हुए प्रगति पट्टी पर घूरना पड़ता था, वे अब सुचारू रूप से चलने लगे, और अंततः मुझे ऐसा महसूस हुआ कि मेरा लैपटॉप मेरी तरफ था।

आइए मैं आपको दिखाता हूं कि मैं यह कैसे करता हूं।

पहले से ही dtypes निर्दिष्ट करें

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

df = pd.read_csv(
    "sales_data.csv",
    dtype={
        "store_id": "int32",
        "product_id": "int32",
        "category": "category"
    }
)

केवल वही कॉलम लोड करें जिनकी आपको आवश्यकता है

कभी-कभी आपके CSV में दर्जनों कॉलम होते हैं, लेकिन आप केवल कुछ की ही परवाह करते हैं। बाकी को लोड करने से केवल मेमोरी बर्बाद होती है और प्रक्रिया धीमी हो जाती है।

cols_to_use = ("order_id", "customer_id", "price", "quantity")

df = pd.read_csv("orders.csv", usecols=cols_to_use)

उपयोग chunksize बड़ी फ़ाइलों के लिए

बहुत बड़ी फ़ाइलों के लिए जो मेमोरी में फिट नहीं होती हैं, टुकड़ों में पढ़ने से आप अपनी नोटबुक को क्रैश किए बिना डेटा को सुरक्षित रूप से संसाधित कर सकते हैं।

chunks = pd.read_csv("logs.csv", chunksize=50_000)

for chunk in chunks:
    # process each chunk as needed
    pblock

सरल, व्यावहारिक और यह वास्तव में काम करता है।

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

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

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

2. मेमोरी को कम करने और संचालन को गति देने के लिए सही डेटा प्रकारों का उपयोग करें

अपने पांडा वर्कफ़्लो को तेज़ बनाने के सबसे आसान तरीकों में से एक है डेटा को सही प्रकार में संग्रहीत करना।

बहुत से लोग डिफॉल्ट से चिपके रहते हैं object या float64 प्रकार. ये लचीले हैं, लेकिन मुझ पर विश्वास करें, ये भारी हैं।

छोटे या अधिक उपयुक्त प्रकारों पर स्विच करने से मेमोरी का उपयोग कम हो सकता है और प्रदर्शन में उल्लेखनीय सुधार हो सकता है।

पूर्णांकों और फ़्लोट्स को छोटे प्रकारों में बदलें

यदि किसी कॉलम को 64-बिट परिशुद्धता की आवश्यकता नहीं है, तो डाउनकास्टिंग से मेमोरी बचाई जा सकती है:

# Example dataframe
df = pd.DataFrame({
    "user_id": (1, 2, 3, 4),
    "score": (99.5, 85.0, 72.0, 100.0)
})

# Downcast integer and float columns
df("user_id") = df("user_id").astype("int32")
df("score") = df("score").astype("float32")

उपयोग category बार-बार स्ट्रिंग के लिए

कई दोहराए गए मानों वाले स्ट्रिंग कॉलम, जैसे देश के नाम या उत्पाद श्रेणियां, में परिवर्तित होने से बड़े पैमाने पर लाभ होता है category प्रकार:

df("country") = df("country").astype("category")
df("product_type") = df("product_type").astype("category")

यह मेमोरी बचाता है और फ़िल्टरिंग और ग्रुपिंग जैसे कार्यों को काफ़ी तेज़ बनाता है।

पहले और बाद में मेमोरी उपयोग की जाँच करें

आप तुरंत प्रभाव देख सकते हैं:

print(df.info(memory_usage="deep"))

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

3. लूपिंग बंद करो. वेक्टराइज़िंग प्रारंभ करें

सबसे बड़ी प्रदर्शन गलतियों में से एक जो मैं देखता हूं वह है पायथन लूप्स का उपयोग करना .apply() उन परिचालनों के लिए जिन्हें वेक्टरकृत किया जा सकता है।

लूप्स लिखना आसान है, लेकिन पांडा वेक्टरकृत ऑपरेशनों के आसपास बनाया गया है जो हुड के नीचे सी में चलते हैं, साथ ही वे बहुत तेजी से चलते हैं।

धीमे दृष्टिकोण का उपयोग करना .apply() (या एक लूप):

# Example: adding 10% tax to prices
df("price_with_tax") = df("price").apply(lambda x: x * 1.1)

यह छोटे डेटासेट पर ठीक काम करता है, लेकिन एक बार जब आप सैकड़ों हजारों पंक्तियों तक पहुंच जाते हैं, तो यह क्रॉल होना शुरू हो जाता है।

तेज़ वेक्टरकृत दृष्टिकोण:

# Vectorized operation
df("price_with_tax") = df("price") * 1.1

इतना ही। समान परिणाम, तीव्रता का क्रम तेज़।

4. प्रयोग करें loc और iloc सही तरीका

मैंने एक बार एक बड़े डेटासेट को कुछ इस तरह से फ़िल्टर करने का प्रयास किया था df(df("price") > 100)("category"). पंडों ने न केवल मुझे चेतावनियाँ दीं, बल्कि कोड जितना धीमा होना चाहिए था, उससे कहीं अधिक धीमा था।

मैंने बहुत जल्दी जान लिया कि जंजीर अनुक्रमण गड़बड़ और अकुशल है; इससे सूक्ष्म बग और प्रदर्शन संबंधी समस्याएं भी पैदा हो सकती हैं।

का उपयोग करते हुए loc और iloc ठीक से आपके कोड को तेज़ और पढ़ने में आसान बनाता है।

उपयोग loc लेबल-आधारित अनुक्रमण के लिए

जब आप पंक्तियों को फ़िल्टर करना चाहते हैं और नाम से कॉलम का चयन करना चाहते हैं, loc क्या आपका सर्वश्रेष्ठ दांव है:

# Select rows where price > 100 and only the 'category' column
filtered = df.loc(df("price") > 100, "category")

यह जंजीर बनाने की तुलना में अधिक सुरक्षित और तेज़ है, और यह बदनामी से बचाता है SettingWithCopyWarning.

उपयोग iloc स्थिति-आधारित अनुक्रमण के लिए

यदि आप पंक्ति और स्तंभ स्थितियों के साथ काम करना पसंद करते हैं:

# Select first 5 rows and the first 2 columns
subset = df.iloc(:5, :2)

इन विधियों का उपयोग करने से आपका कोड साफ और कुशल रहता है, खासकर जब आप असाइनमेंट या जटिल फ़िल्टरिंग कर रहे हों।

5. प्रयोग करें query() तेज़, स्वच्छ फ़िल्टरिंग के लिए

जब आपका फ़िल्टरिंग तर्क गड़बड़ होने लगे, query() चीज़ों को और अधिक प्रबंधनीय महसूस करा सकते हैं।

एकाधिक बूलियन शर्तों को कोष्ठक के अंदर रखने के बजाय, query() आपको साफ़-सुथरे, लगभग SQL-जैसे सिंटैक्स में फ़िल्टर लिखने की सुविधा देता है।

और कई मामलों में, यह तेजी से चलता है क्योंकि पांडा आंतरिक रूप से अभिव्यक्ति को अनुकूलित कर सकते हैं।

# More readable filtering using query()
high_value = df.query("price > 100 and quantity < 50")

यह विशेष रूप से तब काम आता है जब आपकी स्थितियाँ खराब होने लगती हैं या जब आप चाहते हैं कि आपका कोड इतना साफ दिखे कि आप एक सप्ताह बाद इसे फिर से देख सकें, बिना यह सोचे कि आप क्या सोच रहे थे।

यह एक सरल अपग्रेड है जो आपके कोड को अधिक जानबूझकर और बनाए रखने में आसान बनाता है।

6. दोहरावदार स्ट्रिंग्स को श्रेणीबद्ध में बदलें

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

मैंने इसका प्रत्यक्ष अनुभव किया है।

पांडा प्रत्येक अद्वितीय मान को आंतरिक संख्यात्मक कोड के साथ प्रतिस्थापित करके श्रेणीबद्ध डेटा को अधिक कॉम्पैक्ट तरीके से संग्रहीत करता है।

यह मेमोरी उपयोग को कम करने में मदद करता है और उस कॉलम पर संचालन को तेज़ बनाता है।

# Converting a string column to a categorical type
df("category") = df("category").astype("category")

अव्यवस्थित, मुक्त रूप वाले पाठ के लिए श्रेणियाँ बहुत कुछ नहीं करेंगी, लेकिन कई पंक्तियों में दोहराए जाने वाले संरचित लेबल के लिए, वे आपके द्वारा किए जा सकने वाले सबसे सरल और सबसे प्रभावी अनुकूलन में से एक हैं।

7. बड़ी फ़ाइलों को एक साथ लोड करने के बजाय टुकड़ों में लोड करें

आपके सिस्टम पर दबाव डालने के सबसे तेज़ तरीकों में से एक है एक विशाल CSV फ़ाइल को एक साथ लोड करने का प्रयास करना।

पांडा हर चीज़ को मेमोरी में खींचने की कोशिश करेंगे, और इससे चीज़ें धीमी हो सकती हैं या आपका सत्र पूरी तरह से क्रैश हो सकता है।

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

# Process a large CSV file in chunks
chunks = ()
for chunk in pd.read_csv("large_data.csv", chunksize=100_000):
    chunk("total") = chunk("price") * chunk("quantity")
    chunks.append(chunk)

df = pd.concat(chunks, ignore_index=True)

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

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

उस अनुभव के बाद, चंकिंग मेरा पसंदीदा दृष्टिकोण बन गया।

एक बार में सब कुछ लोड करने की कोशिश करने के बजाय, आप एक प्रबंधनीय टुकड़ा लेते हैं, इसे संसाधित करते हैं, परिणाम सहेजते हैं, और फिर अगले टुकड़े पर आगे बढ़ते हैं।

अंतिम concat स्टेप आपको आपकी मशीन पर अनावश्यक दबाव डाले बिना एक साफ, पूरी तरह से संसाधित डेटासेट देता है।

यह लगभग बहुत सरल लगता है, लेकिन एक बार जब आप देखेंगे कि वर्कफ़्लो कितना सहज हो जाता है, तो आपको आश्चर्य होगा कि आपने इसका उपयोग बहुत पहले क्यों नहीं शुरू किया।

अंतिम विचार

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

इस लेख की तकनीकें जटिल नहीं हैं, लेकिन जब आप उन्हें लगातार लागू करते हैं तो उनमें उल्लेखनीय अंतर आता है।

ये सुधार व्यक्तिगत रूप से छोटे लग सकते हैं, लेकिन साथ में ये यह रूपांतरित कर सकते हैं कि आप कितनी तेजी से कच्चे डेटा से सार्थक अंतर्दृष्टि की ओर बढ़ते हैं।

यदि आप अपने पांडा कोड को लिखने और संरचना करने के तरीके के बारे में अच्छी आदतें बनाते हैं, तो प्रदर्शन बहुत कम समस्या बन जाता है।

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