Python में डेटा क्लीनिंग के लिए शुरुआती मार्गदर्शिका

डेटा क्लीनिंग का परिचय

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

डेटा क्लीनिंग में त्रुटियों, outliers, और असंगतियों को हटाना शामिल है और यह सुनिश्चित करना कि आपका सारा डेटा आपके विश्लेषण के अनुरूप फॉर्मेट में हो। जिस डेटा में बहुत सी गलतियाँ हों या जिसने यह क्लीनिंग प्रक्रिया न देखी हो, उसे डर्टी डेटा कहा जाता है।

यह चरण कई जूनियर डेटा प्रोफेशनल्स को वैकल्पिक लग सकता है, लेकिन भरोसा रखिए, यह बेहद महत्वपूर्ण है! उचित डेटा क्लीनिंग के बिना आपका मॉडल गलत निष्कर्ष पर पहुँच सकता है, आपका ग्राफ झूठा ट्रेंड दिखा सकता है, और आपकी सांख्यिकी बेहद गलत हो सकती है।

एक बहुत छोटे डेटासेट पर विचार करें। आप और आपके दोस्त टॉफियाँ बराबर-बराबर बाँट रहे हैं, और आपको तय करना है कि हर व्यक्ति को कितनी टॉफियाँ मिलेंगी। आप नीचे दी गई तालिका में अपना डेटा दर्ज करते हैं।

अब यदि आप टॉफियों की संख्या वाले कॉलम का औसत निकालें, तो आप यह निष्कर्ष निकाल सकते हैं कि प्रत्येक व्यक्ति को 12 टॉफियाँ मिलनी चाहिए।

हालाँकि, यदि आप हर व्यक्ति को 12-12 टॉफियाँ देने की कोशिश करते हैं, तो सभी का हिस्सा मिलने से पहले ही टॉफियाँ खत्म हो जाएँगी, क्योंकि आपकी तालिका में Sandy दो बार आया है। आपके पास 60 नहीं, केवल 40 टॉफियाँ हैं (और वास्तव में 5 नहीं, केवल 4 लोग)!

अपने डेटासेट को साफ न करने पर आपका विश्लेषण गलत निष्कर्ष तक पहुँचने का जोखिम उठाता है।

दोस्तों में टॉफियाँ बाँटने के मामले में अधिकतम परिणाम एक नाराज दोस्त हो सकता है। लेकिन बिजनेस दुनिया में, डेटासेट न साफ करने से ऐसे विश्लेषण हो सकते हैं जो गलत प्रोडक्ट लॉन्च करने, गलत संख्या में कर्मचारियों की भर्ती करने, गलत स्टॉक में निवेश करने, या क्लाइंट से गलत कीमत लेने का सुझाव दें!

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

व्यापक डेटा क्लीनिंग, सावधानीपूर्वक परीक्षण के साथ, इन चिंताओं को कम करने में मदद करेगी। इस ट्यूटोरियल में, हम Python में डेटा क्लीनिंग प्रक्रिया के बारे में वह सब कवर करेंगे जो आपको जानना चाहिए।

डर्टी डेटा को समझना

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

Missing values

अधूरे डेटा सेट बहुत आम हैं। आपके डेटासेट में कई वर्षों का डेटा गायब हो सकता है, किसी ग्राहक के बारे में केवल कुछ जानकारी हो सकती है, या आपकी कंपनी के सभी प्रोडक्ट शामिल न हों।

Missing values का आपके विश्लेषण पर कई प्रभाव हो सकते हैं। महत्वपूर्ण डेटा का बड़ा हिस्सा गायब होना आपके परिणामों में bias ला सकता है। साथ ही, DataFrame में NaN वैल्यू या खाली सेल कुछ Python कोड तोड़ सकते हैं, जिससे मॉडल बनाते समय खासी झुंझलाहट होती है।

Outliers

