Моделюйте змінну Бернуллі з вірогідністю за допомогою упередженої монети

Може хтось скаже мені, як імітувати , де a, b \ in \ mathbb {N} , використовуючи викидання монети (стільки разів, скільки потрібно) з P (H) = p ?$\mathrm{Bernoulli}\left({a\over b}\right)$$a,b\in \mathbb{N}$$P(H)=p$

Я думав використовувати вибірку відхилення, але не зміг її зняти.

Оскільки рішень незліченно багато, давайте знайдемо ефективне .

Ідея, що стоїть за цим, починається зі стандартного способу реалізації змінної Бернуллі: порівняння рівномірної випадкової змінної з параметром . Коли , поверніть ; в іншому випадку поверніть .$U$$a/b$$U \lt a/b$$1$$0$

Ми можемо використовувати -coin як рівномірний генератор випадкових чисел$p$ . Щоб генерувати число рівномірно протягом будь-якого інтервалу , переверніть монету. Коли це голови, рекурсивно генерують рівномірне значення у першій частині інтервалу; коли це хвости, рекурсивно генерують з останньої частини інтервалу. В якийсь момент цільовий інтервал стане настільки малим, що насправді не має значення, як ви вибираєте з нього число: саме так починається рекурсія. Очевидно, що ця процедура генерує рівномірні змінні (до будь-якої бажаної точності), що легко довести індукцією.$U$$[x, y)$$X$$p$$X$$1-p$

Ця ідея не є ефективною, але призводить до ефективного методу. Оскільки на кожному етапі ви збираєтеся намалювати число з певного інтервалу , чому б спочатку не перевірити, чи потрібно взагалі його малювати? Якщо ваше цільове значення лежить поза цим інтервалом, ви вже знаєте результат порівняння між випадковим значенням і цільовим. Таким чином, цей алгоритм має тенденцію швидко припинятися. (Це може бути витлумачено як процедура відбору проб відхилення, яку вимагає питання.)$[x,y)$

Ми можемо оптимізувати цей алгоритм далі. На будь-якому етапі ми насправді маємо дві монети, якими ми можемо користуватися: шляхом відновлення нашої монети ми можемо перетворити її в одну, яка є головою з випадковістю . Тому в якості попереднього обчислення ми можемо рекурсивно вибирати те, що пов'язане з маркуванням призводить до меншої очікуваної кількості фліп, необхідних для припинення. (Цей розрахунок може бути дорогим кроком.)$1-p$

Наприклад, неефективно використовувати монету з для емуляції змінної Бернуллі безпосередньо: вона в середньому займає майже десять оборотів. Але якщо ми будемо використовувати монету , то за два перевороти ми впевнені, що буде зроблено, і очікувана кількість фліп - всього .$p=0.9$$(0.01)$$p=1-0.0=0.1$$1.2$

Ось деталі.

Розділіть будь-який заданий напіввідкритий інтервал на інтервали$I = [x, y)$

Це визначає дві перетворення і які працюють на напіввідкритих інтервалах.$s(*,H)$$s(*,T)$

Що стосується термінології, якщо будь-який набір реальних чисел, нехай вираз$I$

означає , що є нижньою межею для : для всіх . Аналогічним чином , означає являє собою верхню межу для .$t$$I$$t \lt x$$x \in I$$t \gt I$$t$$I$

Напишіть . (Насправді це не матиме значення, якщо справжній замість раціонального; нам потрібно лише )$a/b = t$$t$$0 \le t \le 1$

Ось алгоритм отримання змінної з потрібним параметром Бернуллі:$Z$

1. Встановіть і .$n=0$$I_n = I_0 = [0,1)$

2. Хоча {Киньте монету, щоб отримати . Встановіть Приріст .}$(t\in I_{n})$$X_{n+1}$$I_{n+1} = S(I_n, X_{n+1}).$$n$

3. Якщо тоді задаємо . В іншому випадку встановіть .$t \gt I_{n+1}$$Z=1$$Z=0$

Впровадження

