Simulation d’une variable aléatoire de loi géométrique

Introduction :

Dans cette fiche, nous allons voir comment simuler une variable aléatoire suivant une loi géométrique en langage Python.
Nous rappellerons rapidement la définition de la loi géométrique, et nous donnerons les probabilités sur un exemple.
Ensuite, nous écrirons un programme Python qui simulera un certain nombre de fois une variable aléatoire de loi géométrique et donnera les différentes fréquences obtenues, que nous confronterons au modèle théorique.

Pour revoir les différentes notions de probabilité qui vont être traitées dans cette fiche :

cours sur les lois discrètes.

Loi géométrique

On considère une épreuve de Bernoulli où la probabilité de succès est $p$ .
Soit $X$ la variable aléatoire qui donne le nombre de répétitions de l’épreuve nécessaires pour obtenir le premier succès :

si on obtient le premier succès dès la première épreuve, $X$ prendra la valeur $1$ ;
si on obtient le premier succès à la deuxième épreuve, $X$ prendra la valeur $2$ ;
et cætera.
Alors on dit que $X$ suit une loi géométrique de paramètre $p$ .

Propriété

La probabilité que $X$ prenne la valeur $k$ ( $k$ entier naturel non nul) est alors donnée par la formule :

$\text{P}(X=k)=p(1-p)^k$

Exemple

Soit $X$ une variable aléatoire qui suit la loi géométrique de paramètre $p=\frac 38$ .
Le tableau ci-dessous donne sa loi de probabilité (jusqu’à $k=15$ ) ; nous y mettons aussi les probabilités cumulées :

$\footnotesize k$	$\footnotesize 1$	$\footnotesize 2$	$\footnotesize 3$	$\footnotesize 4$	$\footnotesize 5$	$\footnotesize 6$	$\footnotesize 7$
$\footnotesize p(X=k)$	$\footnotesize 0,3750$	$\footnotesize 0,2344$	$\footnotesize 0,1465$	$\footnotesize 0,0916$	$\footnotesize 0,0572$	$\footnotesize 0,0358$	$\footnotesize 0,0224$
$\footnotesize p(X\leq k)$	$\footnotesize 0,3750$	$\footnotesize 0,6094$	$\footnotesize 0,7559$	$\footnotesize 0,8474$	$\footnotesize 0,9046$	$\footnotesize 0,9404$	$\footnotesize 0,9627$

$\footnotesize 8$	$\footnotesize 9$	$\footnotesize 10$	$\footnotesize 11$	$\footnotesize 12$	$\footnotesize 13$	$\footnotesize 14$	$\footnotesize 15$
$\footnotesize 0,0140$	$\footnotesize 0,0087$	$\footnotesize 0,0055$	$\footnotesize 0,0034$	$\footnotesize 0,0021$	$\footnotesize 0,0013$	$\footnotesize 0,0008$	$\footnotesize 0,0005$
$\footnotesize 0,9767$	$\footnotesize 0,9854$	$\footnotesize 0,9909$	$\footnotesize 0,9943$	$\footnotesize 0,9964$	$\footnotesize 0,9978$	$\footnotesize 0,9986$	$\footnotesize 0,9991$

Programme Python

Épreuve de Bernoulli

Nous avons besoin de simuler une épreuve de Bernoulli.

Nous nous servons pour cela de la fonction $\purple{\text{var\textunderscore bernou}}$ , que nous avons expliquée et programmée dans la fiche sur les variables de Bernoulli :