Outliers वे मान होते हैं जो सामान्य सीमा से बहुत बाहर होते हैं और डेटा का प्रतिनिधित्व नहीं करते। Outliers टाइपो या असाधारण परिस्थितियों का परिणाम हो सकते हैं। सच्चे outliers और सूचनात्मक चरम स्थितियों में फर्क करना महत्त्वपूर्ण है। Outliers आपके परिणामों को तिरछा कर सकते हैं और अंततः गलत उत्तर का सुझाव दे सकते हैं।

डुप्लिकेट

जैसा कि ऊपर देखा, duplicate एंट्रियाँ आपके विश्लेषण में किसी एक एंट्री का अत्यधिक प्रतिनिधित्व करा सकती हैं, जिससे गलत निष्कर्ष निकल सकता है। उन डुप्लिकेट्स पर ध्यान दें जो एक से अधिक बार होते हैं और जिनमें परस्पर-विरोधी या अपडेटेड जानकारी होती है।

भ्रामक/गलत डेटा

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

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

असंगतियाँ

असंगतियाँ कई रूपों में आती हैं। असंगत डेटा एंट्रियाँ टाइपो या त्रुटि की ओर इशारा कर सकती हैं। यदि कोई ग्राहक उल्टी उम्र का होता दिखे, कोई सामग्री का ID नंबर बदलता दिखे, या किसी प्रोडक्ट की एक ही समय में दो कीमतें दिखें, तो सब कुछ सही है या नहीं, यह जाँचने के लिए करीब से देखना चाहिए।

एक और समस्याग्रस्त असंगति डेटा के फॉर्मेट में असंगति है। अलग-अलग मान अलग इकाइयों (किलोमीटर बनाम माइल्स बनाम इंच), अलग शैलियों (Month Day, Year बनाम Day-Month-Year), अलग डेटा प्रकारों (floats बनाम integers), या यहाँ तक कि अलग फाइल प्रकारों (.jpg बनाम .png) में रिपोर्ट हो सकते हैं।

ये असंगतियाँ आपके कोड के लिए मानों की सही व्याख्या करना कठिन, यदि असंभव नहीं, तो बना देंगी। इसका परिणाम गलत विश्लेषण या आपका कोड बिल्कुल न चलने में हो सकता है।

डेटा एक्सप्लोरेशन और प्रीप्रोसेसिंग

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

टेबल-फ़ॉर्मैटेड डेटासेट पर डेटा एक्सप्लोरेशन करने के कुछ सामान्य चरण देखें:

1. सबसे पहले, अपने डेटासेट के स्रोत को देखें और तय करें कि उस स्रोत में कोई bias या एजेंडा तो नहीं जो आपके डेटा की गुणवत्ता या विश्वसनीयता को प्रभावित कर सकता है।
2. अपने डेटा का संदर्भ और कोई अन्य कारक जानें जो आपके डेटा को प्रभावित कर सकते थे, जिन्हें अंदरूनी तौर पर नहीं समेटा गया है।
3. आपके पास कितने अलग-अलग वेरिएबल हैं यह निर्धारित करें। टेबल-फ़ॉर्मैटेड डेटासेट में, वेरिएबल आमतौर पर कॉलम होते हैं, जबकि प्रत्येक एंट्री एक पंक्ति होती है।
4. प्रत्येक वेरिएबल के भीतर कितनी अलग-अलग श्रेणियाँ हैं यह निर्धारित करें। उदाहरण के लिए, यदि आपके वेरिएबल्स में से एक फल का प्रकार है, तो आपको इस वेरिएबल में दर्शाए गए विभिन्न फलों की संख्या का अच्छा अंदाजा होना चाहिए।
5. प्रत्येक कॉलम के सारांश आँकड़ों को देखें, जिनमें mean, median, variance, और standard deviation शामिल हैं।
6. यदि संभव हो, तो प्रत्येक वेरिएबल और जितने अधिक वेरिएबल-युग्म हों उन्हें प्लॉट करें और प्लॉट्स को सच में देखें। किसी भी skew, outliers, रुझान, या सहसंबंध को देखें जो आगे जाँचने लायक हो।
7. यदि आपका डेटासेट relational database का हिस्सा है, तो रिलेशनशिप्स को ध्यान से देखें और समझें कि अलग-अलग टेबल्स एक-दूसरे से कैसे संबंधित हैं।
8. यदि लागू हो, तो pandas लाइब्रेरी की प्रोफाइलिंग सुविधा का उपयोग कर प्रोफाइल रिपोर्ट जेनरेट करें। यह आपके डेटासेट के बारे में उपयोगी जानकारी देगा।

