Comment puis-je générer un Processus de Poisson?

Question Initiale:

Je veux générer un processus de Poisson. Si le nombre d'arrivées par le temps t est N(t) et j'ai une distribution de Poisson de paramètre lambda comment puis-je générer N(t)? Comment faire en C++?

Précisions:

Je voulais à l'origine de générer le processus à l'aide d'une distribution de Poisson. Mais, j'ai été confus au sujet de ce paramètre dans le processus, j'ai besoin; je pensais que je pouvais utiliser N(t) mais qui me dit combien les arrivées ont eu lieu sur l'intervalle (0,t] qui n'était pas ce que je voulais. Alors, je pensais que je pouvais utiliser N(t2)-N(t1) pour obtenir le nombre d'arrivées sur l'intervalle [t1,t2]. Depuis N(t)~Poisson(t x lambda) je pourrais utiliser Poisson(t2 x lambda)-Poisson(t1 x lambda) mais je ne veux pas le nombre d'arrivées dans l'intervalle.

Plutôt, je veux générer le temps explicites que les arrivées se produire.

Je pouvais le faire en faisant de l'intervalle [t2,t1] suffisamment petite pour que chaque intervalle a seulement une arrivée (ce qui se produit comme |t2-t1| -> 0).

OriginalL'auteur | 

  1. 2

    Voici un exemple de code pour la génération de Poisson échantillons à l'aide d' C++ TR1.

    Si vous voulez une loi de Poisson processus, le temps entre les arrivées sont exponentiellement distribués, et exponentielles des valeurs peuvent être générés trivialement par l'inverse de la CDF méthode: -k*log(u) où u est une variable aléatoire uniforme et k est la moyenne de la croissance exponentielle.

    N'est-ce pas un lien vers une distribution de Poisson, pas d'un processus de Poisson?
    Bon point. Si vous souhaitez un processus de Poisson, les temps entre les arrivées sont exponentiellement distribués, et exponentielles des valeurs peuvent être générés trivialement par l'inverse de la CDF méthode: -k*log(u) où u est une variable aléatoire uniforme et k est la moyenne de la croissance exponentielle.
    En passant, n'est pas la moyenne (à l'échelle) de la distribution exponentielle 1/k, pas k?
    Il y a deux conventions différentes pour le paramétrage de la distribution exponentielle.

    OriginalL'auteur John D. Cook

  2. 20

    Si vous avez un processus de Poisson avec un taux de paramètre L (ce qui signifie que, à long terme, il y a L des arrivées par seconde), puis l'inter-heures d'arrivée sont exponentiellement distribué avec une moyenne de 1/L. Donc, le PDF est f(t) = -L*exp(-Lt), et la CDF est F(t) = Prob(T < t) = 1 - exp(-Lt). Si votre problème devient: comment puis-je générer un nombre aléatoire t avec la distribution F(t) = 1 - \exp(-Lt)?

    En supposant que la langue que vous utilisez a une fonction (appelons rand()) pour générer des nombres aléatoires uniformément distribué entre 0 et 1, l'inverse de la CDF technique réduit à calculer: 

    -log(rand()) /L

    Que python fournit une fonction pour générer de façon exponentielle distribué des nombres aléatoires, vous pouvez simuler les 10 premiers événements dans un processus de poisson avec un averate taux de 15 arrivées par seconde comme ceci:

    import random
for i in range(1,10):
   print random.expovariate(15)

    Noter que, qui permettrait de générer de l' *inter*heures d'arrivée. Si vous vouliez que les heures d'arrivée, vous devez tenir le déplacement d'un temps variable comme ceci:

    import random
