Apa yang lebih efisien(mungkin vectorized dengan Matlab terminologi) cara untuk menghasilkan nomor acak dari angka satu dan nol dengan proporsi tertentu? Khusus dengan Numpy?
Seperti kasus saya ini khusus untuk 1/3
, kode saya adalah:
import numpy as np
a=np.mod(np.multiply(np.random.randomintegers(0,2,size)),3)
Tapi apakah ada fungsi built-in yang bisa menangani hal ini lebih efisien setidaknya untuk situasi `K/N dimana K dan N adalah bilangan asli?
Cara sederhana untuk melakukan hal ini akan lebih menghasilkan sebuah ndarray
dengan proporsi angka nol dan satu yang anda inginkan:
>>> 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])
Maka anda hanya dapat shuffle
array, membuat distribusi acak:
>>> 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])
Perhatikan bahwa pendekatan ini akan memberikan anda proporsi yang tepat dari nol/orang-orang yang anda minta, seperti mengatakan binomial pendekatan. Jika anda don't membutuhkan proporsi yang tepat, maka binomial pendekatan ini akan bekerja baik-baik saja.
Jika saya memahami masalah anda dengan benar, anda mungkin mendapatkan beberapa bantuan dengan 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.])
Sederhana satu-liner: anda dapat menghindari menggunakan daftar bilangan bulat dan distribusi probabilitas, yang tidak mudah ditebak dan berlebihan untuk masalah ini menurut saya, dengan hanya bekerja dengan bool pertama dan kemudian casting untuk
intjika diperlukan (meskipun meninggalkan itu sebagai
bool` array harus bekerja dalam banyak kasus).
>>> import numpy as np
>>> np.random.random(9) < 1/3.
array([False, True, True, True, True, False, False, False, False])
>>> (np.random.random(9) < 1/3.).astype(int)
array([0, 0, 0, 0, 0, 1, 0, 0, 1])
Cara lain untuk mendapatkan jumlah yang tepat dari satu dan nol adalah untuk sampel indeks tanpa penggantian menggunakan np.acak.pilihan
:
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
Keluar:
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])