एक्सप्लोरेशन और प्रीप्रोसेसिंग क्यों मायने रखते हैं

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

दूसरा, डेटा एक्सप्लोरेशन आपको ऐसे रुझानों और विश्लेषणों की ओर इशारा कर सकता है जिन पर आपने पहले विचार नहीं किया था। ये आपके नियोजित विश्लेषणों में जोड़ सकते हैं या ऐसा जटिल कारक सामने ला सकते हैं जिसे आपको ध्यान में रखना चाहिए।

तीसरा, यह प्री-एनालिसिस आपके डर्टी डेटा के संकेतों की पहली कड़ी हो सकती है। यहीं आपको कोई outlier दिख सकता है, एहसास हो सकता है कि श्रेणियाँ दोगुनी हैं, या पता चल सकता है कि पिछले साल डेटा संग्रह का तरीका अलग था। ये सभी अहम जानकारी के टुकड़े हैं जो आपको अपने डेटासेट के प्रति जिज्ञासु रहने के लिए प्रोत्साहित करेंगे।

डेटा एक्सप्लोरेशन पर अधिक जानकारी के लिए DataCamp का Data Exploration in Python कोर्स या यह एकदम शुरुआती लोगों के लिए ट्यूटोरियल देखें।

Python में डेटा क्लीनिंग की तकनीकें

आइए Python में कुछ डेटा क्लीनिंग तकनीकों की बारीकियों में जाएँ और देखें कि आम डर्टी डेटा समस्याओं से कैसे निपटा जाए।

Missing values को संभालना

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

जब आपको कोई missing value मिले, तो आपके पास विकल्प है—या तो उस एंट्री को विश्लेषण से हटा दें या उसकी जगह कोई उचित मान इम्प्यूट कर दें। यदि आपका डेटासेट अपेक्षाकृत छोटा है, तो मैं missing values वाली पंक्तियाँ देखने की सलाह दूँगा ताकि आप सर्वोत्तम कदम तय कर सकें।

import pandas as pd # Identify rows with NaN valuesrows_with_nan = df[df.isnull().any(axis=1)] #View the rows with NaN valuesprint(rows_with_nan)संचालित द्वारा

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

हालाँकि, कभी-कभी डिलीट करना सबसे अच्छा विकल्प होता है, उदाहरण के लिए, यदि एंट्री में उसे रखने लायक पर्याप्त अन्य जानकारी नहीं है (जैसे केवल तारीख हो और कोई उपयोगी जानकारी न हो)।

डिलीट करना missing values वाली एंट्रियों से निपटने का सबसे आसान तरीका भी है। तो, यदि आपके पास समय की कमी है और एंट्री का बाकी हिस्सा विश्लेषण के लिए महत्वपूर्ण नहीं है, तो NaNs वाली एंट्रियों को डिलीट करना एक विकल्प है।

आप DataFrame से NaNs वाली पंक्तियाँ हटाने के लिए Pandas की .dropna() मेथड का उपयोग कर सकते हैं।

import pandas as pd # Assuming df is your DataFramedf.dropna(inplace=True)संचालित द्वारा

