Scelta ponderata breve e semplice

Question

Se ho una collezione di elementi in una lista. Voglio scegliere da quella lista secondo un'altra lista di pesi.

Ad esempio, la mia collezione è ['one', 'two', 'three'] ei pesi sono [0.2, 0.3, 0.5], mi aspetto che il metodo mi dia "tre" in circa la metà di tutti i disegni.

Qual è il modo più semplice per farlo?

Answer 1

Questa funzione richiede due argomenti: un elenco di pesi e una lista contenente gli oggetti da scegliere:

from numpy import cumsum 
from numpy.random import rand 
def weightedChoice(weights, objects): 
    """Return a random item from objects, with the weighting defined by weights 
    (which must sum to 1).""" 
    cs = cumsum(weights) #An array of the weights, cumulatively summed. 
    idx = sum(cs < rand()) #Find the index of the first weight over a random value. 
    return objects[idx] 

non fa uso di alcun loop pitone.

Answer 2

Se non si desidera utilizzare numpy, è possibile seguire lo stesso metodo con qualcosa di simile:

from random import random 
from itertools import takewhile 

def accumulate(iterator): 
    """Returns a cumulative sum of the elements. 
    accumulate([1, 2, 3, 4, 5]) --> 1 3 6 10 15""" 
    current = 0 
    for value in iterator: 
     current += value 
     yield current 

def weightedChoice(weights, objects): 
    """Return a random item from objects, with the weighting defined by weights 
    (which must sum to 1).""" 
    limit = random() 
    return objects[sum(takewhile(bool, (value < limit for value in accumulate(weights))))] 

Usiamo itertools.takewhile() per evitare il controllo dei valori una volta che arriviamo al punto vogliamo fermare, in caso contrario, questa è essenzialmente la stessa idea di Mischa Obrecht's answer, solo senza numpy.

Answer 3

È possibile utilizzare l'multinomial distribution (da NumPy) per fare quello che vuoi. Per esempio.

elements = ['one', 'two', 'three'] 
weights = [0.2, 0.3, 0.5] 


import numpy as np 

indices = np.random.multinomial(100, weights, 1) 
#=> array([[20, 32, 48]]), YMMV 

results = [] #A list of the original items, repeated the correct number of times. 
for i, count in enumerate(indices[0]): 
    results.extend([elements[i]]*count) 

Così l'elemento in prima posizione si avvicinò 20 volte, l'elemento in seconda posizione si avvicinò 32 volte, e l'elemento in terza posizione si avvicinò 48 volte, più o meno quello che ci si aspetterebbe data i pesi.

Se hai difficoltà a comprendere la distribuzione multinomiale, ho trovato il documentation davvero utile.

Answer 4

su cui costruire Maus' answer, che è grande se si vuole ottenere ripetutamente valori casuali ponderati, se si voleva solo un singolo valore, si può fare questo in modo molto semplice, combinando numpy.random.multinomial() e itertools.compress():

from itertools import compress 
from numpy.random import multinomial 

def weightedChoice(weights, objects): 
    """Return a random item from objects, with the weighting defined by weights 
    (which must sum to 1).""" 
    return next(compress(objects, multinomial(1, weights, 1)[0])) 

Answer 5

Come sull'inizializzazione dell'elenco solo per abbinare le tue scelte con i pesi previsti. Qui sto facendo una lista di 100 valori che rappresentano la percentuale desiderata di "pull".

>>> import random 
>>> elements = ['one', 'two', 'three'] 
>>> weights = [0.2, 0.3, 0.5] 
>>> 
>>> # get "sum" of result list of lists (flattens list) 
>>> choices = sum([[element] * int(weight * 100)for element, weight in zip(elements, weights)], []) 
>>> random.choice(choices) 
three 

Non è cumulativo, ma sembra che potrebbe essere quello che cercate.

Answer 6

Dal numpy versione 1.7 è possibile utilizzare numpy.random.choice():

elements = ['one', 'two', 'three'] 
weights = [0.2, 0.3, 0.5] 

from numpy.random import choice 
print(choice(elements, p=weights)) 

Answer 7

Dal Python 3.6, si può fare ponderata scelta casuale (con sostituzione) utilizzando random.choices.

casuale.scelte (popolazione, pesi = None, *, cum_weights = Nessuno, k = 1) utilizzo

Esempio:

import random 
random.choices(['one', 'two', 'three'], [0.2, 0.3, 0.5], k=10) 
# ['three', 'two', 'three', 'three', 'three', 
# 'three', 'three', 'two', 'two', 'one']