Bernoulli değişkenini olasılıkla simüle eder

Birisi bana nasıl benzetileceğini söyleyebilir mi $\mathrm{Bernoulli}\left({a\over b}\right)$, nerede $a,b\in \mathbb{N}$, bir bozuk para kullanarak (istediğiniz kadar) $P(H)=p$ ?

Reddetme örneklemesi kullanmayı düşünüyordum ama çivilemedim.

Sayılamayacak kadar çok çözüm olduğu için verimli bir çözüm bulalım .

Bunun arkasındaki fikir, bir Bernoulli değişkenini uygulamanın standart bir yoluyla başlar: tek tip rastgele bir değişkeni karşılaştırın $U$ parametreye $a/b$. Ne zaman$U \lt a/b$, dönüş $1$; aksi halde geri dön$0$.

Biz kullanabilirsiniz $p$-örnek rastgele sayı üreteci olarak para . Sayı oluşturmak için$U$ herhangi bir aralıkta eşit olarak $[x, y)$, parayı Çevir. Kafalar olduğunda, özyinelemeli olarak eşit bir değer üretin$X$ İlk olarak $p$aralığın bir kısmı; kuyruk olduğunda, özyineli olarak üretmek$X$ sondan $1-p$aralığın bir parçası. Bir noktada hedef aralığı o kadar küçük olur ki, ondan nasıl bir sayı seçeceğiniz önemli değildir: özyineleme bu şekilde başlar. Bu prosedürün, indüksiyonla kolayca kanıtlandığı gibi, tekdüze değişkenler (istenen herhangi bir hassasiyete kadar) oluşturduğu açıktır.

Bu fikir etkili değildir, ancak etkili bir yönteme yol açar. Her aşamada belirli bir aralıktan bir sayı çizeceğiniz için$[x,y)$, neden ilk önce çizmeniz gerekip gerekmediğini kontrol etmiyorsunuz? Hedef değeriniz bu aralığın dışındaysa , rastgele değer ile hedef arasındaki karşılaştırmanın sonucunu zaten biliyorsunuzdur. Böylece, bu algoritma hızla sona ermeye meyillidir. (Bu , soruda istenen ret örnekleme prosedürü olarak yorumlanabilir .)

Bu algoritmayı daha da optimize edebiliriz. Herhangi bir aşamada, aslında kullanabileceğimiz iki jetonumuz var: jetonumuzu yeniden etiketleyerek, şans eseri olan bir paraya dönüştürebiliriz$1-p$. Bu nedenle, bir ön hesaplama olarak, hangi yeniden etiketlemenin sonlandırma için gerekli olan daha düşük sayıdaki döndürmeye yol açacağını yinelemeli olarak seçebiliriz. (Bu hesaplama pahalı bir adım olabilir.)

Örneğin, bozuk para kullanmak $p=0.9$ Bernoulli'yi taklit etmek$(0.01)$doğrudan değişken: ortalama olarak yaklaşık on döndürür. Ama eğer bir$p=1-0.0=0.1$ madeni para, o zaman sadece iki döndürme yapıldığından emin olacağız ve beklenen döndürme sayısı sadece $1.2$.

Detaylar burada.

Herhangi bir yarı açık aralığı bölme $I = [x, y)$ aralıklarla

Bu iki dönüşümü tanımlar $s(*,H)$ ve $s(*,T)$ yarı açık aralıklarla çalışan

Bir terminoloji meselesi olarak, $I$ herhangi bir gerçek sayı kümesi ifade izin

demek istediğim $t$ için bir alt sınır $I$: $t \lt x$ hepsi için $x \in I$. Benzer şekilde,$t \gt I$ anlamına geliyor $t$ için bir üst sınır $I$.

Yazmak $a/b = t$. (Aslında, eğer fark etmez$t$rasyonel yerine gerçek; sadece buna ihtiyacımız var$0 \le t \le 1$.)

İşte bir değişken üretmek için algoritma $Z$ istenen Bernoulli parametresiyle:

1. Ayarlamak $n=0$ ve $I_n = I_0 = [0,1)$.

2. Süre $(t\in I_{n})$ {Üretmek için jetonu atın $X_{n+1}$. Ayarlamak$I_{n+1} = S(I_n, X_{n+1}).$ artım $n$.}

3. Eğer $t \gt I_{n+1}$ sonra ayarla $Z=1$. Aksi takdirde,$Z=0$.

uygulama

Açıklamak gerekirse, burada Raloritmanın bir işlevi olarak uygulanması söz konusudur draw. Argümanları hedef değerdir$t$ ve aralık $[x,y)$, başlangıçta $[0,1)$. Yardımcı fonksiyon suygulamasını kullanır$s$. Gerek duymasa da, madeni para sayısını da izler. Rastgele değişkeni, fırlatma sayısını ve incelediği son aralığı döndürür.

s <- function(x, ab, p) {
  d <- diff(ab) * p
  if (x == 1) c(ab[1], ab[1] + d) else c(ab[1] + d, ab[2])
}
draw <- function(target, p) {
  between <- function(z, ab) prod(z - ab) <= 0
  ab <- c(0,1)
  n <- 0
  while(between(target, ab)) {
    n <- n+1; ab <- s(runif(1) < p, ab, p)
  }
  return(c(target > ab[2], n, ab))
}