Missing values को संभालने का सामान्यतः पसंदीदा तरीका है कोई उचित मान इम्प्यूट करना। उचित मान ढूँढना अपने आप में एक कला हो सकता है, लेकिन कई स्थापित तरीके हैं जो एक अच्छा शुरुआती बिंदु देते हैं।

Pandas की .fillna() मेथड mean का उपयोग करते हुए missing values इम्प्यूट कर देती है, ताकि वितरण न बदले।

import pandas as pd # Assuming df is your DataFrame# Replace NaN values with the mean of the columndf.fillna(df.mean(), inplace=True)संचालित द्वारा

scikit-learn लाइब्रेरी में भी एक सरल imputation फंक्शन है जो अच्छी तरह काम करता है।

from sklearn.impute import SimpleImputerimport pandas as pd # Assuming df is your DataFrameimputer = SimpleImputer(strategy='mean')df_imputed = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)संचालित द्वारा

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

Outlier की पहचान और ट्रीटमेंट

Outliers से निपटना थोड़ा पेचीदा है। कुछ दिखने वाले outliers वास्तव में महत्वपूर्ण डेटा होते हैं, जैसे COVID-19 या ग्लोबल मंदी जैसे संकटों पर स्टॉक मार्केट की प्रतिक्रिया। जबकि अन्य टाइपो या अप्रासंगिक, दुर्लभ परिस्थितियाँ हो सकती हैं और हटाए जाने चाहिए।

फर्क जानना अक्सर संदर्भ में अपने डेटा को समझने का मामला होता है, जिसमें आपकी पिछली डेटा एक्सप्लोरेशन मददगार रही होगी, और अपने विश्लेषण के लक्ष्य की स्पष्ट समझ होना भी आवश्यक है।

कई outliers डेटा को प्लॉट करने पर दिख जाते हैं, लेकिन आप सांख्यिकीय तरीकों का उपयोग कर उनकी पहचान भी कर सकते हैं।

एक सामान्य तरीका है प्रत्येक डेटा पॉइंट के लिए Z-score की गणना करना और अत्यधिक Z-score वाले मानों को निकाल देना।

import numpy as npimport pandas as pd # Generate some sample datanp.random.seed(0)data = np.random.randint(low=0, high=11, size=1000)# Add some outliersdata[0] = 100data[1] = -100 # Calculate Z-scoresz_scores = (data - np.mean(data)) / np.std(data) # Identify outliers based on Z-score threshold (e.g., 3)threshold = 3outliers = np.where(np.abs(z_scores) > threshold)[0] print("Outliers identified using Z-score method:")print(data[outliers])संचालित द्वारा

एक और तरीका है वितरण का interquartile range (IQR) निकालना और ऐसे मानों को संभावित outliers मानना जो Q1 − (1.5 × IQR) से नीचे या Q3 + (1.5 × IQR) से ऊपर हों।

import numpy as npimport pandas as pd # Generate some sample datanp.random.seed(0)data = np.random.randint(low=0, high=11, size=1000)# Add some outliersdata[0] = 100data[1] = -100 # Calculate quartiles and IQRq1 = np.percentile(data, 25)q3 = np.percentile(data, 75)iqr = q3 - q1 # Identify outliers based on IQRlower_bound = q1 - (1.5 * iqr)upper_bound = q3 + (1.5 * iqr)outliers = np.where((data < lower_bound) | (data > upper_bound))[0] print("Outliers identified using IQR method:")print(data[outliers])संचालित द्वारा

एक बार outliers की पहचान करके यह तय कर लें कि वे समस्या पैदा कर रहे हैं, तो उनसे निपटने के कई तरीके हैं। यदि आपने तय कर लिया है कि outlier किसी त्रुटि के कारण है, तो त्रुटि को ठीक करके outlier को सुलझाया जा सकता है।

अन्य मामलों में, outlier को डेटासेट से हटाना संभव हो सकता है या उसे किसी कम चरम मान से बदलना, जो वितरण के समग्र आकार को बनाए रखे।