\begin{aligned} \textcolor{#A9A9A9}{\text{1}}&\quad\text{from random import random} \ \textcolor{#A9A9A9}{\text{2}}& \ \textcolor{#A9A9A9}{\text{3}}&\quad\text{def var\textunderscore bernou(p):} \ \textcolor{#A9A9A9}{\text{4}}&\quad\qquad\text{if random() <= p:} \ \textcolor{#A9A9A9}{\text{5}}&\quad\qquad\qquad\text{return 1} \ \textcolor{#A9A9A9}{\text{6}}&\quad\qquad\text{else:} \ \textcolor{#A9A9A9}{\text{7}}&\quad\qquad\qquad\text{return 0} \end{aligned}

if random() <= p:return 1else:return 0

Simulation d’une variable aléatoire de loi géométrique

Ici, nous allons programmer une petite fonction qui simulera une variable aléatoire qui suit une loi géométrique de paramètre $p$ .
Pour cela, nous allons faire appel à la fonction $\purple{\text{var\textunderscore bernou}}$ pour simuler la variable de Bernoulli associée, et nous le ferons tant qu’elle n’obtiendra pas un succès, c’est-à-dire tant qu’elle ne retournera pas $1$ .

Dès qu’elle l’aura obtenu, nous nous arrêterons et nous noterons le nombre de fois que l’épreuve de Bernoulli aura été répétée.
Commençons par définir la fonction $\purple{\text{geo}}$ , qui prend pour argument la probabilité de succès $\purple{\text{p}}$ .

\text{def geo(p):}

Nous avons besoin de compter le nombre de répétitions nécessaires pour obtenir un succès.
Nous initialisons pour cela un compteur $\purple{\text{E}}$ à $1$ (il faudra évidemment au moins $1$ épreuve pour obtenir un succès…) :

\text{E = 1}

Tant que nous n’aurons pas obtenu un succès, autrement dit, tant que nous obtiendrons un échec, nous répéterons l’épreuve de Bernoulli.
Nous nous servons d’une boucle $\purple{\text{while}}$ et, dans la condition, nous faisons appel à la fonction $\purple{\text{var\textunderscore bernou}}$ pour regarder s’il y a échec :

\text{while var\textunderscore bernou(p) == 0:}

Si c’est un échec, nous comptabilisons l’épreuve :

\text{E = E + 1}

Dès que c’est un succès, nous sortons de la boucle.
$\purple{\text{E}}$ contient alors le nombre d’épreuves nécessaires pour obtenir le premier succès.
Nous demandons alors à la fonction de renvoyer la valeur contenue dans $\purple{\text{E}}$ .

À retenir

La fonction est terminée :

\begin{aligned} \textcolor{#A9A9A9}{\text{9}}&\quad\text{def geo(p):} \ \textcolor{#A9A9A9}{\text{10}}&\quad\qquad\text{E = 1} \ \textcolor{#A9A9A9}{\text{11}}&\quad\qquad\text{while var\textunderscore bernou(p) == 0:} \ \textcolor{#A9A9A9}{\text{12}}&\quad\qquad\qquad\text{E = E + 1} \ \textcolor{#A9A9A9}{\text{13}}&\quad\qquad\text{return E} \end{aligned}

E = E + 1return E

Exemple

Illustrons par deux petits exemples ce qui se passe exactement.

Épreuve 1

$\purple{\text{E}}$ vaut $1$ .
$\purple{\text{var\textunderscore bernou}}$ renvoie un échec.
On incrémente $\purple{\text{E}}$ , qui vaut désormais $2$ .
Et on relance la boucle.

Épreuve 2

$\purple{\text{E}}$ vaut $2$ .
$\purple{\text{var\textunderscore bernou}}$ renvoie un échec.
On incrémente $\purple{\text{E}}$ , qui vaut désormais $3$ .
Et on relance la boucle.

Épreuve 3

$\purple{\text{E}}$ vaut $3$ .
$\purple{\text{var\textunderscore bernou}}$ renvoie un succès.
On sort de la boucle, sans incrémenter $\purple{\text{E}}$ .
$\purple{\text{E}}$ vaut alors $3$ , ce qui est bien le nombre d’épreuves nécessaires pour obtenir le premier succès.

Épreuve 1

$\purple{\text{E}}$ vaut $1$ .
$\purple{\text{var\textunderscore bernou}}$ renvoie un succès.
On n’exécute pas la boucle.
$\purple{\text{E}}$ vaut alors $1$ , on a obtenu un succès dès la première épreuve.

Fréquences d’obtention du premier succès

Maintenant que notre fonction de simulation d’une variable de loi géométrique est faite, nous allons y faire appel un certain nombre de fois, afin de la simuler à plusieurs reprises.

Nous noterons alors, à chaque simulation, si le nombre de répétitions nécessaires pour obtenir le premier succès est égal à un entier naturel $k$ donné, et nous afficherons la fréquence associée.
Nous définissons la fonction, que nous nommons $\purple{\text{freq\textunderscore geo}}$ ; elle prendra pour arguments :
la probabilité de succès $\purple{\text{p}}$ de l’épreuve de Bernoulli associée ;
le nombre $\purple{\text{k}}$ d’épreuves nécessaires pour obtenir le premier succès auquel on s’intéresse ;
le nombre $\purple{\text{r}}$ de simulations de la variable que l’on souhaite.

\text{def freq\textunderscore geo(p, k, r):}

Nous allons compter combien de fois le nombre d’épreuves nécessaires est égal à $\purple{\text{k}}$ .
Nous nous servirons pour cela d’un compteur $\purple{\text{c}}$ , que nous initialisons à $\purple{\text{0}}$ :

\text{c = 0}

Nous simulons $\purple{\text{r}}$ fois l’expérience, comme d’habitude au moyen d’un boucle $\purple{\text{for}}$ :

\text{for i in range(r):}

Nous simulons une expérience grâce à la fonction que nous avons programmée dans la partie précédente, et regardons si la valeur renvoyée (soit le nombre de répétitions nécessaires pour obtenir le premier succès) est égale à $\purple{\text{k}}$ .
Auquel cas, nous le comptabilisons en incrémentant $\purple{\text{c}}$ :

\begin{aligned} &\text{if(geo(p) == k):} \ &\qquad\text{c = c + 1} \end{aligned}

C’est la fréquence avec laquelle le premier succès a été obtenu à la $\purple{\text{k}}\text{-ième}$ épreuve qui nous intéresse.
Nous la calculons en divisant $\purple{\text{c}}$ par $\purple{\text{r}}$ , et nous l’affichons.

\begin{aligned} &\text{print($^{\backprime\backprime}$Fréquence d'obtention du premier succès à l'épreuve $^{\prime\prime}$, k, $^{\backprime\backprime}$: $^{\prime\prime}$)} \ &\text{print(c / r)} \end{aligned}

À retenir

La fonction est terminée :

X

c = 0for i in range(r):if(geo(p) == k):c = c + 1print(‵‵Freˊquence d’obtention du premier succeˋsaˋ l’eˊpreuve ′′, k, ‵‵: ′′)print(c / r)

Simulez grâce à cette fonction un grand nombre de fois ( $100\,000$ , ou carrément $1\,000\,000$ ) la variable $X$ qui suit une loi géométrique de paramètre $p=\frac 38$ , en cherchant, par exemple, la fréquence d’obtention du premier succès à l’épreuve $5$ .
Laissez tourner l’algorithme, puis comparez le résultat avec la probabilité théorique $\text{P}(X = 5)$ donnée dans le tableau de la première partie.

Vous pouvez faire de même avec $\purple{\text{k}}$ compris $1$ à $15$ , en comparant à chaque fois avec la probabilité théorique du tableau.

Attention

Si vous entrez pour paramètre de loi géométrique une très petite probabilité de succès (par exemple $0,001$ ), alors il est très probable que le programme doive répéter un grand nombre de fois l’épreuve de Bernoulli associée pour obtenir le premier succès.
Si en plus vous simulez cette variable aléatoire un grand nombre de fois, cela risque de prendre beaucoup de temps… voire d’excéder la capacité que le serveur vous alloue.

Fréquences cumulées

Pour terminer, donnons le programme qui permet de déterminer la fréquence avec laquelle le premier succès est rencontré au plus tard à l’épreuve $k$ .

Cette fréquence sera à rapprocher de la probabilité $\text{P}(X \leq k)$ .

Cette fonction Python est très proche de $\purple{\text{freq\textunderscore geo}}$ : au lieu de comptabiliser quand la fonction $\purple{\text{geo}}$ renvoie $\purple{\text{k}}$ , nous comptabiliserons à chaque fois que le résultat retourné est inférieur ou égal à $\purple{\text{k}}$ .

Nous ne la détaillons donc pas.

À retenir

Nous nommons cette fonction $\purple{\text{freq\textunderscore cum\textunderscore geo}}$ ; elle prend les mêmes arguments que $\purple{\text{freq\textunderscore geo}}$ :

\begin{aligned} \textcolor{#A9A9A9}{\text{23}}&\quad\text{def freq\textunderscore cum\textunderscore geo(p, k, r):} \ \textcolor{#A9A9A9}{\text{24}}&\quad\qquad\text{c = 0} \ \textcolor{#A9A9A9}{\text{25}}&\quad\qquad\text{for i in range(r):} \ \textcolor{#A9A9A9}{\text{26}}&\quad\qquad\qquad\text{if(geo(p) <= k):} \ \textcolor{#A9A9A9}{\text{27}}&\quad\qquad\qquad\qquad\text{c = c + 1} \ \textcolor{#A9A9A9}{\text{28}}&\quad\qquad\text{print($^{\backprime\backprime}$Fréquence d'obtention du premier succès} \ &\quad\qquad\quad\text{au plus tard à l’épreuve $^{\prime\prime}$, k, $^{\backprime\backprime}$: $^{\prime\prime}$)} \ \textcolor{#A9A9A9}{\text{29}}&\quad\qquad\text{print(c / r)} \end{aligned}

Récapitulatif

Nous rappelons ci-dessous l’ensemble des fonctions programmées dans cette fiche :

X

if random() <= p:return 1else:return 0def geo(p):E = 1while varbernou(p) == 0:E = E + 1return Edef freqgeo(p, k, r):c = 0for i in range(r):if(geo(p) == k):c = c + 1print(‵‵Freˊquence d’obtention du premier succeˋsaˋ l’eˊpreuve ′′, k, ‵‵: ′′)print(c / r)def freqcumgeo(p, k, r):c = 0for i in range(r):if(geo(p) <= k):c = c + 1print(‵‵Freˊquence d’obtention du premier succeˋsau plus tard aˋ l’eˊpreuve ′′, k, ‵‵: ′′)print(c / r)

Simulation d’une variable aléatoire de loi géométrique - Python

Loi géométrique

Programme Python

Épreuve de Bernoulli

Simulation d’une variable aléatoire de loi géométrique

Fréquences d’obtention du premier succès

Fréquences cumulées

Récapitulatif