Tout sur le schéma de Bernoulli en Python. Cours de maths

Introduction :

Dans cette fiche, nous allons voir comment simuler une variable aléatoire suivant une loi de Bernoulli en langage Python. Pour cela, nous allons nous servir d’une fonction Python qui simule une variable aléatoire qui suit la loi uniforme sur $[0\ ;\, 1]$ .
Cela fait, nous écrirons un programme Python qui simulera une variable aléatoire comptant le nombre de succès obtenus lors de la répétition d’une épreuve de Bernoulli. Et nous simulerons la loi de probabilité de cette variable aléatoire, pour la rapprocher de la loi binomiale.

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

cours sur les lois discrètes ;
cours sur les lois à densité.

Simulation d’une variable de Bernoulli

Loi uniforme sur $[0\ ;\, 1]$

Soit $Y$ une variable aléatoire qui suit la loi uniforme sur $[0\ ;\, 1]$ .
Nous savons alors que :

la densité de probabilité de $Y$ est la fonction constante $f$ définie sur $[0\ ;\, 1]$ par :

$f(x)=1$

la fonction de répartition est la fonction $F$ définie sur $\mathbb R$ par :

$\begin{cases} F(x)=0 &\textcolor{#A9A9A9}{\text{si $x < 0$}} \ F(x)=x &\textcolor{#A9A9A9}{\text{si $x\in[0\ ;\, 1]$}} \ F(x)=1 &\textcolor{#A9A9A9}{\text{si $x > 0$}} \end{cases}$

Ainsi, pour tout $p\in [0\ ;\, 1]$ :

$\text{P}(X \leq p)=p$

À retenir

En Python, pour simuler la loi uniforme sur $[0\ ;\, 1]$ , nous utilisons la fonction $\purple{\text{random()}}$ – qui ne prend pas d’arguments –, disponible dans le module $\purple{\text{random}}$ .

Cette fonction prendra un nombre au hasard dans l’intervalle $[0\ ;\, 1[$ .
$1$ est exclu, mais ce n’est pas gênant puisque nous travaillons avec une variable aléatoire continue :

$\text{P}(0\leq Y \leq 1)= \text{P}(0\leq Y < 1)=1$

Ainsi, la probabilité que le nombre renvoyé par $\purple{\text{random()}}$ soit inférieur ou égal à un réel $p$ est égale à $p$ .

C’est exactement ce dont nous avons besoin pour simuler une variable aléatoire $X$ qui suit la loi de Bernoulli de paramètre $p$ !

En effet, nous considérons que :

la probabilité que $\purple{\text{random()}}$ renvoie un nombre compris entre $0$ et $p$ est égale à $p$ ,
c’est alors un succès et $X$ prend la valeur $1$ ;
la probabilité que $\purple{\text{random()}}$ renvoie un nombre compris entre $p$ et $1$ est égale à $1-p$ ,
c’est alors un échec et $X$ prend la valeur $0$ .

Astuce

Considérons une variable aléatoire qui suit la loi de Bernoulli de paramètre $0,5$ . Autrement dit, la probabilité d’obtenir un succès est égale à la probabilité d’obtenir un échec, soit $0,5$ .

On peut alors faire appel à la fonction $\purple{\text{randint(0,1)}}$ , aussi disponible dans le module $\purple{\text{random}}$ .

Celle-ci choisira au hasard un entier compris entre $0$ et $1$ , soit $0$ ou $1$ .

C’est d’ailleurs cela que nous faisons dans l’algorithme qui simule une planche de Galton.

Programme Python

Nous allons ici écrire un programme Python, qui simulera une variable suivant une loi de Bernoulli de paramètre $p$ .

Elle retournera $1$ avec une probabilité $p$ , et $0$ avec une probabilité $1-p$ .
Nous commençons par importer la fonction $\purple{\text{random()}}$ :

\text{from random import random}

Nous créons la fonction $\purple{\text{var\textunderscore bernou}}$ , qui prend donc en argument un nombre $\purple{\text{p}}$ compris entre $0$ et $1$ .

\text{def var\textunderscore bernou(p):}

Nous exécutons la fonction $\purple{\text{random}}$ et considérons le cas où le nombre renvoyé est inférieur à $\purple{\text{p}}$ .
Si c’est le cas, il s’agit d’un succès, et la fonction $\purple{\text{var\textunderscore bernou}}$ renvoie $\purple{\text{1}}$ .

\begin{aligned} &\text{if random() <= p} \ &\qquad\text{return 1} \end{aligned}

On s’intéresse au cas contraire, c’est-à-dire lorsque le nombre renvoyé par $\purple{\text{random()}}$ est supérieur à $\purple{\text{p}}$ .
Il s’agit alors d’un échec, et la fonction renvoie $\purple{\text{0}}$ .

\begin{aligned} &\text{else} \ &\qquad\text{return 0} \end{aligned}

À retenir

La fonction est terminée :

\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

Nombre de succès dans un schéma de Bernoulli

Prérequis

Nous nous intéressons maintenant à une variable aléatoire $X$ qui donne le nombre de succès obtenus lors de $n$ répétitions identiques et indépendante d’une épreuve de Bernoulli, où la probabilité de succès est $p$ .

Nous allons nous servir de la fonction Python précédente pour simuler cette variable aléatoire.

Le principe est simple.

Nous allons simuler une épreuve de Bernoulli répétée $n$ fois, de manière identique et indépendante.
Nous compterons au fur et à mesure le nombre de succès obtenus.
Il s’agit donc simplement de faire appel à la fonction $\purple{\text{var\textunderscore bernou}}$ $n$ fois, et d’ajouter au fur et à mesure la valeur qu’elle renvoie.

Programme Python

Commençons par définir notre fonction $\purple{\text{nb\textunderscore succes}}$ , qui prend en paramètres :
le nombre de fois $\purple{\text{n}}$ que l’on répète l’épreuve de Bernoulli ;
la probabilité de succès $\purple{\text{p}}$ dans l’épreuve de Bernoulli.

\text{def nb\textunderscore succes(n, p):}

Nous allons compter le nombre de succès. Nous initialisons une variable $\purple{\text{S}}$ à $\purple{\text{0}}$ .
C’est cette variable qui sera incrémentée à chaque fois que l’on obtiendra un succès.

\text{S = 0}

Nous répétons $\purple{\text{n}}$ fois l’épreuve.
Nous créons donc une boucle $\purple{\text{for}}$ qui s’exécutera $\purple{\text{n}}$ fois :

\text{for i in range(1, n + 1):}

À chaque boucle, nous faisons appel à la fonction $\purple{\text{var\textunderscore bernou}}$ . Et nous ajoutons son résultat à $\purple{\text{S}}$ :
si on a obtenu un succès, $\purple{\text{var\textunderscore bernou}}$ renvoie $1$ , et nous comptabilisons donc bien ce succès dans $\purple{\text{S}}$ ;
si on a obtenu un échec, $\purple{\text{var\textunderscore bernou}}$ renvoie $0$ , et $\purple{\text{S}}$ ne sera pas modifié.

\text{S = S + var\textunderscore bernou(p)}

Au sortir de la boucle, $\purple{\text{S}}$ contiendra donc le nombre de succès obtenus après la répétition des $\purple{\text{n}}$ épreuves.
Nous demandons à la fonction de retourner sa valeur :

\text{return S}

À retenir

La fonction est terminée :

\begin{aligned} \textcolor{#A9A9A9}{\text{9}}&\quad\text{def nb\textunderscore succes(n, p):} \ \textcolor{#A9A9A9}{\text{10}}&\quad\qquad\text{S = 0} \ \textcolor{#A9A9A9}{\text{11}}&\quad\qquad\text{for i in range(1, n + 1):} \ \textcolor{#A9A9A9}{\text{12}}&\quad\qquad\qquad\text{S = S + var\textunderscore bernou(p)} \ \textcolor{#A9A9A9}{\text{13}}&\quad\qquad\text{return S} \end{aligned}

Fréquence des succès

Loi binomiale

La variable aléatoire $X$ que nous avons définie dans la deuxième partie suit une loi binomiale de paramètres $n$ et $p$ .
L’objectif de cette dernière partie est de simuler, par une fonction Python, la variable aléatoire un grand nombre de fois, de noter à chaque expérience le nombre de succès obtenus, puis d’en calculer la fréquence.

Nous confronterons alors les résultats donnés par le programme avec le modèle théorique.

Donnons d’ailleurs déjà le modèle théorique pour $X$ , une variable aléatoire qui suit la loi binomiale de paramètres $n=9$ et $p=\frac 38$ .
Pour déterminer sa loi de probabilité, nous pouvons nous servir de notre calculatrice, d’un tableur, ou tout simplement calculer les probabilités avec la formule apprise en cours.

Pour tout $k\in \lbrace 0,\,1,\,2,\,…,\,8,\,9\rbrace$ :

$\text{P}(X=k)=\begin{pmatrix} 9 \ k \end{pmatrix}\times \left(\dfrac 38\right)^k\times \left(\dfrac 58\right)^{9-k}$

Nous obtenons, en arrondissant à $10^{-4}$ près :

$\scriptsize k$	$\scriptsize 0$	$\scriptsize 1$	$\scriptsize 2$	$\scriptsize 3$	$\scriptsize 4$	$\scriptsize 5$	$\scriptsize 6$	$\scriptsize 7$	$\scriptsize 8$	$\scriptsize 9$
$\scriptsize \text P(X=k)$	$\scriptsize 0,0146$	$\scriptsize 0,0786$	$\scriptsize 0,1886$	$\scriptsize 0,2640$	$\scriptsize 0,2376$	$\scriptsize 0,1426$	$\scriptsize 0,0570$	$\scriptsize 0,0147$	$\scriptsize 0,0022$	$\scriptsize 0,0001$

Fonction Python

Nous commençons par définir notre fonction $\purple{\text{freq\textunderscore succes}}$ , qui prend pour arguments :
le nombre $\purple{\text{n}}$ de répétitions de l’épreuves de Bernoulli (supérieur ou égal à $1)$ ;
la probabilité $\purple{\text{p}}$ de succès (comprise entre $0$ et $1$ ) ;
le nombre $\purple{\text{r}}$ de fois que nous souhaitons simuler l’expérience.

\text{def freq\textunderscore succes(n, p, r):}

Pour compter combien de fois le nombre de succès obtenus est égal à $k$ (compris entre $0$ et $n$ ) parmi les $\purple{\text{r}}$ simulations, nous utilisons une liste $\purple{\text{L}}$ de $n+1$ éléments.

Ainsi :

l’élément $0$ de la liste ( $\purple{\text{L$ ) contiendra le nombre de fois qu’on a obtenu $0$ succès ;
l’élément $1$ de la liste ( $\purple{\text{L$ ) contiendra le nombre de fois qu’on a obtenu $1$ succès ;
l’élément $2$ de la liste ( $\purple{\text{L$ ) contiendra le nombre de fois qu’on a obtenu $2$ succès ;
et cætera.
Bien sûr, nous initialisons chaque élément à $0$ :

\text{L = [0 for i in range(n + 1)]}

Nous souhaitons simuler $\purple{\text{r}}$ fois l’expérience.
Nous nous servons d’une boucle $\purple{\text{for}}$ :

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

Nous faisons appel à la fonction $\purple{\text{nb\textunderscore succes}}$ que nous avons programmée dans la deuxième partie.
Celle-ci simule donc la répétition de $\purple{\text{n}}$ épreuves de Bernoulli, et donne en retour le nombre de succès obtenus, que nous stockons dans la variable $\purple{\text{S}}$ :

\text{S = nb\textunderscore succes(n, p)}

Le nombre de succès obtenus lors de la simulation est $\purple{\text{S}}$ .
Nous incrémentons donc $\purple{\text{L[S]}}$ , pour indiquer qu’on obtenu une fois supplémentaire ce nombre de succès :

\text{L[S] = L[S] + 1}

Ce qui nous intéresse, c’est, après les $\purple{\text{r}}$ simulations, la fréquence d’obtention de $k$ succès, pour $k$ compris entre $0$ et $\purple{\text{n}}$ .
Pour bien le rappeler, nous indiquons que ce sont les fréquences qui sont données ;

\text{print($^{\backprime\backprime}$Fréquences obtenues :$^{\prime\prime}$)}

Pour obtenir ces fréquences, nous allons parcourir la liste $\purple{\text{L}}$ , toujours au moyen d’une boucle $\purple{\text{for}}$ :

\text{for k in range(n + 1):}

Nous calculons tout simplement chacune des fréquences en prenant le quotient du nombre de fois que $\purple{\text{k}}$ succès ont été obtenus (contenu dans $\purple{\text{L[k]}}$ ), par le nombre $\purple{\text{r}}$ de simulations.

\text{print(k, $^{\backprime\backprime}$succès : $^{\prime\prime}$, L[k] / r)}

À retenir

La fonction est terminée :

\begin{aligned} \textcolor{#A9A9A9}{\text{15}}&\quad\text{def freq\textunderscore succes(n, p, r):} \ \textcolor{#A9A9A9}{\text{16}}&\quad\qquad\text{L = [0 for i in range(n + 1)]} \ \textcolor{#A9A9A9}{\text{17}}&\quad\qquad\text{for j in range(r):} \ \textcolor{#A9A9A9}{\text{18}}&\quad\qquad\qquad\text{S = nb\textunderscore succes(n, p)} \ \textcolor{#A9A9A9}{\text{19}}&\quad\qquad\qquad\text{L[S] = L[S] + 1} \ \textcolor{#A9A9A9}{\text{20}}&\quad\qquad\text{print($^{\backprime\backprime}$Fréquences obtenues :$^{\prime\prime}$)} \ \textcolor{#A9A9A9}{\text{21}}&\quad\qquad\text{for k in range(n + 1):} \ \textcolor{#A9A9A9}{\text{22}}&\quad\qquad\qquad\text{print(k, $^{\backprime\backprime}$succès : $^{\prime\prime}$, L[k] / r)} \end{aligned}

Vous pouvez maintenant exécuter cette fonction, pour la variable aléatoire définie dans la partie précédente, qui suit une loi binomiale de paramètres $n=9$ et $p=\frac 38$ . Simulez, pour commencer, un nombre raisonnable de fois l’expérience, afin de vérifier que tout fonctionne bien. Puis simulez-la $1\,000\,000$ de fois (en laissant le temps au programme d’exécuter ses multiples boucles – moins d’une dizaine de secondes, normalement).

Comparez les résultats obtenus avec la loi de probabilité que nous avons donnée.

Récapitulatif

Pour terminer, nous rappelons ci-dessous l’ensemble des fonctions programmées dans ce cours.

\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} \\ \textcolor{#A9A9A9}{\text{8}}& \\ \textcolor{#A9A9A9}{\text{9}}&\quad\text{def nb\textunderscore succes(n, p):} \\ \textcolor{#A9A9A9}{\text{10}}&\quad\qquad\text{S = 0} \\ \textcolor{#A9A9A9}{\text{11}}&\quad\qquad\text{for i in range(1, n + 1):} \\ \textcolor{#A9A9A9}{\text{12}}&\quad\qquad\qquad\text{S = S + var\textunderscore bernou(p)} \\ \textcolor{#A9A9A9}{\text{13}}&\quad\qquad\text{return S} \\ \textcolor{#A9A9A9}{\text{14}}& \\ \textcolor{#A9A9A9}{\text{15}}&\quad\text{def freq\textunderscore succes(n, p, r):} \\ \textcolor{#A9A9A9}{\text{16}}&\quad\qquad\text{L = [0 for i in range(n + 1)]} \\ \textcolor{#A9A9A9}{\text{17}}&\quad\qquad\text{for j in range(r):} \\ \textcolor{#A9A9A9}{\text{18}}&\quad\qquad\qquad\text{S = nb\textunderscore succes(n, p)} \\ \textcolor{#A9A9A9}{\text{19}}&\quad\qquad\qquad\text{L[S] = L[S] + 1} \\ \textcolor{#A9A9A9}{\text{20}}&\quad\qquad\text{print($^{\backprime\backprime}$Fréquences obtenues :$^{\prime\prime}$)} \\ \textcolor{#A9A9A9}{\text{21}}&\quad\qquad\text{for k in range(n + 1):} \\ \textcolor{#A9A9A9}{\text{22}}&\quad\qquad\qquad\text{print(k, $^{\backprime\backprime}$succès : $^{\prime\prime}$, L[k] / r)} \end{aligned}

Simulation d'une variable de Bernoulli et schéma de Bernoulli - Python

Simulation d’une variable de Bernoulli

Loi uniforme sur [0 ; 1][0\ ;\, 1][0 ;1]

Programme Python

Nombre de succès dans un schéma de Bernoulli

Prérequis

Programme Python

Fréquence des succès

Loi binomiale

Fonction Python

Récapitulatif

Loi uniforme sur $[0\ ;\, 1]$