Générer des variables aléatoires Discrètes avec des poids à l'aide de SciPy ou NumPy

Je suis à la recherche d'une simple fonction qui permet de générer un tableau de certaines valeurs aléatoires basés sur leur correspondant (également spécifié) des probabilités. J'ai seulement besoin de générer des valeurs float, mais je ne vois pas pourquoi il ne devrait pas être en mesure de générer une fonction scalaire. Je peux penser à de nombreux moyens de ce bâtiment de fonctions existantes, mais je pense que j'ai probablement raté un évident SciPy ou de fonction NumPy.

E. g.:

>>> values = [1.1, 2.2, 3.3]
>>> probabilities = [0.2, 0.5, 0.3]
>>> print some_function(values, probabilities, size=10)
(2.2, 1.1, 3.3, 3.3, 2.2, 2.2, 1.1, 2.2, 3.3, 2.2)

Remarque: j'ai trouvé scipy.les stats.rv_discrete mais je ne comprends pas comment il fonctionne. Plus précisément, je ne comprends pas ce que cette (ci-dessous) moyens, ni ce qu'il doit faire:

numargs = generic.numargs
[ <shape(s)> ] = ['Replace with resonable value', ]*numargs

Si rv_discrete est ce que je devrais être à l'aide, pourriez-vous svp me fournir un exemple et une explication de l'au-delà "forme" déclaration?

InformationsquelleAutor TimY | 2012-07-07
  1. 59

    Dessin à partir d'une distribution discrète est directement intégré dans numpy.
    La fonction est appelée aléatoire.choix (difficile à trouver sans aucune référence à des distributions dans les numpy docs). 

    elements = [1.1, 2.2, 3.3]
probabilities = [0.2, 0.5, 0.3]
np.random.choice(elements, 10, p=probabilities)
    • Super! Mais, la syntaxe correcte est: np.aléatoire.choix(éléments, 10, p=list(probabilités))
    • Nice. Je pense que cette version est sorti après que j'ai posté ma question d'origine (je pense que cela a été tout d'abord publié dans la version 1.7.0 qui, je crois, est venu en 2013).
    • Très sympa! Semble fonctionner également sans casting de la liste: np.aléatoire.choix(éléments, 10, p=probabilité)).
    • En plus des commentaires par Sina et zeycus, elements et probabilites aurait pu être ordinaire lists au lieu de numpy.arrays et le code devrait fonctionner de la même.
    InformationsquelleAutor goebbe
  2. 25

    Voici un court, relativement simple fonction qui retourne des valeurs pondérées, il utilise NumPy est digitize, accumulate, et random_sample. 

    import numpy as np
from numpy.random import random_sample

def weighted_values(values, probabilities, size):
    bins = np.add.accumulate(probabilities)
    return values[np.digitize(random_sample(size), bins)]

values = np.array([1.1, 2.2, 3.3])
probabilities = np.array([0.2, 0.5, 0.3])

print weighted_values(values, probabilities, 10)
#Sample output:
[ 2.2  2.2  1.1  2.2  2.2  3.3  3.3  2.2  3.3  3.3]

    Il fonctionne comme ceci:

    1. La première utilisation de accumulate nous créer des bacs.
    2. Ensuite, nous créons un tas de nombres aléatoires (entre 0, et 1) à l'aide de random_sample
    3. Nous utilisons digitize de voir les poubelles de ces chiffres tombent.
    4. Et retourner les valeurs correspondantes.
    • Oui c'est en gros ce que je pensais, mais j'ai juste pensé il y a peut être une fonction intégrée qui fait exactement cela. À partir du son de celui-ci, il n'y a pas une telle chose. Je dois avouer que je ne l'ai pas fait avec autant d'élégance. - Merci
    • NumPy offre directement numpy.cumsum(), qui peut être utilisé à la place de np.add.accumulate() (np.add() n'est pas très couramment utilisé, donc je recommande d'utiliser cumsum()).
    • +1 pour la durée de numpy.digitize()! Cependant, SciPy offre en fait une fonction qui répond directement à la question—voir ma réponse.
    • PS:... Comme l'a noté Tim_Y, à l'aide de la fonction SciPy est beaucoup plus lent que d'utiliser votre "manuel" de la solution (sur 10k éléments).
    • Ne les probabilités doivent être normalisées pour cela ?
    • Oui, les probabilités ne doivent être normalisées, parce que random_sample() renvoie des nombres dans [0; 1), de sorte que les bacs ne peuvent se prolonger au-delà de cette plage (si les probabilités serait somme supérieure à 1).

    InformationsquelleAutor fraxel
  3. 15

    Vous allez dans la bonne direction: intégré scipy.stats.rv_discrete() assez crée directement une variable aléatoire discrète. Voici comment cela fonctionne:

    >>> from scipy.stats import rv_discrete  

>>> values = numpy.array([1.1, 2.2, 3.3])
>>> probabilities = [0.2, 0.5, 0.3]

