TP3: Simulation de variables aléatoires

Objectifs de ce TP
  • Utiliser les générateurs aléatoires en Python et numpy pour générer des échantillons de lois non triviales.
  • Bien penser à utiliser le générateur aléatoire pour reproduire les résultats. Une fois le générateur défini, par exemple avec rng = np.random.default_rng(44), on pourra utiliser rng pour générer des variables aléatoires, et si besoin le transmettre en argument des fonctions utilisant de l’aléatoire.

Méthode d’inversion : loi exponentielle et loi de Cauchy

  1. Représenter graphiquement la fonction de répartition d’une loi exponentielle (on pourra se restreindre aux réels positifs).
  1. Écrire une fonction expo qui prend en argument un entier n, un paramètre \lambda > 0, et un générateur aléatoire (e.g., rng) et qui donne en sortie un échantillon de taille n de loi \mathcal{E}(\lambda). On utilisera la méthode d’inversion vue en cours.
  1. Représenter graphiquement l’histogramme d’un tel échantillon pour n=10^2, n=10^3, et pour \lambda = 1/2, 1, 4. Superposer à chaque fois le graphe de la densité de \mathcal{E}(\lambda).
Attention

les conventions pour le paramètre de la loi exponentielle ne sont pas les même que dans votre cours dans scipy.stats…

  1. Illustrer graphiquement la loi des grands nombres avec \lambda = 1/2, 1, 4. On tracera en particulier la droite d’équation y=\mathbb E[X], où X \sim \mathcal{E}(\lambda).
  1. Même exercice avec la loi de Cauchy. Que remarque-t-on à la question 4 ?

Lois discrètes

Loi de Bernoulli

  1. Écrire une fonction bernou qui prend en argument un entier n et un paramètre p \in ]0,1[ et un générateur aléatoire (e.g., rng), et qui donne en sortie un échantillon de taille n de loi \mathcal{B}(p).
  1. Illustrer graphiquement la loi des grands nombres pour un échantillon de taille n=10^3 et différentes valeurs de p.

Loi géométrique

  1. Rappeler les deux méthodes vues en TD pour simuler une loi géométrique.

  2. Écrire une fonction geo_bernou qui prend en argument un entier n, un réal p \in ]0,1[, un générateur aléatoire (e.g., rng) et qui renvoie en sortie un échantillon de taille n de loi \mathcal{G}(p) en se basant sur la fonction bernou.

  1. Écrire une fonction geo_expo qui prend en argument un entier n, un paramètre p \in ]0,1[, et un générateur aléatoire (e.g., rng) et qui renvoie en sortie un échantillon de taille n de loi \mathcal{G}(p) en se basant sur la fonction expo.
  1. Le module time contient la fonction process_time() qui permet de mesurer le temps écoulé entre deux appels. Le code suivant affiche le temps passé à évaluer
import time

t0 = time.process_time()

""" code chunck to be timed """

t1 = time.process_time()

print("Time elapsed when running code chunk:", t1 - t0)

Utiliser cette fonction pour comparer la durée de simulation des deux méthodes.

Note

En pratique, les temps d’exécution peuvent varier suivant la charge d’utilisation de la machine (c’est un phénomène aléatoire). Pour donner une meilleur approximation de temps réel d’exécution, on répète plusieurs fois la mesure et on affiche le temps moyen.

Méthode de rejet et loi Beta

On rappelle que la loi de Beta de paramètres \alpha, \beta > 0, notée \text{Beta}(\alpha, \beta), est donnée par la densité f_{\alpha, \beta}(x) = \dfrac{\Gamma(\alpha+\beta)}{\Gamma(\alpha) \Gamma(\beta)} x^{\alpha-1} (1-x)^{\beta-1}\,, \quad x \in [0,1]\,. La fonction \Gamma s’obtient sur Python avec scipy.special.gamma.

  1. Représenter la densité pour différentes valeurs de \alpha et \beta pour visualiser cette loi.
  1. À l’aide de la méthode de rejet vue en TD, construire une fonction loi_beta qui génère n variables aléatoires de loi \text{Beta}(\alpha,\beta). La fonction prendre donc en paramètre, n, \alpha, \beta, et un générateur aléatoire (e.g., rng).
  1. Illustrer graphiquement votre résultat en représentant l’histogramme pour n=10^3 et différentes valeurs de \alpha, \beta. On superposera à chaque fois la densité adéquate.

Loi sur le disque

  1. Écrire une fonction unif_disque basée sur une méthode de rejet qui génère n variables aléatoires uniformes sur le disque unité à partir de variables aléatoires uniformes indépendantes sur [0,1], et prend comme second argument un générateur aléatoire (e.g., rng).
  1. Utiliser cette fonction pour représenter graphiquement un échantillon de n=100 variables aléatoires uniformes sur le disque.
  1. Écrire une fonction unif_disque2, basée sur la fonction précédente, qui donne en sortie à la fois les points dans le disque mais également, dans une matrice séparée, les points rejetés (et dont les entrées sont similaires à celle de unif_disque). Représenter graphiquement un échantillon en utilisant une couleur pour les points acceptés (dans le disque) et une autre pour les points rejetés (à l’extérieur).
Retour au sommet