Capping एक तरीका है जिसमें आप अपने डेटा के वितरण पर एक कैप या थ्रेशोल्ड तय करते हैं और उन सीमाओं के बाहर के मानों को किसी निर्धारित मान से बदल देते हैं।

import pandas as pdimport numpy as np # Create a sample DataFrame with outliersdata = {    'A': [100, 90, 85, 88, 110, 115, 120, 130, 140],    'B': [1, 2, 3, 4, 5, 6, 7, 8, 9]}df = pd.DataFrame(data) # Define the lower and upper thresholds for capping (Here I used the 5th and 95th percentiles)lower_threshold = df.quantile(0.05)upper_threshold = df.quantile(0.95) # Cap outlierscapped_df = df.clip(lower=lower_threshold, upper=upper_threshold, axis=1) print("Original DataFrame:")print(df)print("\nCapped DataFrame:")print(capped_df)संचालित द्वारा

कुछ मामलों में, आप अपने डेटा को इस तरह ट्रांसफॉर्म कर सकते हैं कि outliers का प्रभाव कम हो जाए, जैसे square root ट्रांसफॉर्मेशन या logarithmic ट्रांसफॉर्मेशन।

डेटा ट्रांसफॉर्म करते समय सावधानी रखें, क्योंकि यदि आप सावधान नहीं हैं तो लंबी अवधि में और समस्याएँ आ सकती हैं। ट्रांसफॉर्मेशन से पहले कुछ बातों पर विचार करें।

1. आधारभूत डेटा वितरण को समझें: कोई भी ट्रांसफॉर्मेशन लागू करने से पहले, अपने डेटा के वितरण और उस पर ट्रांसफॉर्मेशन के प्रभाव को समझना महत्त्वपूर्ण है।
2. उपयुक्त ट्रांसफॉर्मेशन चुनें: ऐसा ट्रांसफॉर्मेशन चुनें जो आपके डेटा वितरण के लिए उपयुक्त हो।
3. शून्य और नकारात्मक मानों को संभालें: कुछ ट्रांसफॉर्मेशन शून्य या नकारात्मक मान वाले डेटा के लिए उपयुक्त नहीं होते। उदाहरण के लिए, लॉगरिद्म लेते समय एक छोटा स्थिरांक जोड़ना समस्याओं से बचा सकता है।
4. ट्रांसफॉर्म हुए डेटा को वैलिडेट करें: ट्रांसफॉर्मेशन के बाद, यह जाँचें कि परिणामी वितरण आपके विश्लेषण की मान्यताओं को पूरा करता है।
5. व्याख्यायोग्यता पर विचार करें: ट्रांसफॉर्म हुआ डेटा मूल डेटा जितना आसानी से समझ में नहीं आ सकता। यह सुनिश्चित करें कि स्टेकहोल्डर्स को व्याख्या पर ट्रांसफॉर्मेशन के प्रभाव समझ में आएँ।

डेटा ट्रांसफॉर्मेशन के बारे में अधिक सीखने के लिए DataCamp के Introduction to Statistics in Python या Statistics Fundamentals with Python जैसे कोर्स लेने की सलाह देता हूँ।

डुप्लिकेट्स से निपटना

हमने देखा है कि डुप्लिकेट्स हमारे विश्लेषण को कैसे बिगाड़ सकते हैं। सौभाग्य से, Python में डुप्लिकेट्स की पहचान और हैंडलिंग सरल है।

Python की pandas लाइब्रेरी में duplicated() मेथड का उपयोग करके, आप DataFrame में डुप्लिकेट पंक्तियों को आसानी से पहचान कर जाँच सकते हैं।

import pandas as pd# Assuming 'df' is your DataFrameduplicate_rows = df[df.duplicated()]संचालित द्वारा