Для ілюстрації тут представлена Rреалізація алоритму як функції draw. Його аргументами є цільове значення та інтервал , спочатку . Він використовує допоміжну функцію, що реалізує . Хоча це і не потрібно, він також відстежує кількість викинутих монет. Він повертає випадкову змінну, кількість викидів та останній інтервал, який вона перевіряла.$t$$[x,y)$$[0,1)$s$s$

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))
}

Як приклад його використання та перевірка його точності візьмемо випадок і . Давайте намалюємо значень за допомогою алгоритму, повідомимо про середнє значення (та його стандартну помилку) та вкажемо середню кількість використаних фліп.$t=1/100$$p=0.9$$10,000$

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

У цьому моделюванні фліп були головами. Хоча нижчий за ціль , Z-бал не суттєвий: це відхилення можна віднести до випадковості. Середня кількість фліп склала - трохи менше десяти. Якби ми використовували монетку, середній було б --still не суттєво відрізняється від мети, але тільки клацання були б необхідні в середньому.$0.0095$$0.01$$-0.5154$$9.886$$1-p$$0.0094$$1.177$

Ось рішення (трохи безладно, але це мій перший удар). Ви можете фактично ігнорувати і WLOG припустити . Чому? Існує розумний алгоритм для створення об'єктивного відкидання монети з двох упереджених обертів монети. Тож можна припустити .$P(H) = p$$P(H)=1/2$$P(H)=1/2$

Щоб створити , я можу придумати два рішення (перше - це не моє власне, а друге - узагальнення):$\text{Bernoulli}(\frac{a}{b})$

Рішення 1

Переверніть неупереджену монету рази. Якщо голова немає, почніть заново. Якщо голови є присутні, повертають першу монету , чи є голови чи ні (бо )$b$$a$$a$$P(\text{first coin is heads | $a$ heads in $b$ coins}) = \frac{a}{b}$

Рішення 2

Це може бути розширено до будь-якого значення . Запишіть у двійковій формі. Наприклад,$\text{Bernoulli}(p)$$p$$0.1 = 0.0001100110011001100110011... \text{base 2}$

Ми створимо нове двійкове число за допомогою монети фліп. Почніть з І додайте цифри залежно від того, якщо з’являється головка (1) або хвости (0). На кожному фліп порівняйте ваше нове двійкове число з двійковим поданням до однієї і тієї ж цифри . Врешті-решт, вони розійдуться і повернуться, якщо перевищує ваш двійковий номер.$0.$$p$ $bin(p)$

На Python:

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

Деякі докази:

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

приблизно 0,4 (але не швидко)

Я бачу просте рішення, але, без сумніву, є багато способів зробити це, деякі, мабуть, простіші за це. Цей підхід можна розділити на два етапи:

1. Генерування з двох подій з однаковою ймовірністю дається несправедливою процедурою метання монети (поєднання певної монети та методу, за допомогою якого вона кидається, генеруючи голову з вірогідністю ). Ці дві не менш вірогідні події ми можемо назвати і . [Для цього існує простий підхід, який вимагає проведення пар викидів і для отримання двох однаково вірогідних результатів, при цьому всі інші результати призводять до створення нової пари рулонів, щоб спробувати знову.]$p$$H^*$$T^*$$H^*=(H,T)$$T^*=(T,H)$

2. Тепер ви генеруєте випадкову прогулянку з двома поглинаючими станами, використовуючи імітовану справедливу монету. Вибравши відстань поглинаючих станів від початку (один вище та один під ним), ви можете встановити шанс поглинання, сказавши, що верхній поглинаючий стан є бажаним співвідношенням цілих чисел. Зокрема, якщо верхній поглинаючий бар'єр розмістити на а нижній на (і почати процес від початку), і запустити випадкову ходу до поглинання, ймовірність поглинання на верхньому бар'єрі дорівнює .$a$$-(b-a)$$\frac{a}{a+(b-a)} = \frac{a}{b}$

   (Тут потрібно зробити деякі розрахунки, щоб показати це, але ви можете отримати ймовірності досить легко, працюючи з відношеннями рецидивів ... або ви можете це зробити шляхом підсумовування нескінченних рядів ... або є інші способи.)