Kullanımının ve doğruluğunun testinin bir örneği olarak, davayı ele alın $t=1/100$ ve $p=0.9$. Hadi çizelim$10,000$ algoritmayı kullanarak değerleri, ortalama (ve standart hatasını) rapor edin ve kullanılan ortalama döndürme sayısını belirtin.

target <- 0.01
p <- 0.9
set.seed(17)
sim <- replicate(1e4, draw(target, p))

(m <- mean(sim[1, ]))                           # The mean
(m - target) / (sd(sim[1, ]) / sqrt(ncol(sim))) # A Z-score to compare to `target`
mean(sim[2, ])                                  # Average number of flips

Bu simülasyonda $0.0095$döndürürlerin kafaları vardı. Hedefinden daha düşük olmasına rağmen$0.01$, Z puanı $-0.5154$önemli değildir: bu sapma şansa bağlanabilir. Ortalama döndürme sayısı$9.886$- ondan biraz daha az. Eğer kullansaydık$1-p$ sikke, ortalama olurdu $0.0094$--Hedeften önemli ölçüde farklı değil, sadece $1.177$ flips ortalama olarak gerekli olurdu.

İşte bir çözüm (dağınık bir çözüm, ama bu benim ilk bıçakım). Aslında yok sayabilirsiniz ve WLOG varsayalım . Neden? İki önyargılı madeni para saygısından tarafsız bir madeni para çevirme üretmek için akıllı bir algoritma vardır . Böylece 1/2 olduğunu varsayabiliriz .$P(H) = p$$P(H)=1/2$$P(H)=1/2$

Bir oluşturmak için iki çözüm düşünebilirim (birincisi benim değil, ikincisi bir genellemedir):$\text{Bernoulli}(\frac{a}{b})$

Çözüm 1

Tarafsız parayı çevirin $b$zamanlar. Eğer$a$kafalar mevcut değil, baştan başla. Eğer$a$kafaları vardır (nedeniyle ilk para bir heads olup dönüş olup, bu$P(\text{first coin is heads | $a$ heads in $b$ coins}) = \frac{a}{b}$)

Çözüm 2

Bu herhangi bir değere genişletilebilir $\text{Bernoulli}(p)$. Yazmak$p$ikili biçimde. Örneğin,$0.1 = 0.0001100110011001100110011... \text{base 2}$

Bozuk para kullanarak yeni bir ikili sayı oluşturacağız. İle başla$0.$ve bir kafa (1) veya kuyruk (0) görünmesine bağlı olarak rakam ekleyin. Her kapakta, yeni ikili numaranızı,$p$ aynı basamağa kadar . Sonunda ikisi birbirinden ayrılacak ve eğer$bin(p)$ ikili numaranızdan büyük.

Python'da:

def simulate(p):
    binary_p = float_to_binary(p)
    binary_string = '0.'
    index = 3
    while True:
        binary_string += '0' if random.random() < 0.5 else '1'
        if binary_string != binary_p[:index]:
            return binary_string < binary_p[:index]
        index += 1

Bazı kanıtlar:

np.mean([simulate(0.4) for i in range(10000)])

yaklaşık 0.4 (hızlı değil)

Basit bir çözüm görüyorum, ancak şüphesiz bunu yapmanın birçok yolu var, bazıları muhtemelen bundan daha basit. Bu yaklaşım iki adıma ayrılabilir:

1. Eşit olmayan bir madeni para atma prosedürü (belirli madalyonun kombinasyonu ve olasılıkla bir kafa üretme yönteminin kombinasyonu) eşit olasılıkla iki olaydan üretilir $p$). Bu iki eşit olay olabilir$H^*$, ve $T^*$. [Bunun için çiftler fırlatmayı gerektiren basit bir yaklaşım var$H^*=(H,T)$ ve $T^*=(T,H)$ eşit derecede olası iki sonuç üretmek için, diğer tüm sonuçlar tekrar denemek için yeni bir çift rulo üretilmesine yol açar.]

2. Simüle edilmiş adil parayı kullanarak iki emici durumla rastgele bir yürüyüş oluşturuyorsunuz. Emici durumların başlangıç ​​noktasından uzaklığını (bir üst ve bir alt) seçerek, üst emme durumunun istenen tamsayı oranı olduğunu söyleyerek emilim şansını ayarlayabilirsiniz. Özellikle, üst emici bariyeri$a$ ve altta $-(b-a)$ (ve süreci başlangıç ​​noktasından başlatın) ve emilim kadar rastgele yürüyüşü çalıştırın, üst bariyerdeki emilim olasılığı $\frac{a}{a+(b-a)} = \frac{a}{b}$.

   (Burada göstermek için bazı hesaplamalar var, ancak rekürrens ilişkileri ile çalışarak olasılıkları kolayca elde edebilirsiniz ... ya da sonsuz serileri toplayarak yapabilirsiniz ... ya da başka yollar var.)