🤳🏻 👨🏼‍🏭 🥔 लगभग कोई फ़ार्मुलों के साथ बूटस्ट्रैप, या लागू आँकड़े 🧓 🏇🏿 🕥

संस्थानों में, छात्रों को विश्लेषणात्मक रूप से एकीकृत करने के लिए सिखाया जाता है, और फिर यह पता चलता है कि व्यवहार में, लगभग सभी अभिन्न को संख्यात्मक तरीके से मानते हैं। खैर, या कम से कम इस तरह से विश्लेषणात्मक समाधान की जांच करें।

आंकड़ों में, एक बेईमान विधि भी है जो आपको विश्लेषण के बिना कई व्यावहारिक सवालों के लगभग जवाब देने की अनुमति देती है, साथ में जानवर बल कंप्यूटिंग: बूटस्ट्रैप (अंग्रेजी बूटस्ट्रैप )। १ ९ E ९ में ब्रैडले एफ्रॉन द्वारा आविष्कार और प्रकाशित।

मान लीजिए कि हमारे पास एक ऑनलाइन स्टोर है जहां हम सभी प्रकार की चीजों का व्यापार करते हैं और ग्राहकों को कई तरह से आकर्षित करते हैं। यह स्पष्ट है कि हम लगातार कुछ परीक्षण कर रहे हैं - पृष्ठ पर चित्र और बटन का स्थान, विज्ञापन पाठ, ऐडवर्ड्स, भागीदार साइटों पर बैनर और इसी तरह। और यहां नवीनतम परिणाम हैं - 893 लोगों के परीक्षण समूह में जो हमारे पास आए, उन्होंने कुछ 34 खरीदे, और 923 लोगों के नियंत्रण समूह में जो पहुंचे, उन्होंने कुछ 28 खरीदा।

सवाल उठता है - मालिकों के पास जाओ और कहो कि "परीक्षण समूह में रूपांतरण 3.81% है, नियंत्रण समूह में 3.03% है, क्या 26% सुधार है, मेरा बोनस कहां है?" या डेटा एकत्र करना जारी रखें, क्योंकि 6 लोगों का अंतर अभी तक आँकड़े नहीं है?

यह समस्या विश्लेषणात्मक रूप से हल करना मुश्किल नहीं है। हम दो यादृच्छिक चर (परीक्षण और नियंत्रण समूहों में रूपांतरण प्रतिशत) देखते हैं। बड़ी संख्या में टिप्पणियों के साथ, द्विपद वितरण सामान्य के समान है। हम अंतर में रुचि रखते हैं। सामान्य वितरण असीम रूप से विभाज्य है, माध्य को घटाएं और विचरण जोड़ें, हमें माध्य 34 / 893-28 / 923 = 0.77% और विचरण (34/893) * (1-34 / 893) / 893 + (28/923) * (1-1) मिलता है। 28/923) / 923। मानक विचलन विचलन की जड़ के बराबर है, हमारे मामले में 0.85% है। 95% संभावना के साथ सही मूल्य प्लस या शून्य से दो मानक विचलन अपेक्षा के भीतर निहित है, अर्थात् -0.93% और 2.48% के बीच।

इसलिए पुरस्कार अभी तक चमक नहीं रहा है, हमें डेटा एकत्र करना जारी रखना चाहिए।

अब हम बूटस्ट्रैप द्वारा उसी समस्या को हल करेंगे। मूल विचार यह है: हमारे प्रयोग को कई बार दोहराना और परिणामों के वितरण को देखना अच्छा होगा। लेकिन हम ऐसा नहीं कर सकते, इसलिए हम गलत काम करेंगे - हम उपलब्ध आंकड़ों से नमूने खींचते हैं और दिखावा करते हैं कि उनमें से प्रत्येक हमारे प्रयोग को दोहराने का परिणाम है।

एल्गोरिथ्म:

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

अब हमारे पास एक वितरण है जिसे हम देख सकते हैं या उससे कुछ की गणना कर सकते हैं। उदाहरण के लिए, आत्मविश्वास अंतराल, मंझला या मानक विचलन।

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

सच है, चमत्कार नहीं होते। यदि वितरण की कोई अपेक्षा नहीं है (जैसे होते हैं), तो बूटस्ट्रैप इसे नहीं ढूंढेगा। ठीक है, वह यह है कि वह नमूने की उम्मीद करेगा, लेकिन सामान्य आबादी नहीं। यह तब लागू होता है जब नमूना अप्रमाणिक होता है या बस छोटा होता है।