>>> distrib = rv_discrete(values=(range(len(values)), probabilities))  # This defines a Scipy probability distribution

>>> distrib.rvs(size=10)  # 10 samples from range(len(values))
array([1, 2, 0, 2, 2, 0, 2, 1, 0, 2])

>>> values[_]  # Conversion to specific discrete values (the fact that values is a NumPy array is used for the indexing)
[2.2, 3.3, 1.1, 3.3, 3.3, 1.1, 3.3, 2.2, 1.1, 3.3]

    La distribution distrib ci-dessus revient donc index de la values liste.

    Plus généralement, rv_discrete() prend une séquence de entier valeurs dans les premiers éléments de son values=(…,…) argument, et renvoie ces valeurs, dans ce cas, il n'est pas nécessaire de convertir spécifiques (float) les valeurs. Voici un exemple:

    >>> values = [10, 20, 30]
>>> probabilities = [0.2, 0.5, 0.3]
>>> distrib = rv_discrete(values=(values, probabilities))
>>> distrib.rvs(size=10)
array([20, 20, 20, 20, 20, 20, 20, 30, 20, 20])

    où (entier) valeurs d'entrée sont directement retournées à la bonne probabilité.

    • NOTE: j'ai essayé de courir timeit sur elle, et il semble être un bon 100x plus lent que le fraxel est purement numpy version. Avez-vous, par hasard, sais pourquoi c'est?
    • Wow, intéressant! Sur 10k éléments, j'ai même un facteur de 300x plus lent. J'ai eu un coup d'oeil sur le code: il y a beaucoup de contrôles effectués, mais je suppose qu'ils ne peuvent pas expliquer cette énorme différence dans la course du temps, je ne voulais pas aller assez profondément dans le Scipy code pour avoir été en mesure de voir où la différence pourrait provenir de...
    • mon naïf pense que la lenteur est due à plus de travail qui se fait en pur Python, moins de travail effectué (sous le capot) en C. (les mathématiques, sciences paquets Python ont tendance à envelopper le code C.)
    • supposons que je commencer avec une équation pour ma distribution de probabilité. il semble ridicule d'avoir à l'utiliser pour générer une probabilité pour chaque valeur, les nourrir que de rv_discrete, et puis revenir de rv_discrete une approximation de la distribution, j'ai commencé avec. est-il possible d'utiliser de l'utilisateur défini par les équations directement avec scipy?
    • Je suppose que votre équation modèles d'un continue variable aléatoire, au lieu d'un discret (qui est le sujet de cette question), donc passer par une variable discrète peut en effet pas être possible (sauf si l'approximation d'une distribution discrète vous aide à obtenir plus rapidement de l'exécution de code). Vous voudrez peut-être regarder comment SciPy gère les variables continues, par exemple à partir de scicomp.stackexchange.com/a/1659/9996.
    • nope, je suis à l'aide d'une variable aléatoire discrète. je ne sais pas pourquoi vous pensez que je ne suis pas. il s'avère que je suis en utilisant une variable aléatoire de Poisson, et il y a une fonction dans numpy pour le prélèvement d'échantillons à partir d'une distribution de Poisson (np.random.poisson). la même, je suis sûr que c'est vrai de la plupart des distributions. ma question reste sans réponse, bien que, pour les plus idiosyncrasiques des distributions.
    • Maintenant, je vois que vous avez eu à l'esprit le cas d'une distribution discrète avec un infini nombre de valeurs possibles (qui ne rentre pas dans cette question). rv_discrete() n'a pas une option pour cela. Je ne suis pas sûr de ce que la méthode pour ce faire est. (Je ne peux que penser un peu compliqué les variations de la méthode habituelle qui transforme une variable aléatoire uniforme dans une variable avec une distribution non uniforme, où la probabilité cumulative est calculée uniquement pour les valeurs les plus courantes et prolongée au-delà qu'en cas de besoin.)

    InformationsquelleAutor Eric O Lebigot
  4. 4

    Vous pouvez également utiliser Lea, un pur Python package dédié à des distributions de probabilité.

    >>> distrib = Lea.fromValFreqs((1.1,2),(2.2,5),(3.3,3))
>>> distrib
1.1 : 2/10
2.2 : 5/10
3.3 : 3/10
>>> distrib.random(10)
(2.2, 2.2, 1.1, 2.2, 2.2, 2.2, 1.1, 3.3, 1.1, 3.3)

    Et voilà!

    InformationsquelleAutor Pierre Denis
  5. 3

    La plus simple de BRICOLAGE solution serait que la somme des probabilités dans une distribution cumulée.
    De cette façon, vous divisez l'unité de l'intervalle en sous-intervalles de longueur égale à l'original de votre probabilités. Maintenant générer un seul nombre aléatoire uniforme sur [0,1), et de et de voir à quel intervalle les terres.

    InformationsquelleAutor ev-br