1
S I M U L AT I O N D E S L O I S D E P R O B A B I L I T É
1.1 Bibliothèque [Link]
La bibliothèque [Link] est une sous-bibliothèque puissante de Numpy dédiée à la
génération de nombres aléatoires, un élément fondamental en programmation pour de nombreuses
applications. Elle permet de simuler des données aléatoires, de créer des échantillons, de générer des
distributions statistiques, et bien plus encore.
Dans le contexte des mathématiques, des statistiques et de la science des données, l’aléatoire
est essentiel pour :
❏ Simuler des phénomènes : Par exemple, lancer une pièce de monnaie ou prédire les résultats
d’un sondage.
❏ Tester des modèles : Générer des données synthétiques pour vérifier le comportement d’un
algorithme.
❏ Créer des échantillons : Extraire une sous-population pour une analyse plus rapide et précise.
1.1.1 Pourquoi utiliser [Link] ?
➥ Performance : Optimisé pour générer rapidement des données aléatoires.
➥ Flexibilité : Propose une large variété de distributions statistiques.
➥ Reproductibilité : Permet de fixer une seed (graine) pour obtenir les mêmes résultats aléatoires,
ce qui est crucial pour les expériences scientifiques ou en apprentissage machine.
➥ Compatibilité : Intégré dans l’écosystème Numpy, facilitant les calculs sur les tableaux et
matrices.
1 of 10
1.1 bibliothèque [Link]
Les nombres générés par [Link] ne sont pas vraiment aléatoires, mais pseudo-aléatoires.
Ils sont calculés à partir d’un algorithme déterministe, garantissant que :
❏ Les résultats sont répétables si vous fixez une seed.
❏ Ils sont suffisamment imprévisibles pour des simulations réalistes dans de nombreuses
applications.
1.1.2 Génération de nombres pseudo-aléatoires
Le module [Link] fournit plusieurs fonctions pour générer des nombres pseudo-
aléatoires.
[Link]()
Cette fonction produit un tableau de nombres aléatoires dérivés d’une distribution uniforme sur
l’intervalle [0, 1[ :
np . random . rand ( d0 , d1 , ... , dn )
➥ Exemple 1.1.1.
import numpy as np
nombres = np . random . rand (5) # 5 nombres uniformes entre 0 et 1
print ( nombres )
➥ Exemple 1.1.2.
import numpy as np
M = np . random . rand (2 ,3) # Matrice de 2 lignes et 3 colonnes
print ( M )
[Link]()
Génère des entiers aléatoires dans un intervalle donné.
np . random . randint ( debut , fin = None , size = None , dtype = int )
➥ Exemple 1.1.3.
import numpy as np
nombres = np . random . randint (2 , 8 , size =5) # 5 entiers entre 2 et 8
print ( nombres )
2 of 10
1.1 bibliothèque [Link]
[Link]()
Génère des nombres à partir d’une distribution normale centrée réduite (moyenne = 0, écart-type
= 1).
np . random . randn ( d0 , d1 , ... , dn )
➥ Exemple 1.1.4.
import numpy as np
nombres = np . random . randn (3) # 3 nombres avec distribution normale
print ( nombres )
[Link]()
Sélectionne des éléments aléatoires dans une séquence donnée, avec ou sans remplacement.
np . random . choice (a , size = None , replace = True , p = None )
➥ Exemple 1.1.5.
import numpy as np
population = [1 , 2 , 3 , 4 , 5]
sample = np . random . choice ( population , size =3 , replace = False ) # É chantillon
sans remplacement
print ( sample )
[Link]()
np . random . shuffle ( T )
➥ Exemple 1.1.6.
T = np . array ([1 , 2 , 3 , 4 , 5])
np . random . shuffle ( T )
print ( arr )
1.1.3 Génération de distributions aléatoires spécifiques
La bibliothèque [Link] permet de générer des données respectant différentes distri-
butions statistiques, essentielles pour les simulations, la modélisation probabiliste, et les analyses
statistiques.
3 of 10
1.1 bibliothèque [Link]
Distribution uniforme
La distribution uniforme génère des valeurs où chaque intervalle a une probabilité égale d’occurrence.
numpy . random . uniform ( debut , fin , size )
➥ Exemple 1.1.7.
import numpy as np
nombres = np . random . uniform (0 , 10 , size =5) # 5 nombres entre 0 et 10
print ( nombres )
Distribution normale (ou gaussienne)
Une distribution normale suit une courbe en cloche, avec une moyenne et un écart-type définis.
numpy . random . normal ( loc , scale , size
❏ loc : Moyenne de la distribution.
❏ scale : Écart-type.
❏ size : Taille du tableau généré.
➥ Exemple 1.1.8.
import numpy as np
nombres = np . random . normal (10 , 2 , size =5) # Moyenne = 10 , é cart - type = 2
print ( nombres )
Distribution binomiale
La distribution binomiale modélise le nombre de succès dans un nombre fixe d’essais indépendants,
chacun ayant une probabilité donnée de succès.
numpy . random . binomial (n , p , size )
➥ Exemple 1.1.9.
import numpy as np
nombres = np . random . binomial (10 , 0.5 , size =5) # 10 essais avec p =0.5
print ( nombres )
4 of 10
1.2 méthode de la transformation inverse
Distribution géométrique
Modélise le nombre d’essais nécessaires avant le premier succès dans une suite d’expériences
indépendantes.
numpy . random . geometric (p , size )
➥ Exemple 1.1.10.
import numpy as np
nombres = np . random . geometric ( p =0.3 , size =5) # Probabilit é de succ è s = 0.3
print ( nombres )
Distribution de Poisson
La distribution de Poisson modélise le nombre d’événements qui se produisent dans un intervalle
donné, selon un taux moyen.
numpy . random . poisson ( lam , size )
❏ lam : Taux moyen d’occurrence.
❏ size : Taille du tableau généré.
➥ Exemple 1.1.11.
import numpy as np
nombres = np . random . poisson ( lam =3 , size =5) # Taux moyen = 3 é v é nements
print ( nombres )
1.2 Méthode de la transformation inverse
La méthode de la transformation inverse est une technique utilisée pour simuler des variables
aléatoires dont la fonction de masse ou la densité de probabilité est connue. Elle consiste à utiliser
la fonction inverse de la fonction de répartition de la variable aléatoire pour générer des échantillons
de cette variable.
➥ Exemple 1.2.1.
Voici un exemple pour vous montrer comment utiliser cette méthode pour simuler une variable
aléatoire X suivant une loi de probabilité donnée :
5 of 10
1.2 méthode de la transformation inverse
Considérons une variable aléatoire X suivant une loi de probabilité discrète donnée par la
fonction de masse suivante :
P (X = 1) = 0.3, P (X = 2) = 0.2, P (X = 3) = 0.5
Voici les étapes pour simuler X en utilisant la loi uniforme sur [0, 1] :
1. Calculer la fonction de répartition de X :
F (x) = P (X <= x) = P (X = 1) + P (X = 2) + P (X = 3) pour x = 1, 2, 3.
F (1) = 0.3, F (2) = 0.3 + 0.2 = 0.5, F (3) = 1
2. Trouver la fonction inverse de la fonction de répartition F(x) :
F −1 (y ) = 1 pour 0 <= y < 0.3
F −1 (y ) = 2 pour 0.3 <= y < 0.5
F −1 (y ) = 3 pour 0.5 <= y <= 1
3. Générer une variable aléatoire Y suivant une loi uniforme sur [0, 1] en utilisant numpy :
import numpy as np
Y = np . random . uniform (0 , 1)
4. Appliquer la fonction inverse F −1 (Y ) pour obtenir X :
if Y < 0.3:
X = 1
elif Y < 0.5:
X = 2
else :
X = 3
En résumé, pour simuler X en utilisant la méthode de la transformation inverse, nous avons d’abord
calculé la fonction de répartition de X, puis trouvé sa fonction inverse. Ensuite, nous avons généré
une variable aléatoire uniforme Y sur [0, 1] et utilisé la fonction inverse pour obtenir X.
Il est important de noter que cette méthode est généralement utilisée pour les variables aléatoires
discrètes, pour les variables continues il y a d’autres méthodes comme la méthode de l’inversion de
la fonction de densité de probabilité.
➥ Exemple 1.2.2.
6 of 10
1.3 simulation des lois usuelles
Considérons une variable aléatoire X dont la fonction de masse : P(1) = 1/3, P(2) = 1/6, P(3)
= 1/3 P(4)=1/6. Comment simuler X avec la loi uniforme sur [0, 1].
1.3 Simulation des lois usuelles
1.3.1 La loi de Bernoulli de paramètres p
La loi de Bernoulli est utilisée pour modéliser des phénomènes aléatoires qui ont deux résultats
possibles : succès ou échec. Le paramètre p est la probabilité de succès. Pour simuler une loi de
Bernoulli en utilisant [Link](0, 1), vous pouvez suivre les étapes suivantes :
1. Générer une variable aléatoire Y suivant une loi uniforme sur [0, 1] en utilisant numpy :
2. Définir la probabilité de succès p, par exemple p = 0.7
3. Utiliser la variable aléatoire Y pour simuler un événement de Bernoulli en comparant Y avec
p:
➥ Exemple 1.3.1.
import numpy as np
# D é finir le param è tre p
p = 0.8
# G é n é rer une variable al é atoire Y suivant une loi uniforme sur [0 , 1]
Y = np . random . uniform (0 , 1)
# Utiliser la variable al é atoire Y pour simuler un é v é nement de Bernoulli
if Y < p :
X = 1 # succ è s
else :
X = 0 # é chec
# Afficher le r é sultat de l ’é v é nement simul é
print ( " R é sultat de l ’é v é nement simul é : " , X )
1.3.2 la loi binomiale de paramètres (n,p)
La loi binomiale est utilisée pour modéliser des phénomènes aléatoires qui ont un nombre
fini de répétitions et deux résultats possibles (succès ou échec). Le paramètre n est le nombre de
répétitions et le paramètre p est la probabilité de succès. Pour simuler une loi binomiale en utilisant
[Link](0, 1), vous pouvez suivre les étapes suivantes :
1. Définir les paramètres n et p, par exemple n = 10 et p = 0.7
7 of 10
1.3 simulation des lois usuelles
2. Initialiser un compteur pour compter le nombre de succès :
3. Répéter les étapes suivantes n fois :
— Générer une variable aléatoire Y suivant une loi uniforme sur [0, 1] en utilisant numpy :
— Utiliser la variable aléatoire Y pour simuler un événement de Bernoulli en comparant Y
avec p :
4. Le compteur qui contient le nombre de succès simule une variable aléatoire X suivant une loi
binomiale de paramètres (n, p)
En résumé, pour simuler une loi binomiale en utilisant [Link](0, 1), nous générons
d’abord une variable aléatoire uniforme Y sur [0, 1] pour simuler un événement de Bernoulli pour
chaque répétition, et comparons cette variable avec la probabilité de succès p pour déterminer si
l’événement est un succès. Nous comptons le nombre de succès obtenus lors de n répétitions, cela
simule une variable aléatoire suivant une loi binomiale de paramètres (n, p).
➥ Exemple 1.3.2.
import numpy as np
# D é finir les param è tres n et p
n = 10
p = 0.3
# Initialiser un compteur pour compter le nombre de succ è s obtenus
success_count = 0
# R é p é ter les é tapes suivantes n fois
for i in range ( n ) :
# G é n é rer une variable al é atoire Y suivant une loi uniforme sur [0 , 1]
Y = np . random . uniform (0 , 1)
# Utiliser la variable al é atoire Y pour simuler un é v é nement de Bernoulli
en comparant Y avec p
if Y < p :
success_count += 1
# Le compteur de succ è s simule une variable al é atoire X suivant une loi
binomiale de param è tres (n , p )
X = success_count
# Afficher le r é sultat de l ’é v é nement simul é
print ( " Nombre de succ è s obtenus : " , X )
1.3.3 la loi géométrique de paramètres p
La loi géométrique est utilisée pour modéliser des phénomènes aléatoires qui ont un nombre fini
d’essais et deux résultats possibles (succès ou échec). Le paramètre p est la probabilité de succès.
8 of 10
1.3 simulation des lois usuelles
Pour simuler une loi géométrique en utilisant [Link](0, 1), vous pouvez suivre les étapes
suivantes :
1. Définir la probabilité de succès p, par exemple p = 0.2
2. Initialiser un compteur pour compter le nombre d’essais nécessaires pour obtenir un succès
3. Répéter les étapes suivantes jusqu’à obtenir un succès
— Générer une variable aléatoire Y suivant une loi uniforme sur [0, 1] en utilisant numpy
— Incrémenter le compteur d’essais
— Utiliser la variable aléatoire Y pour simuler un événement de Bernoulli en comparant Y
avec p
4. Le compteur d’essais simule une variable aléatoire X suivant une loi géométrique de paramètre
p
En résumé, pour simuler une loi géométrique en utilisant [Link](0, 1), nous générons
d’abord une variable aléatoire uniforme Y sur [0, 1] pour simuler un événement de Bernoulli
pour chaque essai, et comparons cette variable avec la probabilité de succès p pour déterminer si
l’événement est un succès. Nous comptons le nombre d’essais nécessaires pour obtenir un succès,
cela simule une variable aléatoire suivant une loi géométrique de paramètre p.
Il est important de noter que cette méthode de simulation de la loi géométrique est basée sur
le fait que la variable aléatoire qui compte le nombre d’essais nécessaires pour obtenir un succès
suivant une loi de Bernoulli est une variable aléatoire suivant une loi géométrique.
➥ Exemple 1.3.3.
9 of 10
1.3 simulation des lois usuelles
import numpy as np
# D é finir le param è tre p
p = 0.3
# Initialiser un compteur pour compter le nombre d ’ essais n é cessaires pour
obtenir un succ è s
attempts = 0
# R é p é ter les é tapes suivantes jusqu ’à obtenir un succ è s
while True :
# G é n é rer une variable al é atoire Y suivant une loi uniforme sur [0 , 1]
Y = np . random . uniform (0 , 1)
# Incr é menter le compteur d ’ essais
attempts +=1
# Utiliser la variable al é atoire Y pour simuler un é v é nement de Bernoulli
en comparant Y avec p
if Y < p :
break
# Le compteur d ’ essais simule une variable al é atoire X suivant une loi g é om é
trique de param è tre p
X = attempts
# Afficher le r é sultat de l ’é v é nement simul é
print ( " Nombre d ’ essais n é cessaires pour obtenir un succ è s : " , X )
10 of 10
