डेटा का यादृच्छिक वितरण

Question

मैं डेटा की एक बड़ी मात्रा में एक यादृच्छिक क्रम में डेटा की एक छोटी राशि कैसे वितरित करूं?

उदाहरण के लिए, मेरे पास 'वास्तविक' डेटा की कई हजार लाइनें हैं, और मैं 'वास्तविक' डेटा में एक यादृच्छिक क्रम में नियंत्रण डेटा के दर्जन या दो पंक्तियां डालना चाहता हूं।

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

यदि मैं केवल यादृच्छिक संख्याएं उत्पन्न करने पर भरोसा करता हूं तो एक संभावना है (हालांकि बहुत छोटा है) कि मेरा सभी नियंत्रण डेटा, या कम से कम क्लंप, 'असली' डेटा के काफी संकीर्ण चयन के भीतर डाला जाएगा। ऐसा होने से रोकने का सबसे अच्छा तरीका क्या है?

इसे एक और तरीके से वाक्यांश करने के लिए, मैं अपने वास्तविक डेटा में नियंत्रण डेटा डालना चाहता हूं, बिना किसी तीसरे पक्ष के गणना के लिए कि कौन सी पंक्तियां नियंत्रित हैं और वास्तविक हैं।

---

अद्यतन: मैंने इसे 'समुदाय विकी' बना दिया है, इसलिए यदि कोई मेरा प्रश्न संपादित करना चाहता है तो यह अधिक समझ में आता है और फिर आगे बढ़ता है।

---

अद्यतन: मुझे एक उदाहरण आज़माएं (मैं इस भाषा या मंच को निर्भर नहीं करना चाहता क्योंकि यह कोडिंग प्रश्न नहीं है, यह एक सांख्यिकीय प्रश्न है)।

• मेरे पास 'वास्तविक' डेटा की 3000 पंक्तियां हैं (यह राशि उपयोगकर्ता के डेटा की मात्रा के आधार पर रन से चलने के लिए बदल जाएगी)।
• मेरे पास 'नियंत्रण' डेटा की 20 पंक्तियां हैं (फिर से, यह उपयोगकर्ता की नियंत्रण पंक्तियों की संख्या के आधार पर बदल जाएगी, शून्य से ऊपर कुछ भी)।

अब मैं इन 20 'नियंत्रण' पंक्तियों को लगभग 15012 या 'असली' डेटा डालने के बाद लगभग डालना चाहता हूं (3000/20 = 150)। हालांकि मैं यह उतना सटीक नहीं होना चाहता जितना कि मैं नहीं चाहता कि नियंत्रण पंक्तियों को आउटपुट डेटा में उनके स्थान के आधार पर पहचानने योग्य हो।

इसलिए मुझे कोई आपत्ति नहीं है 'नियंत्रण' पंक्तियों के कुछ साथ clumped जा रहा है या वहाँ के लिए बहुत कुछ या सभी में कोई 'नियंत्रण' पंक्तियों के साथ कुछ वर्गों हो सकता है, लेकिन आम तौर पर मैं 'नियंत्रण' चाहते हैं पंक्तियों में समान रूप से वितरित पंक्तियों को समान रूप से वितरित किया जाता है।

Answer 1

वहाँ हमेशा एक संभावना है कि वे एक दूसरे के करीब यदि आप ऐसा मिलता है यह वास्तव में यादृच्छिक :)

लेकिन मुझे क्या होता है:

1. आप वास्तविक डेटा और की x की N पंक्तियों नियंत्रण डेटा
2. एक पंक्ति के एक सूचकांक आप i वें नियंत्रण पंक्ति सम्मिलित करना चाहिए पाने के लिए, मैं का उपयोग करेंगे: N/(x+1) * i + r, जहां r कुछ यादृच्छिक संख्या, ईए के लिए अलग है नियंत्रण पंक्तियों का ch, N/x की तुलना में छोटा। r निर्धारित करने का कोई भी तरीका चुनें, यह या तो गाऊशियन या यहां तक ​​कि फ्लैट वितरण हो सकता है।i नियंत्रण पंक्ति का एक सूचकांक है, इसलिए यह 1<=i<x
3. इस तरह से आप सुनिश्चित कर सकते हैं कि आप एक ही स्थान पर अपनी नियंत्रण पंक्तियों के संघनन से बचें। साथ ही आप यह सुनिश्चित कर सकते हैं कि वे एक दूसरे से नियमित दूरी पर नहीं होंगे।

