9 Probabilités et statistiques
Dans un premier temps la statistique de la proportion de nombres commençant par un certain chiffre sera étudiée. Puis dans un second des modèles probabilistes seront introduits et simulés.
- statistiques et probabilités
- loi de Benford
- série harmonique aléatoire
- marche aléatoire
- histogrammes
- importation de données
- optimisation par compilation
- percolation
- transition de phase
Exercice 9.1: Série harmonique de signe aléatoire
Le but de cet exercice est de simuler la convergence d'une série harmonique donc le signe est tiré aléatoirement. Plus précisément si \( (X_i)_{i\in\mathbb{N}} \) est une suite de variables aléatoires indépendantes valant \( -1 \) ou \( 1 \) avec probabilité \( \frac{1}{2} \), alors on définit la somme partielle: $$ W_0 = 0 \,, \qquad\qquad W_n = \sum_{i=1}^n \frac{X_i}{i} \,, $$ et la question est de déterminer si la suite \( (W_n)_{n\in\mathbb{N}} \) converge et si oui vers quoi.
a) Écrire une fonction sign() qui simule la variable aléatoire \( X_i \).
b) Écrire une fonction simulate(n) qui retourne une liste avec une réalisation de \( (W_1,W_2,\dots,W_n) \).
c) Faire la représentation graphique de la fonction \( n \mapsto W_n \) pour différentes réalisations par exemple pour \( 0\leq n\leq 1 000 \) et émettre une conjecture quant à la convergence de la suite \( (W_n)_{n\in\mathbb{N}} \).
d) ! Déterminer l'histogramme de \( W_{1 000} \) pour \( 10^4 \) ou \( 10^5 \) réalisations pour avoir une idée de la loi de la variable aléatoire limite.
Exercice 9.2: Loi de Benford
La loi de Benford prédit que statistiquement dans une liste de nombres donnés, la probabilité qu'un de ces nombres commence par le chiffre 1 est plus importante que celle qu'un nombre commence par le chiffre 9. Plus précisément la loi de Benford prédit que la probabilité qu'un nombre commence par le chiffre \( d \) est: $$ p_d = \log_{10}\bigg(1+\frac{1}{d}\bigg) \,, $$ où \( \log_{10} \) désigne le logarithme en base 10. Il est possible de vérifier que la loi de Benford est la seule qui reste invariante par changement d'unités, i.e. en multipliant les nombres de la liste par une constante les probabilités précédentes restent inchangées.
a) Écrire une fonction firstdigit(n) qui pour un nombre n donné retourne son premier chiffre et une fonction occurrences(liste) qui retourne le nombre d'occurrences des premiers chiffres de liste.
Faire en sorte que la fonction occurrences fonctionne même si la liste contient des zéros en les ignorant.
b) Vérifier si la loi de Benford semble satisfaite pour la suite des nombres \( (2^n)_ {n\in\mathbb{N}} \) en comparant l'histogramme empirique avec la loi de Benford.
c) Vérifier si la loi de Benford semble satisfaite pour la suite des nombres \( (3n+1)_ {n\in\mathbb{N}} \).
d) En allant sur le site de l'INSEE à l'adresse: https://www.insee.fr/fr/statistiques/5395878, télécharger le fichier au format CSV contenant les données de la population par sexe et âge regroupé (POP1A). Importer ces données pour avoir la population par code postal, sexe et tranche d'âge.
La documentation sur comment lire un fichier est disponible ici.
e) Déterminer si la liste de toutes les populations par commune, sexe et âge suit la loi de Benford.
f) Sommer les données précédentes pour obtenir la liste des populations par commune et déterminer si elle suit la loi de Benford.
g) !! Lire la documentation du module Pandas disponible ici et l'utiliser pour refaire les deux questions précédentes mais avec le fichier de population POP1B avec les âges non regroupés.
Utiliser la fonction read_csv de Pandas.
h) !! En allant sur le site de l'INSEE ou autre télécharger votre jeu de données préféré, et tester s'il suit la loi de Benford.
Utiliser par exemple les comptes détaillés de l'État disponibles ici.
Exercice 9.3: Ruine du joueur
Le but est de simuler l'évolution de la somme d'argent d'un joueur jouant à pile ou face. À chaque lancer le joueur gagne un euro si c'est pile et en perd un si c'est face. La probabilité d'obtenir pile est notée \( p \), celle d'obtenir face \( q \). En particulier \( p=q=\frac{1}{2} \) si la pièce est équilibrée.
Mathématiquement, la somme \( S_i \) possédée par le joueur au temps \( i \) est donnée par une marche aléatoire: $$ S_{i}=\begin{cases} 0\,, & \text{si}\:S_{i-1}=0\,,\\ S_{i-1}+X_{i}\,, & \text{si}\:S_{i-1}\geq1\,, \end{cases} $$ où les \( (X_i)_ {i\geq1} \) sont des variables aléatoires indépendantes de loi \( \mathbb{P}(X_i=1) = p \) et \( \mathbb{P}(X_i=-1) = q \).
a) Écrire une fonction simulate(p,k,N) qui génère une réalisation de longueur \( N \) du processus à partir de \( S_0=k \), c'est-à-dire qui retourne \( (S_0,S_1,S_2,\dots,S_N) \). Représenter graphiquement plusieurs réalisations.
b) Simuler un joueur qui, commençant avec une somme \( k \), joue jusqu'à tout perdre ou avoir la somme \( n \geq k \).
c) Si \( T \) désigne le temps auquel le jeu s'arrête, i.e. lorsque \( S_T = 0 \) ou \( S_T = n \), retrouver par simulation les résultats théoriques sur le temps moyen: $$ \mathbb{E}(T)=\begin{cases} k(n-k)\,, & \text{si}\:p=q\,,\\ \dfrac{n}{p-q}\dfrac{1-\rho^{k}}{1-\rho^{n}}-\dfrac{k}{p-q}\,, & \text{si}\:p\neq q\,, \end{cases} $$ et le lieu de sortie: $$ \mathbb{P}(S_{T}=0)=\begin{cases} \dfrac{n-k}{n}\,, & \text{si}\:p=q\,,\\ \dfrac{\rho^{k}-\rho^{n}}{1-\rho^{n}}\,, & \text{si}\:p\neq q\,, \end{cases} $$ où \( \rho = q/p \). Pour cela on pourra faire un graphique de ces quantités en fonction de \( p \) ou se contenter de considérer le cas \( p=q=\frac{1}{2} \).
Exercice 9.4: !! Percolation
Le but est d'étudier un modèle de percolation dans un milieu poreux. Le milieu est modélisé par une matrice aléatoire de booléens qui détermine les sites qui peuvent être envahis par l'eau et ceux qui sont imperméables. Une matrice percole s'il existe un chemin d'eau allant de la ligne supérieure vers la ligne inférieure. Dans les exemples suivants, les entrées d'une matrice pouvant être envahies par l'eau sont colorées et les entrées effectivement remplies d'eau sont en bleu. La première matrice ne percole pas alors que la seconde oui:
a) Écrire une fonction generate(n,p) qui génère une matrice de booléens de taille \( n \times n \) telle que chaque entrée ait probabilité \( p \) d'être juste et \( 1-p \) d'être fausse.
La fonction numpy.random.binomial peut être utile.
b) Définir une fonction fill(isopen) qui pour une matrice de booléens donnée renvoie une autre matrice de booléens avec les entrées envahies par l'eau.
Définir une matrice de booléens isfull pour stocker si une entrée est remplie par l'eau ou pas, puis définir une fonction récursive flow(isopen, isfull, i, j) permettant d'envahir toutes les entrées possibles à partir de \( (i,j) \).
c) À l'aide de Matplotlib représenter le remplissage de différentes matrices générées aléatoirement.
d) Définir une fonction percolate(isopen) permettant de déterminer si une matrice de booléens percole ou non.
e) !! Calculer le temps nécessaire pour déterminer si une matrice de taille \( 50 \times 50 \) avec \( p=0.9 \) percole ou non. Lire la documentation du module numba pour réduire le temps de calcul en compilant une des fonctions: https://numba.pydata.org/.
La fonction qui est la plus utilisée est la fonction récursive, donc c'est celle qu'il faut optimiser en la compilant.
f) En faisant des statistiques, déterminer la probabilité qu'une matrice aléatoire booléenne de taille \( n \times n \) avec probabilité \( p \) percole. Étudier cette probabilité en fonction de \( p \) et de \( n \).
Faire le graphique de cette probabilité de percolation en fonction de \( p \) pour différentes valeurs de \( n \).
Dans la limite des \( n \) très grands, une matrice percole presque sûrement si \( p>0.592746 \) et presque jamais sinon.
g) !!! Les statistiques effectuées au point précédent sont un exemple typique de calculs pouvant être facilement exécutés en parallèle, car chaque cas est indépendant des autres. Paralléliser l'algorithme précédent de manière à utiliser tous les cœurs de votre processeur, par exemple à l'aide du module mpi4py.
L'utilisation de Jupyter Lab pour faire du calcul parallèle est assez complexe à mettre en œuvre, il vaut mieux utiliser la ligne de commande pour exécuter un script en parallèle, par exemple pour quatre cœurs: mpirun -n 4 script.py. À noter que Open MPI ou MPICH doit être installé sur votre ordinateur.