यह उन पंक्तियों वाला DataFrame लौटाता है जो डुप्लिकेट हैं। जब आपके पास डुप्लिकेट पंक्तियों का यह DataFrame हो, और यदि वे बहुत अधिक न हों, तो मैं आपको उन्हें देखने के लिए प्रोत्साहित करूँगा।

अधिकांश डुप्लिकेट्स सटीक कॉपी हो सकते हैं और Pandas की drop_duplicates() मेथड से सरलता से हटाए जा सकते हैं:

# Removing duplicatescleaned_df = df.drop_duplicates()संचालित द्वारा

कुछ मामलों में, डुप्लिकेट रिकॉर्ड्स को एकीकृत करना अधिक उपयुक्त हो सकता है, यानी जानकारी को एग्रीगेट करना। उदाहरण के लिए, यदि डुप्लिकेट्स एक ही इकाई के लिए कई एंट्रियों का प्रतिनिधित्व करते हैं, तो हम उन्हें एग्रीगेशन फंक्शन्स का उपयोग करके मर्ज कर सकते हैं:

# Merging duplicates by aggregating valuesmerged_df = df.groupby(list_of_columns).agg({'column_to_merge': 'sum'})संचालित द्वारा

यह डुप्लिकेट पंक्तियों को एक में मिला देगा, और निर्धारित फंक्शन्स जैसे sum, mean, आदि के आधार पर मानों को एग्रीगेट करेगा।

import pandas as pd#Sample DataFramedata = {     'customer_id' : [102, 102, 101, 103, 102]     'product_id' : ['A', 'B', 'A', 'C', 'B']     'quantity_sold : [5, 3, 2, 1, 4]}df = pd.DataFrame(data)df}संचालित द्वारा

# Merging duplicates by aggregating valuesmerged_df = df.groupby(['cutomer_id', 'product_id']).agg({'quantity_sold': 'sum'}).reset_index()merged_dfसंचालित द्वारा

असंगतियों का समाधान

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

डेटा के फॉर्मेट में असंगतियों को कुछ मानकीकरण विधियों से सुधारा जा सकता है। स्ट्रिंग से अग्र/पश्च स्पेस हटाने के लिए .strip() मेथड का उपयोग करें। .upper() और .lower() स्ट्रिंग्स में केस को मानकीकृत करते हैं। और तारीखों को pd.to_datetime से datetimes में बदलने पर डेट फॉर्मैटिंग मानकीकृत हो जाती है।

आप .astype() मेथड का उपयोग कर यह भी सुनिश्चित कर सकते हैं कि किसी DataFrame के कॉलम में हर मान एक ही डेटा टाइप का हो।

अन्य फॉर्मेटिंग असंगतियाँ जिन्हें आपको ठीक करना पड़ सकता है, उनमें शामिल हैं:

• यूनिट कन्वर्ज़न
• ईमेल, फोन, और पता मानकीकरण
• स्ट्रिंग्स से विराम चिह्न हटाना
• सामान्य संक्षेपों को संभालने के लिए वैल्यू मैपिंग का उपयोग

value_mapping = {'M': 'Male', 'F': 'Female'}standardized_value = value_mapping.get('M', 'Unknown')संचालित द्वारा

डेटा ट्रांसफॉर्मेशन और फीचर इंजीनियरिंग

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

Normalization और standardization

Normalization और standardization दो तकनीकें हैं जिनका उपयोग फीचर्स को समान स्केल पर लाने के लिए किया जाता है, जो कई मशीन लर्निंग एल्गोरिद्म के लिए महत्वपूर्ण है।

Normalization डेटा को आम तौर पर 0 और 1 के बीच स्थिर रेंज में स्केल करती है। इससे सभी फीचर्स समान स्केल पर आ जाते हैं और बड़े परिमाण वाले फीचर्स अन्य पर हावी नहीं होते।

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(data)संचालित द्वारा