Answer 2

मेरा विचार यहां है। आप मौजूदा पंक्तियों के माध्यम से केवल लूप क्यों नहीं करते हैं और यह तय करने के लिए कि आप यादृच्छिक डेटा डालेंगे, प्रत्येक पंक्ति के लिए "सिक्का फ़्लिप करें"।

for (int i=0; i<numberOfExistingRows; i++) 
{  
    int r = random(); 
    if (r > 0.5) 
    { 
     InsertRandomData(); 
    }  
} 

यह आपको पूरे डेटा में एक अच्छा यादृच्छिक वितरण देना चाहिए।

Answer 3

3000 वास्तविक डेटा पंक्तियों और निम्न उदाहरण के लिए 20 नियंत्रण पंक्तियों के साथ जा रहे हैं (मैं अंग्रेज़ी के साथ की तुलना में उदाहरण के साथ बेहतर कर रहा हूँ)

आप 3000 के बीच संभव के रूप में समान रूप से 20 नियंत्रण पंक्तियों प्रसार करने के लिए थे, तो असली डेटा पंक्तियां आप प्रत्येक 150 वें वास्तविक डेटा पंक्ति में एक डालेंगे। तो अगली प्रविष्टि अनुक्रमणिका के लिए उस नंबर को 150, चुनें।
ए) 0 और 150 के बीच एक यादृच्छिक संख्या उत्पन्न करें और इसे प्रविष्टि अनुक्रमणिका
से घटाएं b) वहां नियंत्रण पंक्ति डालें।
ग) द्वारा 150
घ) कदम एक पर दोहराएँ)

बेशक

यह एक बहुत ही कच्चे तेल एल्गोरिथ्म है और यह कुछ सुधार :)

Answer 4

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

तो एक यादृच्छिक अंतराल चुनें, वास्तविक डेटा की कई पंक्तियों को कॉपी करें, नियंत्रण डेटा डालें, समाप्त होने तक दोहराएं। उस यादृच्छिक अंतराल को कैसे चुनें?

मैं नियंत्रण डेटा आकार से विभाजित वास्तविक डेटा आकार के साथ सेट सेट के साथ एक गाऊशियन विचलित का उपयोग करने की अनुशंसा करता हूं, जिसमें से पहले मापा जा सकता है या अनुमानित माना जाता है। इस गाऊशियन के मानक विचलन को निर्धारित करें कि आप कितना "फैलाना" सहन करना चाहते हैं। छोटे stddev का मतलब है कि अधिक लेप्टोकर्टिक वितरण का अर्थ वर्दी दूरी के कड़े अनुपालन का है। बड़े stdev का अर्थ है एक और प्लैटिकर्टिक वितरण और वर्दी दूरी के लिए कमजोर अनुपालन।

अब फ़ाइल के पहले और अंतिम खंडों के बारे में क्या? यही है: बहुत शुरुआत या बहुत अंत में नियंत्रण डेटा सम्मिलित करने के बारे में क्या? एक चीज जो आप कर सकते हैं, इनके लिए विशेष मामले के अनुमानों के साथ आना है ... लेकिन एक अच्छी चाल इस प्रकार है: वास्तविक डेटा में अपना "इंडेक्स" शुरू करें, गॉसियन के आधे से कम मतलब और अपना पहला विचलन उत्पन्न करें। वास्तविक डेटा में "इंडेक्स" वैध होने तक किसी वास्तविक डेटा को आउटपुट न करें। डेटा के अंत में एक सममित चाल भी काफी अच्छी तरह से काम करनी चाहिए (बस: जब तक आप वास्तविक डेटा के अंत से कम से कम आधे गॉसियन का मतलब नहीं है, तब तक "इंडेक्स" तक पहुंचने तक विचलन उत्पन्न करते रहें। अगर इससे पहले इंडेक्स बंद था अंत में, अंत में डेटा उत्पन्न करें।

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

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