बूटस्ट्रैप को लागू करना आसान है। नीचे दिए गए उदाहरण में C लिखा है (यह सरल नहीं हो सकता है) और, I / O के अलावा, यह केवल दो पुस्तकालय कार्यों का उपयोग करता है: एक छद्म यादृच्छिक संख्या जनरेटर और छंटाई। चलो इसे अलग ले जाओ।

प्रस्तावना में विशेष टिप्पणियों की आवश्यकता नहीं होती है। सी में कोई bool नहीं है, हम डेटा को int में स्टोर करेंगे।

 #include <stdio.h> #include <stdlib.h> typedef int Data_t; #define ARRAY_SIZE(x) sizeof(x)/sizeof(x[0])

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

 static double bootstrap(const Data_t* data, unsigned n) { unsigned i; double sum = 0; for (i = 0; i < n; i++) { sum += data[rand() % n]; } return sum / n; }

परिणामों को सॉर्ट करने के लिए फ़ंक्शन की तुलना करें

 static int compare(const void* a, const void* b) { if (*(double*)a > *(double*)b) return 1; if (*(double*)a < *(double*)b) return -1; return 0; }

स्रोत डेटा

 int main(int argc, char* argv[]) { Data_t test[893] = { 0 }; Data_t control[923] = { 0 }; unsigned i; for (i = 0; i < 34; i++) { test[i] = 1; } for (i = 0; i < 28; i++) { control[i] = 1; }

हम कमांड लाइन से एक पैरामीटर के साथ छद्म यादृच्छिक संख्या जनरेटर को इनिशियलाइज़ करते हैं। अगर हम
सबकुछ ठीक किया, फिर इसे बदलते समय नतीजे ज्यादा नहीं तैरने चाहिए
पैरामीटर।

  if (argc == 2) { srand(atoi(argv[1])); }

यहां हम परिणाम जोड़ेंगे

  double t_minus_c[10000];

मुख्य चक्र

  for (i = 0; i < ARRAY_SIZE(t_minus_c); i++) { t_minus_c[i] = bootstrap(test, ARRAY_SIZE(test)) - bootstrap(control, ARRAY_SIZE(control)); }

हम 95% आत्मविश्वास अंतराल का निर्धारण करते हैं: हम परिणामों को क्रमबद्ध करते हैं, नीचे से 2.5% छोड़ते हैं और ऊपर से समान राशि, परिणाम दिखाते हैं।

  qsort(t_minus_c, ARRAY_SIZE(t_minus_c), sizeof(double), compare); printf("LCL=%g%%\n", 100. * t_minus_c[250]); printf("UCL=%g%%\n", 100. * t_minus_c[9750]); return 0; }

हम जाँच करते हैं:

  $ gcc -wall -o बूटस्ट्रैप bootstrap.c
 $ ./bootstrap
 LCL = -0.891368%
 UCL = 2.43898%

अन्य छद्म यादृच्छिक संख्याओं के साथ एक जोड़ी अधिक बार:

  $ ./bststrap 42
 LCL = -0.86589%
 UCL = 2.43898%
 $ ./bootstrap 2013
 LCL = -0.959673%
 UCL = 2.52184%

यह एक सैद्धांतिक परिणाम (-0.93% से 2.48% तक) की तरह दिखता है।

और शहर की बाड़ क्यों थी?

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

प्राथमिक स्रोत

एफ्रोन बी (1979)। बूटस्ट्रैप विधियाँ: कटहल पर एक और नज़र। एन। सांख्यिकीविद। १-२६
डोनाल्ड ई। नुथ। सेमीन्यूमेरिकल अल्गोरिद्म, द आर्ट ऑफ़ कंप्यूटर प्रोग्रामिंग का वॉल्यूम 2, अध्याय 4.2.2, पृष्ठ 232। एडिसन-वेस्ले, बोस्टन, तीसरा संस्करण, 1998।

लगभग कोई फ़ार्मुलों के साथ बूटस्ट्रैप, या लागू आँकड़े

एल्गोरिथ्म:

और शहर की बाड़ क्यों थी?

प्राथमिक स्रोत

More articles: