প্রদত্ত (সংখ্যাগত) বিতরণ সহ এলোমেলো সংখ্যা তৈরি করুন

Question

বিভিন্ন মানগুলির জন্য আমার কিছু সম্ভাবনার ফাইল রয়েছে যেমন:

1 0.1
2 0.05
3 0.05
4 0.2
5 0.4
6 0.2

আমি এই বিতরণটি ব্যবহার করে এলোমেলো সংখ্যা উত্পন্ন করতে চাই। এটি পরিচালনা করে এমন একটি বিদ্যমান মডিউল কি বিদ্যমান? এটি আপনার নিজের কোড করা মোটামুটি সহজ (ক্রমবর্ধমান ঘনত্বের ফাংশন তৈরি করুন, একটি এলোমেলো মান তৈরি করুন [0,1] এবং সংশ্লিষ্ট মানটি চয়ন করুন) তবে মনে হচ্ছে এটি একটি সাধারণ সমস্যা হওয়া উচিত এবং সম্ভবত কেউ এর জন্য একটি ফাংশন / মডিউল তৈরি করেছে for এটা।

আমার এটি দরকার কারণ আমি জন্মদিনের একটি তালিকা তৈরি করতে চাই (যা মানক randomমডিউলে কোনও বিতরণ অনুসরণ করে না )।

Comments

ছাড়া অন্য random.choice()? আপনি সংঘটনগুলির যথাযথ সংখ্যার সাথে মাস্টার তালিকা তৈরি করে একটি বেছে নিন। এটি অবশ্যই একটি সদৃশ প্রশ্ন।

— এসলট

এলোমেলো ওজনযুক্ত পছন্দের

— এসলট

@ এসলট কি বিতরণে বড় পার্থক্যের জন্য খুব মেমরি নিবিড় নয়?

— লুকাস মোসকোপস

@ এস.লোট: আপনার পছন্দের পদ্ধতিটি অল্প সংখ্যক ঘটনার জন্য সম্ভবত খুব ভাল হবে তবে যখন প্রয়োজন হয় না তখন আমি বিশাল তালিকা তৈরি করা এড়াতে চাইতাম।

— পাফকু

@ এস.লোট: ঠিক আছে, প্রায় 10000 * 365 = 3650000 = 3.6 মিলিয়ন উপাদান। পাইথনে মেমরির ব্যবহার সম্পর্কে আমি নিশ্চিত নই তবে এটি কমপক্ষে 3.6 এম * 4 বি = 14.4 এমবি M অতিরিক্ত পরিমাণ নয়, তবে এমন কোনও জিনিস নয় যা আপনার যখন এড়ানো উচিত তখনই সমান সরল পদ্ধতিতে অতিরিক্ত মেমরির প্রয়োজন হয় না।

— পাফকু

Answer 1

scipy.stats.rv_discreteআপনি যা চান তা হতে পারে আপনি valuesপ্যারামিটারের মাধ্যমে আপনার সম্ভাবনাগুলি সরবরাহ করতে পারেন । তারপরে আপনি rvs()এলোমেলো সংখ্যা উত্পন্ন করতে বিতরণ অবজেক্টের পদ্ধতিটি ব্যবহার করতে পারেন ।

মন্তব্যগুলিতে ইউজিন পাখোমভ নির্দেশ করেছেন, আপনি কোনও pকীওয়ার্ড প্যারামিটারও numpy.random.choice()যেমন পাস করতে পারেন

numpy.random.choice(numpy.arange(1, 7), p=[0.1, 0.05, 0.05, 0.2, 0.4, 0.2])

যদি আপনি পাইথন ৩.6 বা তার বেশি ব্যবহার random.choices()করেন তবে আপনি স্ট্যান্ডার্ড লাইব্রেরি থেকে ব্যবহার করতে পারেন - মার্ক ডিকিনসনের উত্তর দেখুন ।

Comments

আমার মেশিনে numpy.random.choice()প্রায় 20 গুণ দ্রুত হয়।

— ইউজিন পাখোমভ

এটি আসল প্রশ্নের সাথে ঠিক একই রকম কাজ করে। যেমন:numpy.random.choice(numpy.arange(1, 7), p=[0.1, 0.05, 0.05, 0.2, 0.4, 0.2])

— ইউজিন পাখোমভ