Standardization दूसरी ओर, डेटा को 0 mean और 1 standard deviation में ट्रांसफॉर्म करती है। यह तकनीक तब उपयोगी होती है जब डेटा के स्केल और रेंज अलग-अलग हों, और यह सुनिश्चित करती है कि प्रत्येक फीचर का मॉडल पर तुलनीय प्रभाव हो।

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
standardized_data = scaler.fit_transform(data)संचालित द्वारा

आपके डेटा की विशेषताएँ और लक्षित मॉडल की आवश्यकताएँ तय करेंगी कि डेटा को कैसे स्केल करना है। Normalization और standardization के अंतर पर हमारी समर्पित ट्यूटोरियल Normalization vs. Standardization: अंतर कैसे जानें देखें।

Categorical वेरिएबल्स को एन्कोड करना

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

एक सामान्य तकनीक one-hot encoding है, जो प्रत्येक श्रेणी को बाइनरी वेक्टर में बदलती है। यह विधि nominal categorical वेरिएबल्स के लिए विशेष रूप से उपयोगी है, जहाँ श्रेणियों में कोई आंतरिक क्रम या पदानुक्रम नहीं होता।

import pandas as pd

encoded_data = pd.get_dummies(data, columns=['categorical_column'])
संचालित द्वारा

import pandas as pd

# Create a sample DataFrame with a categorical column
data = {
    'ID': [1, 2, 3, 4, 5],
    'Color': ['Red', 'Blue', 'Green', 'Red', 'Blue']
}
df = pd.DataFrame(data)

# Perform one-hot encoding
encoded_data = pd.get_dummies(df, columns=['Color'])

print("Original DataFrame")
print(df)

print("\nEncoded DataFrame:")
print(encoded_data)
संचालित द्वारा

दूसरा तरीका label encoding है, जो प्रत्येक श्रेणी को एक अद्वितीय पूर्णांक आवंटित करता है। प्रत्येक श्रेणी को संख्यात्मक मान से मैप किया जाता है, जिससे categorical लेबल्स ordinal संख्याओं में बदल जाते हैं। यह तरीका ordinal categorical वेरिएबल्स के लिए उपयुक्त है, जहाँ प्राकृतिक क्रम या रैंकिंग होती है।

from sklearn.preprocessing import LabelEncoderencoder = LabelEncoder()encoded_data['categorical_column'] = encoder.fit_transform(data['categorical_column'])संचालित द्वारा

from sklearn.preprocessing import LabelEncoderimport pandas as pd#Create a sample DataFrame with categorical column data = {    'ID' : [1, 2, 3, 4, 5]    'Color' : [ 'Red', 'Blue', 'Green', 'Red', 'Green' ]}df = pd.DataFrame(data)#Perform label encodingencoder  = LabelEncoder()df ['Color_LabelEncoded'] = encoder.fit_transform(df['Color'])print("Original DataFrame:")print(df[['ID', 'Color']])print("\nDataFrame with Label Encoded Column:")print(df[['ID', 'Color_LabelEncoded']])संचालित द्वारा

उचित एन्कोडिंग विधि चुनना categorical वेरिएबल की प्रकृति और मशीन लर्निंग एल्गोरिद्म की आवश्यकताओं पर निर्भर करता है। Nominal वेरिएबल्स के लिए आम तौर पर one-hot encoding बेहतर है, जबकि ordinal वेरिएबल्स के लिए label encoding उपयुक्त है।

फीचर इंजीनियरिंग तकनीकें

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

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

इस स्थिति में, आप मौजूदा फीचर्स को मिलाकर या प्रासंगिक जानकारी निकालकर नया फीचर बना सकते हैं।

उदाहरण के लिए, आप "Overall Condition" नाम का फीचर बना सकते हैं, जो घर के व्यक्तिगत घटकों की स्थिति रेटिंग्स—जैसे किचन की स्थिति, बेसमेंट की गुणवत्ता, प्रॉपर्टी की उम्र, हाल के नवीनीकरण आदि—को समेकित करे।

