Бинарный случайный массив с определенной пропорцией?

Какова эффективная (возможно, векторизация с терминологией Matlab) способ генерации случайного числа нулей и единиц с определенной пропорцией? Специально с Numpy?

Поскольку мой случай является особым для 1/3, мой код:

import numpy as np 
a=np.mod(np.multiply(np.random.randomintegers(0,2,size)),3)

Но есть ли встроенная функция, которая могла бы справиться с этим более эффективно, по крайней мере, для ситуации K/N, где K и N - натуральные числа?

Ответы

Ответ 1

Еще один подход, используя np.random.choice:

>>> np.random.choice([0, 1], size=(10,), p=[1./3, 2./3])
array([0, 1, 1, 1, 1, 0, 0, 0, 0, 0])

Ответ 2

Простым способом сделать это было бы сначала создать ndarray с долей нулей и единиц, которые вы хотите:

>>> import numpy as np
>>> N = 100
>>> K = 30 # K zeros, N-K ones
>>> arr = np.array([0] * K + [1] * (N-K))
>>> arr
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1])

Тогда вы можете просто shuffle массив, делая распределение случайным:

>>> np.random.shuffle(arr)
>>> arr
array([1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0,
       1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1,
       1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
       0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,
       1, 1, 1, 0, 1, 1, 1, 1])

Обратите внимание, что этот подход даст вам точную долю нулей/единиц, которые вы запрашиваете, в отличие от биномиального подхода. Если вам не нужна точная пропорция, то биномиальный подход будет работать нормально.

Ответ 3

Вы можете использовать numpy.random.binomial. Например. пусть frac - доля единиц:

In [50]: frac = 0.15

In [51]: sample = np.random.binomial(1, frac, size=10000)

In [52]: sample.sum()
Out[52]: 1567

Ответ 4

Если я правильно понимаю вашу проблему, вы можете получить помощь numpy.random.shuffle

>>> def rand_bin_array(K, N):
    arr = np.zeros(N)
    arr[:K]  = 1
    np.random.shuffle(arr)
    return arr

>>> rand_bin_array(5,15)
array([ 0.,  1.,  0.,  1.,  1.,  1.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,
        0.,  0.])

Ответ 5

Простой однострочный: вы можете избежать использования списков целых чисел и распределений вероятностей, которые, на мой взгляд, неинтуитивны и излишни для этой проблемы, просто работая сначала с bool а затем при необходимости bool к bool int (хотя оставить его как массив bool следует работать в большинстве случаев).

>>> import numpy as np
>>> np.random.random(9) < 1/3.
array([False,  True,  True,  True,  True, False, False, False, False])   
>>> (np.random.random(36) < 1/3.).astype(int)
array([0, 0, 0, 0, 0, 1, 0, 0, 1])

Ответ 6

Другой способ получения точного числа единиц и нулей - выборка индексов без замены с использованием np.random.choice:

arr_len = 30
num_ones = 8

arr = np.zeros(arr_len, dtype=int)
idx = np.random.choice(range(arr_len), num_ones, replace=False)
arr[idx] = 1

Из:

arr

array([0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1,
       0, 0, 0, 0, 0, 1, 0, 0])