@ ইউজেনপাখোমভ এটি দুর্দান্ত, আমি তা জানতাম না। আমি দেখতে পাচ্ছি যে এর উত্তর উল্লেখ করার পরে আরও একটি উত্তর রয়েছে তবে এতে কোনও উদাহরণ কোড নেই এবং এতে প্রচুর পরিমাণে উন্নতি নেই। আরও ভাল দৃশ্যমানতার জন্য আমি এই উত্তরে একটি মন্তব্য যুক্ত করব।

— সোভেন মারনাচ

আশ্চর্যের বিষয় হল, rv_discrete.rvs () ও (লেন (পি) * আকার) সময় এবং স্মৃতিতে কাজ করে! যখন পছন্দ () অনুকূল O (লেন (পি) + লগ (লেন (পি)) * আকার) সময় চলবে বলে মনে হচ্ছে।

— alyaxey

আপনি যদি পাইথন ৩.6 বা তার চেয়েও নতুন ব্যবহার করছেন তবে এর জন্য আরও একটি উত্তর রয়েছে যাতে কোনও অ্যাডন প্যাকেজ প্রয়োজন হয় না।

— মার্ক রান্সম

Answer 2

পাইথন ৩.6 থেকে পাইথনের স্ট্যান্ডার্ড লাইব্রেরিতে এর জন্য একটি সমাধান রয়েছে random.choices।

ব্যবহারের উদাহরণ উদাহরণ: আসুন একটি জনসংখ্যা সেট করুন এবং ওপির প্রশ্নের সাথে মিলিত ওজনগুলি:

>>> from random import choices
>>> population = [1, 2, 3, 4, 5, 6]
>>> weights = [0.1, 0.05, 0.05, 0.2, 0.4, 0.2]

এখন choices(population, weights)একটি একক নমুনা উত্পন্ন:

>>> choices(population, weights)
4

Keyচ্ছিক কী-ওয়ার্ড-যুক্তি kএক সাথে একবারে একাধিক নমুনার অনুরোধ করার অনুমতি দেয়। এটি মূল্যবান কারণ random.choicesকোনও নমুনা উত্সাহিত করার আগে প্রতিবার যখন ডাকা হয় তখন কিছু কাজ করতে হয়; একবারে অনেকগুলি নমুনা তৈরি করে, আমাদের কেবল একবার সেই প্রস্তুতিমূলক কাজটি করতে হবে। এখানে আমরা এক মিলিয়ন নমুনা উত্পন্ন করি এবং collections.Counterআমরা যে বিতরণটি পাই তা আমাদের দেওয়া ওজনের সাথে মোটামুটি মেলে তা পরীক্ষা করে দেখতে ব্যবহার করুন ।

>>> million_samples = choices(population, weights, k=10**6)
>>> from collections import Counter
>>> Counter(million_samples)
Counter({5: 399616, 6: 200387, 4: 200117, 1: 99636, 3: 50219, 2: 50025})

Comments

এটির জন্য পাইথন ২.7 সংস্করণ রয়েছে?

— abbas786

@ অ্যাবাবাস 6 in6: অন্তর্নির্মিত নয়, তবে এই প্রশ্নের অন্যান্য উত্তরগুলি পাইথন ২.7 এ কাজ করা উচিত। আপনি এলোমেলো.চয়েজগুলির জন্য পাইথন 3 উত্সও সন্ধান করতে পারেন এবং যদি তেমন ঝোঁক থাকে তবে এটি অনুলিপি করতে পারেন।

— মার্ক ডিকিনসন

Answer 3

সিডিএফ ব্যবহার করে তালিকাটি তৈরি করার একটি সুবিধা হ'ল আপনি বাইনারি অনুসন্ধান ব্যবহার করতে পারেন। প্রিপ্রোসেসিংয়ের জন্য আপনার ও (এন) সময় এবং স্থানের প্রয়োজন থাকলেও আপনি ও (কে লগ এন) এ কে নম্বর পেতে পারেন। যেহেতু সাধারণ পাইথন তালিকাগুলি অক্ষম, আপনি arrayমডিউলটি ব্যবহার করতে পারেন ।

আপনি যদি ধ্রুবক স্থানের জন্য জেদ করেন তবে আপনি নিম্নলিখিতগুলি করতে পারেন; ও (এন) সময়, ও (1) স্থান।