जहाँ फीचर्स और टार्गेट वेरिएबल के बीच संबंध nonlinear हो, वहाँ मौजूदा फीचर्स की घातें लेकर polynomial फीचर्स जेनरेट किए जा सकते हैं। यह तरीका वेरिएबल्स के बीच जटिल संबंधों को कैप्चर करने में मदद करता है जो लाइनarly separable नहीं होते।

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(degree=2)
polynomial_features = poly.fit_transform(data)
संचालित द्वारा

अन्य मामलों में, आपके पास उच्च-आयामी डेटासेट हो सकते हैं या फीचर्स के बीच multicollinearity हो सकती है। ऐसी स्थिति में Principal Component Analysis (PCA) जैसी तकनीकों का उपयोग डेटासेट की आयामिकता घटाने के लिए किया जा सकता है, जबकि प्रासंगिक जानकारी का अधिकांश हिस्सा बरकरार रहता है।

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
transformed_features = pca.fit_transform(data)संचालित द्वारा

फीचर इंजीनियरिंग सुनिश्चित करती है कि आपके मॉडल के उपयोग के लिए आपके पास सही फॉर्मेट में सही डेटा हो। फीचर इंजीनियरिंग में कई तकनीकें हैं, और आप कौन-सी चुनते हैं यह काफी हद तक आपके उद्देश्य पर निर्भर करेगा।

और तकनीकों के लिए यह feature engineering कोर्स देखें।

Python में डेटा क्लीनिंग: श्रेष्ठ अभ्यास और सुझाव

डेटा क्लीनिंग किसी भी डेटा विश्लेषण या मशीन लर्निंग प्रोजेक्ट का अहम चरण है। अपनी डेटा क्लीनिंग प्रक्रिया को सुव्यवस्थित करते समय ये श्रेष्ठ अभ्यास ध्यान में रखें:

कच्चा डेटा अलग रखें

हमेशा मूल प्रति सुरक्षित रखें!

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

व्यक्तिगत रूप से, मैं कोई भी बदलाव करने से पहले हमेशा कच्ची डेटा फ़ाइल की एक कॉपी बनाता/बनाती हूँ और फ़ाइल नाम में “-RAW” प्रत्यय जोड़ देता/देती हूँ ताकि स्पष्ट रहे कि वही मूल है।

अपना डेटा-क्लीनिंग कोड डॉक्यूमेंट करें

अपने कोड में टिप्पणियाँ जोड़ें जो हर क्लीनिंग स्टेप के उद्देश्य और की गई मान्यताओं को समझाएँ।

अनपेक्षित परिणामों पर नज़र रखें

सुनिश्चित करें कि आपकी डेटा क्लीनिंग से वितरण में भारी बदलाव या अनचाहा bias न आ रहा हो। क्लीनिंग के बाद बार-बार डेटा एक्सप्लोरेशन यह सुनिश्चित करने में मदद कर सकता है कि आप सही दिशा में हैं।

डेटा क्लीनिंग लॉग रखें

यदि आपकी क्लीनिंग प्रक्रिया लंबी है या स्वचालित है, तो एक अलग दस्तावेज़ रखें जिसमें हर क्लीनिंग स्टेप का विवरण दर्ज हो।

तारीख, की गई विशिष्ट कार्रवाई, और सामने आई समस्याओं जैसे विवरण आगे काम आ सकते हैं।

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

पुन: प्रयोज्य फ़ंक्शन्स लिखें

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

कुछ भी छूट न जाए, इसके लिए DataCamp की Data Cleaning Checklist का उपयोग करें!

निष्कर्ष

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

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

और जानकारी व इंटरएक्टिव अभ्यासों के लिए DataCamp का डेटा क्लीनिंग कोर्स देखें। व्यावहारिक अभ्यास के लिए यह डेटा क्लीनिंग कोड-अलॉन्ग आज़माएँ।