कुशलता से अंतराल में समान रूप से वितरित मान कैसे उत्पन्न करें?

Question

मान लीजिए कि मैं अंतराल से यादृच्छिक संख्याओं का एक सेट उत्पन्न करना चाहता हूं (a, b)। उत्पन्न अनुक्रम में यह गुण भी होना चाहिए कि यह क्रमबद्ध है। मैं इसे हासिल करने के दो तरीके सोच सकता हूं।

आज्ञा देना nलंबाई की अनुक्रम उत्पन्न किया जाना है।

पहला एल्गोरिथम:

Let `offset = floor((b - a) / n)`
for i = 1 up to n:
   generate a random number r_i from (a, a+offset)
   a = a + offset
   add r_i to the sequence r

दूसरा एल्गोरिथम:

for i = 1 up to n:
    generate a random number s_i from (a, b)
    add s_i to the sequence s
sort(r)

मेरा सवाल है, क्या एल्गोरिथ्म 1 ऐसे अनुक्रमों का उत्पादन करता है जो एल्गोरिथम 2 द्वारा उत्पन्न लोगों के समान ही अच्छा है?

Comments

BTW यह क्रमबद्ध यादृच्छिक संख्या की एक सूची उत्पन्न करने के लिए उल्लेखनीय रूप से आसान है R। एक समान अंतराल पर यादृच्छिक संख्याओं के सेट की एक सरणी उत्पन्न करने के लिए , निम्नलिखित कोड काम करता है :। एन [ ए , बी $k$$n$$[a, b]$rand_array <- replicate(k, sort(runif(n, a, b))

— रॉबर्ट एफए

Answer 1

पहला एल्गोरिथ्म दो कारणों से बुरी तरह विफल रहता है:

1. का तल लेना इसे बहुत कम कर सकता है। वास्तव में, जब , यह शून्य होगा, जो आपको एक सेट देता है जिसके मूल्य सभी समान हैं!b - a < $(a-b)/n$$b-a \lt n$

2. जब आप मंजिल नहीं लेते हैं, तो परिणामी मान समान रूप से वितरित किए जाते हैं। उदाहरण के लिए, iid वर्दी वेरिएंट के किसी भी सरल यादृच्छिक नमूने में ( और ), वहाँ एक संभावना है कि सबसे बड़ा ऊपरी अंतराल में से । एल्गोरिथ्म 1 के साथ, एक संभावना है कि अधिकतम उस अंतराल में होगा। कुछ उद्देश्यों के लिए यह सुपर-एकरूपता अच्छा है, लेकिन सामान्य तौर पर यह एक भयानक त्रुटि है क्योंकि (ए) कई आँकड़े बर्बाद हो जाएंगे लेकिन (बी) यह निर्धारित करना बहुत मुश्किल हो सकता है।एक = 0 ख = 1 ( 1 - 1 / n ) n ≈ 1 / ई ≈ 37 % 1 - 1 / n 1 100 $n$$a=0$$b=1$$(1-1/n)^n\approx 1/e\approx 37\%$$1-1/n$$1$$100\%$

3. यदि आप छँटाई से बचना चाहते हैं, तो इसके बजाय स्वतंत्र घातीय-वितरित चर उत्पन्न करें । राशि द्वारा विभाजित करके उनकी संचयी राशि को सीमा तक सामान्य करें । सबसे बड़ा मूल्य छोड़ें (जो हमेशा )। रेंज में पुनर्विक्रय ।( 0 , 1 ) 1 ( ए , बी $n+1$$(0,1)$$1$$(a,b)$

तीनों एल्गोरिदम के हिस्टोग्राम दिखाए जाते हैं। (प्रत्येक में प्रत्येक के स्वतंत्र सेटों के संचयी परिणामों को दर्शाया गया है ।) एल्गोरिथ्म 1 के लिए हिस्टोग्राम में किसी भी दृश्यमान भिन्नता की कमी वहाँ की समस्या को दर्शाती है। अन्य दो एल्गोरिदम में भिन्नता वही है जो अपेक्षित होनी चाहिए - और आपको यादृच्छिक संख्या जनरेटर से क्या चाहिए ।एन = $1000$$n=100$

स्वतंत्र गणवेश चर को अनुकरण करने के कई और (मनोरंजक) तरीकों के लिए, सामान्य वितरण से ड्रा का उपयोग करके एक समान वितरण से ड्रॉइंग को देखें ।

यहां वह Rकोड है जो आंकड़ा का उत्पादन करता है।

b <- 1
a <- 0
n <- 100
n.iter <- 1e3

offset <- (b-a)/n
as <- seq(a, by=offset, length.out=n)
sim.1 <- matrix(runif(n.iter*n, as, as+offset), nrow=n)
sim.2 <- apply(matrix(runif(n.iter*n, a, b), nrow=n), 2, sort)
sim.3 <- apply(matrix(rexp(n.iter*(n+1)), nrow=n+1), 2, function(x) {
  a + (b-a) * cumsum(x)[-(n+1)] / sum(x)
})

par(mfrow=c(1,3))
hist(sim.1, main="Algorithm 1")
hist(sim.2, main="Algorithm 2")
hist(sim.3, main="Exponential")

Comments

मेरे उत्तर में एल्गोरिदम (रैंक ऑर्डर आँकड़ों के आधार पर) से आप क्या समझते हैं? ;-)

— QUIT है - ऐनी-मूस

@ एनीनी यह मेरे एल्गोरिथ्म का एक कम कुशल संस्करण है। 3. (आपके द्वारा अनावश्यक रिस्कल्स को बहुत अधिक शामिल करना प्रतीत होता है।) आप वर्दी का लॉग लेकर एक्सपोनेंशियल वेरिएंट उत्पन्न करते हैं, जो मानक है।

— whuber

Answer 2

पहले एल्गोरिथ्म का उत्पादन भी समान रूप से स्थान दिया

कम विसंगति श्रृंखला भी देखें ।

$[0;1]$

(के रूप में कहे अनुसार, इस स्तरीकरण के लिए एक वांछित संपत्ति जैसे हो सकता है। हाल्टन और सोबेल की तरह कम विसंगति श्रृंखला है उनके उपयोग के मामलों की है।)

एक उचित लेकिन महंगा दृष्टिकोण (वास्तविक मूल्यों के लिए)

... बीटा-वितरित यादृच्छिक संख्याओं का उपयोग करना है। समान वितरण का रैंक क्रम सांख्यिकीय बीटा वितरित है। आप इसका उपयोग बेतरतीब ढंग से सबसे छोटा , फिर दूसरा सबसे छोटा, ... दोहराने के लिए कर सकते हैं।

$[0;1]$$\text{Beta}[1,n]$1 - एक्स ~ बीटा [ n , 1 ] - ln ( 1 - एक्स ) ~ घातीय [ एन ] - ln ( यू [ 0 ; 1 ] $n$$1-X\sim \text{Beta}[n, 1]$$-\ln (1-X)\sim \text{Exponential}[n]$$\frac{-\ln(U[0;1])}{n}$

$$\begin{align*} -\ln (1-x) &= \frac{-\ln(1-u)}{n} \\ 1-x &= u^\frac{1}{n} \\ x &= 1 - u^\frac{1}{n} \end{align*}$$

निम्नलिखित एल्गोरिथ्म में कौन सी पैदावार होती है:

x = a
for i in range(n, 0, -1):
    x += (b-x) * (1 - pow(rand(), 1. / i))
    result.append(x) 

इसमें संख्यात्मक अस्थिरता शामिल हो सकती है, और कंप्यूटिंग powऔर हर वस्तु के लिए एक विभाजन छँटाई की तुलना में धीमा हो सकता है।

पूर्णांक मानों के लिए आपको एक अलग वितरण का उपयोग करने की आवश्यकता हो सकती है।

छंटाई अविश्वसनीय रूप से सस्ती है, इसलिए बस इसका उपयोग करें

लेकिन परेशान मत करो। सॉर्टिंग बहुत हास्यास्पद है, इसलिए बस सॉर्ट करें। इन वर्षों में, हम अच्छी तरह से समझ गए हैं कि छँटाई एल्गोरिदम को कैसे लागू किया जाए जो छँटाई युगल से बचने के लायक नहीं है। सैद्धांतिक रूप से यह लेकिन निरंतर शब्द एक अच्छे कार्यान्वयन में इतनी हास्यास्पद रूप से छोटा है कि यह सही उदाहरण है कि बेकार सैद्धांतिक जटिलता परिणाम कैसे हो सकते हैं। एक बेंचमार्क चलाएं। 1 मिलियन रैंडम उत्पन्न करें और सॉर्ट किए बिना। इसे कुछ बार चलाएं, और मुझे आश्चर्य नहीं होगा यदि बहुत बार छंटाई गैर-छंटाई की जाती है, क्योंकि छंटनी की लागत अभी भी आपकी माप त्रुटि से बहुत कम होगी।$O(n \log n)$

Comments

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

— whuber

मुझे लगता है कि फ़्लोटिंग पॉइंट गणित का उपयोग करने वाले रकम के साथ संख्यात्मक मुद्दे बहुत पहले एक समस्या बन जाते हैं। (और छद्म यादृच्छिक संख्याओं में चक्रीय पैटर्न के साथ समस्याएं!) टेराबाइट्स के लिए छंटाई के दृष्टिकोण को स्केल करना और वितरित सिस्टम पर छूटना काफी आसान है।

— है क्विट - Anony-Mousse

$10^{12}$

ठीक है, उन्हें संग्रहीत करने के लिए तर्क नहीं है। लेकिन तब आपको मेरे दृष्टिकोण की आवश्यकता होगी, संचयी राशि का उपयोग करने वाला आपका संस्करण 3 काम नहीं करेगा।

— है क्विट - Anony-Mousse

यह एक उत्कृष्ट बिंदु है। अब मुझे अतिरिक्त गणनाओं का गुण दिखाई दे रहा है! (+1)

— whuber

Answer 3

यह इस बात पर भी निर्भर करता है कि आप यादृच्छिक संख्याओं के साथ क्या कर रहे हैं। संख्यात्मक एकीकरण समस्याओं के लिए विधि एक (जब फर्श ऑपरेटर को हटाकर सही किया जाता है) बेहतर बिंदु सेट का उत्पादन करेगा। आप जो कर रहे हैं वह स्तरीकृत नमूनाकरण का एक रूप है और इसका फायदा यह है कि यह क्लंपिंग से बचा जाता है। उदाहरण के लिए 0- (ba) / n रेंज में अपने सभी मूल्यों को प्राप्त करना असंभव है। कहा कि अन्य अनुप्रयोगों के लिए यह बहुत बुरा हो सकता है, यह इस बात पर निर्भर करता है कि आप इसके साथ क्या करना चाहते हैं।

Comments

+1 मुझे लगता है कि यह सवाल का एक उपयोगी योगदान है, विशेष रूप से स्तरीकरण के संदर्भ में एल्गोरिथम 1 को चिह्नित करके।

— whuber