def random_distr(l):
    r = random.uniform(0, 1)
    s = 0
    for item, prob in l:
        s += prob
        if s >= r:
            return item
    return item  # Might occur because of floating point inaccuracies

Comments

তালিকার মধ্যে (আইটেম, প্রোব) জোড়গুলির ক্রমটি আপনার প্রয়োগের ক্ষেত্রে গুরুত্বপূর্ণ?

— stackoverflowuser2010

@

— স্ট্যাকওভারফ্লোজার 2010

খুশী হলাম। আমি এটি স্কিপি.স্ট্যাটস.আরভি_ডিসক্রিটের চেয়ে 30% দ্রুত গতিতে পেয়েছি।

— অ্যাস্পেন

বেশ কয়েকবার এই ফাংশনটি একটি কী-ইরর ফেলে দেবে কারণ শেষ লাইন।

— imrek

@ ড্রঙ্কনমাস্টার: আমি বুঝতে পারছি না। আপনি কি সচেতন l[-1]তালিকার শেষ উপাদানটি প্রদান করেন?

— sdcvvc

Answer 4

হতে পারে এটি দেরীতে এক ধরণের। তবে আপনি প্যারামিটারটি numpy.random.choice()পাস করে ব্যবহার করতে পারেন p:

val = numpy.random.choice(numpy.arange(1, 7), p=[0.1, 0.05, 0.05, 0.2, 0.4, 0.2])

Comments

ওপি ব্যবহার করতে চায় না random.choice()- মন্তব্যগুলি দেখুন।

— পোব্রলকি

numpy.random.choice()সম্পূর্ণরূপে পৃথক random.choice()এবং সম্ভাব্যতা বিতরণ সমর্থন করে।

— ইউজিন পাখোমভ

Answer 5

(ঠিক আছে, আমি জানি আপনি সঙ্কুচিত-মোড়কের জন্য জিজ্ঞাসা করছেন, তবে সম্ভবত সেই গৃহজাত সমাধানগুলি আপনার পছন্দ অনুসারে যথেষ্ট পরিমাণে সংহত ছিল না: :-)

pdf = [(1, 0.1), (2, 0.05), (3, 0.05), (4, 0.2), (5, 0.4), (6, 0.2)]
cdf = [(i, sum(p for j,p in pdf if j < i)) for i,_ in pdf]
R = max(i for r in [random.random()] for i,c in cdf if c <= r)

আমি সিউডো-কনফার্ম করেছি যে এই এক্সপ্রেশনটির আউটপুটটিকে চোখের জল দিয়ে কাজ করে:

sorted(max(i for r in [random.random()] for i,c in cdf if c <= r)
       for _ in range(1000))

Comments

এটি চিত্তাকর্ষক দেখাচ্ছে। কেবল প্রসঙ্গের বিষয়গুলিতে রাখতে, উপরের কোডটির টানা 3 কার্যকর করা থেকে প্রাপ্ত ফলাফল: ['প্রব্লেট সহ 1 টি গণনা: 0.1 হল: 113', '2 সহ প্রাবের সংখ্যা: 0.05 হল: 55', 'গণনা 3 টি প্রোব সহ: 0.05 হ'ল: 50 ',' প্রোবের সাথে 4 এর গণনা: 0.2 হল: 201 ',' প্রোব সহ 5 এর গণনা: 0.4 হ'ল: 388 ',' সমান 6 টি গণনা: 0.2 হল: 193 ']। ............. ['প্রোব সহ 1 টি গণনা: 0.1 হ'ল: 77', 'প্রোব সহ 2 টি গণনা: 0.05 হ'ল: 60', 'প্রোবের সাথে 3 এর গণনা: 0.05 হ'ল: 51 ',' প্রবুদ্ধির সাথে 4 এর গণনা: 0.2 হল: 193 ',' প্রোব সহ 5 টি গণনা: 0.4 হ'ল: 438 ',' 6 সহ প্রব: 0.2 রয়েছে: 181 '] ........ ..... এবং

— বৈভব

