डेटा के साथ काम करें - डेटा प्रोसेसिंग एल्गोरिदम के साथ काम करें।

और मुझे दैनिक आधार पर सबसे विविध के साथ काम करना था, इसलिए मैंने प्रकाशनों की एक श्रृंखला में सबसे लोकप्रिय की एक सूची बनाने का फैसला किया।

यह लेख डेटा के साथ काम करने के लिए सबसे आम नमूना तकनीकों पर केंद्रित है।

सरल यादृच्छिक नमूना

मान लीजिए कि यदि आप एक चयन करना चाहते हैं, जहां प्रत्येक तत्व को चयनित होने की समान संभावना है।

नीचे हम डेटासेट से ऐसे 100 तत्वों का चयन करते हैं।

sample_df = df.sample(100) 

स्तरीकृत नमूनाकरण

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

1 मिलियन कार्यकर्ता शहर ए में रहते हैं

2 मिलियन कलाकार बी शहर में रहते हैं

3 लाख वरिष्ठ नागरिक शहर C में रहते हैं

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

यदि हम विशेष रूप से क्रमशः ए , बी और सी शहरों से 10, 20 और 30 लोगों का एक नमूना बनाते हैं, तो त्रुटि न्यूनतम होगी।

पायथन में, इसे इस तरह किया जा सकता है:

 from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.25) 

जलाशय का नमूना

मुझे समस्या का यह सूत्रीकरण पसंद है:

मान लीजिए कि आपके पास एक बड़े अज्ञात आकार के तत्वों की एक धारा है जिसे आप केवल एक बार पुनरावृत्त कर सकते हैं।

एक एल्गोरिथ्म बनाएं जो धारा से एक तत्व को बेतरतीब ढंग से चुनता है जैसे कि किसी भी तत्व को समान संभावना के साथ चुना जा सकता है।

यह कैसे करना है?

मान लें कि हमें एक अनंत धारा से 5 वस्तुओं का चयन करने की आवश्यकता है, ताकि धारा में प्रत्येक तत्व को समान रूप से चुना जा सके।

 import random def generator(max): number = 1 while number < max: number += 1 yield number #    stream = generator(10000) #    k=5 reservoir = [] for i, element in enumerate(stream): if i+1<= k: reservoir.append(element) else: probability = k/(i+1) if random.random() < probability: #    ,    reservoir[random.choice(range(0,k))] = element print(reservoir) ------------------------------------ [1369, 4108, 9986, 828, 5589] 

गणितीय रूप से यह साबित करना संभव है कि प्रत्येक तत्व को समान रूप से चुना जा सकता है।

कैसे?

जब गणित की बात आती है, तो एक छोटे से विशेष मामले के साथ समाधान शुरू करने की कोशिश करना सबसे अच्छा है।

तो आइए 3 तत्वों से मिलकर एक धारा देखें, जहां हमें केवल 2 का चयन करने की आवश्यकता है।

हम पहला तत्व देखते हैं, इसे सूची में सहेजते हैं, क्योंकि टैंक में अभी भी जगह है। हम दूसरे तत्व को देखते हैं, इसे सूची में सहेजें, क्योंकि टैंक में अभी भी जगह है।

हम तीसरा तत्व देखते हैं। यह और अधिक दिलचस्प हो जाता है। हम 2/3 प्रायिकता के साथ तीसरे तत्व को बचाएंगे।

आइए अब देखें कि पहले तत्व की अंतिम संभावना को बचाया जा रहा है:

जलाशय से पहले तत्व के विस्थापन की संभावना तीसरे तत्व के चयनित होने की संभावना के बराबर है, इस संभावना से गुणा कि दो के पहले तत्व को विस्थापन के लिए चुना जाएगा। वह है:

2/3 * 1/2 = 1/3

अर्थात्, सहेजे जाने वाले पहले तत्व की अंतिम संभावना:

1 - 1/3 = 2/3

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

यही है, प्रत्येक तत्व को 2/3 की संभावना या सामान्य मामले में k / n के साथ बचाया जाएगा।

रैंडम अंडरसम्पलिंग और ओवरसमलिंग

जीवन में अक्सर असंतुलित डेटा सेट होते हैं।

इस मामले में व्यापक रूप से उपयोग की जाने वाली विधि को रसमलिंग कहा जाता है (कभी-कभी वे रूसी अनुवाद में "रेज़ामापलिंग" कहते हैं । इसका सार या तो बहुत बड़े सेट (अंडरस्लेमप्लिंग) से तत्वों को हटाने और / या अपर्याप्त रूप से बड़े सेट (ओवरसम्पलिंग) में अधिक तत्वों को जोड़ने में निहित है।

चलो कुछ असंतुलित सेट बनाकर शुरू करते हैं।

 from sklearn.datasets import make_classification X, y = make_classification( n_classes=2, class_sep=1.5, weights=[0.9, 0.1], n_informative=3, n_redundant=1, flip_y=0, n_features=20, n_clusters_per_class=1, n_samples=100, random_state=10 ) X = pd.DataFrame(X) X['target'] = y 

अब हम इस तरह यादृच्छिक अंडरसम्पलिंग और ओवरसम्पलिंग कर सकते हैं:

 num_0 = len(X[X['target']==0]) num_1 = len(X[X['target']==1]) print(num_0,num_1) #   undersampled_data = pd.concat([ X[X['target']==0].sample(num_1) , X[X['target']==1] ]) print(len(undersampled_data)) #   oversampled_data = pd.concat([ X[X['target']==0] , X[X['target']==1].sample(num_0, replace=True) ]) print(len(oversampled_data)) ------------------------------------------------------------ OUTPUT: 90 10 20 180 

असंतुलित-सीखने का उपयोग करके एंडरसमापलिंग और ओवरसैंपलिंग

असंतुलित-सीखना (imblearn) असंतुलित डेटासेट की समस्याओं से निपटने के लिए एक अजगर पुस्तकालय है।

इसमें पुनरुत्पादन के लिए कई अलग-अलग तरीके हैं।

एक। Tomek लिंक का उपयोग कर एंडर्समपलिंग:

प्रदान की गई विधियों में से एक को टोमेक लिंक कहा जाता है। इस मामले में "लिंक" विभिन्न वर्गों के तत्वों के जोड़े हैं जो पास हैं।

एल्गोरिथ्म का उपयोग करते हुए, हम अंततः युग्म तत्व को बड़े सेट से हटा देंगे, जो क्लासिफायर को बेहतर तरीके से काम करने की अनुमति देगा।

 from imblearn.under_sampling import TomekLinks tl = TomekLinks(return_indices=True, ratio='majority') X_tl, y_tl, id_tl = tl.fit_sample(X, y) 

ख। SMOTE के साथ Oversampling:

SMOTE (सिंथेसिस माइनॉरिटी ओवरामॉपलिंग मेथड) में, हम एक छोटे से सेट में मौजूदा लोगों के साथ निकटता में तत्व बनाते हैं।

 from imblearn.over_sampling import SMOTE smote = SMOTE(ratio='minority') X_sm, y_sm = smote.fit_sample(X, y) 

लेकिन इम्बेलर में अंडरस्मैपलिंग (क्लस्टर सेंट्रोइड्स, नियरिमिस, आदि) के अन्य तरीके और ओवरसैमलिंग (ADASYN और bSMOTE) हैं, जो उपयोगी भी हो सकते हैं।

निष्कर्ष

एल्गोरिदम डेटा साइंस का खून है।

नमूनाकरण डेटा के साथ काम करने में सबसे महत्वपूर्ण क्षेत्रों में से एक है, और केवल एक सतही अवलोकन ऊपर दिया गया है।

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