Algorithmique : Loi Binomiale

Détails

Vote utilisateur: 5 / 5

Etoiles activesEtoiles activesEtoiles activesEtoiles activesEtoiles actives
 

Algorithmique - Loi binomiale

1. Loi de bernoulli

Une variable aléatoire suivant la loi de Bernoulli est appelée variable de Bernoulli, du nom du mathématicien suisse Jacques Bernoulli (1654-1705).

La loi de Bernoulli est la loi de la variable aléatoire qui modélise le résultat d'une épreuve qui n'admet que deux issues (épreuve de Bernoulli) : 1 pour « succès », 0 pour « échec ».

On note généralement \(p\) la probabilité du succès (soit d'obtenir 1) et donc \(1-p\) celle d'obtenir 0 (échec). Donc si la variavle aléatoire \(X\) suit une loi de Bernoulli de paramètre \(p\) on a :

$$P(X=k) = \left\lbrace \begin{array}{ll} p~~~~&\text{si}~~k=1\\1-p~~~~&\text{si}~~k=0\\0~~~~&\text{sinon} \end{array}\right.$$

  • Exercice 1 : fonction bernoulli(p)
    Ecrire une fonction bernoulli(p) qui renvoie 0 ou 1 avec la probabilité \(p\).
from random import *

# Le module random est un module qui regroupe des fonctions permettant de simuler le hasard. Pour pouvoir l'utiliser, il faut l'importer pour le mettre en mémoire. Donc dès qu'on voudra utiliser les fonctions qui suivent pour simuler le hasard, on devra mettre en entête la commande from random import *.

# random() : Donne un flottant au hasard dans l'intervalle [0 ; 1[.
# uniform(a,b) : Donne un flottant au hasard entre a et b. 

# Ecrire une fonction bernoulli(p) qui renvoie 0 ou 1 avec la probabilité p

def bernoulli(p):
    x=uniform(0,1)
    if ... :
        return 1
    else:
        return 0

 

  • Application 1 : En prenant par exemple \(p=0.3\) par exemple, lancer 10 fois la fonction et compter le nombre de 1 obtenus, c'est à dire le ombre de succès lors d'une répétition de 10 épreuves de Bernoulli.

 

  • Exercice 2 : Ecrire une fonction nombredesucces(n,p) qui renvoie le nombre de succès (de 1) obtenus pour une répétion de n épreuves de Bernoulli.

 

# Exercice 2 : Ecrire une fonction nombredesucces(n,p) qui renvoie le nombre de succès (de 1) obtenus pour une répétion de n épreuves de Bernoulli.

def nombredesucces(n,p):
    ...
    for ... :
        ...
    return ...

n=100
p=0.3
print(nombredesucces(n,p))

 

2. Loi Binomiale

La loi binomiale modélise le nombre de succès obtenus lors de la répétition indépendante de plusieurs expériences aléatoires identiques de Bernoulli. Pour chaque expérience appelée épreuve de Bernoulli, on utilise une variable aléatoire qui prend la valeur 1 lors d'un succès et la valeur 0 sinon. La variable aléatoire, somme de toutes ces variables aléatoires, compte le nombre de succès et est de loi binomiale.

La fonction B(n,p).

La fonction précédente nombredesucces(n,p) permet de simuler une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\).
Elle permet donc également de simuler une variable aléatoire suivant une loi de Bernoulli de paramètres p en prenant simplement \(n=1\).
On peut donc définir une fonction B(n,p) identique.

  • Exercice 3 : Ecrire une fonction listeB(n,p,nb) qui renvoie une liste de \(nb\) valeurs d'une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\).
#  Exercice 3 : Ecrire une fonction listeB(n,p,nb) qui renvoie une liste de \(nb\) valeurs d'une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\).

def B(n,p):
    return nombredesucces(n,p)

def listeB(n,p,nb):
    return [B(n,p) for ... ]

 

  • Remarque : les valeurs prises par la variable aléatoires correspondent aux nombres de succès possibles (dans la répétition de \(n\) épreuves de Bernoulli) et donc elles sont comprises entre 0 et \(n\). Il y a de ce fait  \((n+1)\) valeurs possibles.

 

  •  Exercice 4 : Ecrire une fonction frequencelisteB(n,p,nb) qui renvoie une liste des fréquences des \((n+1)\) valeurs possibles par une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\) sur un échantillon de taille \(nb\).

 

#  Exercice 4 : Ecrire une fonction frequencelisteB(n,p,nb) qui renvoie une liste des fréquences des \((n+1)\) valeurs possibles par une variable aléatoire suivant une loi binomiale de paramètres \(n\) et \(p\) sur un échantillon de taille \(nb\).

def frequencelisteB(n,p,nb):
    f=[0]*(n+1) # permet de générer une liste de (n+1) valeurs égales à 0
    L= listeB(n,p,nb)
    for S in L:
        f[S]=f[S]+1/nb
    return f
  • Par exemple on obtient :
>>> frequencelisteB(20,0.3,100)
([0.01, 0.01, 0.02, 0.04, 0.15, 0.16, 0.20000000000000004, 0.17, 0.12999999999999998, 0.08, 0.02, 0.01, 0, 0, 0, 0, 0, 0, 0, 0, 0])

 

  • Complément et Amélioration : on peut améliorer l'affichage en proposant une liste de couples (valeurs, fréquences). On cherche un affiche de ce type :
>>> frequencelisteB2(20,0.3,100)
(0, 0)
(1, 0.02)
(2, 0.05)
(3, 0.07)
(4, 0.11999999999999998)
(5, 0.21000000000000005)
(6, 0.17)
(7, 0.13999999999999999)
(8, 0.060000000000000005)
(9, 0.12999999999999998)
(10, 0.03)
(11, 0)
(12, 0)
(13, 0)
(14, 0)
(15, 0)
(16, 0)
(17, 0)
(18, 0)
(19, 0)
(20, 0)

 

  • Voici une solution possible qui renvoie les couples valeurs et fréquences grace à la fonction enumerate.

 

 

Articles Connexes