['প্রোব সহ 1 টি গণনা: 0.1 হ'ল: 84', 'প্রোব সহ 2 টি গণনা: 0.05 হ'ল: 52', 'প্রোব সহ 3 এর গণনা: 0.05 হ'ল: 53', 'প্রোব সহ 4 এর গণনা: 0.2 হল: 210 ',' প্রোব সহ 5 টি গণনা: 0.4 হ'ল: 405 ',' সম্ভাব্য 6 এর গণনা: 0.2 হল: 196 ']

— বৌভ

একটি প্রশ্ন, আমি কীভাবে সর্বোচ্চ ফিরিয়ে দেব (i ..., যদি 'i' কোনও বস্তু হয়?

— বৈভব

@Vaibhav i কোনও বস্তু নয়।

— মার্সেলো ক্যান্টোস

Answer 6

আমি একটি কাস্টম অবিচ্ছিন্ন বিতরণ থেকে এলোমেলো নমুনা আঁকার জন্য একটি সমাধান লিখেছি ।

আপনার অনুরূপ ব্যবহারের ক্ষেত্রে আমার এটি প্রয়োজন (যেমন প্রদত্ত সম্ভাবনার বন্টন সহ এলোমেলো তারিখ উত্পন্ন করা)।

আপনার কেবল মজাদার random_custDistএবং লাইন দরকার samples=random_custDist(x0,x1,custDist=custDist,size=1000)। বাকি সাজসজ্জা ^^।

import numpy as np

#funtion
def random_custDist(x0,x1,custDist,size=None, nControl=10**6):
    #genearte a list of size random samples, obeying the distribution custDist
    #suggests random samples between x0 and x1 and accepts the suggestion with probability custDist(x)
    #custDist noes not need to be normalized. Add this condition to increase performance. 
    #Best performance for max_{x in [x0,x1]} custDist(x) = 1
    samples=[]
    nLoop=0
    while len(samples)<size and nLoop<nControl:
        x=np.random.uniform(low=x0,high=x1)
        prop=custDist(x)
        assert prop>=0 and prop<=1
        if np.random.uniform(low=0,high=1) <=prop:
            samples += [x]
        nLoop+=1
    return samples

#call
x0=2007
x1=2019
def custDist(x):
    if x<2010:
        return .3
    else:
        return (np.exp(x-2008)-1)/(np.exp(2019-2007)-1)
samples=random_custDist(x0,x1,custDist=custDist,size=1000)
print(samples)

#plot
import matplotlib.pyplot as plt
#hist
bins=np.linspace(x0,x1,int(x1-x0+1))
hist=np.histogram(samples, bins )[0]
hist=hist/np.sum(hist)
plt.bar( (bins[:-1]+bins[1:])/2, hist, width=.96, label='sample distribution')
#dist
grid=np.linspace(x0,x1,100)
discCustDist=np.array([custDist(x) for x in grid]) #distrete version
discCustDist*=1/(grid[1]-grid[0])/np.sum(discCustDist)
plt.plot(grid,discCustDist,label='custom distribustion (custDist)', color='C1', linewidth=4)
#decoration
plt.legend(loc=3,bbox_to_anchor=(1,0))
plt.show()

এই সমাধানটির পারফরম্যান্স নিশ্চিতভাবে অসম্ভব, তবে আমি পঠনযোগ্যতা পছন্দ করি।

Answer 7

তাদের উপর ভিত্তি করে আইটেমগুলির একটি তালিকা তৈরি করুন weights:

items = [1, 2, 3, 4, 5, 6]
probabilities= [0.1, 0.05, 0.05, 0.2, 0.4, 0.2]
# if the list of probs is normalized (sum(probs) == 1), omit this part
prob = sum(probabilities) # find sum of probs, to normalize them
c = (1.0)/prob # a multiplier to make a list of normalized probs
probabilities = map(lambda x: c*x, probabilities)
print probabilities

ml = max(probabilities, key=lambda x: len(str(x)) - str(x).find('.'))
ml = len(str(ml)) - str(ml).find('.') -1
amounts = [ int(x*(10**ml)) for x in probabilities]
itemsList = list()
for i in range(0, len(items)): # iterate through original items
  itemsList += items[i:i+1]*amounts[i]

# choose from itemsList randomly
print itemsList

একটি অপ্টিমাইজেশন হ'ল সর্বোচ্চ তালিকাভুক্ত সাধারণ বিভাজক দ্বারা পরিমাণকে স্বাভাবিক করতে, লক্ষ্য তালিকাটি আরও ছোট করে তুলতে।

এছাড়াও, এই আকর্ষণীয় হতে পারে।

Comments

আইটেমের তালিকা বড় হলে এটি অতিরিক্ত মেমরির প্রচুর পরিমাণে ব্যবহার করতে পারে।

— পাফকু

@ পেফকু একমত কেবল একটি সমাধান, দ্বিতীয়টি যা আমার মনে এসেছিল (প্রথমটি ছিল "ওজনের সম্ভাবনা অজগর" :) এর মতো কিছু সন্ধান করা।)