t= 0
for i in range(1,10):
   t+= random.expovariate(15)
   print t
    Assurez-vous de ne pas prendre de journal de 0 lors du calcul de log(rand()). Un truc commun est de calculer log(1.0 - rand()) au lieu de cela, comme rand() généralement renvoie un nombre, qui est inférieur à 1.

    OriginalL'auteur

  3. 3

    Je serais très prudent sur l'utilisation de l'inverse de la CDF et de pompage d'un nombre aléatoire uniforme à travers elle. Le problème ici est que, souvent, l'inverse de la CDF est numériquement instable ou les fonctions pour produire, il peut donner des fluctuations indésirables près des extrémités de l'intervalle. Pour cette raison, je recommande quelque chose comme le rejet de la méthode utilisée dans "Numerical Recipes in C". Voir la poidev fonction donnée dans ch 7.3 du CNRC: http://www.nrbook.com/a/bookcpdf/c7-3.pdf

    Le lien pointe vers un fichier pdf vide. J'ai la version C++ (v3 je crois) et il ne comprend même pas une loi de Poisson s'écarter. Mais, ma compréhension est que le dévie sont des échantillons de la distribution qui laisse-moi où j'ai commencé.

    OriginalL'auteur

  4. 1

    Afin de choisir un échantillon à partir d'une distribution, vous devez calculer l'inverse de la fonction de répartition cumulative (CDF). Vous choisissez d'abord un nombre aléatoire uniformément sur le réel de l'intervalle [0, 1], et ensuite prendre l'inverse de la CDF de cette valeur.

    Merci mes pensées étaient seulement ça, mais je me sentais bizarre depuis le cdf génère N(t) mais pas t. Et, je ne sais pas la manière correcte de l'échantillon à partir de N(t) pour obtenir un processus de Poisson. Qu'advient-il si je ne suis pas d'échantillon de manière uniforme à partir de la CDF (ça va encore être un processus de Poisson)?
    L'inversion de la CDF d'une loi de Poisson n'est pas facile ou plus efficace. Pour une approche plus efficace, voir Corwin du lien ou voir ma réponse sur la façon d'utiliser le C++ TR1.

    OriginalL'auteur Adam Rosenfield

  5. 1

    Si vous êtes à l'aide de python, vous pouvez utiliser aléatoire.expovariate(taux) afin de générer de l'heure d'arrivée des taux d'événements par intervalle de temps

    OriginalL'auteur

  6. 0

    De la discussion ici tous les détails au sujet en utilisant l'inverse de l'échantillonnage pour générer des inter-arrivées, ce qui est généralement ce que les gens veulent faire de jeux.

    https://stackoverflow.com/a/15307412/1650437

    OriginalL'auteur

  7. 0

    En python, vous pouvez essayer de code ci-dessous.

    Si vous voulez générer de manière aléatoire 20 lectures en 60 secondes. ie (20) est le lambda)

     def poisson_job_generator():
    rateParameter = 1.0/float(60/20) 
    while True:
        sl = random.expovariate(rateParameter)

    OriginalL'auteur

  8. 0

    Générer des temps d'arrivée via un Processus de Poisson ne veut pas dire à l'aide d'une distribution de Poisson. Il est fait par la création d'une distribution exponentielle basé sur la loi de Poisson taux d'arrivée des lamda.

    En bref, vous avez besoin de générer une distribution exponentielle avec une moyenne = 1/lamda, voir l'exemple suivant: 

    #include <iostream>
#include <iterator>
#include <random>

int
main ()
{
 //seed the RNG
 std::random_device rd; //uniformly-distributed integer random number generator
 std::mt19937 rng (rd ()); //mt19937: Pseudo-random number generation

 double averageArrival = 15;
 double lamda = 1 /averageArrival;
 std::exponential_distribution<double> exp (lamda);

double sumArrivalTimes=0;
double newArrivalTime;


 for (int i = 0; i < 10; ++i)
  {
   newArrivalTime=  exp.operator() (rng); //generates the next random number in the distribution 
   sumArrivalTimes  = sumArrivalTimes + newArrivalTime;  
   std::cout << "newArrivalTime:  " << newArrivalTime  << "    ,sumArrivalTimes:  " << sumArrivalTimes << std::endl;  
  }

}

    Le résultat de l'exécution de ce code: 

    newArrivalTime:  21.6419    ,sumArrivalTimes:  21.6419
newArrivalTime:  1.64205    ,sumArrivalTimes:  23.2839
newArrivalTime:  8.35292    ,sumArrivalTimes:  31.6368
newArrivalTime:  1.82962    ,sumArrivalTimes:  33.4665
newArrivalTime:  34.7628    ,sumArrivalTimes:  68.2292
newArrivalTime:  26.0752    ,sumArrivalTimes:  94.3045
newArrivalTime:  63.4728    ,sumArrivalTimes:  157.777
newArrivalTime:  3.22149    ,sumArrivalTimes:  160.999
newArrivalTime:  1.64637    ,sumArrivalTimes:  162.645
newArrivalTime:  13.8235    ,sumArrivalTimes:  176.469

    sur la base de votre expérience, vous pouvez soit utiliser: newArrivalTime ou sumArrivalTimes.

    ref: http://www.math.wsu.edu/faculty/genz/416/lect/l05-45.pdf

    OriginalL'auteur