Algorithmique : Simuler une variable aléatoire

Détails: Mis à jour : 9 Mars 2021

1. Loi d'une variable aléatoire, espérance et écart-type

Nous allons définir une variable aléatoire \(X\) dont on connait la loi de probabilité.
Par exemple \(X\) est une variable aléatoire qui donne le gain algébrique d'un jeu quelconque.

k	-10	-1	5
P( X = k)	0,2	0,3	0,5

On notera ces valeurs dans deux listes X et p au début du programme.

1a) Vérifier (à la main) que l'on obtient \(E(X)= \mu=0,2 \) et \( \sigma(X) \approx 5,72 \).

1b) En reprenant les fonctions du module (Moyenne, médiane variance), on peut facilement obtenir deux fonctions qui renvoient l'espérance et l'écart-type de cette variable aléatoire.

# 1°) Définition des valeurs prises par la v.a. et les probabilités associées
X=[-10,-1,5]
p=[0.2,0.3,0.5]
#
#Calcul de l'espérance et de l'écart-type (voir le module correspondant) 
# on l'adapte avec des probabilités en place des effectifs
#
def esperance(valeurs,probabilites):
  e=0
  a= len(valeurs) # la longueur de la liste
  for i in range(a):
      e = e + probabilites[i]*valeurs[i] # somme des pi*xi
  return e
#
# variance(X,p)
#
def variance(valeurs,probabilites):
  var,N = 0,0
  e=esperance(valeurs,probabilites)
  n=len(valeurs)
  for i in range(n):   
    var = var+probabilites[i]*(valeurs[i]-e)**2
  return var
#
#  ecart-type  : ecarttype(X,p) 
#  
import math
# 
def ecarttype(valeurs,probabilites):
  return math.sqrt(variance(valeurs,probabilites))
#

1c) Vérifier dans la console que l'on obtient bien les résultats attendus :

# Dans la console python
X=[-10,-1,5]
p=[0.2,0.3,0.5]  

esperance(X,p)
0.20000000000000018
variance(X,p)
32.76
ecarttype(X,p)
5.7236352085016735

2. Simulation d'une variable aléatoire

On a besoin du module random et de l'instruction random.random() qui renvoie un réel pseudo-aléatoire entre 0 et 1 (exclu). L'idée ici est de construire une fonction nommée simul(valeurs , probabilites) qui va renvoyer une valeur prise par la variable aléatoire \(X\) selon la loi associée.

Dans le cas présent, on va générer un réel nb entre 0 et 1 (exclu) avec la fonction random.random() puis, si il appartient à l'intervalle [0 ; 0.2] renvoyer \(-10\), si il est dans [0.2 ; 0.2+0.3] renvoyer \(-1\) et sinon renvoyer \(5\).

Bien entendu on va construire une fonction qui ne dépend pas des listes initiales.

2) Ecrire cette fonction et la tester.

import random
def simul(valeurs,probabilites):
    nb=random.random()
    ....

Par exemple vous devez obtenir :

# Dans la console python
valX=[-10,-1,5]
proba=[0.2,0.3,0.5]  
simul(valX,proba)
-10
simul(valX,proba)
-1

3. Simulation d'un échantillon de taille n

Nous allons maintenant simuler un échantillon de taille n. Pour cela il faudra effectuer une boucle sur n en utilisant la fonction simul précédente et renvoyer une liste de valeurs de la variable. \(X\).

Aide :

L= [ ] : création d'une liste vide
L . append(i) : ajoute un élément i en fin de la liste L.
On peut aussi écrire : L = L + [ i ]

3) Ecrire cette fonction et la tester.

def echantillon(valeurs,probabilites,taille):
    listeX=[]
    for i in range(taille):
       ...
    return listeX

4. Comparaison fréquences et probabilités

Nous voudrions afficher la liste des fréquences associées aux valeurs de X dans l'échantillon. L'idée étant de visualiser que si n est grand, les fréquences devraient se rapprocher des probabilités.

Méthode 1
La méthode la plus naturelle si l'on ne connait pas quelques fonctions spécifiques à Python, est de faire une boucle sur les éléments de la liste valeurs, de les comparer à celles de la liste échanti puis de créer un compteur F[ i ] pour chaque valeurs et enfin de diviser par n. C'est un peut long !

def frequences(valeurs,probabilites,taille):
    echanti=echantillon(valeurs,probabilites,taille)
    n=len(echanti)
    i=0
    F=[0]*len(valeurs) # va créer une liste de longueur len(valeurs) composée de 0 
    for val in valeurs:
        for x in echanti:
            if val==x:
                F[i]=...
        F[i]=...
        i=i+1
    return F,probabilites

Méthode 2
On peut aussi utiliser la fonction index vous permet de connaitre la position d'une valeur cherchée dans la liste.
X.index(y) va donner l'indice (le rang) de la valeur y dans la liste X. Attention, on sait que le premier élément de la liste X est d'indice 0, c'est X[0].

Par exemple ici : Avec la liste X = [ -10 , -1 , 5 ]
X.index(-10) doit renvoyer 0, X.index(-1) doit renvoyer 1 et X.index(5) doit renvoyer 2. Tester le.

def frequences2(valeurs,probabilites,taille):
    echanti=echantillon(valeurs,probabilites,taille)
    n=len(echanti)
    F=[0]*len(valeurs) # va créer une liste de longueur len(valeurs) composée de 0 
    for x in echanti:
        F[valeurs.index(x)]=...
    for i in range(len(valeurs)): # on divise les occurences par n pour avoir les fréquences après afin d'éviter le cumul d'erreurs dans la boucle
      F[i]=F[i]/n   
    return F,probabilites 
Méthode 3

Méthode 3
Il y a encore plus rapide. On va pour cela utiliser la fonction count et la fonction append.
La fonction count s'utilise sous la forme X.count(y) qui compte le nombre de valeurs y dans la liste X.
La fonction append s'utilise sous la forme X.append(y) et ajoute l'élément y à la liste X.

Complétez la fonction ci-dessous, une seule ligne est manquante ! Notez la simplicité de la solution.

def frequences3(valeurs,probabilites,taille):
    echanti=echantillon(valeurs,probabilites,taille)
    n=len(echanti)
    F=[]
    for x in valeurs:
        ...
    return F,probabilites

5. Moyenne

Écrire une fonction qui renvoie la moyenne de l'échantillon.

Aide : la fonction sum(liste) renvoie la somme des valeurs d'une liste.

def moyenne(liste):
    return ...

6. Proportion des écarts entre f et p

Écrire une fonction de paramètres (valeurs , probabilites , n , N) qui va simuler N échantillons de taille n de la variable aléatoire X (d’espérance \( \mu \) et d’écart type \( \sigma \). )
Si m désigne la moyenne de cet échantillon, la fonction devra renvoyer la proportion des cas où l’écart entre m et \( \mu \) est inférieur ou égal à \( \dfrac{2\sigma}{\sqrt{n}} \)"

Aide : sous python, la fonction valeur absolue se nomme abs()

def ecart(valeurs,probabilites,taille,nbechantillons):
    ...
    return ...

{module [104]}