— খচিক

Answer 8

আরেকটি উত্তর, সম্ভবত দ্রুত :)

distribution = [(1, 0.2), (2, 0.3), (3, 0.5)]  
# init distribution  
dlist = []  
sumchance = 0  
for value, chance in distribution:  
    sumchance += chance  
    dlist.append((value, sumchance))  
assert sumchance == 1.0 # not good assert because of float equality  

# get random value  
r = random.random()  
# for small distributions use lineair search  
if len(distribution) < 64: # don't know exact speed limit  
    for value, sumchance in dlist:  
        if r < sumchance:  
            return value  
else:  
    # else (not implemented) binary search algorithm  

Answer 9

from __future__ import division
import random
from collections import Counter


def num_gen(num_probs):
    # calculate minimum probability to normalize
    min_prob = min(prob for num, prob in num_probs)
    lst = []
    for num, prob in num_probs:
        # keep appending num to lst, proportional to its probability in the distribution
        for _ in range(int(prob/min_prob)):
            lst.append(num)
    # all elems in lst occur proportional to their distribution probablities
    while True:
        # pick a random index from lst
        ind = random.randint(0, len(lst)-1)
        yield lst[ind]

প্রতিপাদন:

gen = num_gen([(1, 0.1),
               (2, 0.05),
               (3, 0.05),
               (4, 0.2),
               (5, 0.4),
               (6, 0.2)])
lst = []
times = 10000
for _ in range(times):
    lst.append(next(gen))
# Verify the created distribution:
for item, count in Counter(lst).iteritems():
    print '%d has %f probability' % (item, count/times)

1 has 0.099737 probability
2 has 0.050022 probability
3 has 0.049996 probability 
4 has 0.200154 probability
5 has 0.399791 probability
6 has 0.200300 probability

Answer 10

অন্যান্য সমাধানের উপর ভিত্তি করে, আপনি সঞ্চয়ের বিতরণ উত্পন্ন করেন (পূর্ণসংখ্যা হিসাবে বা আপনার পছন্দ অনুযায়ী ভাসা), তারপরে আপনি এটি দ্রুত তৈরি করতে দ্বিখণ্ডিত ব্যবহার করতে পারেন

এটি একটি সাধারণ উদাহরণ (আমি এখানে পূর্ণসংখ্যা ব্যবহার করেছি)

l=[(20, 'foo'), (60, 'banana'), (10, 'monkey'), (10, 'monkey2')]
def get_cdf(l):
    ret=[]
    c=0
    for i in l: c+=i[0]; ret.append((c, i[1]))
    return ret

def get_random_item(cdf):
    return cdf[bisect.bisect_left(cdf, (random.randint(0, cdf[-1][0]),))][1]

cdf=get_cdf(l)
for i in range(100): print get_random_item(cdf),

get_cdfফাংশন এটা 20, 60, 10, 10 থেকে রূপান্তর হবে 20 মধ্যে, 20 + + 60, 20 + + 60 + + 10, 20 + 60 + 10 + 10

এখন আমরা ২০ + +০ + ১০ + ১০ পর্যন্ত একটি এলোমেলো সংখ্যা বাছাই করি random.randintতারপরে আমরা দ্রুত উপায়ে প্রকৃত মান পেতে বাইসেক্ট ব্যবহার করি

Answer 11

আপনি NumPy এলোমেলো নমুনা বিতরণ একবার তাকান করতে পারেন

Comments

অদ্ভুত ফাংশনগুলি কেবল নিজের নির্দিষ্টকরণের জন্য কোনও সমর্থন ছাড়াই সীমিত সংখ্যক বিতরণকে সমর্থন করে বলে মনে হয়।

— পাফকু

docs.scipy.org/doc/numpy-1.14.0/references/routines.random.html এর পরিবর্তে ডকস.স্কিপি.আর.ডোক / নম্পি

— রেফারেন্স

Answer 12

এই উত্তরগুলির কোনওটিই বিশেষভাবে পরিষ্কার বা সহজ নয়।

এখানে একটি পরিষ্কার, সহজ পদ্ধতি যা কাজের গ্যারান্টিযুক্ত।

জড়ো_আরঙ্কিতকরণ_প্রবণতা এমন একটি অভিধান নেয় pযা সম্ভাবনা বা ফ্রিকোয়েন্সিগুলিতে প্রতীকগুলি ম্যাপ করে । এটি যে টিপলগুলি থেকে নির্বাচন করতে হবে তার ব্যবহারযোগ্য তালিকার আউটপুট দেয়।

def accumulate_normalize_values(p):
        pi = p.items() if isinstance(p,dict) else p
        accum_pi = []
        accum = 0
        for i in pi:
                accum_pi.append((i[0],i[1]+accum))
                accum += i[1]
        if accum == 0:
                raise Exception( "You are about to explode the universe. Continue ? Y/N " )
        normed_a = []
        for a in accum_pi:
                normed_a.append((a[0],a[1]*1.0/accum))
        return normed_a

উৎপাদনের:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

কেন এটি কাজ করে

আহরণ পদক্ষেপ (প্রথম প্রতীক ক্ষেত্রে বা 0) নিজেই এবং পূর্ববর্তী প্রতীক সম্ভাব্যতা বা ফ্রিকোয়েন্সি মধ্যে একটি বিরতি প্রতিটি প্রতীক সক্রিয়। এই ব্যবধানগুলি অন্তর্ভুক্ত 0.0 -> 1.0 (পূর্ববর্তী প্রস্তুত) অবধি বর্তমান প্রতীকটির অন্তর শেষ পয়েন্টের কম বা সমান হওয়া অবধি তালিকার মধ্য দিয়ে পদক্ষেপের মাধ্যমে (এবং এইভাবে সরবরাহিত বিতরণের নমুনা) থেকে নির্বাচন করতে ব্যবহার করা যেতে পারে।

নিয়মমাফিককরণ কিছু মান নিশ্চিত সবকিছু অঙ্কের করতে প্রয়োজন থেকে আমাদের রিলিজ। সাধারণীকরণের পরে সম্ভাবনার "ভেক্টর" এর পরিমাণ 1.0 হয়।

কোড বাকি নির্বাচন ও বন্টন থেকে ইচ্ছামত দীর্ঘ নমুনা জেনারেট করার জন্য নীচে:

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

ব্যবহার:

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

Answer 13

এটি করার আরও কার্যকর উপায় এখানে :

কেবলমাত্র আপনার 'ওজন' অ্যারে (সূচকগুলিকে সংশ্লিষ্ট আইটেম হিসাবে ধরে) এবং নীচের সাথে নীচের ফাংশনটি কল করুন। নমুনা প্রয়োজন। অর্ডারযুক্ত জোড় পরিচালনা করতে এই ফাংশনটি সহজেই সংশোধন করা যায়।

সূচকগুলি (বা আইটেমগুলি) তাদের নিজস্ব সম্ভাব্যতা ব্যবহার করে নমুনাযুক্ত / বাছাই (প্রতিস্থাপন সহ) ফেরত দেয়:

def resample(weights, n):
    beta = 0

    # Caveat: Assign max weight to max*2 for best results
    max_w = max(weights)*2

    # Pick an item uniformly at random, to start with
    current_item = random.randint(0,n-1)
    result = []

    for i in range(n):
        beta += random.uniform(0,max_w)

        while weights[current_item] < beta:
            beta -= weights[current_item]
            current_item = (current_item + 1) % n   # cyclic
        else:
            result.append(current_item)
    return result

লুপটিতে ব্যবহৃত ধারণার উপর একটি সংক্ষিপ্ত নোট। আমরা ক্রমবর্ধমান বিটা থেকে বর্তমান আইটেমটির ওজন হ্রাস করি যা এলোমেলোভাবে সমানভাবে নির্মিত একটি সংখ্যামূলক মান এবং আইটেমটি সন্ধানের জন্য বর্ধমান বর্তমান সূচক, যার ওজন বিটার মানের সাথে মেলে।