Probability Stochastic Processes and Simulation In Python fr
publicité
See discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/360767123 Probability Stochastic Processes and Simulation In Python fr Book · May 2022 CITATIONS READS 0 527 2 authors: Mohammed Slimane Sarah Ibri University of Oran University of Science and Technology Houari Boumediene 3 PUBLICATIONS 3 CITATIONS 15 PUBLICATIONS 79 CITATIONS SEE PROFILE All content following this page was uploaded by Sarah Ibri on 21 May 2022. The user has requested enhancement of the downloaded file. SEE PROFILE 1 Probabilité, Processus Stochastiques & Simulation en Python Par Mohammed Slimane & Sarah Ibri Probabilité, Processus Stochastiques & Simulation en Python Outils nécessaires pour la modélisation stochastique Écrit par Mohammed Slimane & Sarah Ibri 2022 Edition Ce livre est sous la licence Creative Commons. Louange à Allah par le bienfait duquel les bonnes choses se concrétisent À mes parents, ma petite soeur À tous les patients cancéreux priant qu’Allah les guérisse, Amen. Au peuple de la Palestine. Mohammed À mes parents Sarah 2 Table des matières I Probabilités et variables aléatoires 1 Introduction à la Probabilité 1.1 Introduction . . . . . . . . . . . . . . . . . . 1.2 Expérience aléatoire . . . . . . . . . . . . . 1.2.1 Univers discrets et continus . . . . . 1.2.2 Espace probabilisable et évènements 1.3 Probabilité . . . . . . . . . . . . . . . . . . 1.3.1 Propriétés de la probabilité . . . . . 1.3.2 Equiprobabilité . . . . . . . . . . . . 1.4 Probabilités conditionnelles . . . . . . . . . 1.4.1 Probabilités composées . . . . . . . 1.4.2 Probabilités totales . . . . . . . . . . 1.4.3 Formule de Bayes . . . . . . . . . . . 1.5 Indépendance . . . . . . . . . . . . . . . . . 1.5.1 Indépendance conditionnelle . . . . . 1.6 Exercices . . . . . . . . . . . . . . . . . . . 1.7 Solutions . . . . . . . . . . . . . . . . . . . 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 10 10 11 13 16 16 17 22 24 24 25 28 29 32 36 2 Variables Aléatoires 2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Variables aléatoires discrètes (v.a.d) . . . . . . . . . . 2.3 Variables aléatoires continues (v.a.c) . . . . . . . . . . 2.4 Espérance et Variance . . . . . . . . . . . . . . . . . . 2.4.1 Espérance . . . . . . . . . . . . . . . . . . . . . 2.4.2 Variance . . . . . . . . . . . . . . . . . . . . . . 2.4.3 Inégalités de probabilités . . . . . . . . . . . . 2.5 Distributions usuelles . . . . . . . . . . . . . . . . . . . 2.5.1 Distributions discrètes . . . . . . . . . . . . . . 2.5.2 Distributions continues . . . . . . . . . . . . . 2.6 Variables aléatoires multiples . . . . . . . . . . . . . . 2.6.1 Distribution jointe, marginale et conditionnelle 2.6.2 Covariance et coefficient de corrélation . . . . . 2.7 Fonction génératrice des moments . . . . . . . . . . . 2.7.1 Calcul des moments par la FGM . . . . . . . . 2.8 Transformation de variables aléatoires . . . . . . . . . 2.9 Variables aléatoires indépendantes . . . . . . . . . . . 2.10 Espérance et variance conditionnelle . . . . . . . . . . 2.10.1 Loi de l’espérance totale . . . . . . . . . . . . . 2.11 Séquences de v.a et Convergence . . . . . . . . . . . . 2.11.1 Séquence de v.a (s.v.a) . . . . . . . . . . . . . . 2.11.2 Somme des suites de v.a indépendantes . . . . 2.11.3 Convergence . . . . . . . . . . . . . . . . . . . 2.11.4 Loi des grands nombres . . . . . . . . . . . . . 2.11.5 Théorème central limite . . . . . . . . . . . . . 2.12 Application : régression linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 41 45 47 49 49 49 50 55 55 60 65 65 68 71 71 72 75 76 78 81 81 82 83 86 86 87 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TABLE DES MATIÈRES 4 2.13 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.14 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . II Processus Stochastiques 3 Processus Stochastiques 3.1 Introduction . . . . . . . . . . . . . . . . . . 3.1.1 Fonctions CDF et statistiques de PS 3.1.2 Classes des processus stochastiques . 3.2 Processus de comptage . . . . . . . . . . . . 3.3 Processus de Poisson . . . . . . . . . . . . 3.3.1 Loi de Nt . . . . . . . . . . . . . . . 3.3.2 Loi de Sn . . . . . . . . . . . . . . . 3.3.3 Loi de Tn . . . . . . . . . . . . . . . 3.3.4 Somme et composition des processus 3.4 Exercices . . . . . . . . . . . . . . . . . . . 3.5 Solutions . . . . . . . . . . . . . . . . . . . 90 92 97 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . de Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 99 101 102 104 105 106 106 107 108 110 111 4 Chaînes de Markov 4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . 4.2 Chaînes de Markov à temps discret . . . . . . . . . . 4.2.1 Matrice et graphe de transitions . . . . . . . 4.2.2 Loi de probabilité de Xn . . . . . . . . . . . . 4.2.3 Probabilités de transitions en n étapes . . . . 4.2.4 Équation de Chapman Kolmogorov . . . . . . 4.2.5 Classification des états . . . . . . . . . . . . . 4.2.5.1 États récurrents et états transitoires 4.2.6 Cas des CMs infinies . . . . . . . . . . . . . . 4.2.7 États périodiques . . . . . . . . . . . . . . . . 4.2.8 Temps moyen du premier passage . . . . . . . 4.2.9 Temps moyen de retour . . . . . . . . . . . . 4.2.10 Probabilités d’absorption . . . . . . . . . . . 4.2.11 Temps moyen d’absorption . . . . . . . . . . 4.2.12 Distributions stationnaires et limites . . . . . 4.3 Chaînes de Markov à temps continu . . . . . . . . . 4.3.1 Probabilités de transition . . . . . . . . . . . 4.3.2 Temps de séjour . . . . . . . . . . . . . . . . 4.3.3 Équation de Chapman Kolmogorov . . . . . . 4.3.4 Matrice génératrice . . . . . . . . . . . . . . . 4.3.5 Équations avant et arrière . . . . . . . . . . . 4.3.6 Probabilités stationnaires . . . . . . . . . . . 4.3.7 Chaîne de Markov intégrée . . . . . . . . . . 4.3.8 Temps moyen du premier passage . . . . . . . 4.4 Application : PageRank Algorithm . . . . . . . . . . 4.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . 4.6 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 112 112 113 114 115 115 117 118 120 121 121 122 122 123 124 128 128 129 129 129 130 132 133 134 137 139 142 5 Application aux modèles de files d’attente 5.1 Introduction . . . . . . . . . . . . . . . . . . 5.2 Composants d’un système de files d’attente 5.3 Notation de Kendall A/B/C/K/P/D . . . . 5.4 Étude de station . . . . . . . . . . . . . . . 5.4.1 Loi de Little . . . . . . . . . . . . . 5.4.2 La station M/M/1 . . . . . . . . . . 5.4.3 La station M/M/1/K . . . . . . . . 5.4.4 La station M/M/s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 150 151 151 151 152 154 156 159 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TABLE DES MATIÈRES 5.5 5.6 5 5.4.5 La station M/M/s/K . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 III Simulation 6 Génération des variables aléatoires 6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Génération des nombres aléatoires . . . . . . . . . . . . 6.2.1 Générateurs congruentiels linéaires . . . . . . . . 6.2.2 Méthodes congruentielles mixtes . . . . . . . . . 6.2.3 Générateurs récursifs multiples . . . . . . . . . . 6.2.4 Mersene Twister RNG (MT) . . . . . . . . . . . 6.2.5 RNG Combinés . . . . . . . . . . . . . . . . . . . 6.2.5.1 Somme/Différence . . . . . . . . . . . . 6.2.5.2 Wichmann-Hill . . . . . . . . . . . . . . 6.2.6 Critères de qualité . . . . . . . . . . . . . . . . . 6.3 Tests statistiques des générateurs de nombres aléatoires 6.3.1 Tests de Fréquence . . . . . . . . . . . . . . . . . 6.3.1.1 Test Kolmogorov-Smirnov (K-S) . . . . 6.3.1.2 Test Chi-square (χ2 ) . . . . . . . . . . . 6.3.2 Test d’autocorrélation . . . . . . . . . . . . . . . 6.4 Simulation des variables aléatoires . . . . . . . . . . . . 6.4.1 Simulation de v.a discrètes . . . . . . . . . . . . 6.4.1.1 Méthode de transformation inverse . . . 6.4.1.2 Méthode d’acceptation-rejet . . . . . . 6.4.2 Simulation de v.a continues . . . . . . . . . . . . 6.4.2.1 Méthode de transformation inverse . . . 6.4.2.2 Méthode d’acceptation-rejet . . . . . . 6.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . 172 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 174 174 175 175 176 178 180 180 181 181 181 182 182 183 184 185 185 185 186 187 187 189 191 192 7 Simulation en Python 7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Outils de simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.1 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.1.1 Python Standard Library . . . . . . . . . . . . . . . 7.2.1.2 Écosystème de Python . . . . . . . . . . . . . . . . 7.2.2 Symbulate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.2.1 Simulation des variables aléatoires . . . . . . . . . . 7.2.3 Simpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.3.1 Environnements . . . . . . . . . . . . . . . . . . . . 7.2.3.2 Évènements . . . . . . . . . . . . . . . . . . . . . . . 7.2.3.3 Ressources partagées . . . . . . . . . . . . . . . . . 7.2.3.4 Exceptions . . . . . . . . . . . . . . . . . . . . . . . 7.3 Simulation des processus stochastiques . . . . . . . . . . . . . . . . . 7.3.1 Simulation du processus de Poisson . . . . . . . . . . . . . . . 7.3.2 Simulation de chaîne de Markov à temps discret . . . . . . . 7.3.3 Simulation de chaîne de Markov à temps continu . . . . . . . 7.3.4 Simulation des files d’attente . . . . . . . . . . . . . . . . . . 7.3.4.1 Simulation la station M/M/1 . . . . . . . . . . . . . 7.3.4.2 Simulation des stations de files d’attente avec simpy 7.3.4.3 Exemple de station de lavage auto . . . . . . . . . . 7.3.4.4 Simulation des réseaux de files d’attente avec simpy 7.3.4.5 Simulation des files d’attente avec priorités . . . . . 7.4 Application : Ordonnancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 195 195 195 195 197 198 201 202 202 203 204 205 205 205 206 207 208 208 209 211 214 215 216 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TABLE DES MATIÈRES 7.5 6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 Appendices 221 A Dénombrement A.1 Principe de multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . A.2 Liste (Tirage Avec Ordre et Remplacement) . . . . . . . . . . . . . . . . A.3 Arrangement et permutation (Tirage avec Ordre et sans remplacement) A.4 Combinaison (Tirage sans ordre et sans remplacement) . . . . . . . . . . A.5 Combinaison avec répétition (Tirage sans ordre avec remplacement) . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 222 223 223 223 224 B Autres types de modèles de files d’attente B.1 Modèles de files d’attente avec priorité . . . . . . . . . B.2 Réseaux des files d’attente . . . . . . . . . . . . . . . . B.2.1 Files d’attente en série . . . . . . . . . . . . . . B.2.2 Réseaux de Jackson . . . . . . . . . . . . . . . B.3 Modèles avec des distributions non exponentielles . . . B.3.1 Service de distribution générale . . . . . . . . . B.3.2 Service de distribution dégénérée (déterministe) B.3.3 Service de distribution Erlang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 226 227 227 227 228 228 229 229 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C Tables statistiques 230 References 232 Préface À l’ère de l’intelligence artificielle, de la robotique, des systèmes intelligents et de l’apprentissage automatique, qui prennent de plus en plus de place dans pratiquement tous les domaines ; et depuis l’émergence des applications intelligentes sur lesquelles s’appuient la plupart des grands acteurs de l’informatique ; dans ce grand tourbillon technologique, on demande à l’informaticien de savoir, de créer et d’innover toujours plus. Cependant, le développement des compétences nécessaires pour la maîtrise de ces technologies récentes ne peut se concrétiser sans avoir les bases essentielles en probabilités qui est l’un de leurs piliers fondamentaux. La maîtrise des fondements de ce pilier est ainsi devenue chose incontournable. C’est dans cette optique que nous proposons cet ouvrage sur les probabilités, les processus stochastiques et la simulation, et dont le pari est de simplifier les concepts de bases par l’exemple et par la pratique. Cet ouvrage est destiné en premier lieu aux informaticiens, mais peut évidemment servir toute personne désirant apprendre les concepts élémentaires en probabilités avec leur côté pratique pour pouvoir par la suite, aborder d’autres sujets plus avancés tels que l’apprentissage automatique et l’intelligence artificielle. La particularité de cet ouvrage réside dans le nombre important d’exemples, d’exercices et de codes offerts dans le but de faciliter l’assimilation des différents concepts présentés. Les codes sont écrits en langage de programmation Python et permettent d’exposer les APIs et les bibliothèques les plus courantes et les plus efficaces pour la probabilités, les processus stochastiques et la simulation. Python étant l’un des langages de programmation les plus populaires que les débutants peuvent apprendre rapidement à cause de la simplicité de sa syntaxe et la lisibilité de son code. Il est polyvalent et ses packages sont parmi les plus matures des langages informatiques. La première partie de cet ouvrage est consacrée aux bases des probabilités : dans le premier chapitre les définitions des concepts les plus élémentaires en probabilités sont présentés. Le chapitre 2 se concentre sur la notion des variables aléatoires discrètes et continues en présentant les distributions de probabilité les plus connues. Dans les chapitres de la deuxième partie nous abordons respectivement, les processus stochastiques, les chaînes de Markov discrètes et continues, ainsi que leur application aux systèmes de files d’attente. La dernière partie quant à elle est consacrée à la simulation. Nous présentons d’abord les générateurs des nombres et des variables aléatoires, ensuite les différents modules offerts par Python pour la simulation des systèmes plus élaborés. Tout au long de l’ouvrage, le lecteur peut trouver une panoplie de codes Python. Les codes écrits montrent comment implémenter les différents concepts sur machine en utilisant les bibliothèques disponibles en Python, et en même temps, ils contribuent à leur enrichissement avec de nouvelles classes et fonctionnalités. Le code source est disponible sur la platforme Github sur le lien suivant https://github.com/ibslim/probabook. Enfin, et pour aider le lecteur à mieux appréhender l’utilité des concepts théoriques, nous avons ajouté plusieurs applications réelles avec leurs implémentations à la fin des chapitres. Plusieurs personnes ont fourni des évaluations précieuses de ce livre. Bien entendu, toutes les erreurs restent de la responsabilité des auteurs. Nous tenons à remercier Rachid Bechar pour sa contribution, ses commentaires et ses corrections. Nous sommes redevables à Mohammed Tayebi pour son examen approfondi et le temps précieux qu’il a passé à détecter plusieurs erreurs. Qu’Allah vous récompense pour vos efforts. Pour tout commentaire ou suggestion, le lecteur peut communiquer avec les auteurs sur l’adresse suivante : [email protected]. 7 Première partie Probabilités et variables aléatoires 8 9 Chapitre 1 Introduction à la Probabilité 1.1 Introduction Lorsque nous sommes confrontés à des événements incertains, c’est-à-dire des événements qui ne peuvent être prédits avec une certitude totale, nous essayons de connaître les chances (probabilités) qu’ils se produisent. La théorie des probabilités nous donne les outils pour quantifier ces chances, pour modéliser et étudier des situations incertaines complexes afin de pouvoir prendre les bonnes décisions. Par exemple, en IA (Intelligence Artificielle), les robots doivent évaluer leur environnement qui est principalement dynamique et incertain avant de choisir les actions (les plus appropriées) qui les conduisent à leurs objectifs. Dans ce chapitre, les bases de la théorie des probabilités sont présentées ainsi que de nombreux exemples, exercices et codes. 1.2 Expérience aléatoire Une expérience est un processus ou une procédure associés à un ensemble de conditions (artificielles ou naturelles) pouvant être répétées à l’infini. Elle possède un ensemble bien défini de résultats possibles observés lorsqu’on la réalise sous ces conditions et donne un et un seul résultat après sa réalisation. Le résultat de cette expérience est défini par l’observateur/expérimentateur (il s’intéresse à quoi ? quel est le sujet de l’observation ?). Si cette expérience se réalise en une seule étape alors elle est dite simple (élémentaire). Dans le cas contraire (nécessite plusieurs étapes), elle est dite composée. Une expérience est déterministe si les conditions déterminent de façon unique le résultat de la procédure réalisée (les mêmes conditions donnent toujours le même résultat avec certitude). Si après répétition de ce processus, les mêmes conditions d’expérimentation ne donnent pas nécessairement le même résultat, alors cette expérience n’est pas prévisible, elle est dite aléatoire (le résultat dépend du hasard). La modélisation de ce type d’expériences est l’objet de la théorie de probabilité. Un modèle de probabilités est une représentation mathématique de l’aspect aléatoire des expériences. Il consiste en une description complète des résultats possibles et une quantification de cette qualité de l’indéterminisme de ces phénomènes. Définition 1. Une expérience aléatoire est une expérience qui vérifie les deux conditions suivantes : - On peut déterminer parfaitement, par avance, tous les résultats possibles (il y en a au moins deux). - On ne peut pas prévoir, par avance, lequel de ces résultats sera obtenu même si on connaît les conditions d’expérimentation. Chaque renouvellement de l’expérience est appelé une épreuve. Pour, une expérience composée, une épreuve peut combiner plusieurs épreuves élémentaires, consécutives ou simultanées. Dans la suite de cet ouvrage, nous allons noter les expériences aléatoires R indicé par un numéro. 10 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 11 Définition 2. Soit R une expérience aléatoire. L’ensemble fondamental (univers) de R, noté Ω, est l’ensemble des résultats possibles de sa réalisation. Le résultat de l’expérience aléatoire R sera noté ω (élément de Ω). Si R est une expérience aléatoire composée des expériences aléatoires (Ri )1..n , alors son univers Ω est égal au produit cartésien des univers des Ri (Ωi ) dans l’ordre de leurs réalisations. Ω= n Y Ωi i=1 Chaque épreuve de R est notée comme un tuple ordonné (ω1 , ω2 , · · · , ωi , · · · , ωn ). 1.2.1 Univers discrets et continus L’ensemble des nombres naturels (les entiers positifs) est un ensemble infini et c’est un prototype des ensembles infinis dénombrables. En général, un ensemble infini est dit infini dénombrable s’il existe une fonction un à un (bijection : on peut étiqueter/énumérer ses éléments avec des entiers naturels) qui assigne les éléments de cet ensemble à l’ensemble des nombres naturels. En d’autres termes, chaque élément de l’ensemble peut être assigné à un nombre naturel unique et réciproquement, chaque nombre naturel correspond à un élément unique de cet ensemble. Par exemple, l’ensemble des nombres carrés : 1, 4, 9, 25, ... est un ensemble dénombrable infini. Les ensembles qui sont soit finis ou infinis dénombrables sont dit dénombrables. L’ensemble des points sur une ligne droite et l’ensemble des nombres réels entre 0 et 1 sont des exemples d’ensembles infinis non dénombrables. Les ensembles qui ne sont ni finis ni infinis dénombrables sont dits indénombrables. Comme tout ensemble, Ω peut être dénombrable ; Dans ce cas, on dit qu’il est discret ; le cas contraire (lorsque Ω est indénombrable), on dit qu’il est continu. Exemple 1. Soient les expériences suivantes : - R1 : Le lancer d’une pièce de monnaie. - R1 est aléatoire car on peut pas prévoir avec certitude le résultat avant sa réalisation. - Les résultats possibles de R1 sont pile et face notés p et f respectivement, donc Ω1 = {p, f } est fini (discret). - R2 : Lancer vertical d’une boule de masse m en l’air avec une vitesse initiale v et observer la hauteur h où sa vitesse s’annule : - R2 n’est pas aléatoire, elle est déterministe car on peut prévoir avec certitude son résultat avant sa réalisation, en appliquant les lois de la physique. (ce type d’expériences est intéressant lorsque nous avons un phénomène qui n’est pas aléatoire et on ignore sa loi ; pour la déterminer, on pose certaines hypothèses et expérimentalement on essaye de confirmer leurs validités et en déduire les lois qui gouvernent ce phénomène.) - R3 : Le lancer d’un dé : - R3 est aléatoire car on peut pas prévoir avec certitude le résultat avant sa réalisation. - Les résultats possibles de R3 sont les numéros des faces, donc Ω3 = {1, 2, 3, 4, 5, 6} est fini (discret). - R4 : Choisir une lettre aléatoirement du mot ’statistics’ - R4 est aléatoire car on ne peut pas prévoir avec certitude le résultat avant sa réalisation. - Les résultats possibles de R4 sont les lettres de ce mot, donc Ω4 = {s, t, a, i, c} est fini (discret). - R5 : Le lancer d’une pièce de monnaie suivi par le lancer d’un dé. - R5 est une expérience composée de deux expériences aléatoires simples R1 et R3 , puisqu’on ne peut pas prévoir les résultats des expériences aléatoires composantes alors on ne peut pas prévoir CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 12 celui de R5 , elle est donc aléatoire. - Un résultat possible de R5 est un tuple constitué du résultat de R1 suivi par celui de R3 . Son univers Ω5 est le produit cartésien de Ω1 et Ω3 qui est fini (discret). Ω5 = Ω1 × Ω3 = {p, f } × {1, 2, 3, 4, 5, 6} = {(p, 1), (p, 2), · · · , (f, 5), (f, 6)} - R6 : Nous lançons une pièce de monnaie trois fois. - R6 est une expérience composée de trois répétitions de la même expérience aléatoire simple R1 . Comme on ne peut pas prévoir les résultats de cette expérience composante alors on ne peut pas prévoir celui de R6 , elle est donc aléatoire. - Un résultat possible de R6 est un tuple constitué du résultat de chaque répétition de R1 dans l’ordre. Son univers Ω6 est le produit cartésien de Ω1 par lui même trois fois et qui est fini (discret). Ω6 = Ω31 = {p, f }3 = {(p, p, p), (p, p, f ), · · · , (f, f, p), (f, f, f )} - R7 : Pour un carré C dessiné dans le plan Q, on choisit au hasard un point à l’intérieur de C. - R7 est aléatoire par hypothèse (au hasard). - Les résultats possibles de R7 sont les points se situants dans le carré C, donc Ω7 = {(x, y) ∈ Q|(x, y) ∈ C}. Dans ce cas, on a un univers Ω7 qui est infini non dénombrable puisque Ω7 ⊂ R2 (continu). - R8 : Dans l’expérience qui consiste à lancer un dé jusqu’à l’apparition du nombre 6, l’univers est l’ensemble des nombres naturels Ω8 = N, le résultat k indique que le 6 est obtenu au k ieme lancer. Cet ensemble est discret (infini dénombrable). - R9 : Pour l’expérience qui consiste à mesurer le temps jusqu’à la première arrivée d’un événement donné, l’univers est l’intervalle Ω9 = [0, ∞[ de nombres réels positifs qui représentent le temps d’arrivée de l’évènement. Ω9 est continu (infini non dénombrable). À vos claviers! Le code suivant utils (qui se trouve dans le package "lib") est un module utilitaire. Il contient plusieurs fonctions communes à tous les codes. Les applications finies sont modélisées en Python avec la structure de données dict qui est un ensemble de paires (clé,valeur) où la clé est l’élément antécédent et la valeur est l’image de ce dernier. "utils.py" est dans un dossier appelé "lib" et sera importé en utilisant l’instruction suivante : "import sys ;sys.path.append(’../lib’)" puisqu’il n’est pas un module standard ou installé dans Python. # utils.py import matplotlib.pyplot as plt from sympy.stats import density from itertools import accumulate,product from fractions import Fraction #--------------------------------------------------------------------------------# Fraction is a class that respresents rational numbers Fracstr = lambda p,q : str(Fraction(p,q)) # To format the dictionary values to 2 decimal floats get_round_dic = lambda dic:{k:round(float(v),2) for k,v in dic.items()} # Returns the sample space (SS) of the random experiment (RE) get_Omega = lambda re: set(density(re).dict.keys()) # power: returns cartesian product of a set with itself n times set_Power = lambda omega,n: set(product(omega,repeat=n)) # product: returns the cartesian product of the given sets set_Product = lambda omegas: set(product(*omegas)) # filter: selects elements from a set based on some criterion set_Filter = lambda predicate,collection:set(filter(predicate,collection)) # Pe: returns the probabbility of an event from equally likely SS Pe = lambda Omega, Event : Fraction(len(Event), len(Omega)) # Pde: returns the probabbility of an elementary event from equally likely SS Pde = lambda Omega : { omega : Fracstr(1,len(Omega)) for omega in Omega} CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 13 # Pgiven: returns conditional probability of A given B Pgiven = lambda EventB,EventA :\ Fraction(len(set(EventA) & set(EventB)), len(EventA)) À vos claviers! Le code suivant modélise quelques expériences aléatoires données en exemples en utilisant le package sympy N 01 et itertools N 02 et en important les fonctions utilitaires suivantes : get_Omega, set_P roduct et set_P ower. # Code101.py from sympy.stats import Coin, Die import sys;sys.path.append(’../lib’) from utils import get_Omega,set_Product,set_Power """ In this section package sympy.stats is used class Coin models the coin tossing experiment class Die models the die rolling experiment """ Omega1 Omega3 Omega5 Omega6 = = = = {’P’,’F’} set(range(1,7)) set_Product([Omega1,Omega3]) set_Power(Omega1,3) ;print("Omega ;print("Omega ;print("Omega ;print("Omega 1 3 5 6 = = = = ",Omega1) ",Omega3) ",Omega5) ",Omega6) print("\n Using sympy.....................................\n") #R1 coin = Coin(’Coin’) coin_omega=get_Omega(coin) print("- R1 Toss a coin omega : ",coin_omega) #R3 die = Die(’Die’) die_omega=get_Omega(die) print("- R3 Roll die omega : ",die_omega) #R6 threeCoins_omega=set_Power(coin_omega,3) print("- R6 Toss coins omega : ", threeCoins_omega) #______________________________ Output ______________________________________ # Omega 1 = {’P’, ’F’} # Omega 3 = {1, 2, 3, 4, 5, 6} # Omega 5 = {(’F’, 5), (’P’, 1), (’F’, 1), (’P’, 2), (’F’, 2), (’P’, 3), # (’F’, 3), (’F’, 6), (’P’, 4), (’F’, 4), (’P’, 5), (’P’, 6)} # Omega 6 = {(’P’, ’F’, ’P’), (’P’, ’P’, ’P’), (’F’, ’P’, ’P’), (’P’, ’P’, ’F’), # (’P’, ’F’, ’F’), (’F’, ’P’, ’F’), (’F’, ’F’, ’P’), (’F’, ’F’, ’F’)} # Using sympy..................................... # - R1 Toss a coin omega : {H, # - R3 Roll die omega : {1, 2, # - R6 Toss coins omega : {(T, # (T, 1.2.2 T} 3, 4, 5, 6} T, T), (H, T, T), (H, H, H), (T, H, T), T, H), (H, T, H), (T, H, H), (H, H, T)} Espace probabilisable et évènements Définition 3. Soit R une expérience aléatoire dont l’univers est Ω, 1- Une Tribu (σ-Algèbre) F de Ω est un ensemble des parties de Ω vérifiant les propriétés suivantes : i- Ω ∈ F ii- F est clos pour le complément : ∀E ∈ F ⇒ E c ∈ F iii- F est clos pour l’union dénombrable des parties de Ω : [ {Ei }i≥0 ⊂ F ⇒ Ei ∈ F i≥0 - La paire (Ω, F) est appelée l’espace probabilisable associé à l’expérience aléatoire R. N01 : SymPy est une bibliothèque Python pour le calcul symbolique, elle offre la possibilité de manipuler les expressions algébriques. N02 : itertools contient un ensemble d’outils pour implémenter des blocs de construction itératifs (iterators). Il contient des fonctions de générateurs combinatoires product(), permutations(), combinations(). CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 14 Soit un espace probabilisable (Ω, F) associé à l’expérience aléatoire R. 2- Un événement E est un élément de la tribu F (sous ensemble de l’univers Ω). E est un évènement ⇐⇒ E ∈ F, ( E ⊂ Ω ) 3- Un événement élémentaire E est un événement qui est constitué d’un seul élément de Ω. E est un évènement élémentaire ⇐⇒ E ∈ F et |E| = 1( ∃ω ∈ Ω : E = {ω} ) Soit l’univers Ω, sa tribu la plus simple est l’ensemble constitué de deux parties Ω et ∅ (voir qu’elle vérifie toutes les propriétés i,ii et iii), elle est appelée la tribu triviale. L’ensemble constitué de toutes les parties de Ω (noté 2Ω ) vérifie les propriétés d’une tribu alors c’est la tribu maximale (appelée la tribu grossière). On dit qu’un événement E se produit si le résultat de l’expérience appartient à E. Exemple 2. Soient les expériences aléatoires de l’exemple 1.1 : 1- Pour toutes les Ri et Ωi , pour i de 1, 3, 4, 5, 6, nous avons : a- (Ωi , 2Ωi ) est un espace probabilisable (tribu grossière, toutes les parties de Ω sont des événements). b- (Ωi , {∅, Ωi }) est un espace probabilisable (tribu triviale, juste ces deux parties de Ω sont des évènements). 2- Pour R1 et Ω1 = {p, f }, on a : a- (Ω1 , {∅, {p}, {f }, {p, f }}) (tribu grossière). b- (Ω1 , {∅, {p, f }}) (tribu triviale). c- (Ω1 , {∅, {p}, {p, f }}) n’est pas un espace probabilisable car le complément de {p}, ({f } ∈ / F). 3- Pour R3 et Ω3 = {1, 2, 3, 4, 5, 6}, on a : a- (Ω3 , {∅, {1}, {2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6}}) est un espace probabilisable. b- (Ω3 , {∅, {1}, {2, 3, 4, 5, 6}, {1, 5}, {2, 3, 5}, {1, 2, 3, 4, 5, 6}}) n’est pas un espace probabilisable car la propriétés ii n’est pas satisfaite ({1, 5} ∪ {2, 3, 5} n’est pas un élément de F). 4- Pour R6 et Ω6 = {p, f }3 donnés, on a : a- (Ω6 , {∅, {(p, p, p)}, Ω6 /{(p, p, p)}, Ω6 }) est un espace probabilisable. Comme tout ensemble, en plus de sa forme explicite (en énumérant ses éléments), les événements sont décrits en donnant une propriété qui les caractérise de façon implicite. Souvent cette description est une expression langagière qui sera explicitée pour pouvoir faire un calcul dans le contexte de la théorie de la probabilité. A titre d’exemple, pour R3 (le lancer d’un dé), l’événement E décrit par la propriété suivante : "le résultat obtenu est un nombre pair" est explicitement décrit par E = {2, 4, 6}. La tribu des événements est un ensemble des sous ensembles, alors toutes les opérations ensemblistes sont valides sur la tribu. Seulement dans le cadre de cette théorie, on associe une terminologie spécifique (interprétation probabiliste) à ces opérations. Opération ensembliste Notation c Opération Se réalise ssi négation E ne se réalise pas Complément E Union E∪F ou E ou F se réalise Intersection E∩F et E et F se réalisent simultanément Différence E−F seulement de E se réalise et pas F Différence symétrique E∆F non simultanément E ou F se réalise mais pas E et F Afin de manipuler les événements, on utilise l’algèbre des ensembles (les propriétés de leurs opérations : associativité, distributivité, les relations de Morgan, etc). CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 15 Si E ∩ F = ∅ alors les deux évènements E et F sont disjoints. Deux évènements E et F sont mutuellement exclusifs si la réalisation de l’un exclu la réalisation de l’autre. Les évènements E1 , E2 , · · · , En sont mutuellement exclusifs si la réalisation de l’un exclu la réalisation des autres. À vos claviers! Le code suivant présente la manipulation des opérations sur les évènements. #Code102.py from sympy.stats import Die import sys;sys.path.append(’../lib’) from utils import get_Omega,set_Filter print("Events manipulation (operations)") abc_Omega = {1,2,3,4,5,6} A = {2,5} B = {3,4,5} isEvent = A < abc_Omega a_bar = abc_Omega - A C = A | B D = A & B E = A - B F = A ^ B ;print("Sample space Omega : ",abc_Omega) ;print("Event A : ", A) ;print("Event B : ",B) ;print("is A event of Omega : ", isEvent) ;print("Complement of A : ", a_bar) ;print("Union of A and B : ", C) ;print("Intersection of A and B : ", D) ;print("Difference of A and B : ", E) ;print("Symetric Diff A and B : ", F) # isEvenNumber: predicate to check if a number is even isEvenNumber = lambda nb : nb % 2 == 0 die_omega=get_Omega(Die(’Die’)) evenNb =set_Filter(isEvenNumber,die_omega) print("Event A even numbers : ", evenNb) evenNbComplement = set(die_omega) - set(evenNb) print("Event Complement of A : ", evenNbComplement) #______________________________ Output ______________________________________ # Events manipulation (operations) # Sample space Omega : {1, 2, 3, 4, 5, 6} # Event A : {2, 5} # Event B : {3, 4, 5} # is A event of Omega : True # Complement of A : {1, 3, 4, 6} # Union of A and B : {2, 3, 4, 5} # Intersection of A and B : {5} # Difference of A and B : {2} # Symetric Diff A and B : {2, 3, 4} # Event A even numbers : {2, 4, 6} # Event Complement of A : {1, 3, 5} À vos claviers! Le code suivant implémente l’expérience R6 avec E={(p,p,f),(p,f,p),(f,p,p)} l’événement que pile apparaît deux fois. #Code103.py from sympy import Symbol from sympy.stats import Coin import sys;sys.path.append(’../lib’) from utils import get_Omega,set_Power,set_Filter # class Symbol sets symbols for algebric expressions. "T" for coin tail # twoTails: checks if the outcome has two tails twoTails = lambda triple : triple.count(Symbol("T") )==2 coin_omega=get_Omega(Coin(’Coin’)) threeCoins_omega = set_Power(coin_omega,3) has2Tails = set_Filter(twoTails,threeCoins_omega) print("Event with two tails only : ", has2Tails) #______________________________ Output ______________________________________ # Event with two tails only : {(T, T, H), (H, T, T), (T, H, T)} CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 1.3 16 Probabilité Une probabilité est une fonction qui assigne un nombre réel entre 0 et 1 (inclus) à un évènement donné. Ce nombre représente la chance que cet évènement se réalise. Les axiomes de probabilités sont des règles mathématiques que la fonction de probabilité doit satisfaire. Définition 4. Soit l’espace probabilisable (Ω, F) associé à l’expérience aléatoire R. Une probabilité P est une fonction de F vers l’intervalle [0,1]. P : F 7→ [0, 1] qui satisfait les axiomes suivants : - normalité : P (Ω) = 1 (une norme sur Ω) - σ-Additivité-infinie : pour toute famille d’événements mutuellement exclusifs, la probabilité de leur union est la somme des probabilités de chacun d’eux. [ X {Ei }i>0 et ∀i 6= j, Ei ∩ Ej = ∅ =⇒ P ( Ei ) = P (Ei ) i>0 i>0 On appelle le triplet (Ω, F, P ) l’espace probabilisé. Dans le cas des espaces dénombrables, les probabilités peuvent être affectées à chaque sous ensemble de l’espace. Cependant, pour les espaces indénombrables, des sous ensembles "peu communs" peuvent être construits et pour lesquels, on ne peut pas associer une probabilité. Ainsi, et pour des raisons mathématiques fondamentales, une probabilité peut être affectée seulement pour les sous ensembles bien définis quand l’espace est indénombrables (l’axiome σAdditivité-infinie n’est pas toujours vérifiable dans certains cas, voir [11]). C’est pourquoi la probabilité est définie pour une tribu sur l’univers avec une structure particulière qui permet de satisfaire l’axiome du σ-additivité. L’affectation de la probabilité aux événements est, en fait, un passage d’un contexte concret vers un modèle mathématique. Pour que le choix des probabilités données aux événements soit pratique, l’affectation doit résulter en un modèle "convenable" pour les situations réelles. Il existe deux approches principales pour affecter des probabilités aux événements, l’approche de fréquence-relative et l’approche subjective (Bayesienne). Dans l’approche de fréquence-relative, les probabilités sont affectées aux résultats d’une expérience physique ayant la particularité de pouvoir être répétée plusieurs fois sous des conditions identiques. C’est le cas du lancer du dé par exemple, ces probabilités peuvent être déterminées expérimentalement. Dans l’approche subjective (Bayesienne), le mot probabilité est en général synonyme de plausibilité, la probabilité est définie comme le degré de croyance que possède une personne donnée concernant la réalisation d’un certain événement. C’est le cas, par exemple, des chances qu’on peut donner à une équipe de gagner un match. Cette approche est généralement limitée aux expériences qui ne peuvent pas être répétées. 1.3.1 Propriétés de la probabilité Proposition 1. Soit l’espace probabilisé (Ω, F, P ), les propriétés suivantes sont satisfaites : 1- Additivité-finie : Soit une séquence finie d’évènements {Ei }i∈{1..n} , mutuellement exclusifs alors : n n [ X P ( Ei ) = P (Ei ) i=1 i=1 2- Règle du complément : ∀E ∈ F, P (E c ) = 1 − P (E). CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 17 3- Règle de l’union : ∀E, F ∈ F, P (E ∪ F ) = P (E) + P (F ) − P (E ∩ F ) 4- Formule d’inclusion-exclusion : soit une séquence finie d’évènements {Ei }i∈{1..n} , P (∪ni=1 Ei ) = n X P (Ei )− i=1 X X P (Ei ∩Ej )+ i<j≤n P (Ei ∩Ej ∩Ek )...(−1)n−1 P (E1 ∩...∩En ) i<j<k≤n 5- Monotonicité : ∀E, F ∈ F, E ⊂ F ⇒ P (E) ≤ P (F ). Démonstration 1. 1- démontrons P que P (∅) = 0, en utilisant l’axiome de l’additivité-infinie avec Ei = ∅, ∀i. Nous ∞ avons P (∅) = i=1 ai tel que ai = P (∅), ∀i, ceci implique P (∅) = 0. Soit une séquence finie d’évènements {Ei }i∈{1..n} , mutuellement exclusifs alors, considérons la séquence infinie suivante : {Ai }i>0 tel que Ai = Ei , pour i ≤ n et Ai = ∅, pour i > n, donc : ∞ [ Ai = i=1 P( n [ Ei ) = P ( i=1 ∞ [ Ai ) = i=1 n X n [ Ei i=1 P (Ai ) + i=1 ∞ X P (Ai ) = i=n+1 n X P (Ei ) i=1 2- La deuxième propriété découle de la propriété de σ-Additivité-finie : Soit E un évènement, et E c son complément. Puisque E et E c sont mutuellement exclusifs. Et puisque E ∪ E c = Ω On a 1 = P (Ω) = P (E ∪ E c ) = P (E) + P (E c ), Donc P (E c ) = 1 − P (E). 4- Par induction, on suppose que la propriété est vraie, soit : Rn = ∪ni=1 Ei X X X P (Rn ) = P (Ei ) − P (Ei ∩ Ej ) + P (Ei ∩ Ej ∩ Ek ) + ... + (−1)n−1 P (E1 ∩ ... ∩ En ) i≤n i<j≤n i<j<k≤n On démontre la propriété pour Rn+1 n P (Rn+1 ) = P (∪n+1 i=1 Ei ) = P (En+1 ∪ (∪i=1 Ei )) = P (En+1 ) + P (Rn ) − P (En+1 ∩ Rn ) En+1 ∩ Rn = ∪ni=1 (En+1 ∩ Ei ) X P (En+1 ∩Rn ) = P (Ei ∩En+1 )− i<n+1 P (Rn+1 ) = X i≤n+1 1.3.2 P (Ei )− X P (Ei ∩Ej ∩En+1 )+...+(−1)n−1 P (E1 ∩...∩En+1 ) i<j<n+1 X i<j≤n+1 P (Ei ∩Ej )+ X P (Ei ∩Ej ∩Ek )+...+(−1)n P (E1 ∩...∩En+1 ) i<j<k≤n+1 Equiprobabilité Soit l’espace probabilisé (Ω, F, P ) : si Ω est fini (|Ω| = n < ∞) alors Ω = {ω1 , ω2 , · · · ωn } où ωi est un évènement élémentaire pour tout 1 ≤ i ≤ n, dans ce cas, on prend souvent F = 2Ω la tribu discrète de Ω et la probabilité P est caractérisée par la donnée de sa projection p sur Ω, p : Ω → [0, 1] tel que p(ωi ) = P ({ωi }) noté pi . Pour un évènement E = {ωi1 , ωi2 , · · · , ωih } on a: h X P ({ωi1 , ωi2 , · · · , ωih }) = pik k=1 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 18 Définition 5. Équiprobabilité Soit l’espace probabilisé (Ω, F, P ) : Les événements élémentaires sont dits équiprobables si Ω est fini et ils ont la même probabilité. 1 ∀ωi ∈ Ω, p(ωi ) = |Ω| La probabilité d’un évènement E dans cet espace est : ∀E ∈ F, P (E) = |E| |Ω| Dans ce cas, le calcul des probabilités revient à un dénombrement (voir annexe A). Dans les expériences aléatoires avec un espace de probabilités fini, il est naturel de supposer que les résultats sont équiprobables (ceci est, en fait, basé sur un jugement (croyance)). Ce modèle est appelé le modèle de probabilité classique ou modèle de Laplace. À vos claviers! Le code suivant utilise la fonction Pe définie dans Lib qui implémente le calcul de la probabilité d’un évènement dans le cas équiprobable. #Code104.py from functools import partial import sys;sys.path.append(’../lib’) from utils import Pe, Pde # partial: returns a new function from the given one by setting the specified parameters Omega = {1,2,3,4,5,6} ;print("Omega : ", Omega) A = {2,5} ;print("Event A : ", A) Pe = partial(Pe,Omega) pe_A = Pe(A) ;print("Probability of A : ", pe_A) Pde = Pde(Omega) ;print("Probability App : ", Pde) #______________________________ Output ______________________________________ # Omega : {1, 2, 3, 4, 5, 6} # Event A : {2, 5} # Probability of A : 1/3 # Probability App : {1: ’1/6’, 2: ’1/6’, 3: ’1/6’, 4: ’1/6’, 5: ’1/6’, 6: ’1/6’} Exemple 3. Trois dés non truqués sont lancés. Quelle est la probabilité que le score du troisième dé est égal à la somme des scores des deux premiers. Solution Dans ce cas l’espace probabilisé est : 1- Ω = {1, 2, 3, 4, 5, 6}3 = {(i, j, k) : i, j, k = 1..6} tel que i est le résultat du premier dé, j est le résultat du deuxième dé et k est le résultat du troisième dé. |Ω| = 6 × 6 × 6 = 216 2- La tribu est 2Ω 1 3- Si on considère que les résultats sont équiprobables, alors ∀ωi ∈ Ω, p(ωi ) = 216 . Donc pour cet espace probabilisé (Ω, 2Ω , P ), l’événement E que "le score du troisième dé est égal à la somme des scores des deux premiers" est composé des résultats suivants : E ={(1, 1, 2), (1, 2, 3), (2, 1, 3), (1, 3, 4), (3, 1, 4), (1, 4, 5), (4, 1, 5), (1, 5, 6), (5, 1, 6), (2, 2, 4), (2, 3, 5), (3, 2, 5), (2, 4, 6), (4, 2, 6), (3, 3, 6)} P (E) = |E| 15 5 = = |Ω| 216 72 À vos claviers! Le code de l’exemple précédent. #Code105.py from sympy.stats import Die import sys;sys.path.append(’../lib’) CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 19 from utils import get_Omega, Pe, Pde, set_Filter, set_Power die_Omega=get_Omega(Die(’Die’)) threeDices_Omega = set_Power(die_Omega , 3) print("- Drop 3 Dices Omega : ", list(threeDices_Omega)[:4]) print("- Omega length : " , len(threeDices_Omega)) P_3Dices_Omega = Pde(threeDices_Omega) print("- Proba mapping : " , list(P_3Dices_Omega.items())[:4]) # ev_Property: checks if the sum of the two first elements equals the 3rd one ev_Property = lambda omega : omega[0] + omega[1] == omega[2] E = set_Filter(ev_Property, threeDices_Omega) ; print("- E Length: ",len(E)) p_E = Pe(threeDices_Omega, E) ; print("- Probability of E : ",p_E) #______________________________ Output ______________________________________ # - Drop 3 Dices Omega : [(4, 2, 2), (1, 4, 4), (2, 2, 4), (5, 5, 1)] # - Omega length : 216 # - Proba mapping : [((4, 2, 2), ’1/216’), ((1, 4, 4), ’1/216’), ((2, 2, 4), ’1/216’), ((5, 5, 1) , ’1/216’)] # - E Length: 15 # - Probability of E : 5/72 Exemple 4. Dans un café, les clients paient une tasse de thé 30DA, 20DA ou 10DA. Pour savoir combien doit payer, le client lance un dé. Si 1 apparaît, il paie 10DA, s’il obtient 2,3,4 ou 5 alors il paie 20DA sinon il paie 30 DA. Deux amis vont à ce café, qu’elle est la probabilité que la somme payée par les deux ensemble ne dépasse pas 30DA ? Solution 1- L’univers de cette expérience est Ω = {1, 2, 3, 4, 5, 6}2 2- Puisque Ω est fini, alors on prend comme tribu 2Ω 3- On suppose que les éléments de l’univers sont équiprobables, donc ∀ωi ∈ Ω, P (ωi ) = 1/|Ω| = 1/36 Donc pour cet espace probabilisé (Ω, 2Ω , P ), soient les évènements suivants : E1 = { le premier paie 10 et le deuxième 10 } = {(i, j)|i = 1 et j = 1} E2 = { le premier paie 10 et le deuxième 20 } = {(i, j)|i = 1 et j ∈ {2, 3, 4, 5}} E2 = { le premier paie 20 et le deuxième 10 } = {(i, j)|i ∈ {2, 3, 4, 5} et j = 1} L’événement E que la somme payée par les deux ensemble ne dépasse pas 30 DA peut être écrit comme la réunion de ces trois évènements disjoints : E = E1 ∪ E2 ∪ E3 P (E) = P (E1 ∪ E2 ∪ E3 ) = P (E1 ) + P (E2 ) + P (E3 ) = 1 4 4 9 1 |E1 | |E2 | |E2 | + + = + + = = |Ω| |Ω| |Ω| 36 36 36 36 4 Exemple 5. Soit l’expérience du lancer de deux pièces. E est l’évènement que la première pièce donne face et F l’évènement que la seconde donne face. Quelle est la probabilité que la première ou la deuxième donne face ? Solution On note face par H et pile par T (Head et T ail en Anglais). 1- L’univers : Ω = {H, T }2 = {(H, H), (H, T ), (T, H), (T, T )} 2- La tribu F = 2Ω 3- La probabilité associée aux éléments de Ω équiprobables. Donc pour cet espace probabilisé (Ω, 2Ω , P ), soient les évènements suivants : On a : E ={ la première pièce donne face } F ={ la seconde pièce donne face } K ={ la première ou la deuxième donne face } 1 1 1 E ={(H, H), (H, T )}, P (E) = + = 4 4 2 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 20 1 1 1 + = 4 4 2 K =E ∪ F, P (K) = P (E ∪ F ) = P (E) + P (F ) − P (E ∩ F ) 1 puisque P (E ∩ F ) = P ({(H, H)}) = 4 1 1 1 3 P (K) = + − = 2 2 4 4 F ={(H, H), (T, H)}, P (F ) = À vos claviers! Le code de l’exemple précédent. #Code106.py from sympy.stats import Coin from sympy import Symbol from functools import partial import sys;sys.path.append(’../lib’) from utils import get_Omega, set_Power, set_Filter, Pde, Pe coin_Omega=get_Omega(Coin(’Coin’)) twoCoins_Omega = set_Power(coin_Omega, 2) print("- Toss 2 Coins Omega : ",twoCoins_Omega) p_2Coins_Omega = Pde(twoCoins_Omega) print("- Proba map : ",p_2Coins_Omega) # ev_Property: checks if the ith element of the outcome equals val ev_Property = lambda i, val, omega : omega[i] == val # set_Filter: filters the given SS using ev_Property with the specified parameters E = set_Filter(partial(ev_Property,0, Symbol("T")) , twoCoins_Omega) p_E = Pe(twoCoins_Omega, E) print("- Event E : ",E, " Probability : ",p_E) F = set_Filter(partial(ev_Property,1, Symbol("T")) , twoCoins_Omega) p_F = Pe(twoCoins_Omega, F) print("- Event F : ",F, " Probabulity : ",p_F) EF = E & F p_EF = Pe(twoCoins_Omega, EF) print("- Event E et F : ",EF, " Probability : ", p_EF) K = E | F p_K = p_E + p_F - p_EF print("- Event K (E or F) : ", K, " Probability : ", p_K) #______________________________ Output ______________________________________ # - Toss 2 Coins Omega : {(H, T), (T, T), (T, H), (H, H)} # - Proba map : {(H, T): ’1/4’, (T, T): ’1/4’, (T, H): ’1/4’, (H, H): ’1/4’} # - Event E : {(T, H), (T, T)} Probability : 1/2 # - Event F : {(T, T), (H, T)} Probabulity : 1/2 # - Event E et F : {(T, T)} Probability : 1/4 # - Event K (E or F) : {(H, T), (T, H), (T, T)} Probability : 3/4 Exemple 6. Ici nous cherchons à savoir quelle est la probabilité que dans une classe de n enfants (non jumeaux) au moins deux enfants ont le même jour d’anniversaire. On considère qu’une année possède 365 jours (on ignore le cas des années bissextile) et que tous les jours sont équiprobables. Solution Une classe de n enfants non jumeaux est représentée comme n-tuplet des dates de naissance de ces enfants (di dans l’ensemble Y = {d1 , d2 , · · · d365 } est celle du ieme enfant), L’expérience aléatoire consiste à choisir une liste de n éléments de Y (n-tuplet) comme résultat qui représente une classe. 1- L’univers : Ω = Y n = {(ωi1 , ωi2 , · · · , ωin )}1≤ik ≤365 dont la cardinalité est |Ω| = 365n 2- La tribu F = 2Ω 3- Les éléments de Ω sont équiprobables. Pour cet espace probabilisé (Ω, 2Ω , P ), soit l’événement suivant : E : Dans une classe de n enfants (non jumeaux) au moins deux enfants ont le même jour CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 21 d’anniversaire. (il existe une date d’anniversaire qui se répète plus d’une fois dans le n-tuplet). E c : est le complément de E , avoir une classe de n enfants dont les dates des anniversaires sont toutes différentes ; sa cardinalité est le nombre des arrangements (voir annexe A) de n éléments parmi 365. P (E) = 1 − P (E c ) = 1 − 365! An |E c | = f (n) = 1 − 356n = 1 − |Ω| 365 (365 − n)!365n Figure 1.1 – Probabilité en fonction de n À vos claviers! Le code de l’exemple précédent. #Code107.py # function prod of numpy is used to compute the product of the vector’s elements def get_birth(n, L): import numpy as np F = lambda n : 1 - np.prod([(365-i)/365 for i in range(n)]) E = [F(i) for i in range(n)] for i in L :print("F(",i,"):",F(i)) return E # plotter: plots the function associated with the birthday probability example def plotter(n,E): import matplotlib.pyplot as plt plt.plot(range(n), E, linewidth=1) xpos = [23, 30, 41, 57] for xc in xpos: plt.axvline(x=xc, color=’r’, linewidth=1, linestyle=’--’) ypos = [0.5, 0.7, 0.9, 0.99] for yc in ypos: plt.hlines(y=yc, xmin=0, xmax=100, linewidth=1, color=’r’, linestyle=’--’) plt.xlabel(’$n$’); plt.show() plt.ylabel(r’$F(n)$’); plt.title(’Birth day problem’) n = 100 L = [23,30,41,57] plotter(n,get_birth(n,L)) #______________________________ # F(23): 0.5072972343239857 # F(30): 0.7063162427192688 # F(41): 0.9031516114817354 # F(57): 0.9901224593411699 Output ______________________________________ La figure 1.4 montre la probabilité en fonction de n. Nous pouvons voir que pour n = 23, P (E) = 0.50, donc pour une classe de 23 élèves, il y a 50% de chance qu’au moins deux enfants aient le même jour d’anniversaire ce qui est tellement élevée par rapport à notre intuition. Pour n = 41 on aura p = 90% et p atteint 99% pour n = 57. N03 : Numpy est une bibliothèque Python pour le calcul numérique offrant des opérations pour manipuler les matrices, les vecteurs et les méthodes numériques usuelles. CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 22 Application Identifiant numérique des fichiers Parmi les applications concrètes de ce problème, on trouve les méthodes qui associent des identifiants numériques à des fichiers. Donc si nous avons n fichiers, il faut prendre K (qui est la taille de l’ensemble des identifiants assez grand pour que la probabilité que deux fichiers aient le même identifiant soit très faible). La fonction de hachage cryptographique En cryptographie, la fonction de hachage h est utilisée conjointement avec la signature électronique pour générer une empreinte numérique d’une information qui sera signée et attachée à cette information pour prouver son authenticité et afin de garantir l’objectif d’intégrité et la non répudiation. Elle associe à tout message m de taille arbitraire un message clé k de taille fixe identifiant m. h est définie : h : {0, 1}∞ → {0, 1}n En se basant sur la définition de h, l’attaque d’anniversaire (birth day attack) exploite les propriétés probabilistes pour violer le principe de l’intégrité en changeant le message m associé à une clé k. Comme la taille des messages est arbitraire et n est fixe alors il est possible de trouver deux messages différents qui ont la même clé par h. On dit qu’on a trouvé une collision et le problème associé est appelé le problème de collision. En donnant h, le but de cette attaque est de trouver deux messages m1 et m2 tel que m1 6= m2 et h(m1 ) = h(m2 ). Cette paire est appelée la collision. 1.4 Probabilités conditionnelles Soit A un évènement d’une expérience R. P (A) nous donne la chance de réalisation de A avant que l’expérience n’ait lieu. P (A) est appelée la probabilité inconditionnelle (à priori). Supposons que nous savons que dans cette expérience un évènement B s’est réalisé, mais nous ne savons pas si A l’est ou pas. Sachant que B s’est réalisé, l’espace Ω est remplacé par celui de B. La probabilité de réalisation de A sachant que B s’est réalisé est appelée la probabilité conditionnelle. Définition 6. Probabilité Conditionnelle Soit l’espace probabilisé (Ω, F, P ) associé à l’expérience aléatoire R et l’évènement B de probabilité non nulle. L’application PB définit de (Ω, F) vers l’intervalle [0, 1] par : ∀A ∈ F, PB (A) = P (A ∩ B) P (B) est une probabilité sur une tribu de B. (satisfait les axiomes de probabilité). On appelle PB la probabilité conditionnelle sachant B et on la note P (.|B). Lorsque P est équiprobable, alors |A ∩ B| ∀A ∈ F, P (A|B) = |B| Proposition 2. Propriétés de la probabilité conditionnelle Comme P(.|B) est une probabilité sur la restriction de l’univers sachant la réalisation de B, alors elle a les mêmes propriétés que la probabilité ordinaire. Exemple 7. Nous lançons deux dés tel que chacun des 36 résultats possibles est équiprobable. Nous observons que le premier dé donne 4 ; sachant cette information, quelle est la probabilité que la somme des deux dés soit égale à 6 ? CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 23 Solution Sachant cette information "avoir 4 comme résultat pour le premier dé", l’ensemble des résultats possibles de la suite de cette expérience (le nouvel univers) est : Ω = {(4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6)} associée à sa probabilité uniforme. Soit E l’événement ’la somme des deux dés est 6’ et F l’événement ’le premier dé est 4’. E ∩ F = {(4, 2)} |E ∩ F | 1/36 1 P (E ∩ F ) = = = P (E|F ) = P (F ) |F | 6/36 6 Ceci est dû au fait que si F se produit, alors pour que E puisse se produire, le résultat doit être dans E et F : E ∩ F . Et puisqu’on sait que F s’est produit, alors F devient le nouvel espace de probabilité et donc la probabilité que E ∩ F se produit sera égale à la probabilité de E ∩ F par rapport à la probabilité de F . À vos claviers! Le code solution de l’exemple précédent. #Code108.py import sys;sys.path.append(’../lib’) from utils import set_Power,set_Filter, Pe, Pgiven Omega = set_Power(range(1,7), 2) # set_Filter: filters the outcomes having the first element equals 4. F= set_Filter(lambda a: a[0] == 4,Omega) print("F given Event : ", F, ", P(F)=", Pe(Omega,F)) # set_Filter: filters the outcomes having the sum of the 1st and the 2nd elements equals 6. E= set_Filter(lambda a : a[0] + a[1] == 6,Omega) print("E event : ",E, ", P(E)=", Pe(Omega,E)) EF = E & F print("E and F event : ",EF, ", P(E & F)=", Pe(Omega,EF)) p_given_F = Pgiven(E,F) print("Probability of E given F : ", p_given_F) #______________________________ Output ______________________________________ # F given Event : {(4, 6), (4, 5), (4, 4), (4, 3), (4, 2), (4, 1)} , P(F)= 1/6 # E event : {(5, 1), (3, 3), (1, 5), (4, 2), (2, 4)} , P(E)= 5/36 # E and F event : {(4, 2)} , P(E & F)= 1/36 # Probability of E given F : 1/6 Exemple 8. Soit une urne U qui contient 4 boules rouges R et 6 vertes G. Deux boules sont tirées de U de façon aléatoire l’une après l’autre et sans remplacement. Quelle est la probabilité que la deuxième boule tirée est rouge sachant que la première tirée est rouge ? Solution R = {r1 , r2 , r3 , r4 } G = {g1 , g2 , g3 , g4 , g5 , g6 } U =R∪G Ω = {(b1 , b2 ) ∈ U 2 et b1 6= b2 }, |Ω| = |U |(|U | − 1) = 10 × 9 = 90 A = { 1ere boule rouge } = {(b1 , b2 ) ∈ Ω et b1 ∈ R}, |A| = |R|(|U | − 1) = 4 × 9 = 36 4×9 4 P (A) = |A| |Ω| = 10×9 = 10 eme B={2 boule rouge } = {(b1 , b2 ) ∈ Ω et b2 ∈ R} A ∩ B = {(b1 , b2 ) ∈ Ω, b1 ∈ R et b2 ∈ R}, |A ∩ B| = |R|(|R| − 1) = 4 × 3 = 12 12 P (B ∩ A) = |A∩B| |Ω| = 90 Sachant que A s’est réalisé, donc on a un nouvel univers : ΩA = A, et la tribu associée est 2ΩA . Dans cet univers, soit l’évènement BA "la deuxième boule est rouge" : BA = {(ri , rj ) ∈ ΩA , rj ∈ R} = A ∩ B, |BA | = |A ∩ B| P (B|A) = |BA | |A ∩ B| |Ω| |A ∩ B| P (A ∩ B) 12 1 = = × = = = |ΩA | |A| |A| |Ω| P (A) 36 3 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 24 À vos claviers! Le code solution de l’exemple précédent. #Code109.py from functools import partial import sys;sys.path.append(’../lib’) from utils import Pe, Pgiven, set_Filter # get_diff_pairs: returns cartesian product of U discarding the diagonal elements def get_diff_pairs(U): return [(i,j) for i in U for j in U if i!=j] R = { ’r1’ , ’r2’, ’r3’, ’r4’ } B = { ’b1’, ’b2’, ’b3’, ’b4’, ’b5’, ’b6’ } Omega=get_diff_pairs(R | B) P=partial(Pe,Omega) # selects the outcomes having the 1st element starting with ’r’ A=set_Filter(lambda X:X[0][0]==’r’,Omega) print("Probability of A:",P(A)) B=set_Filter(lambda X:X[1][0]==’r’,Omega) print("Probability of B:",P(B)) AB=set_Filter(lambda X:X[0][0]==’r’ and X[1][0]==’r’,Omega) print("Probability of AB:",P(AB)) print("Probability of B given A:",Pgiven(B,A)) #______________________________ # Probability of A: 2/5 # Probability of B: 2/5 # Probability of AB: 2/15 # Probability of B given A: 1/3 1.4.1 Output ______________________________________ Probabilités composées Ayant une urne qui contient deux boules bleues et trois boules rouges, quelle est la probabilité de tirer (sans remplacement) une boule rouge ensuite une boule bleue. Le raisonnement commun est que 3/5 est la probabilité que la première boule soit rouge (inconditionnelle), ensuite 2/4 = 1/2 est la probabilité que la deuxième boule tirée soit bleue car pour le deuxième tirage on sait qu’il n’en reste que 4 boules dans l’urne (conditionnelle). Donc la probabilité que la première soit rouge et la deuxième soit bleue est 3/5 × 1/2 = 3/10 : si R est l’évènement de tirer une boule rouge en premier et B l’évènement de tirer une boule bleue en deuxième alors P (R ∩ B) = P (R) × P (B|R), celle-ci est appelée la règle de la chaîne et peut être étendue à n évènements successifs comme suit : Proposition 3. Soit une famille d’évènements (Ei )i∈I Si I est fini et ∀i ∈ I, P (Ei ) 6= 0 alors : \ P ( Ei ) = P (E1 )P (E2 |E1 ) · · · P (En |E1 ∩ · · · ∩ En−1 ) 1.4.2 Probabilités totales Soit l’expérience qui consiste à lancer un dé, le résultat obtenu est dans {1,2,3,4,5,6}, ensuite une pièce de monnaie est lancée un nombre de fois égal au résultat obtenu par le dé. Supposons que la pièce de monnaie est truquée tel que p(pile)=3/4 et p(face)=1/4, et on veut calculer la probabilité de ne pas obtenir pile dans cette expérience. Ω se compose d’une partition dont chaque élément correspond à une valeur de k obtenue par le lancer du dé. Par exemple pour k = 2, la partie associée est {(P, P ), (P, F ), (F, P ), (F, F )}. Pour chaque valeur de k la probabilité de ne pas avoir pile est p(pilec ) = (1/4)k , et puisque les évènements correspondants aux différentes valeurs de k sont mutuellement exclusifs, alors la probabilité recherchée est : 11 1 1 1 1 1 1 1 1 1 1 + ( )2 + ( )3 + ( )4 + ( )5 + ( )6 = 0.1641 46 4 6 4 6 4 6 4 6 4 6 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 25 Proposition 4. Soit (Ei )i∈I une partition de Ω (évènements mutuellement exclusifs) et A un évènement, alors : X P (A) = P (A|Ei )P (Ei ) i∈I Figure 1.2 – Diagramme de probabilités Totales Soit la partition A et Ac (Ā) de Ω, on peut visualiser la formule de probabilités totales par le diagramme des probabilités conditionnelles dont les branches attachées à la racine représentent cette partition avec sa probabilité associée auxquelles d’autres branches sont attachées et qui représentent les évènements B et B̄ conditionnées par A et Ā. Pour calculer la probabilité totale de B, il suffit de sommer les probabilités des branches menant à B. Figure 1.3 – Diagramme de probabilités conditionnelles 1.4.3 Formule de Bayes Proposition 5. Formule de Bayes Soit (Ei )i∈I une partition de Ω et A un évènement, alors : P (A|Ei )P (Ei ) j∈I P (A|Ej )P (Ej ) P (Ei |A) = P Ceci vient du fait que : P (Ei |A) = P (Ei ∩ A) P (A ∩ Ei ) P (A|Ei )P (Ei ) = =P P (A) P (A) j∈I P (A|Ej )P (Ej ) Une autre approche pour exprimer la règle de Bayes, est l’utilisation du taux de probabilité (odds). Le taux de probabilité d’un évènement A est défini par : OA = P (A) P (A) OA = et la probabilité de A : P (A) = c 1 − P (A) P (A ) 1 + OA CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 26 Soient H et E deux évènements qui représentent respectivement une hypothèse et une preuve d’une affaire donnée. OH|E = P (H|E) P (E|H)P (H) P (E) P (E|H) P (H|E) = = × = OH × 1 − P (H|E) P (H c |E) P (E) P (E|H c )P (H c ) P (E|H c ) P (H) P (H c ) est le P (E|H) P (E|H c ) est appelé OH = taux de probabilité à priori de H (avant la connaissance de E). le taux de vraisemblance ou le facteur de Bayes. Cette règle met à jour le taux de probabilité à priori de H|E en multipliant le taux de probabilité à priori de H par le facteur de Bayes, ce qui indique combien la nouvelle preuve (E) change notre croyance en cette hypothèse. Exemple 9. [10] Une équipe de plongeurs sous-marin cherche une épave de navire. Ils croient qu’elle existe dans la zone de recherche avec une probabilité 0.4. Une recherche dans cette zone permet de détecter l’épave avec une probabilité 0.9 si elle existe. Quelle est la probabilité que l’épave soit dans cette zone si l’équipe effectue la recherche sans détecter l’épave ? Solution : H : l’épave existe E : l’épave n’est pas détectée Nous cherchons P (H|E). Méthode1. OH|E = P (H|E) = OH|E OH|E +1 = P (H) P (E|H) 0.4 0.1 1 P (H|E) = × = × = P (H c |E) P (H c ) P (E|H c ) 0.6 1 15 1 16 Méthode2. P (H|E) = 0.1 × 0.4 1 P (E|H) × P (H) = = c c P (E|H) × P (H) + P (E|H ) × P (H ) 0.1 × 0.4 + 1 × 0.6 16 Exemple 10. On cherche la probabilité de devoir tirer au moins 5 cartes (5 ou plus) d’un paquet de 52 cartes avant que le premier as n’apparaît. Solution La première façon de résoudre ce problème est de calculer la taille de l’espace de probabilités qui contient 52! éléments, et de calculer le nombre d’éléments dans l’événement E de tirer au moins 5 cartes avant que le premier as n’apparaît et qui contient 48 × 47 × ... × 44 × 47!, nous avons donc 48 × 47 × ... × 44 × 47! P (E) = = 0.6588 52! Une autre façon plus simple pour calculer la même probabilité consiste à appliquer la règle de la chaîne en considérant les étapes successives de l’expérience. Soit Ei l’événement que le ieme tirage n’est pas un as, alors : P (E1 ∩ E2 ∩ ... ∩ E5 ) =P (E1 )P (E2 |E1 ) · · · P (E5 |E4 , E3 , ..., E1 ) 48 47 44 = × × ... × 52 51 48 =0.6588 Dans la deuxième méthode, il suffit de trouver les probabilités de quelques événements bien choisi sans devoir explicitement spécifier l’espace de probabilités. Exemple 11. Dans un examen, les étudiants doivent répondre à une question à choix multiple. Un étudiant connaît la réponse avec une probabilité p ou bien il la devine (avec une probabilité 1 − p). Ayant n réponses proposées dont une seule est correcte. Quelle est la probabilité que l’étudiant connaît la réponse sachant qu’il a choisi la bonne réponse ? CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 27 Solution Soit E l’événement que l’étudiant connaît la réponse et F que sa réponse est juste. En appliquant la formule de Bayes, On a : P (E|F ) = P (E ∩ F ) P (F ) P (F |E) × P (E) P (F |E) × P (E) + P (F/E c ) × P (E c ) 1×p = 1 × p + 1/n × (1 − p) n×p = 1 + (n − 1) × p = À vos claviers! Le code solution de l’exemple précédent. #Code110.py from itertools import product N, p = 4, 0.4 # omega’s outcomes are represented as tuples (X,i,j) s.t : # X is Y if the student knows the answer and N otherwise # i is the correct answer and j is the given answer E = set(product({’N’},set(range(1,N+1)),set(range(1,N+1)))) F = set([(’Y’,i,i) for i in range(1,N+1)]) Omega = F.union(E); Dist = { o : (1-p)/(N*N) if o[0]==’N’ else p/N print(Dist) for o in Omega } PF = 0; PEF=0 for i in Omega: if i[1] == i[2]: PF += Dist[i] if i[0] == ’Y’ : PEF += Dist[i] print("P(E|F) = %0.5f" % (PEF/PF)) print("Bayes rule: ",N*p/(1+(N-1)*p)) #______________________________ Output ______________________________________ # {(’N’, 3, 3): 0.0375, (’Y’, 4, 4): 0.1, (’Y’, 2, 2): 0.1, (’N’, 4, 3): 0.0375, # (’N’, 3, 2): 0.0375, (’N’, 1, 4): 0.0375, (’N’, 2, 2): 0.0375, (’N’, 4, 4): 0.0375, # (’Y’, 1, 1): 0.1, (’N’, 3, 4): 0.0375, (’N’, 1, 3): 0.0375, (’N’, 2, 3): 0.0375, # (’N’, 1, 2): 0.0375, (’N’, 1, 1): 0.0375, (’N’, 2, 1): 0.0375, (’Y’, 3, 3): 0.1, # (’N’, 3, 1): 0.0375, (’N’, 2, 4): 0.0375, (’N’, 4, 1): 0.0375, (’N’, 4, 2): 0.0375} # P(E|F) = 0.72727 # Bayes rule: 0.7272727272727273 Exemple 12. Nous avons trois urnes, chacune contient 100 boules. — L’urne 1 contient 75 rouges et 25 vertes — L’urne 2 contient 60 rouges et 40 vertes — L’urne 3 contient 45 rouges et 55 vertes Nous choisissons une urne aléatoirement, ensuite nous tirons aléatoirement une boule de cette urne. 1- Quelle est la probabilité que la boule choisie soit rouge ? 2- Supposons que nous avons tiré une boule rouge, quelle est la probabilité que cette boule est tirée de l’urne 1. Solution - Soit E l’événement que la boule tirée soit rouge. - Soit Fi l’événement que la iéme urne est choisie. 1- En utilisant le théorème de probabilité totales, nous avons P (E) =P (E|F1 )P (F1 ) + P (E|F2 )P (F2 ) + P (E|F3 )P (F3 ) =75/100 × 1/3 + 60/100 × 1/3 + 45/100 × 1/3 =3/5 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 28 2- En utilisant la règle de Bayes, nous avons P (E|F1 )P (F1 ) P (E) =(75/100 × 1/3)/(3/5) P (F1 |E) = =5/12 En utilisant le diagramme des probabilités conditionnelles, on peut trouver la probabilité des branches qui se terminent avec E. Il suffit de sommer ces valeurs pour trouver la probabilité de E (la probabilité totale). Figure 1.4 – Diagramme de probabilités conditionnelles Exemple 13. [9] Une maladie donnée affecte une personne sur 10000. Il existe un test pour vérifier si une personne en est atteinte. La probabilité que le résultat soit positif alors que la personne n’a pas la maladie est 2%. La probabilité que le résultat soit négatif alors que la personne a la maladie est 1%. Une personne a effectué le test qui a donné un résultat positif. Quelle est la probabilité que la personne ait la maladie en question ? Solution Soit M l’événement que la personne ait la maladie et T l’événement que le résultat des analyses soit positif. 1 10000 P (T |M c ) =0.02 P (M ) = P (T c |M ) =0.01 P (T |M ) =1 − 0.01 = 0.99 On applique la règle de Bayes : P (T |M )P (M ) P (T |M )P (M ) + P (T |M c )P (M c ) 0.99 × 0.0001 = = 0.0049 0.99 × 0.0001 + 0.02 × (1 − 0.0001) P (M |T ) = 1.5 Indépendance Il faut noter que dans l’exemple 1.8 si nous remplaçons les boules après chaque tirage, les probabilités ne changent pas, ceci est dû au fait que l’environnement initial de l’expérience ne change pas (comme si la même expérience a été répétée une nouvelle fois). CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 29 Les événements sont donc indépendants lorsque chaque événement n’est pas affecté par les autres événements. C’est le cas du lancer de pièce où chaque lancer est un événement indépendant, c.à.d que les lancers précédents n’affectent pas le lancer courant et la probabilité est 1/2 à chaque lancer. Définition 7. Deux événements E et F sont indépendants (noté E ⊥ F ) si : P (E ∩ F ) = P (E)P (F ) Cette définition implique que : P (E|F ) = P (E), ceci veut dire que E et F sont indépendants si le fait de savoir que F s’est produit n’affecte pas la probabilité que E se produise, alors E est indépendant de F . Parfois l’indépendance de deux événements est claire car il n’existe pas d’interactions physiques entre eux ; mais quand ce n’est pas le cas, on doit vérifier si la condition d’indépendance est satisfaite. Exemple 14. Supposons que deux dés sont lancés. Soit A l’événement que le résultat du premier dé est égal à 3, B est l’événement que la somme des deux est 9 et C l’événement que la somme des deux est égale à 7. Est ce que A et B sont indépendants ? même question pour A et C. Solution L’expérience a 36 résultats équiprobables (i, j) : 1 ≤ i, j ≤ 6 tel que i est le résultat du premier dé et j le résultat du second. 1 6 = 36 6 4 1 P (B) = P ({(i, j)|i + j = 9, 1 ≤ i, j ≤ 6}) = = 36 9 1 P (A ∩ B) = P ({(3, 6)}) = 36 P (A ∩ B) 6= P (A)P (B) P (A) = P ({(i, j)|i = 3, 1 ≤ j ≤ 6}) = A et B sont donc dépendants. P (C) = P ({(i, j)|i + j = 7, 1 ≤ i, j ≤ 6}) = P (A ∩ C) = P ({(3, 4)}) = 6 1 = 36 6 1 36 P (A ∩ C) = P (A)P (C) A et C sont donc indépendants. On peut expliquer ce résultat par le fait que l’évènement C peut se réaliser pour n’importe quel valeur obtenue par le premier dé, donc il est indépendant de celui-ci. Ceci n’est pas le cas pour l’évènement B car on ne peut pas avoir une somme de 9 si par exemple le premier dé donne 1 ou 2 donc la réalisation de B dépend du résultat du premier dé. On ne doit pas confondre événements disjoints et événements indépendants. En effet, si E et F sont disjoints alors il ne sont pas indépendants parce-que si P (E) 6= 0 et P (F ) 6= 0 alors, P (E ∩ F ) = 0 car E ∩ F = ∅ et P (E) × P (F ) 6= 0 et les deux sont non nulles ce qui veut dire que E et F ne sont pas indépendants. 1.5.1 Indépendance conditionnelle Le concept d’indépendance peut être étendu aux événements conditionnellement indépendants. CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 30 Définition 8. Deux événements A et B sont conditionnellement indépendants sachant un autre événement C tel que P (C) > 0 si : P (A ∩ B|C) = P (A|C) × P (B|C) Si A et B sont conditionnellement indépendants, alors on a P (A|B, C) = P (A|C). En effet : P (A|B, C) = P (A|C) × P (B|C) P (A ∩ B|C) = = P (A|C) P (B|C) P (B|C) Exemple 15. On note face par H et pile par T (Head et T ail en Anglais). Dans une boite il existe deux pièces, la première non truquée et la deuxième est truquée de sorte que P (T ) = 1. On choisit une pièce aléatoirement et on la lance deux fois. Soit les événements suivants : — A : l’événement que le premier lancer donne pile (T). — B : l’événement que le deuxième lancer donne pile (T). — C : l’événement que la première pièce soit choisie. Calculer P (A|C), P (B|C), P (A ∩ B|C), P (A), P (B), P (A ∩ B) Solution P (A|C) = P (B|C) = 21 P (A ∩ B|C) = 14 = 12 × 12 = P (A|C)P (B|C) Donc A et B sont conditionnellement indépendants. En utilisant la règle de probabilité totale, nous avons : 1 1 1 3 × +1× = 2 2 2 4 1 1 3 1 P (B) = P (B|C)P (C) + P (B|C c )P (C c ) = × + 1 × = 2 2 2 4 P (A ∩ B) = P (A ∩ B|C)P (C) + P (A ∩ B|C c )P (C c ) P (A) = P (A|C)P (C) + P (A|C c )P (C c ) = = P (A|C)P (B|C)P (C) + P (A|C c )P (B|C c )P (C c ) 1 1 1 1 5 = × × +1×1× = 2 2 2 2 8 Ici, on peut remarquer que A et B ne sont pas indépendants car : P (A ∩ B) = 5 9 6= P (A)P (B) = 8 16 À vos claviers! Le code solution de l’exemple précédent. #Code111.py from sympy.stats import Coin, density, given, FiniteRV, P from sympy import Symbol, Eq import sys;sys.path.append(’../lib’) from utils import get_Omega,set_Product #pmf_i: returns the probability of getting tail in the ith toss of coin omega[0] pmf_i = (lambda omega, i : (density(cf).dict[omega[i]] if omega[0]==1 else density(cu).dict[omega[i]])) # The outcome is encoded as follows (H=1, T=2): # chosen coin * 100 + 1st toss * 10 + 2nd toss encode_omega = (lambda o: o[0]*100+(1 if o[1]==H else 2)*10+(1 if o[2] == H else 2)) get_proba = lambda o : PC[o[0]] * pmf_i(o, 1) * pmf_i(o, 2) H=Symbol(’H’) # PC: chosen coin, cu: unfair coin, cf: fair coin PC, cu, cf = { 1:1/2, 2:1/2}, Coin(’CU’, 1) , Coin(’CF’) omegaPC , omegaC = PC.keys(), get_Omega(cf) CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ # generates the SS of the experiment (X,Y,Z): # X is the chosen coin, Y, Z is the outcome of resp, the 1st and 2nd Omega = set_Product([omegaPC, omegaC, omegaC]) dist = { o: PC[o[0]]* pmf_i(o, 1) * pmf_i(o, 2) for o in Omega } print("Distribution : ", dist) 31 toss # Encodes the distribution’s outcomes as numbers to make it easy for events handling dist_encoded = { encode_omega(o) : get_proba(o) for o in Omega } print("Encoded distribution : ",dist_encoded) X A B C AB = = = = = FiniteRV(’X’, dist_encoded) X % 100 < 20 ; print("Probability X % 10 < 2 ; print("Probability X < 200 ; print("Probability Eq(X % 100,11) ; print("Probability AGC = given(A,C) BGC = given(B,C) ABGC = given(AB,C) of of of of getting T in the first toss: %0.2f" % P(A)) getting T in the second toss: %0.2f" % P(B)) choosing the first coin: %0.2f" % P(C)) A and B: %0.2f" % P(AB)) ; print("Probability of A|C: %0.2f" % P(AGC)) ; print("Probability of B|C: %0.2f" % P(BGC)) ; print("Probability of A and B | C: %0.2f" % P(ABGC)) #______________________________ Output ______________________________________ # Distribution: {(2, T, T): 0, (2, H, H): 0.5, (2, T, H): 0, (2, H, T): 0, # (1, T, T): 0.125, (1, H, T): 0.125, (1, T, H): 0.125, (1, H, H): 0.125} # Encoded distribution: {222: 0, 211: 0.5, 221: 0, 212: 0, 122: 0.125, # 112: 0.125, 121: 0.125, 111: 0.125} # Probability of getting T in the first toss: 0.75 # Probability of getting T in the second toss: 0.75 # Probability of choosing the first coin: 0.50 # Probability of A and B: 0.62 # Probability of A|C: 0.50 # Probability of B|C: 0.50 # Probability of A and B | C: 0.25 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 1.6 32 Exercices Exercice 1. Soient les expériences suivantes : - R1 : Le genre du délégué choisi d’une classe de 20 étudiants. - R2 : La distance entre la fléchette et le centre de la cible dans le jeu des fléchettes (La cible a 30cm de diamètre). - R3 : L’adresse IP du premier site web visité après une recherche sur Google (les adresses IP sont de la forme a.b.c.d tel que a,b ,c,d sont des nombres entre 0 et 255). - R4 : Les numéros des boules obtenues d’un tirage de deux boules sans remise (l’une après l’autre) d’une urne qui contient cinq boules numérotées. - R5 : Le temps total nécessaire pour vider un réservoir d’eau de volume V équipé avec une vanne de diamètre D. - R6 : Le choix d’une classe parmi 6 classes et le choix de l’enseignant de math parmi 3 enseignants pour cette classe. - R7 : Nombre de naissances dans un hôpital par jour - R8 : La durée maximale du retard des étudiants qui arrivent à un cours de 60 mns. - R9 : Jeter une barre B à l’intérieur d’un cercle C, ensuite observer l’angle entre le diamètre horizontal de C et B. - R10 : Jeter une barre B de longueur l sur un plan dans lequel un cercle C de diamètre D est dessiné et observer si B tombe à l’intérieur de C. 1- Déterminer pour chacune des expériences si : elle est aléatoire ou non, si la réponse est oui, donner sa nature (simple/composée), son univers et spécifier le type de ce dernier(discret/continu). 2- Coder les expériences 1,4, 6, 9, 10. Exercice 2. 1- Donner l’espace probabilisable correspondant à la tribu triviale et celui de la tribu grossière des EAs 1,4, 6, 9, 11 de l’exercice 01. 2- Soient les ensembles de parties de Ω = {1, 2, 3} suivants : A- F = {{1, 2}, {1, 2, 3}} B- F = {{}, {1}, {1, 2, 3}, {2, 3}} C- F = {{}, {1}, {2}, {2, 3}} D- F = {{}, {1}, {2}, {3}, {1, 3}, {2, 3}, {1, 2}, {1, 2, 3}} Dites lesquels sont des tribus. Exercice 3. Donner un espace probabilisable correspondant à une EA avec une tribu non triviale et non grossière. Exercice 4. Pour les EP des EA de l’exercice 01, donner : 1- des exemples d’évènements 2- des exemples d’évènements disjoints Exercice 5. Codage Écrire le code Python qui : 1- génère la tribu triviale et grossière d’un ensemble fini donné. 2- vérifie si un ensemble de partie d’un ensemble fini donné est une tribu. 3- vérifie si un ensemble est un évènement d’un EP donné. 4- retourne l’union et l’intersection d’une collection de parties de Ω Exercice 6. Codage En utilisant la classe Die avec 4 faces du module sympy.stat (voir chapitre 7) 1- Modéliser l’EA du lancer de deux dés, afficher son univers. 2- Écrire une lambda expression qui correspond à l’évènement E1 "la somme des résultats obtenus est premier". 3- Écrire une lambda expression qui correspond à l’évènement E2 "le produit des résultats obtenus est supérieur à k" (k donné en paramètre). CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 33 4- Afficher l’évènement E1 et son complément. 5- Afficher l’évènement E2 , son complément, sa réunion et son intersection avec E1 . Exercice 7. Codage En utilisant la classe Die avec 8 faces du module sympy.stat (voir chapitre 7) : 1- Afficher son univers 2- Écrire une lambda expression qui correspond à l’évènement "le résultat obtenu est multiple de k" (k donné en paramètre). 3- Écrire une lambda expression qui correspond à l’évènement "le résultat obtenu est inférieur à k"(k donné en paramètre). 4- Afficher l’évènement A "le résultat obtenu est multiple de 2" et son évènement complémentaire. 5- Afficher l’évènement B "le résultat obtenu est multiple de 7", son complément, sa différence et sa différence symétrique avec A. Exercice 8. 1- Trouver c pour que les applications suivantes soient des probabilités : i- f (k) = c/k! tel que k ∈ N ii- f (k) = cxk tel que 0 < x < 1 et k ∈ N Exercice 9. Codage 1- Écrire la fonction Python qui retourne la distribution non équiprobable d’un univers Ω fini Pn de n évènements élémentaires, où ei a comme probabilité pi = i/ k=1 k. 2- Afficher la probabilité des évènements A = {i est pair }, B = {i < n/2}. Exercice 10. Soit l’expérience aléatoire qui consiste à lancer trois pièces de monnaie non truquées. 1- Quelle est la probabilité que le score de la troisième pièce soit différent des scores des deux premières. 2- Codage. Écrire le code Python qui simule cette expérience. Exercice 11. Soit une famille d’évènements {Ei }{1≤i≤m} de l’espace probabilisable (Ω, F, P ). Les collections de k (1 ≤ k ≤ m) évènements de cette famille notée {Ai }{1≤i≤k} vérifiant les conditions suivantes : 1 , ∀1 ≤ i ≤ k i. P (Ai ) = m 1 ii. P (Ak |A1 , A2 , ..., Ak−1 ) = m−k+1 , ∀1 ≤ k ≤ m 1- Démontrer la propriété suivante : ∀k ≤ m, P (Ak ∩ Ak−1 , ..., A2 ∩ A1 ) = (m − k)! m! 2- Pour m assez grand, démontrer que : P (Am ∪ Am−1 ∪ ... ∪ A2 ∪ A1 ) ≈ 1 − * Pour la question 2, utiliser la formule suivante : xn n=0 n! P∞ 1 e = ex Exercice 12. 1. Démontrer la propriété 3 (la règle de l’union) de la proposition 1. 2. Démontrer la propriété 5 (la monotonicité) de la proposition 1. Exercice 13. Une pièce de monnaie non truquée est lancée 80 fois. Quelle est la probabilité d’avoir exactement 40 piles ? Exercice 14. Quelle est la probabilité que deux différentes faces apparaissent chacune deux fois dans le lancer de 4 dés ? Codage Implémenter la solution de cet exercice en : 1. Générant les éléments de Ω et des évènements associés et calculer la probabilité demandée. 2. Programmer le calcul de la même probabilité en utilisant l’analyse combinatoire. CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 34 Exercice 15. Deux dés sont lancés. Quelle est la probabilité conditionnelle que la somme des deux soit égale à 6 sachant que les deux valeurs obtenues sont différentes. Codage implémenter la solution de cet exercice en : 1. Générant les éléments de Ω et des évènements associés et calculer la probabilité demandée. 2. Programmer le calcul de la même probabilité en utilisant l’analyse combinatoire. Exercice 16. Soit une urne qui contient 8 boules dont 2 rouges et 6 de couleurs différentes du rouge. Quelle est la probabilité de devoir tirer au moins 3 boules avant d’avoir la première boule rouge. Codage. Écrire le code Python qui calcule la probabilité demandée en utilisant : 1. l’analyse combinatoire et 2. la règle de la chaîne. Exercice 17. Démontrer la proposition 2 de la probabilité conditionnelle. Exercice 18. Soit un comité qui contient 8 hommes et 6 femmes. Deux personnes sont choisies comme responsables de ce comité. 1- Quelle est la probabilité que la deuxième personne choisie soit une femme sachant que la première est un homme ? 2- Écrire le code Python de cette expérience. Exercice 19. Nous avons trois classes, chacune contient 20 élèves. — La classe 1 contient 16 élèves du quartier A et 4 du quartier B — La classe 2 contient 14 élèves du quartier A et 6 du quartier B. — La classe 3 contient 12 élèves du quartier A et 8 du quartier B. Nous choisissons une classe aléatoirement, ensuite un élève aléatoirement de cette classe. 1- Quelle est la probabilité que l’élève choisi soit du quartier B ? 2- Supposons que nous avons choisi un élève du quartier A, quelle est la probabilité qu’il soit de la classe 1. 3- Écrire le code Python de cette expérience. Exercice 20. Deux joueurs participent à un jeu qui consiste, à tirer, à tour de rôle, une question aléatoirement, le premier qui donne une fausse réponse perd le jeu. Le premier joueur a une probabilité p1 de répondre juste et le deuxième a une probabilité p2 de répondre juste. Quelle est la probabilité que le premier joueur perd le jeu. Exercice 21. [10] Dans une affaire de meurtre, deux personnes fugitives X et Y sont suspectées. Après une première enquête, il s’avère que les deux personnes ont la même probabilité d’être le tueur, que le vrai tueur a le sang du groupe A et que 10% de la population a ce groupe sanguin. Une autre enquête révèle que la personne X a le groupe sanguin de type A, mais on connais pas le groupe sanguin de Y. Quelle est la probabilité que X soit le tueur ? Exercice 22. Deux dés sont lancés. Soit E l’évènement que le premier donne un nombre pair et F l’évènement que la somme des deux est impair. Est ce que E et F sont indépendants ? Exercice 23. Une application informatique contient 4 erreurs : e1 , e2 , e3 , e4 . Dans la phase de vérification, elle est testée par plusieurs testeurs indépendant l’un de l’autre. Chaque testeur a une probabilité 1/3 de trouver et corriger chacune des erreurs. On suppose que les erreurs sont indépendantes les unes des autres et les tests aussi. 1. Quelle est la probabilité que l’erreur e1 ne soit pas corrigée à la fin du neme test ? 2. Quelle est la probabilité que toutes les erreurs soient corrigées à la fin du neme test ? 3. Combien faut-il de testeurs pour que la probabilité que toutes les erreurs soient corrigées soit supérieure ou égale à 0.9 ? CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 35 Exercice 24. Une personne participe à un jeu. Elle est devant trois boites l’une des trois contient une somme d’argent et les deux autres sont vides. Le participant doit choisir une boite. Il connaît la boite gagnante avec une probabilité p ou bien il la devine (avec une probabilité 1 − p). Quelle est la probabilité que le participant connaît (triché au jeu) la boite gagnante sachant qu’il a choisi celle qui contient la somme d’argent. Exercice 25. Nous avons deux boites, la première B1 contient 2 boules blanches et 7 boules noires et la deuxième B2 contient 5 boules blanches et 6 boules noires. On lance une pièce de monnaie si elle donne face on choisit B1 sinon B2 et puis on tire une boule de la boite choisie et on la remet dans l’autre boite. On répète cette expérience m fois, on s’intéresse à la couleur de la dernière boule tirée. 1. Pour m = 2, trouver la probabilité que la séquence du lancer des pièces donne face et pile sachant que la dernière boule tirée est blanche. 2. Écrire le code Python qui modélise cette expérience. CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 1.7 36 Solutions Solution 1. - R1 : Oui, Simple, Ω1 = {H, F } Discret. - R2 : Oui, Simple, Ω2 = [0, 15], Continu - R3 : Oui, Simple, Ω3 = {a.b.c.d|a, b, c, d ∈ {0, ..., 255}}, Discret - R4 : Oui, Composée, Ω4 = {(b1 , b2 ) ∈ {1, ..., 5}2 |b1 6= b2 }, Discret - R5 : Non, On peut prévoir le temps nécessaire pour vider le réservoir en fonction de V et D. - R6 : Oui, Composée, Ω6 = {(C, E)|C ∈ {1, ..., 6}, E ∈ {1, 2, 3}}, Discret - R7 : Oui, Simple, Ω7 = {0, 1, 2, 3...} = N, Discret - R8 : Oui, Simple, Ω8 = [0, 60], Continu - R9 : Oui, Simple, Ω9 = [0, 2π], Continu - R10 : Oui, Simple, Ω10 = {I, O}, Discret Solution 2. 1- Tribu triviale et grossière : a- R1 , EP avec tribu triviale : ({H, F }, {{}, {H, F }}) et tribu grossière : ({H, F }, {{}, {H}, {F }, {H, F }}). b- R4 , EP avec tribu triviale : (Ω4 , {{}, Ω4 }) et tribu grossière : (Ω4 , 2Ω4 ). c- R6 , EP avec tribu triviale : (Ω6 , {{}, Ω6 }) et tribu grossière : (Ω6 , 2Ω6 ). d- R9 , EP avec tribu triviale : (Ω9 , {{}, Ω9 }) et tribu grossière : (Ω9 , 2Ω9 ). e- R11 , EP avec tribu triviale : (Ω11 , {{}, Ω11 }) et tribu grossière : (Ω11 , 2Ω11 ). 2- Les tribus : A- Non, il ne contient pas l’ensemble vide. B- Oui, il satisfait toutes les propriétés de la tribu sur Ω. C- Non, pas d’univers. D- Oui, tribu grossière. Solution 3. Soit l’EA qui consiste à lancer un dé ayant 4 faces, donc son univers est Ω = {1, ..., 4}, on choisit l’ensemble F = {{}, {2, 3, 4}, {1}, Ω} qui vérifie les propriétés de la tribu sur Ω. (Ω, F) est un espace probabilisable avec F non triviale et non grossière. Solution 4. - R1 : {H}, {H} ∩ {F } = ∅ - R2 : {x ≤ 10}, {x ≤ 5} ∩ {10 ≤ x ≤ 15} = ∅ - R3 : {x|x commence par 192}, {x|x commence par 192} ∩ {x|x commence par 178} = ∅ - R4 : {(b1 , b2 ), (b3 , b4 )}, {(b1 , b2 ), (b3 , b4 )} ∩ {(b2 , b1 ), (b4 , b3 )} = ∅ - R6 : {(C1 , E2 ), (C3 , E1 )}, {(C1 , E2 ), (C3 , E1 )} ∩ {(C2 , E3 ), (C4 , E2 )} = ∅ - R7 : {x ≥ 10}, {x < 10} ∩ {10 ≤ x ≤ 20} = ∅ - R8 : {x ∈ [0, 15]}, {x ∈ [0, 10]} ∩ {x ∈]10, 15]} = ∅ - R9 : {a ∈ [0, π/2]}, {a ∈ [0, π/4]} ∩ {a ∈ [π/3, π/2]} = ∅ - R10 : {I}, {I} ∩ {O} = ∅ Solution 5. codage Solution 6. codage Solution 7. codage Solution 8. 1- f (k) = c/k! pour k ∈ N f doit vérifier les trois conditions de la probabilité : positivité, normalité et additivité. i- Positivité : c doit être positif c ≥ 0 ii- Additivité : f vérifie cette condition puisque elle est un ensemble dénombrable P∞ P∞définie sur P ∞ iii- Normalité : f doit vérifier k=0 f (k) = 1 alors k=0 c/k! = c k=0 1/k! = ce = 1 Donc pour c = 1/e, f est une probabilité. 2- f (k) = cxk pour k ∈ N f doit vérifier les trois conditions de la probabilite : positivité, normalité et additivité. i- Positivité : c doit être positif c ≥ 0 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 37 ii- Additivité : f vérifie cette condition comme elle estP définie sur unP ensemble dénombrable P∞ ∞ ∞ iii- Normalité : f doit vérifier k=0 f (k) = 1 alors k=0 cxk = c k=0 xk = c/(1 − x) = 1 puisque 0 < x < 1. Donc pour c = 1 − x, f est une probabilité. Solution 9. codage Solution 10. 1. Ω = {p, f }3 , E : {(i, j, k) ∈ Ω|k 6= i et k 6= j}, P (E) = 1/4 Solution 11. {Ei }{1≤i≤m} est une famille d’évènements de l’espace probabilisable (Ω, F, P ). Soit {Ai }{1≤i≤m} une sous famille de k évènements de {Ei }{1≤i≤m} vérifiant (i) et (ii). 1- On démontre (1) par induction sur k. 1 Pour k = 1, le cas est vérifié en utilisant l’hypothèse (i) on a : P (Ak ) = m On suppose que la propriété est vraie pour k et on la démontre pour k + 1 ≤ m : P (Ak+1 , Ak , ..., A2 , A1 ) = P (Ak+1 |Ak , ..., A2 , A1 )P (Ak , ..., A1 ) 1 (m − k)! (m − k) m! (m − (k + 1))! = m! = Donc la propriété est vraie. 2- Soit m un nombre assez grand, on applique la règle d’inclusion-exclusion : P (Am ∪ ... ∪ A1 ) = m X P (Ak ) − k=1 X P (Ai , Ai ) + ... + (−1)m−1 (P (Am , ..., A2 , A1 ) i≤j≤m 1 1 2 (m − 2)! 3 (m − 3)! 0 1 = Cm − Cm + Cm + ... + (−1)m−1 Cm m m! m! m! 1 1 1 1 = − + + ... + (−1)m−1 1! 2! 3! m! m k−1 X (−1) = ≈ 1 − e−1 pour m assez grand. k! k=1 Solution 12. 3- Réunion : P (E ∪ F ) = P (E) + P (F ) − P (E ∩ F ) E ∪ F = (E − F ) ∪ (F − E) ∪ (E ∩ F ) (E − F ), (F − E) et (E ∩ F ) sont disjoints P (E ∪ F ) = P (E − F ) + P (F − E) + P (E ∩ F ) = P (E) − P (E ∩ F ) + P (F ) − P (E ∩ F ) + P (E ∩ F ) = P (E) + P (F ) − P (E ∩ F ) 5- Monotonicité : ∀E, F ∈ F, E ⊂ F ⇒ P (E) ≤ P (F ). P (F ) = P (E ∪ EFc ) = P (E) + P (EFc ) − P (E ∩ EFc ) = P (E) + P (EFc ) ≥ P (E) EFc est le complément de E dans F . Solution 13. Dans cette expérience, l’espace de probabilité est composé de toutes les séquences de pile et face de longueur 80. Sa taille est donc de 280 séquences. Le nombre de séquences ayant exactement 40 C80 40 . 40 piles est égale à C80 (voir annexe A), donc la probabilité d’avoir exactement 40 pile est : 280 √ Afin de calculer cette valeur, nous utilisons l’approximation de Stirling suivante : n! ≈ 2πn( ne )n pour une valeur de n suffisamment grande (n ≥ 10) et e = 2.718. Ce qui donne 2√1π10 = 0.089. CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 38 Solution 14. Ω = {1, .., 6}4 E est l’évènement d’avoir deux différentes faces apparaissant chacune deux fois. Nous avons C62 possibilités des deux différentes faces qui apparaissent et pour chacune des pos4! = 6 d’arrangements possibles (permutations avec répétition). sibilités il existe 2!2! Donc P (E) = 6! 6× 2!4! |Ω| = 60 64 . Solution 15. L’ensemble de tous les résultats possibles est composé de 36 éléments équiprobables. Soit A l’événement que la somme des deux soit égale à 6, et B l’événement que les valeurs obtenues soient différentes. En tous, il existe 30 résultats de valeurs différentes et 4 d’entre eux ont la 2 somme égales à 6. Donc P (A ∩ B) = 4 et P (B) = 30. Ainsi, P (A|B) = P P(A∩B) (B) = 15 Solution 16. Soit Ei l’évènement que la boule obtenue du ieme tirage n’est pas rouge. Soit E l’évènement de devoir tirer au moins trois boules avant d’avoir la première boule rouge. P (E) = P (E1 ∩ E2 ∩ E3 ) en utilisant la règle de la chaîne : 5 P (E) = P (E1 )P (E2 |E1 )P (E3 |E1 , E2 ) = 68 × 57 × 64 = 14 Solution 17. On démontre que P.|A vérifie les propriétés d’une probabilité sur l’EP (A, 2A ) : i- P.|A (A) = P P(A∩A) (A) = 1 ii- Soit une une famille d’évènements mutuellement exclusifs {Ei }i>0 : S S P P S P ( i>0 (Ei ∩A)) P (( i>0 Ei )∩A) i ∩A) = = i>0 P (E = i>0 P.|A (Ei ) P.|A ( i>0 Ei ) = P (A) P (A) P (A) Solution 18. 1. Le fait que la première personne choisie soit un homme, réduit l’univers à 13 personnes dont 6 femmes et 7 hommes. Donc la probabilité que la deuxième personne choisie soit une femme est 6/13 (utilisant le nouvel univers). 2. Codage Solution 19. 1. Soient EA , EB l’évènement que l’élève soit du quartier A, B respectivement. Soient Ci l’évènement que l’élève soit de la classe i. En utilisant la règle de la probabilité totale : P (EB ) = P (EB ∩ C1 ) + P (EB ∩ C2 ) + P (EB ∩ C3 ) = P (EB |C1 )P (C1 ) + P (EB |C2 )P (C2 ) + P (EB |C3 )P (C3 ) = 4/20 × 1/3 + 6/20 × 1/3 + 8/20 × 1/3 = 3/10. 2. La probabilité que l’élève soit de la classe 1 sachant qu’il est du quartier A. En appliquant la règle de Bayes : P (C1 |EA ) = P (C1 ∩ EA ) P (EA ) P (C1 ∩ EA ) = P (EA ∩ C1 ) = P (EA |C1 )P (C1 ) = P (C1 |EA ) = 16 1 × 20 3 8 10 8 × = 30 7 21 Solution 20. Soit l’événement E = "joueur1 perd" et Ek : "joueur1 perd au k ieme tour" P (Ek ) = (p1 p2 )k−1 (1 − p1 ) donc P (E) = P (E1 ∪ E2 ∪ E3 ....) Puisque les Ei sont des événements disjoints alors : P (E) = P (E1 ) + P (E2 ) + P (E3 ) + · · · = (1 − p1 )[1 + p1 p2 + (p1 p2 )2 + (p1 p2 )3 ...] 1 − p1 = 1 − p1 p2 CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 39 Solution 21. Soit l’hypothèse H : X est le vrai tueur et E : le vrai tueur a le groupe sanguin A. Si nous utilisons la méthode des ODDs : OH|E = OH|E P (H|E) et P (H|E) = c P (H |E) OH|E + 1 P (H|E) P (H) P (E|H) 1/2 1 = × = × = 10 c c c P (H |E) P (H ) P (E|H ) 1/2 0.1 Donc P (H|E) = 10 11 . Si on applique directement la règle de Bayes : P (H|E) = P (E|H) × P (H) 1 × 1/2 0.5 10 = = = P (E|H) × P (H) + P (E|H c ) × P (H c ) 1 × 1/2 + 0.1 × 1/2 0.55 11 Solution 22. E = {(i, j)|i ∈ {2, 4, 6}, 0 ≤ j ≤ 6} P (E) = 18/36 = 1/2 F = {(i, j)|i + j ∈ {3, 5, 7, 9, 11} and 0 ≤ i, j ≤ 6} P (F ) = 18/36 = 1/2 E ∩ F = {(i, j)|i + j ∈ {3, 5, 7, 9, 11}, i ∈ {2, 4, 6}, 0 ≤ j ≤ 6} P (E ∩ F ) = 9/36 = 1/4 = P (E)P (F ) Donc E et F sont indépendants Solution 23. 1. Soit An l’évènement que l’erreur e1 ne soit pas corrigée à la fin du neme test, et soit Ei l’événement que l’erreur e1 ne soit pas corrigée par le ieme testeur. P (Ei ) = 2/3 et les événements Ei sont indépendants. Qn P (An ) = P (E1 ∩ E2 ∩ ... ∩ En ) = i=1 2/3 = (2/3)n 2. Soit Bn l’évènement que toutes les erreurs soient corrigées à la fin du nime test et Fi l’événement que l’erreur ei n’est pas corrigée à la fin du nime test. P (Fi ) = (2/3)n ∀i = 1, . . . , 4. Q4 P (Bn ) = P (F1c ∩ F2c ∩ F3c ∩ F4c ) = k=1 (1 − (2/3)n ) = (1 − (2/3)n )4 3. P (Bn ) ≥ 0.9 ⇐⇒ (1 − (2/3)n )4 ≥ 0.9 ⇐⇒ n log(2/3) ≤ log(1 − 0.91/4 ) log(1 − 0.9)1/4 log(2/3) ⇐⇒ n ≥ 10. ⇐⇒ n ≥ Solution 24. K est l’évènement que la personne connaît la boite qui contient l’argent. S l’évènement que la boite choisie contient la somme d’argent. P (K|S) = P (S|K)P (K) p = P (S|K)P (K) + P (S|K c )P (K c ) p + (1/3)(1 − p) Solution 25. F P est l’évènement d’obtenir Face ensuite Pile lorsque la pièce est lancée deux fois. B est l’événement que la deuxième boule déplacée soit blanche. P (F P |B) = P (B|F P )P (F P ) P (B|F F )P (F F ) + P (B|F P )P (F P ) + P (B|P F )P (P F ) + P (B|P P )P (P P ) CHAPITRE 1. INTRODUCTION À LA PROBABILITÉ 40 À chaque étape, chaque urne a une probabilité 1/2 d’être choisie, ensuite la probabilité de choisir une boule blanche au deuxième tirage dépend à la fois de l’urne choisie et de la première boule tirée. P (B|F F ) = 2/9 × 1/8 + 7/9 × 1/4 P (B|F P ) = 1/2 × 2/9 + 7/9 × 5/12 P (B|P F ) = 5/11 × 3/10 + 6/11 × 1/5 P (B|P P ) = 5/11 × 2/5 + 6/11 × 1/2 P (F P |B) = 0.32 À vos claviers! 2. Codage #exo1_24.py from itertools import product import copy def prob_urne_boule(u,i): return u[i[2]][i[3]]/(u[i[2]][’B’] + u[i[2]][’N’]) u0={ ’F’:{’B’:2,’N’:7}, ’P’:{ ’B’:5, ’N’:6}} omega=list(product([’F’,’P’],[’B’,’N’],[’F’,’P’],[’B’,’N’])) PB = 0; PBFP=0 for i in omega: u = copy.deepcopy(u0) i0c = ’F’ if i[0] == ’P’ else ’P’ # tirage et transfert de boule u[i[0]][i[1]] = u[i[0]][i[1]] - 1; u[i0c ][i[1]] = u[i0c ][i[1]] + 1 P1 = prob_urne_boule(u0, (None,None, i[0],i[1])) P = 0.25 * P1 * prob_urne_boule(u,i) if i[3] == ’B’: PB = PB + P if i[0] == ’F’ and i[2]==’P’ and i[3]==’B’: PBFP += P print(i[0]," ",i[1]," %0.2f" %P, ’ \t ’, u) print(’P(B) = %0.2f ’%PB, ’ \t P(F,P,B) = %0.2f’ % PBFP, ’ \t P(FP|B) = %0.2f’ % (PBFP/PB) ) #______________________________ Output ______________________________________ # F B 0.01 {’F’: {’B’: 1, ’N’: 7}, ’P’: {’B’: 6, ’N’: 6}} # F B 0.05 {’F’: {’B’: 1, ’N’: 7}, ’P’: {’B’: 6, ’N’: 6}} # ..... # P N 0.07 {’F’: {’B’: 2, ’N’: 8}, ’P’: {’B’: 5, ’N’: 5}} # P N 0.07 {’F’: {’B’: 2, ’N’: 8}, ’P’: {’B’: 5, ’N’: 5}} # P(B) = 0.34 P(F,P,B) = 0.11 P(FP|B) = 0.32 Chapitre 2 Variables Aléatoires 2.1 Introduction Quand nous avons une expérience aléatoire, comme le lancer d’une pièce par exemple, et nous attribuons une valeur à chaque résultat élémentaire, alors on aura défini une variable aléatoire qui prend la valeur correspondante au résultat obtenu. Par exemple, si nous donnons la valeur 10 à pile et la valeur 20 à face (supposons que ce sont les sommes en dinar que nous allons gagner en obtenant pile ou face) alors nous aurons défini une variable aléatoire dont l’ensemble des valeurs est {10, 20}. Plus formellement, une variable aléatoire X est une fonction à valeurs réelles qui affecte une valeur à chaque résultat possible ω d’une expérience aléatoire dans l’espace probabilisé (Ω, F, P ). Soit B l’ensemble des sous ensembles réels résultants de l’union et de l’intersection finies des intervalles de R appelés l’ensemble des boréliens qui est la tribu engendrée par les intervalles de R. Définition 1. Soit une expérience aléatoire dont l’espace probabilisé est (Ω, F, P ). Une variable aléatoire v.a est la fonction X : Ω −→ R tel que pour tout borélien B ∈ B(R), l’image de l’ensemble B (X −1 (B) = {ω ∈ Ω|X(ω) ∈ B} notée {X ∈ B}) est un évènement de Ω (un élément de la tribu F de Ω). X: Ω −→ R ω 7−→ x = X(ω) X est une v.a =⇒ ∀B ∈ B(R) : X −1 (B) ∈ F Le domaine d’une v.a X est l’univers de l’expérience aléatoire (Ω) Le rang RX d’une v.a X (X(Ω)) est l’ensemble des valeurs possibles qu’elle peut prendre dans R. L’évènement {X ∈ {x}} sera noté {X = x} (respectivement {X ∈] − ∞, x]} = {X ≤ x}, {X ∈] − ∞, x[} = {X < x}, {X ∈ [x, +∞[} = {X ≥ x}, {X ∈]x, +∞[} = {X > x}, {X ∈ ]x1 , x2 ]} = {x1 < X ≤ x2 }) Figure 2.1 – Définition de variable aléatoire 41 CHAPITRE 2. VARIABLES ALÉATOIRES 42 Définition 2. Soit X une v.a, on appelle la distribution de probabilité de X (la loi de X, notée PX ) l’application PX : B(R) −→ [0, 1] qui associe à tout borélien B, la probabilité de l’évènement {X ∈ B} PX : B(R) B −→ [0, 1] 7−→ PX (B) = P ({X ∈ B}) = P (X −1 (B)) Le diagramme ci-dessous schématise la composition des applications X et P pour définir la loi de X (PX ). P F(Ω) X [0, 1] PX B(R) Figure 2.2 – La distribution de probabilité (loi) d’une variable aléatoire Exemple 1. Supposons que notre expérience consiste à lancer deux pièces. Soit X la fonction qui associe à chaque résultat de cette expérience le nombre de piles obtenus, les valeurs prises par cette fonction sont 0, 1 et 2. Pour tout i ∈ {0, 1, 2}, on note Bi la classe des boréliens qui contiennent i seulement. Tout autre borélien s’écrit comme union des boréliens disjoints de ces trois classes. L’image inverse d’un borélien Bi est l’image inverse de {i} (X −1 (Bi ) = X −1 ({i})) qui est dans F et l’image inverse d’un borélien quelconque est l’union des images inverses de boréliens disjoints des classes Bi qui composent ce dernier, alors cette image est dans F, donc c’est une v.a. Déterminer PX . Solution X est une v.a (X : Ω −→ R) dont le domaine est Ω = {P, F }2 le rang RX = {0, 1, 2} et sa distribution PX : PX (B0 ) = P (X ∈ B0 ) = P (X −1 (B0 )) = P (X −1 ({0})) = P {(f, f )} = 1/4 PX (B1 ) = P (X ∈ B1 ) = P (X −1 (B1 )) = P (X −1 ({1})) = P {(f, p), (p, f )} = 2/4 PX (B2 ) = P (X ∈ B2 ) = P (X −1 (B2 )) = P (X −1 ({2})) = P {(p, p)} = 1/4 Pour les autres boreliens, on applique la règle de l’additivité de la probabilité P . Définition 3. Soit X une v.a, la fonction de répartition de X (notée FX ) est la fonction définie de R vers [0, 1] qui à tout x ∈ R associe la probabilité du borélien ] − ∞, x] (noté aussi X ≤ x) : FX : R −→ [0, 1] x 7−→ FX (x) = PX (] − ∞, x]) = P (X ∈] − ∞, x]) = P (X ≤ x) Appelée aussi la fonction de distribution cumulative (cdf ) CHAPITRE 2. VARIABLES ALÉATOIRES 43 Le diagramme ci-dessous schématise la composition de PX et de l’application U qui associe x ∈ R avec son demi-intervalle ] − ∞, x] pour définir la cdf de X (FX ). B(R) U PX [0, 1] FX R Exemple2. La suite de l’exemple précèdent, on a : 1/4 si x = 0 ou x = 2 PX (x) = 2/4 si x = 1 et qui sera notée : PX = 41 1{0,2} + 24 1{1} Trouver la fonction de répartition de X (cdf ) FX . Solution Nous avons FX (x) = P (X ≤ x) = P (X ∈] − ∞, x]) FX (x) = 0, pour x < 0 FX (x) = PX (B0 ) = 1/4 pour 0 ≤ x < 1 FX (x) = P (X ≤ 0) + P (0 < X ≤ x) = FX (0) + PX (B1 ) = 1/4 + 2/4 = 3/4, FX (x) = P (X ≤ 1) + P (1 < X ≤ x) = FX (1) + PX (B2 ) = 3/4 + 1/4 = 1, pour 1 ≤ x < 2 pour x ≥ 2 FX = 41 1[0,1[ + 34 1[1,2[ + 1[2,∞[ À vos claviers! Afin d’implémenter en Python les applications sur Ω, on doit d’abord créer une fonction ou une lambda expression qui associe une valeur à chaque événement élémentaire ω de Ω, ensuite on applique cette association à Ω en utilisant la fonction map(function,iterator) et le résultat sera mis en correspondance avec la fonction zip(). Enfin, on crée un dictionnaire pour le résultat final avec la fonction dict(). À partir du module utils nous importons les fonctions : createFiniteRV qui crée le dictionnaire d’une v.a finie selon les étapes décrites dans le premier paragraphe, getCDF() qui permet de définir la cdf à partir d’un dictionnaire de la distribution d’une v.a finie et getInversedFiniteRV() qui retourne l’image inverse de cette v.a. La fonction plot_function() dessine la courbe de la cdf en utilisant la bibliothèque matplotlib et son module pyplot. Pour plotter la distribution de probabilités on utilise la fonction bar() et step() pour la cdf. # utils.py (Continuation) # sort_PDF: returns a key sorted distribution of the argument def sort_PDF(prob_RV): return {key:prob_RV[key] for key in sorted(prob_RV.keys())} # zip : create an iterator that aggregate a collection’s elements # map : applies a function to the elements of a list. # create_FiniteRV: Create a distribution by mapping a function on Omega’s elements def create_FiniteRV(Omega, map_X): return dict(zip(Omega, map(map_X, Omega))) # get_InversedFiniteRV: inverses a finite RV distribution (value:key) def get_InversedFiniteRV(finiteRV): return {v:{i for i in finiteRV.keys() if finiteRV[i] == v } for k,v in finiteRV.items()} # get_PMF: returns the probability distribution P_X of X def get_PMF(finiteRV, probability_Omega): inv_X = get_InversedFiniteRV(finiteRV) prob_values = list(map(sum, [[probability_Omega[omega] for omega in event] for event in inv_X.values()])) return dict(zip(inv_X.keys(), prob_values)) # accumulate : returns the reduced result by applying the given operation on a set # get_CDF: cumulative distribution function CDF of X def get_CDF(prob_RV): sprob_RV =sort_PDF(prob_RV)# {key:prob_RV[key] for key in sorted(prob_RV.keys())} return sprob_RV,dict(zip(sprob_RV.keys(), list(accumulate(sprob_RV.values())))) CHAPITRE 2. VARIABLES ALÉATOIRES 44 # plot_Pdf_Cdf: plots PDF and CDF of RV X def plot_Pdf_Cdf(pdf0, cdf0, choice =None): first = list(pdf0.keys())[0] last = list(pdf0.keys())[-1] keys = [first-1] + list(pdf0.keys()) + [last+1] pvalues = [0.0]+ list(pdf0.values()) fig = plt.figure() ncols0 = 2 if choice == None else 1 axes = fig.subplots(nrows=1, ncols=ncols0) axes[0].bar(keys, pvalues + [0.0], width=0.05) if not choice: cvalues = [0.0]+ list(cdf0.values()) axes[1].step(keys, [0.0]+ cvalues) plt.show() À vos claviers! Le code qui implémente la variable aléatoire. #Code201.py import sys;sys.path.append(’../lib’) from utils import (set_Power, create_FiniteRV, get_InversedFiniteRV,get_PMF, get_CDF,plot_Pdf_Cdf) # Random Variable Implementation : Encapsulate the logic of RV X. p:Tail, f:head distribution = {(’f’,’p’):1/4, (’p’,’f’):1/4, (’f’,’f’):1/4, (’p’,’p’):1/4} Omega = set_Power({’p’,’f’}, 2) prob_Omega = distribution ;print(’Omega ;print(’ProbaOmega : ’,Omega) : ’,prob_Omega) #map_X: counts the number of tails map_X = lambda a : a.count(’p’) rv_X = create_FiniteRV(Omega, map_X) rng_X = set(rv_X.values()) inv_X = get_InversedFiniteRV(rv_X) pdf_X = get_PMF(rv_X, prob_Omega) pdf_X, cdf_X = get_CDF(pdf_X) ;print(’RV dictionary ;print(’RV Range ;print(’inversed RV ;print(’P_X RVProbLaw ;print(’CDF of X : : : : : ’,rv_X) ’,rng_X) ’,inv_X) ’,pdf_X) ’,cdf_X) plot_Pdf_Cdf(pdf_X, cdf_X) #______________________________ Output ______________________________________ # Omega : {(’f’, ’p’), (’p’, ’p’), (’f’, ’f’), (’p’, ’f’)} # ProbaOmega : {(’f’, ’p’): 0.25, (’p’, ’f’): 0.25, (’f’, ’f’): 0.25, (’p’, ’p’): 0.25} # RV dictionary : {(’f’, ’p’): 1, (’p’, ’p’): 2, (’f’, ’f’): 0, (’p’, ’f’): 1} # RV Range : {0, 1, 2} # inversed RV : {1: {(’p’, ’f’), (’f’, ’p’)}, 2: {(’p’, ’p’)}, 0: {(’f’, ’f’)}} # P_X RVProbLaw : {1: 0.5, 2: 0.25, 0: 0.25} # CDF of X : {0: 0.25, 1: 0.75, 2: 1.0} Figure 2.3 – Courbe de la distribution et de la cdf (code201.py) Proposition 1. Les propriétés de la cdf sont : 1- Positive et bornée sur l’unité : 0 ≤ FX (x) ≤ 1 2- Monotone croissante : x1 ≤ x2 =⇒ FX (x1 ) ≤ FX (x2 ) 3- Limites : limx→+∞ FX (x) = FX (∞) = 1, limx→−∞ FX (x) = FX (−∞) = 0 py :sympy.stats.cdf(RExpr) donne la cdf de la v.a RExpr RExpr : est une expression symbolique aléatoire qui représente une v.a écrite en fonction d’autre v.a,s. sympy.stats.Density(RExpr) retourne un objet qui représente la pmf d’une v.a.d. Sa propriété dict donne le dictionnaire correspondant. sympy.stats.FiniteRV(name, Density,..) retourne un objet qui représente la v.a.d finie en donnant sa pmf sous forme de dictionnaire. CHAPITRE 2. VARIABLES ALÉATOIRES 45 4- Continuité à droite : limx→a+ FX (x) = FX (a+ ) = FX (a) 5- PX (a < x ≤ b) = FX (b) − FX (a), PX (X > a) = 1 − FX (a), 2.2 FX (b− ) = PX (X < b) Variables aléatoires discrètes (v.a.d) Dans cette section nous traitons le cas où le rang de la v.a est dénombrable. Dans ce cas elle est dite discrète. Définition 4. Une v.a X est discrète (v.a.d) si son rang RX est un ensemble fini ou infini dénombrable. c-à-d RX = {xi ∈ R}i∈I et I une partie de N finie ou infinie dénombrable. Dans ce cas la loi de X : PX est une loi discrète. En plus de sa loi de probabilité et sa fonction de répartition, elle peut être définie par les probabilités individuelles. Définition 5. Soit E un ensemble, on appelle la fonction f : E −→ R une fonction de masse si son domaine de définition Df est fini ou infini dénombrable et elle satisfait les propriétés suivantes : -P ∀e ∈ Df , 0 ≤ f (e) ≤ 1 - ei ∈Df f (ei ) = 1 Soit X une v.a.d, la fonction pX définie de RX vers [0, 1] qui à tout xi ∈ RX associe la probabilité de {X = xi } : pX : RX −→ [0, 1] xi 7−→ pX (xi ) = PX (X = xi ) = pi est appelée la fonction de masse de probabilité (pmf ) de X et notée pX . Le diagramme ci-dessous montre la composition de l’application X et p pour définir la loi de X (pX ) dans le cas discret. p Ω X [0, 1] pX RX Si X est une v.a.d, alors on peut calculer : PX ({xi }) = P ({X = xi }) = P (X = xi ) = pX (xi ), ∀xi ∈ RX ! [ PX (B) = P (X ∈ B) = P {X = xi } xi ∈B∩RX X = P ({X = xi }) = xi ∈B∩RX FX (x) = P (X ≤ x) = X xi ∈B∩RX X xi ≤x P (X = xi ) = X P ({X = xi }) = X pX (xi ) xi ∈B∩RX pX (xi ) xi ≤x Si X est finie et RX = {x0 , x1 , ..., xn } telque x0 ≤ x1 ≤ · · · ≤ xn alors : ∀x ∈ [−∞, x0 [, FX (x) = 0 ∀x ∈ [xi , xi+1 [, FX (x) = FX (xi−1 ) + pX (xi ) = FX (xi−1 ) + pX (xi )1[xi ,xi+1 [ (x) ∀x ∈ [xn , ∞[, FX (x) = 1 CHAPITRE 2. VARIABLES ALÉATOIRES 46 Exemple 3. Pour la préparation d’un examen, un professeur choisit aléatoirement deux exercices parmi 10 dont quatre sont difficiles à résoudre. Soit une v.a X représentant le nombre d’exercices difficiles choisis pour l’examen. Quelle est la fonction de masse de X ? Solution Soit E (resp. E c ) l’ensemble des exercices faciles (respectivement difficiles). L’expérience consiste à choisir deux exercices parmi E ∪ E c . Comme le résultat est non ordonné et sans répétition, alors l’espace Ω est : Ω = {{e1 , e2 }|(e1 , e2 ) ∈ (E ∪ E c )2 et e1 6= e2 } 2 le nombre de possibilités est une combinaison de 2 parmi 10 (C10 ). La v.a X est définie par : X : Ω −→ R {e1 , e2 } 7−→ x = X({e1 , e2 }) = Nb_Exercices_Difficiles({e1 , e2 }) = 1E c (e1 ) + 1E c (e2 ) RX = {0, 1, 2} pX (k) = P (X = k), ∀k ∈ RX pX (0) = P ({{e1 , e2 }|(e1 , e2 ) ∈ E 2 et e1 6= e2 }) = 1 C62 2 = 3 C10 pX (1) = P ({{e1 , e2 }|((e1 ∈ E et e2 ∈ E c ) ou (e2 ∈ E et e1 ∈ E c )) et e1 6= e2 }) = pX (2) = P ({{e1 , e2 }|e1 ∈ E c et e2 ∈ E c et e1 6= e2 }) = C61 C41 8 = 2 C10 15 C42 2 2 = 15 C10 pX (x) = 0, ∀x ∈ / RX pX = 8 1 1 1{0} + 1{1} + 1{2} 3 15 15 Exemple 4. Soit Ω l’univers d’une expérience aléatoire donnée et X une v.a.d associée dont le rang est RX = {1, 2, 3} et sa pmf : pX = 1 1 1 1{1} + 1{2} + 1{3} 2 3 6 1- Donner sa fonction de distribution cumulative FX . 2- Écrire le code Python qui modélise X et plotte ses fonctions pmf et cdf. Solution 1- Sa cdf est donnée par : FX = 21 1[1,2[ + 56 1[2,3[ + 1[3,∞[ À vos claviers! 2- Le code suivant modélise X et sa pmf et sa cdf. #Code202.py import sys;sys.path.append(’../lib’) from utils import get_CDF, plot_Pdf_Cdf, get_round_dic #dic1: defines a r.v on Omega={o1.o2.o3}, dic2: defines the associated probabilities dic1,dic2={’o1’:1,’o2’:2,’o3’:3 }, {1:0.5,2:0.33,3:0.17 } rv_X = dict(dic1) rng_X = set(rv_X.values()) pdf_X = get_round_dic(dict(dic2)) pdf_X, cdf_X = get_CDF(pdf_X) ;print(’RV map ;print(’RV Range ;print(’P_X RVProbLaw ;print(’Cdf of X : : : : ’,rv_X) ’,rng_X) ’,pdf_X) ’,get_round_dic(cdf_X)) plot_Pdf_Cdf(pdf_X, cdf_X) #______________________________ Output ______________________________________ # RV map : {’o1’: 1, ’o2’: 2, ’o3’: 3} # RV Range : {1, 2, 3} # P_X RVProbLaw : {1: 0.5, 2: 0.33, 3: 0.17} # Cdf of X : {1: 0.5, 2: 0.83, 3: 1.0} CHAPITRE 2. VARIABLES ALÉATOIRES 47 Figure 2.4 – Courbe de la pmf et la cdf (code202.py) Le code suivant utilise les fonctions prédéfinies dans sympy.stats FiniteRV, density, cdf pour la v.a dont le rang est {0, 1, 2, 3} et la pmf suivante : pX = 1 2 3 4 1{0} + 1{1} + 1{2} + 1{3} 10 10 10 10 À vos claviers! #Code203,py from sympy.stats import FiniteRV, density, cdf import sys;sys.path.append(’../lib’) from utils import get_CDF,plot_Pdf_Cdf, get_round_dic # distribution of r.v X pmf = {0:.1,1:0.2,2:.3,3:.4} rv_X = FiniteRV(’X’,pmf) pdf_X = get_round_dic(density(rv_X).dict) cdf_X = get_round_dic(cdf(rv_X)) spdf_X, cdf_X = get_CDF(pdf_X) ;print(’RV Range ;print(’pdf_X ;print(’cdf_X ;print(’Cdf of X : : : : ’,set(pmf.keys())) ’,pdf_X) ’,cdf_X ) ’,get_round_dic(cdf_X)) plot_Pdf_Cdf(spdf_X, cdf_X) #______________________________ # RV Range : {0, 1, 2, 3} # pdf_X : {0: 0.1, 1: 0.2, 2: # cdf_X : {0: 0.1, 1: 0.3, 2: # Cdf of X : {0: 0.1, 1: 0.3, 2: Output ______________________________________ 0.3, 3: 0.4} 0.6, 3: 1.0} 0.6, 3: 1.0} Figure 2.5 – Courbe de la pmf et la cdf (code203.py) 2.3 Variables aléatoires continues (v.a.c) Contrairement à la v.a discrète, le rang d’une v.a continue est indénombrable. C’est le cas par exemple de la durée de vie d’une batterie ou bien le temps jusqu’à l’arrivée du prochain séisme ou encore la quantité de précipitation durant une période donnée. Pour le cas continu, on parle de la probabilité que la v.a prenne une valeur dans un intervalle donné au lieu de la probabilité d’être égale à une valeur donnée. Donc pour une v.a.c P (X = x) = 0 ∀x ∈ R car en prenant des unités de mesure de plus en plus fines, la probabilité CHAPITRE 2. VARIABLES ALÉATOIRES 48 que la v.a soit égale exactement à x devient nulle. Pour cette raison, on ne peut pas parler de fonction de masse de probabilité dans le cas continu, mais plutôt de fonction de densité de probabilité qui est la limite (lorsqu’elle existe) de la probabilité que X prenne une valeur dans l’intervalle [x, x+∆x] divisé par la longueur de cet intervalle (qui est ∆x) lorsque ∆x −→ 0 : dFX (x) FX (x + ∆x) − FX (x) PX (X ∈]x, x + ∆x]) 0 = lim = = FX (x) ∆x→0 ∆x→0 ∆x ∆x dx fX (x) = lim si FX (x) est differentiable en x. f (x) en fait mesure la probabilité que X soit proche de x et non pas égale à x. Définition 6. Soit X une v.a et sa fonction de répartition correspondante FX . X est continue si son rang RX est un ensemble non dénombrable. Une v.a X admet une densité si la limite suivante existe : fX (x) = lim ∆x→0 FX (x + ∆x) − FX (x) PX (X ∈]x, x + ∆x]) = lim ∆x→0 ∆x ∆x Dans ce cas fX est appelée la fonction densité de probabilité de X et FX est dérivable et X (x) 0 (x) = dFdx sa dérivée est fX (fX (x) = FX ). La loi de probabilité de X est définie pour n’importe quel ensemble B de nombres réels, par la relation suivante : Z Z PX (X ∈ B) = dP = fX (x)dx B x∈B Rb Si B = [a, b] alors P (X ∈ B) = a fX (x)dx. Ra Si a = b, alors P (X ∈ B) = a fX (x)dx = 0. Ceci explique que : P (X = x) = 0 ∀x ∈ R. fX satisfait les propriétés suivantes : - Son domaine de définition Df est non dénombrable. - Positive : ∀x ∈ Df , fX (x)R ≥ 0 - Intégrable et normée : Df fX (x)dx = 1 Exemple 5. Soit X une v.a.c, et f une fonction définie par : fX (x) = ce−x/2 pour x ≥ 0 et 0 sinon. c est une constante positive. 1. Trouver la valeur de c pour que f soit une fonction de densité de X. 2. Trouver la fonction de distribution cumulative FX . 3. Trouver PX (2 < X < 4). Solution 1. La fonction f vérifie : a. Df = R+ b. f (x) ≥ 0 car c > 0. c. Intégrable et normée si : R +∞ f (x)dx = 1 −∞ R +∞ R f (x)dx = 0∞ ce−x/2 dx = 2c = 1, donc c = 1/2 −∞ Pour c = 1/2, f est une fonction de densité. 2. FX (x) = Rx −∞ f (x)dx = Rx 1 −x/2 e dx 0 2 = 1 − e−x/2 3. PX (2 < X < 4) = F (4) − F (2) = e−1 − e−2 CHAPITRE 2. VARIABLES ALÉATOIRES 2.4 49 Espérance et Variance 2.4.1 Espérance Dans le cas d’une v.a.d, l’espérance de X est la moyenne pondérée des valeurs possibles que X peut prendre ; chaque valeur est pondérée par la probabilité que X prenne cette valeur. Par contre si X est une v.a.c, l’espérance est la surface délimitée par la courbe de X fois sa densité. Définition 7. Soit X une v.a, l’espérance de X notée E(X) est définie dans le cas général par : Z E(X) = XdP B 1- Si X est une v.a.d et pX sa pmf, alors : X xi pX (xi ) E(X) = xi ∈RX 2- Si X est une v.a.c et fX sa pdf, alors : Z E(X) = xfX (x)dx RX Proposition 2. Propriétés de l’ Espérance 1- Constante : si X est constante (sa valeur est c),alors E(X) = c. 2- Indicatrice : ∀A ∈ F, E(1A ) = P (A) 3- Linéarité : E(aX + bY ) = aE(X) + bE(Y ) 4- Monotonie : X < Y (c.a.dP (X < Y ) = 1) =⇒ E(X) < E(Y ) 5- Fonction : φ : R −→ R (une P fonction croissante) : Cas discret : E(φ(X)) = RX φ(x)pX (x) R Cas continu : E(φ(X)) = RX φ(x)fX (x)dx 2.4.2 Variance La variance mesure la dispersion des valeurs de X par rapport à son espérance. Une grande valeur de la variance veut dire que X prend des valeurs éloignées de l’espérance, la distribution est donc très dispersée ; par contre une petite valeur indique que la distribution est concentrée autour de sa moyenne. Définition 8. Soit X une v.a, la variance de X notée V(X) est l’espérance des carrés des écarts de X à sa moyenne si elle est définie. V(X) = E((X − E(X))2 ) , si elle existe σX = σ(X) = p V(X) est appelée l’écart type de X Il faut noter que la variance a une unité différente que celle de X. Si par exemple X est en mètres, la variance est en mètre carré ; pour cette raison, on définit l’écart type qui est simplement la racine carrée de la variance. Proposition 3. Propriétés de la Variance 1- Constante : si X est constante (sa valeur est c),alors V(X) = 0. CHAPITRE 2. VARIABLES ALÉATOIRES 50 2- Positive : V(X) ≥ 0 3- V(X) = E(X 2 ) − E2 (X) Exemple 6. Soit la pmf d’une v.a.d X donnée par : pX = 1 2 1{1} + 1{2} 3 3 1- Calculer son espérance et sa variance. 2- Écrire le code python qui modélise cette v.a Solution P E(X) = xi ∈RX xi pX (xi ) = 1 × 2/3 + 2 × 1/3 = 4/3. P E(X 2 ) = xi ∈RX x2i pX (xi ) = 1 × 2/3 + 4 × 1/3 = 2. V(X) = E(X 2 ) − E2 (X) = 2 − 16/9 = 2/9. À vos claviers! #Code204,py from sympy.stats import FiniteRV, density, cdf, E, variance import sys;sys.path.append(’../lib’) from utils import get_CDF,plot_Pdf_Cdf, get_round_dic,plt pmf = {1:0.66,2:0.34} rv_X = FiniteRV(’X’,pmf) pdf_X = density(rv_X).dict cdf_X = get_round_dic(cdf(rv_X)) spdf_X, cdf_X = get_CDF(pdf_X) E_X, V_X = E(rv_X), variance(rv_X) ;print(’RV Range ;print(’pdf_X ;print(’cdf_X ;print(’Cdf of X ;print(’E(X) : : : : : ’,set(pmf.keys()) ) ’,pdf_X) ’,cdf_X) ’,get_round_dic(cdf_X)) ’,round(E_X,2), ’, V_X : ’, round(V_X,2)) plot_Pdf_Cdf(spdf_X, cdf_X, E_X) #______________________________ # RV Range : {1, 2} # pdf_X : {1: 0.66, 2: 0.34} # cdf_X : {1: 0.66, 2: 1.0} # Cdf of X : {1: 0.66, 2: 1.0} # E(X) : 1.34 , V_X : 0.22 Output ______________________________________ Figure 2.6 – Courbe de la pmf et la cdf (code204.py) et l’espérance (en rouge) 2.4.3 Inégalités de probabilités Il existe plusieurs inégalités importantes en probabilités. Les inégalités de Markov et de Chebychev sont à la base de plusieurs d’autres inégalités, elles nous permettent d’avoir des bornes sur les probabilités en connaissant seulement l’espérance et/ou la variance de la loi de probabilités. Proposition 4. Inégalités entre P, E et V : - 1- Cauchy-Schwartz : E(XY )2 ≤ E(X 2 )E(Y 2 ) py : sympy.stats.E(RExpr ,..) retourne une expression symbolique qui représente l’espérance de la RExpr donnée. py : sympy.stats.variance (RExpr,..) retourne une expression symbolique qui represente la variance de RExpr donnée. CHAPITRE 2. VARIABLES ALÉATOIRES 51 - 2- Markov : Soit X une v.a non négative et φ une fonction croissante, P (φ(X) ≥ t) ≤ E(φ(X)) t - 3- Chebychev : P (|X − E(X)| ≥ c) ≤ V(X) c2 - 4- Jensen : Soit φ une fonction convexe : E(φ(X)) ≥ φ(E(X)) Démonstration 2- Inégalité de Markov (pour le cas φ = I est la fonction identité) - Soit a une valeur donnée - Soit la v.a indicatrice 1X≥a - E(1X≥a ) = P (X ≥ a) - X ≥ a1X≥a vu que X est non négative - E(X) ≥ aE(1X≥a ) = aP (X ≥ a) Figure 2.7 – Inégalité de Markov 3- Inégalité de Chebychev - (X − E(X))2 est une v.a non négative 2 ) - P ((X − E(X))2 ≥ c2 ) ≤ E((X−E(X)) , on applique l’inégalité de Markov pour a = c2 c2 - P (|X − E(X)| ≥ c) ≤ E((X−E(X))2 ) c2 = V(X) c2 Exemple 7. Si le nombre de requêtes traitées par un serveur est une v.a X de moyenne 500/mn. Trouver une borne à la probabilité qu’il traite en une minute au moins 1000 requêtes ? Si la variance est 100, trouver une borne à la probabilité qu’il traite entre 400 et 600 requêtes en une minute ? Solution 1. Par l’inégalité de Markov : P (X ≥ 1000) ≤ 500 1 = 1000 2 2. Par l’inégalité de Chebychev : P (|X − 500| ≥ 100) ≤ σ2 1 1 99 = , donc P (|X − 500| < 100) ≥ 1 − = = 0.99 1002 100 100 100 Exemple 8. Trois colocataires veulent décider lequel doit préparer le dîner. Ils lancent tous une pièce non truquée en même temps, ils continuent jusqu’à ce que l’un d’eux obtienne un résultat différent des deux autres. Quelle est l’espérance du nombre de lancers nécessaires. Solution Soit X v.a qui donne le nombre de lancers jusqu’à obtenir une valeur différente des deux autres. son rang RX = N∗ Chaque ieme lancer, nous avons l’univers Ωi = {P, F }3 CHAPITRE 2. VARIABLES ALÉATOIRES 52 Soit Li l’évènement que le ieme lancer donne des résultats différents (Li c résultats similaires). Li c = {(P, P, P ), (F, F, F )} P (Li ) = 1 − P (Li c ) = 34 = p La réalisation de l’évènement X = k correspond au fait d’avoir des résultats similaires (toutes des faces ou toutes des piles) aux k − 1 premiers lancers et un résultat diffèrent au k ieme lancer. c (X = k) = (∩k−1 i=1 Li ) ∩ Lk (intersection des évènements disjoints) donc : c k−1 pX (k) = P (X = k) = P ((∩k−1 × p, ∀k ∈ N∗ i=1 Li ) ∩ Lk ) = (1 − p) ∞ ∞ X X 1 p = E(X) = kpX (k) = k × (1 − p)k−1 × p = (1 − (1 − p))2 p k=1 k=1 On peut dire que X compte le premier succès (avoir differents lancers), c’est une v.a geometrique de moyenne p1 . Exemple 9. Soit X, une v.a.d de rang RX = {−1, 0, 1, 2, 3}, sa pmf pX (k) = 1/5 pour k ∈ RX et soit Y = 2|X|. 1- Trouver le rang et la pmf de Y . 2- Écrire le programme Python qui modélise cette situation. Solution 1- RY = {2|x| t.q x ∈ RX } = {0, 2, 4, 6}, sa pmf doit être définie ∀k ∈ RY . pY (k) = P (Y = k) = P ({2|x| = k t.q x ∈ RX }) = P ({|x| = [k/2] t.q x ∈ RX }) = P ({x = [k/2] ou x = −[k/2] t.q x ∈ RX }) pY (0) = P (X = 0) = 1/5 pY (2) = P (X ∈ {−1, 1}) = P (X = −1) + P (X = 1) = 2/5 pY (4) = P (X = 2) = 1/5 pY (6) = P (X = 3) = 1/5 À vos claviers! #Code205,py from sympy.stats import FiniteRV, density, cdf, E, variance from sympy.functions import Abs import sys;sys.path.append(’../lib’) from utils import get_CDF,plot_Pdf_Cdf, get_round_dic # RV X pmf = {-1:0.2,0:0.2,1:0.2,2:0.2,3:0.2} rv_X = FiniteRV(’X’,pmf) # RV Y=2|X| rv_Y = 2 * Abs(rv_X) pdf_Y = get_round_dic(density(rv_Y).dict) rng_Y = set(pdf_Y.keys()) cdf_Y =get_round_dic(cdf(rv_Y)) spdf_Y, cdf_Y = get_CDF(pdf_Y) E_Y = round(E(rv_Y),2) V_Y = round(variance(rv_Y),2) ;print(’pdf_Y ;print(’Range_Y ;print(’cdf_Y ;print(’cdf_Y : : : : ’,pdf_Y) ’,rng_Y) ’,cdf_Y ) ’,get_round_dic(cdf_Y)) ;print(’E(Y) : ’, E_Y, ’, V(Y):’, V_Y) plot_Pdf_Cdf(spdf_Y, cdf_Y, E_Y) #______________________________ Output ______________________________________ # pdf_Y : {2: 0.4, 0: 0.2, 4: 0.2, 6: 0.2} # Range_Y : {0, 2, 4, 6} # cdf_Y : {0: 0.2, 2: 0.6, 4: 0.8, 6: 1.0} # cdf_Y : {0: 0.2, 2: 0.6, 4: 0.8, 6: 1.0} # E(Y) : 2.80 , V(Y): 4.16 CHAPITRE 2. VARIABLES ALÉATOIRES 53 Figure 2.8 – Courbe de la pmf et la cdf (code205.py) Exemple 10. Soit la fonction f suivante : f (x) = x45 1{X≥1} (x) 1- Démontrer que f est une fonction de densité. 2- Soit X une v.a.c dont la pdf est fX = f , Trouver E(X), V(X), Solution 1- f est intégrable et son intégral : Z +∞ Z fX (t)dt = −∞ ∞ −∞ ∞ 4 1{X≥1} (t)dt = (−t−4 ) 1 = 1 t5 f (t) est continue sur R/{0}, positive et la surface délimitée par sa courbe est égale à l’unité, donc elle peut être une pdf pour une v.a. 2 ∞ Z +∞ Z +∞ 4 4 −3 4 E(X) = xfX (x)dx = dx = − x = 4 x 3 3 −∞ 1 1 Z +∞ Z +∞ 4 ∞ dx = −2x−2 1 = 2 E(X 2 ) = x2 fX (x)dx = 3 x −∞ 1 16 2 2 2 V(X) = E(X ) − E (X) = 2 − = 9 9 À vos claviers! Le code suivant montre comment utiliser le calcul symbolique pour vérifier qu’une fonction donnée est une densité de probabilité. #Code206.py # Symbol is a class that allows creating algebric expressions # integrate(f,D) function calculates the integral of f over domain D from sympy import Symbol, oo, Piecewise, integrate from sympy.plotting import plot from sympy.stats import ContinuousRV, density, E, variance,cdf # symbols x,t = Symbol(’x’), Symbol(’t’) # function f: checks if it is density, its integral has cdf properties f = Piecewise((4/x**5, x >= 1), (0, True)) ;print("f(x) = ",f) val = integrate(f,(x,-oo,+oo)) ;print("f is normed ? surface = ", val) F = integrate(f,(x,-oo,t)) ;print("F(t) = ", F) print("Lim x->-oo F(x)= ", F.subs(t,-oo),"Lim x->+oo F(x)= ", F.subs(t,+oo)) # create RV X with f as PDF X = ContinuousRV(symbol=x, density= f) cdf_X = cdf(X)(t) ;print("PDF_X = ",density(X)(t)) ;print("CDF_X = ",cdf_X) EX2 = integrate(x**2 * f) print("E(X)=",E(X), ",E(X^2)=",EX2, "=", E(X**2),",Var(X)=", variance(X)) # plot f and F plot(f, adaptive=False, nb_of_points=400) plot(F, adaptive=False, nb_of_points=400) #______________________________ Output ______________________________________ # f(x) = Piecewise((4/x**5, x >= 1), (0, True)) # F(t) = Min(1, t)**(-4) - 1/t**4 CHAPITRE 2. VARIABLES ALÉATOIRES # # # # # Lim x->-oo F(x)= 0 Lim x->+oo F(x)= 1 f is normed ? surface = 1 PDF_X = Piecewise((Piecewise((4/z**5, z >= 1), (0, True)), (z >= -oo) & (z < oo)), (0, True)) CDF_X = Min(1, z)**(-4) - 1/z**4 E(X)= 4/3 ,E(X^2)= Piecewise((0, x <= 1), (2 - 2/x**2, True)) = 2 ,Var(X)= 2/9 Figure 2.9 – Courbe de la pdf et la cdf (code206.py) 54 Distributions usuelles 2.5.1 Distributions discrètes 1- Uniforme (U(a, b)) : représente une EA avec un univers fini dont les éléments sont tous équiprobables et dans l’intervalle [a, b]. 2- Bernoulli (Ber(p)) : représente une EA avec un univers de deux résultats seulement, souvent appelés succès et échec, paramétrée avec p qui représente la probabilité du succès (et donc 1 − p est la probabilité de l’échec). 3- Géométrique (Geo(p)) : représente une EA avec un univers infini dont les éléments représentent l’apparition du premier succès (avoir k − 1 échecs suivis d’un succès (k ieme ) pour une suite d’épreuves de Bernoulli Ber(p)). 4- Pascal (Pas(n, p)) : représente le nombre de répétitions nécessaires de l’épreuve de Bernoulli (avec probabilité de succès p) jusqu’à l’obtention de n succès 5- Binomial (Bin(n, p)) : représente le nombre total de succès obtenus de n répétitions d’une épreuve de Bernoulli Ber(p). 6- Poisson (Pois(λ)) : représente une EA qui compte le nombre d’occurrences d’un certain événement dans un intervalle de temps. Loi X Uniform Bernouli Géométrique Pascal Binomial Poisson X; Uni(a, b) Ber(p) Geo(p) Pas(n, p) Bin(n, p) Pois(λ) Par a, b ∈ N p ∈ [0, 1] p ∈ [0, 1] n ∈ N∗ , p ∈ [0, 1] n ∈ N∗ , p ∈ [0, 1] λ ∈ R∗ Rang {a, · · · , b} {0, 1} N∗ N∗ {0, .., n} N pX (k) 1 b−a+1 [x]−a+1 b−a+1 1[a,b[ (x) + 1[b,∞[ (x) pk (1 − p)1−k (1 − p)k−1 p k−1 n Cn−1 p (1 − p)(k−n) Cnk pk (1 − p)n−k e−λ λk /k! p1[0,1[ (x) + 1[1,∞[ (x) 1 − (1 − p)[x] P[x] e−λ p 1/p n(1−p) p np λ p(1 − p) (1 − p)/p2 n(1−p) p2 np(1 − p) λ FX (x) E(X) V(X) a+b 2 (b − a + 1)2 − 1 12 i=1 Cni pi (1 − p)n−i CHAPITRE 2. VARIABLES ALÉATOIRES 2.5 λi i=1 i! P[x] Courbe 55 CHAPITRE 2. VARIABLES ALÉATOIRES 56 À vos claviers! Le code suivant implémente quelques distributions discrètes en Python. #Code207.py from from from from sympy import S , Symbol, symbols, Rational sympy.stats import density, cdf sympy.stats import E, variance as V sympy.stats import (FiniteRV, Die, Coin, DiscreteUniform, Bernoulli, Binomial, Geometric, Poisson, Hypergeometric) # I- Finite Random Var List myDensity = {0: .1, 1: .2, 2: .3, 3: .4} p = S.One / 5 finiteRVs = { "Finite R.V :":FiniteRV(’X’, myDensity), "Die6 :":Die(’D6’, 6), "Die4 :":Die(’D4’, 4), "Coin Half :":Coin(’C’), "Coin3/5 :":Coin(’C2’, Rational(3, 5)), "Discrete Uniform3:":DiscreteUniform(’X’, symbols(’a b c’)), "Discrete Uniform5:":DiscreteUniform(’Y’, list(range(5))), "Bernoulli3/4 :":Bernoulli(’X’, S(3)/4), "Bernoulli Half :":Bernoulli(’X’, S.Half, ’Heads’, ’Tails’), "Binomial Half 4 :":Binomial(’X’, 4, S.Half), "Hypergeometric :":Hypergeometric(’X’, 10, 5, 3) } # Print density, Expectation and Variance of each FRV in list above. for k,X in finiteRVs.items() : Pdf, Ex, Vx = density(X).dict, E(X), V(X) print(k,’ \t ’, Pdf, ’ \t ’, Ex, ’ \t ’, Vx) print("-------------------------------------------------------------") # II- Discrete (infinite) RV List k = Symbol("k") lamda = Symbol("Lambda", positive=True) # rate = lamda discreteRVs = { "Geometric:":Geometric("X", p), # Geometric(p=1/5) "Poisson :":Poisson("X", lamda) # Poisson(lambda) } print("-----------------------------------------------------------") for key,X in discreteRVs.items() : Pdf, Cdf, Ex, Vx = density(X)(k), cdf(X)(k), E(X), V(X) #simplify(V(X)) print(key,’ \t ’,Pdf, ’ \t ’, Cdf, ’ \t ’, Ex, ’ \t ’, Vx) #______________________________ Output ______________________________________ # R.V Distribution E Variance # Finite R.V :{0:0.1, 1:0.2, 2:0.3, 3:0.4} 2.00 1.00 # Die6 :{1:1/6, 2:1/6, 3:1/6, 4:1/6, 5:1/6, 6:1/6} 7/2 35/12 # Die4 :{1:1/4, 2:1/4, 3:1/4, 4: 1/4} 5/2 5/4 # Coin Half :{H:1/2, T:1/2} H/2+T/2 (-H/2 + T/2)**2/2 + (H/2 T/2)**2/2 # Coin3/5 :{H:3/5, T:2/5} 3*H/5+2*T/5 2*(-3*H/5 + 3*T/5)**2/5 + 3*(2*H/5 - 2*T/5)**2/5 # Discrete Unif3:{b:1/3, c:1/3, a:1/3} a/3+b/3+c/3 (-a/3 - b/3 + 2*c/3)**2/3 + (-a/3 + 2*b/3 - c/3)**2/3 + (2*a/3 - b/3 - c/3)**2/3 # Discrete Unif5:{0:1/5, 1:1/5, 2:1/5, 3: 1/5, 4: 1/5} 2 2 # Bernoulli3/4 :{0:1/4, 1:3/4} 3/4 3/16 # Bernoulli Half:{Tails:1/2, Heads:1/2} Heads/2+Tails/2 (-Heads/2 + Tails /2)**2/2 + (Heads/2 - Tails/2)**2/2 # BinomialcHalf4:{0:1/16, 1:1/4, 2:3/8, 3:1/4, 4:1/16} 2 1 # Hypergeometric:{0:1/12, 1:5/12, 2:5/12, 3:1/12} 3/2 7/12 # -----------------------------------------------------------------------# Geometric:(4/5)**(k - 1)/5 Piecewise((1 - 5*(4/5)**(k + 1)/4, k >= 1), (0, True)) 5 20 # Poisson :Lambda**k*exp(-Lambda)/factorial(k) Piecewise(((-Lambda**(-k - 1)*Lambda**(k + 1) *(k + 1)*exp(Lambda)*lowergamma(k + 1, Lambda)/factorial(k + 1) + exp(Lambda))*exp(-Lambda), k >= 0), (0, True)) Lambda Lambda Dans ce qui suit nous montrons quelques résultats donnés dans le tableau précèdent : Pmf de la loi Binomiale : pX (k) = Cnk pk (1 − p)n−k La probabilité que la v.a X prenne la valeur k est expliqué par le fait qu’il existe Cnk séquences de n résultats ayant k succès avec une probabilité p et n − k échecs avec une probabilité 1 − p (pour le résultat (ωi1 , ωi2 , ..., ωin ) les positions des k succès est le sous-ensemble {j1 , j2 , ..., jk } choisis de {1, 2, ..., n} ). Si n = 3 et k = 2, alors les séquences possibles sont : {(succès,succès,échec), (succès,échec,succès)et (échec, succès,succès)} chaque tuplet correspond à un sous-ensemble de CHAPITRE 2. VARIABLES ALÉATOIRES 57 deux positions ({1,2}, {1,3},{2,3}) le nombre de ces sous-ensembles est C32 = 3 et chaque séquence a une probabilité égale à p2 × (1 − p) (2 succès avec la probabilité p et 1 échec avec la probabilité 1 − p). Il faut noter que puisque l’expérience derrière la loi Binomiale est de lancer n fois une pièce, on peut penser à une v.a Binomiale X de paramètres (n, p) comme la somme de n v.a indépendantes X1 , X2 , ..., Xn de Bernoulli de paramètre p. Cette interprétation est parfois utile comme on peut le voir dans l’exemple 11. Calcul de l’espérance d’une v.a.d Géométrique. : Soient X ; Geo(p), et q = p − 1 E(X) = ∞ X kq k−1 k=0 ∞ ∞ X 1 d X k q p d d k = (q ) = p ( )= q )=p ( p=p dq dq dq 1 − q (1 − q)2 p k=1 k=1 Calcul de l’espérance d’une v.a.d Poisson : Soit X ; Poi(λ) E(X) = ∞ X xe−λ λx x=0 x! = ∞ ∞ ∞ X X X λx−1 λk e−λ λx = λe−λ = λe−λ = λe−λ eλ = λ (x − 1)! (x − 1)! k! x=1 x=1 k=0 Calcul de la variance d’une v.a.d Uniforme. : Soient X ; Uni(a, b) et n = b − a + 1 V(X) = E(X 2 ) − E2 (X) E(X) = b X i=b−n+1 E(X 2 ) = b X i=b−n+1 b n+1 1 1 X i= i= n n 2 b−n+1 b 1 2 (n + 1)(2n + 1) 1 X 2 i = i = n n 6 b−n+1 n2 − 1 (n + 1)(2n + 1) (n + 1)2 − = V(X) = 6 4 12 Exemple 11. Soient deux v.a X ; Bin(n, p) et Y ; Bin(m, p) et Z = X + Y . Trouver la pmf de Z. Solution Pn Pm Une méthode simple, consiste à considérer que : Z = X + Y = i=1 Xi + i=1 Yi tel que les Xi , Yi ; Ber(p) et elles sont indépendantes. On déduit donc que Z ; Bin(n + m, p) et donc sa pmf est : k PZ (k) = Cn+m × pk × (1 − p)n+m−k 1{0,1,··· ,n+m} (k) Si on cherche le même résultat directement, ça devient plus compliqué. En effet, le rang de CHAPITRE 2. VARIABLES ALÉATOIRES 58 RZ = {0, 1, 2, ..., n + m} et en utilisant la loi de probabilité totale, on a : P (Z = k) = P (X + Y = k) = n X P (X + Y = k|X = i) × P (X = i) i=0 = = = n X i=0 n X i=0 n X P (Y = k − i|X = i) × P (X = i) P (Y = k − i) × P (X = i) car X et Y sont indépendantes k−i Cm × pk−i × (1 − p)m−k+i × Cni × pi × (1 − p)n−i i=0 = pk × (1 − p)m+n−k n X k−i Cm × Cni i=0 k = Cn+m × pk × (1 − p)n+m−k 1{0,1,··· ,n+m} (k) À vos claviers! #Code208.py from sympy.stats import Binomial from sympy import S from sympy.stats import density # sum2Bin: creates two binomial r.v X,Y with parameters (n,p) and (m,p) as well # as their sum Z. W is binomial r.v with parameters (n+m, p) def sum2Bin(n, m, p): X, Y, W = Binomial(’X’, n, p), Binomial(’Y’, m, p), Binomial(’X’, n+m, p) Z = X + Y return [{ ’dic’: density(X).dict, ’legend’: ’X ~ Bin(’+str(n)+’,1/2)’}, { ’dic’: density(Y).dict, ’legend’: ’Y ~ Bin(’+str(m)+’,1/2)’}, { ’dic’: density(Z).dict, ’legend’: ’Z = X+Y’}, { ’dic’: density(W).dict, ’legend’: ’W ~ Bin(’+str(n+m)+’,1/2)’}] # plotter: plots X,Y,Z and W def plotter(rv_infos): import matplotlib.pyplot as plt plt.figure(figsize=(12, 8)) for i in range(len(rv_infos)): plt.subplot(221 + i).set_title(rv_infos[i][’legend’]) plt.bar(list(rv_infos[i][’dic’].keys()), rv_infos[i][’dic’].values()) plt.show() # s2b=sum2Bin(10, 20, S.Half) # prints associated distribution of X,Y,Z and W. for i in range(len(s2b)): print("Pmf de " + s2b[i][’legend’][0] + ’ : ’, s2b[i][’dic’]) plotter(s2b) #______________________________ Output _____________________________________ # Pmf de X : {0: 1/1024, 1: 5/512, 2: 45/1024,..., 10: 1/1024} # Pmf de Y : {0: 1/1048576, 1: 5/262144, ..., 20: 1/1048576} # Pmf de Z : {0: 1/1073741824, 1: 15/536870912, ..., 30: 1/1073741824} # Pmf de W : {0: 1/1073741824, 1: 15/536870912, ..., 30: 1/1073741824} CHAPITRE 2. VARIABLES ALÉATOIRES Figure 2.10 – Courbe de la pmf (code208.py) 59 123456- Distributions continues Uniforme (U(a, b)) : se caractérise par une représentation uniforme des valeurs prises par la v.a sur l’intervalle [a, b]. Exponentielle (Expo(λ)) : modélise la durée de vie d’un phénomène sans mémoire avec une moyenne 1/λ. Normale (N (µ, σ 2 )) : la densité d’une v.a normale est la fonction de Gauss. Logistic (Logistic) : sa fonction de répartition est une fonction logistique. Triangulaire (T riang(a, b, c)) : sa fonction de densité est affine croissante pour les valeurs entre a et c (c est son mode) et affine décroissante entre c et b. Gamma (Gamma(n, λ)) : représente la somme de n v.a expo(λ). Elle est basée sur la fonction Gamma. Loi X Uniforme Exponentielle Normale 2 Logistic Triangulaire Gamma X; U(a, b) Expo(λ) N (µ, σ ) Logistic T riang(a, b, c) Gamma(n, λ) Par a, b ∈ R λ∈R µ, σ - a, b, c n, λ Rang [a, b] R R R [−∞, +∞] [0, ∞[ fX (x) 1 b−a 1[a,b] (x) ex (1+ex )2 λα xα−1 e−λx 1[0,∞[ (x) Γ(α) FX (x) x−a b−a 1[a,b[ (x) 2((x−a)1[a,c[ (x)+(b−x)1[c,b[ (x)) (b−a)(b−c) ( (x−a)2 si a < x ≤ c (b−a)(c−a) b−x2 − (b−a)(b−c) si c < x ≤ b E(X) V(X) a+b 2 (b−a+1)2 −1 12 λe + 1[b,∞[ (x) −λx 1[0,∞[ (x) √1 e 2πσ (x−µ)2 2σ 2 1 − e−λ x Rx 1 λ µ 0 a+b+c 3 α λ 1 λ2 σ π 2 /3 a2 +b2 +c2 −ab−ac−bc 18 α λ2 −∞ 2 √1 e−t /2 2π dt ex 1+ex Rt 0 λα tα−1 e−λt 1[0,∞[ (t)dt Γ(α) CHAPITRE 2. VARIABLES ALÉATOIRES 2.5.2 Plot 60 CHAPITRE 2. VARIABLES ALÉATOIRES 61 Propriété d’absence de mémoire de la loi Exponentielle La propriété la plus importante de la loi exponentielle est l’absence de mémoire. Proposition 5. Une v.a.c X ; Expo(λ) ssi X satisfait la propriété suivante : P (X > x + a|X > a) = P (X > x) pour x, a ≥ 0 Cette propriété est appelée l’absence de mémoire. Démonstration 1- Soient la v.a.c X ; Expo(λ) et x, a deux nombres réels positifs, P (X > x + a|X > a) = = P (X > x + a) P (X > x + a, X > a) = P (X > a) P (X > a) 1 − FX (x + a) e−λ(x+a) = e−λx = P (X > x) = 1 − FX (a) e−λa Donc X satisfait la propriété de l’absence de mémoire. 2- Soient une v.a.c X qui satisfait la propriété de l’absence de mémoire et x, a deux nombres réels positifs, P(X > x + a) = P(X > a)P(X > x + a | X > a) = P(X > x)P(X > a) 1 − FX (x + a) = (1 − FX (x))(1 − FX (a)) GX (x + a) = GX (x)GX (a) avec GX (z) := 1 − FX (z) GX (n) = GX (1)n = enlnGX (1) GX (1/m) = GX (1)1/m GX (r) = GX (1)r ∀n ∈ N ∀m ∈ N ∀r ∈ Q GX (x) = GX (1)x = exlnGX (1) ∀x ∈ R Donc X ; Expo(λ) avec λ = −lnG(1) Le dernier résultat, généralisation pour tous les réels, est justifié parle fait que tout réel est la limite d’une suite de nombres rationnels (pour la démonstration voir la référence [1]). Ceci signifie que si aucun événement ne s’est produit jusqu’au temps a, le temps d’attente à partir du moment a jusqu’à l’arrivée du prochain événement suit la même distribution que le temps d’attente à partir du moment initial (instant 0). Exemple 12. Supposons que la durée d’un appel dans une cabine téléphonique (en minutes) est une v.a.c X ; Expo(1/10). 1- Si quelqu’un arrive juste avant vous (il téléphone dans la cabine), trouver la probabilité que vous attendiez : a) moins de 5 minutes, b) plus de 10 minutes, c) entre 5 et 10 minutes. 2- Calculer la moyenne du temps d’attente ainsi que la variance. 3- Écrire le code Python qui modélise cette situation. Solution Soit X la v.a qui représente la durée de l’appel X ; Expo(λ). Soit Y la v.a qui représente la durée de votre attente. On suppose que vous êtes arrivés après A minutes d’appel de celui qui occupe la cabine. Vous avez déjà l’information (et lui aussi) que sa durée d’appel X est supérieure à A. Avec cette CHAPITRE 2. VARIABLES ALÉATOIRES 62 condition, votre durée d’attente sera le reste de son appel c.à.d Y = X − A. "Y ne dépasse pas 5 min" est équivalent à X < 5 + A sachant que X > A (la figure 2.11 montre la relation entre X et Y et les bornes d’attente Max et Min). En utilisant la propriétés d’absence de mémoire de la v.a Expo , la probabilité d’attendre pas plus de d minutes est : P (Y < d) = P (X < A + d|X > A) = 1 − P (X > A + d|X > A) = 1 − P (X > d) = P (X ≤ d) Cette expression montre que la durée d’attente n’est pas fonction de l’instant d’arrivée (elle ne se rappelle pas à quel moment on est arrivé - absence de mémoire) et elle suit la même loi que la durée d’appel Y ; Expo(λ). Figure 2.11 – Relation entre les deux v.a X et Y 1 P (Y < 5) = P (X < 5) = 1 − e−λ5 = 1 − e− 2 = 0.3934 P (Y > 10) = P (X > 10) = 1 − P (X ≤ 10) = 1 − 1 + e−1 = 0.3678 P (5 ≤ Y ≤ 10) = P (5 ≤ X ≤ 10) = 1 − [P (X < 5) + P (X > 10)] = 1 − (0.3934 + 0.3678) = 0.2388 1 E(Y ) = E(X) = = 10 λ 1 V(Y ) = V(X) = 2 = 100 λ À vos claviers! #Code209.py # subs: substitutes parameters with values in the algebric expression # simplify: simplifies an algebric expression. from sympy.stats import Exponential, density, cdf, E, variance, given, P from sympy import Symbol, simplify, And lamda , z = Symbol("lambda", positive=True), Symbol("z") X = Exponential("x", lamda) pdf_X, cdf_X, E_X, V_X = density(X)(z), cdf(X)(z), E(X), variance(X) print(’RV X. \n pdf:’,pdf_X,’\n cdf:’,cdf_X,’\n E:’,E_X,’\n V:’,V_X) Z = X.subs(lamda,1/10) pdf_Z = density(Z)(z) ;cdf_Z = cdf(Z)(z) ;E_Z = E(Z) ;V_Z = variance(Z) print(’RV Z. \n pdf:’, pdf_Z,’\n cdf:’, cdf_Z,’\n E:’,E_Z,’\n V:’,V_Z) Y = given(X - 3, X > 3) pdf_Y = simplify(density(Y)(z)) P_Y5 = P(Y < 5).subs(lamda, 1/10) P_Y10 = P(Y > 10).subs(lamda, 1/10) P_Y510 = P(And(Y > 5,Y < 10)).subs(lamda, 1/10) print(’RV Y. \n pdf:’, pdf_Y,’\n P(Y<5):’,P_Y5,’\n P(Y<10):’,P_Y10,’\n P(Y>5,Y<10):’,P_Y510) #______________________________ Output ______________________________________ # RV X. # pdf: lambda*exp(-lambda*z) # cdf: Piecewise((1 - exp(-lambda*z), z >= 0), (0, True)) # E: 1/lambda # V: lambda**(-2) # RV Z. # pdf: 0.1*exp(-0.1*z) # cdf: Piecewise((1 - exp(-0.1*z), z >= 0), (0, True)) # E: 10.0000000000000 # V: 100.000000000000 # RV Y. CHAPITRE 2. VARIABLES ALÉATOIRES # # # # 63 pdf: -lambda*(Heaviside(-z) - 1)*exp(-lambda*z) P(Y<5): 0.393469340287367 P(Y<10): 0.367879441171442 P(Y>5,Y<10): 0.238651218541191 Exemple 13. Un fabricant de voitures veut garantir que la probabilité qu’une voiture donnée tombe en panne dans sa première année d’utilisation soit inférieure à p = 0.1. Sachant que la durée d’arrivée d’une panne suit une loi exponentielle : 1- Quelle est la durée moyenne minimale d’avoir une panne ? 2- Écrire le code Python de cet exemple. Solution Soit Tp la v.a donnant le temps jusqu’à la première panne qui suit une loi exponentielle de paramètre λp (Tp ; E(λp ), paramétré par p). Le fabricant veut garantir que : P (Tp ≤ 1) = 1 − e−λp ×1 ≤ p =⇒ λp ≤ −ln(1 − p) =⇒ E(Tp ) = 1 1 ≥− λp ln(1 − p) Pour p=0.1, E(Tp ) = λ1p ≥ 9.5. Donc, la durée moyenne minimale jusqu’à la première panne est 9.5 ans (pour que la probabilité de la première panne soit inférieure à 0.1). La loi Normale centrée réduite (loi Normale standard). Une v.a X qui suit la loi Normale centrée réduite est notée X ; N (0, 1), son espérance est égale à 0 et sa variance est égale à 1. Cette loi est généralement définie par sa fonction de répartition φ : R → R+ : Z z 1 2 1 φ(z) = √ e− 2 t dt ∀z ∈ R 2π −∞ Il n’existe pas d’expression analytique à cette fonction. Pour avoir la valeur de φ(z) = P (X ≤ z), on utilise souvent des tables de valeurs. L’aire sous la courbe de la loi centrée réduite est égale à 1. Elle est symétrique par rapport à Figure 2.12 – La répartition de la densité de la loi Normal centrée réduite z = 0 (comme c’est une fonction paire : ∀x ∈ R, φ(x) = φ(−x), 50% est à gauche du 0 et 50% à sa droite). La répartition complète est montrée sur la figure 2.12. Pour avoir la valeur de φ(z), on utilise les tables de la loi normale centrée réduite gauche ou droite. La première nous donne l’aire à droite de la valeur z et la deuxième nous donne celle à gauche. Voici un exemple de son utilisation. Exemple 14. Le nombre de journées ensoleillées par an dans une ville donnée suit une loi normale avec une moyenne de µ = 230 jours et un écart type égale à σ = 52 jours. 1- Quelle est la probabilité que l’année prochaine, dans cette ville il y aura plus de 300 jours de soleil ? Solution Si X est la v.a représentant le nombre de journées ensoleillées annuelle sur cette ville, X ; N (µ, σ) alors : 300 − 230 X − 230 > ) = 1 − φ(1.346) P (X > 300) = P ( 52 52 CHAPITRE 2. VARIABLES ALÉATOIRES 64 Figure 2.13 – La valeur de la cdf au point z = 0.09012 (en utilisant la table à droite) = 1-0.9099=0.0912 (en utilisant la table à gauche) = 0.5-0.4099=0.09012 (en utilisant la table de 0 à z) (Voir table de loi normale centrée réduite (Z-table) en annexe C pour la valeur de φ(1.346)) À vos claviers! Le code suivant implémente une v.a centrée réduite X et Y = 3 ∗ X + 5. #Code210,py from sympy.stats import E,variance, Normal,density from sympy import Symbol from sympy.plotting import plot def processNormalRV(rv_Name, rv_X): print(’E(’,rv_Name,’)= ’,E(rv_X),’ V(’,rv_Name,’)= ’,variance(rv_X)) z = Symbol(’z’) plot(density(rv_X)(z), (z, -10, 20)) processNormalRV(’X’, Normal(’X’,0,1)) processNormalRV(’Y’, 3*Normal(’X’,0,1)+5) #______________________________ # E( X )= 0 V( X )= 1 # E( Y )= 5 V( Y )= 9 Output ______________________________________ Figure 2.14 – Loi normale standard vs non standard (code210.py) Dans ce code, une v.a X centrée réduite est créée et utilisée pour en créer une autre égale à 3 ∗ X + 5, l’espérance et la variance des deux variables sont calculées et les deux v.a sont plotées en utilisant le package plotting de sympy. Sur les deux graphiques, on voit bien que X est centrée sur l’axe x = 0 avec E(X) = 0 alors que Y est centrée sur l’axe x = 5 avec E(Y ) = 5 ; la variance de Y (V(Y ) = 9) est également nettement plus large par rapport à celle de X (V(X) = 1) ce qui a donné un graphe plus large que celui de X. CHAPITRE 2. VARIABLES ALÉATOIRES 2.6 65 Variables aléatoires multiples Dans beaucoup d’expériences, on peut être intéressé à plus d’une variable aléatoire en relation entre elles. Par exemple, dans l’étude de l’efficacité d’un régime alimentaire donné, on peut s’intéresser à l’âge des participants, leur sexe ainsi que la nature de leur travail (physique, intellectuelle,...). Ici, on présente le cas de deux v.a (bivariée, ou bivariate en Anglais), ce qui peut facilement être étendu à plusieurs v.a (multivariée, ou Multivariate en Anglais). 2.6.1 Distribution jointe, marginale et conditionnelle Définition 9. Soient deux v.a X et Y . La loi de probabilité jointe de X et Y est définie par : ∀(B1 , B2 ) ∈ B 2 PXY (B1 × B2 ) = P ((X, Y ) ∈ B1 × B2 ) = P (X ∈ B1 , Y ∈ B2 ), Le rang de cette loi jointe est : RXY = {(x, y)/x ∈ RX et y ∈ RY } La fonction de répartition jointe de X et Y est définie par : FXY (x, y) = PXY (]−∞, x]×]−∞, y]) = P ((X, Y ) ∈]−∞, x]×]−∞, y]) = P (X ≤ x, Y ≤ y) La fonction de répartition marginale par rapport à X (respec Y ) est définie par : FX (x) = FXY (x, ∞) = PXY (] − ∞, x] × R) = P (X ≤ x) FY (y) = FXY (∞, y) = PXY (R×] − ∞, y]) = P (Y ≤ y) La distribution conditionnelle de X sachant Y est définie par : PX|Y (B1 , B2 ) = P (X ∈ B1 |Y ∈ B2 ) = PXY (B1 , B2 ) , PY (B2 ) FX|Y (x, y) = PX|Y (] − ∞, x], ] − ∞, y]) = ∀(B1 , B2 ) ∈ B 2 FXY (x, y) FY (y) Définition 10. cas discret Soient X et Y deux v.a.d : 1- La fonction de masse jointe de X et Y est définie par : pXY (x, y) = PXY ({(x, y)}) = P ((X, Y ) = (x, y)) = P (X = x, Y = y) 2- La fonction de masse marginale de X (respectivement Y ) est : X X pX (x) = pXY (x, y) (PY (y) = pXY (x, y)) y∈RY x∈RX 3- La fonction de masse conditionnelle de X et Y est définie par : pX|Y (x, y) = P (X = x|Y = y) = pXY (x, y) pY (y) Exemple 15. Soient deux v.a.d X, Y avec la fonction de masse jointe suivante : RXY = RX × RY = {0, 1} × {0, 1, 2} (X,Y) (0,0) (0,1) (0,2) (1,0) (1,1) (1,2) pXY (x, y) 1 6 1 4 1 8 1 8 1 6 1 6 CHAPITRE 2. VARIABLES ALÉATOIRES 66 Trouver : 1. P (X = 0, Y ≤ 1) 2. Les marginales de X et de Y 3. P (Y = 1|X = 0) Solution 1- P (X = 0, Y ≤ 1) = PXY ({0} × {0, 1}) = pXY (0, 0) + pXY (0, 1) = 1/6 + 1/4 = 5/12 2- Les marginales ∀x ∈ RX : pX (x) = X pXY (x, y) = pXY (x, 0) + pXY (x, 1) + pXY (x, 2) = y∈{0,1,2} 13 11 1{0} (x) + 1{1} (x) 24 24 De la même façon, pour Y , =1) = 1/4 × 24/13 = 8/13 3- P (Y = 1|X = 0) = P (X=0,Y P (X=0) (X,Y) 0 1 2 PX 0 1 6 1 4 1 8 13 24 1 1 8 1 6 1 6 11 24 PY 7 24 5 12 7 24 1 À vos claviers! #Code211.py import numpy as np from functools import reduce from scipy.stats import rv_discrete import matplotlib.pyplot as plt import seaborn as sns from random import random generateDRV=lambda rv: [rv.ppf(random()) for _ in range(1000)] def getbar3Data(Rg_x, Rg_y, p_xy): xpos, ypos = reduce(lambda ls, e: ls+[e]*len(Rg_y), Rg_x, []) , [0,1]*len(Rg_x) zpos = np.zeros(len(xpos)) dx, dy = np.ones(len(xpos))*0.02, np.ones(len(xpos))*0.02 dz = list(p_xy.flatten()) return xpos, ypos, zpos, dx, dy, dz def plotjointDistribution(xpos, ypos, zpos, dx, dy, dz): fig = plt.figure() ax1 = fig.add_subplot(111, projection=’3d’) ax1.bar3d(xpos, ypos, zpos, dx, dy, dz, color=’#00ceaa’) plt.show() # random variables Rg_x, Rg_y = np.array([0,1,2]), np.array([0,1]) p_xy = np.array([[1/6,1/4,1/8],[1/8,1/6,1/6]]) # data for joint distribution plotting xpos, ypos, zpos, dx, dy, dz = getbar3Data(Rg_x, Rg_y, p_xy) plotjointDistribution(xpos, ypos, zpos, dx, dy, dz) # data for marginal plotting p_x, p_y = np.sum(p_xy, axis=0), np.sum(p_xy, axis=1) rv_X = rv_discrete(name=’X’, values=(Rg_x, p_x)) rv_Y = rv_discrete(name=’Y’, values=(Rg_y, p_y)) sns.jointplot(generateDRV(rv_X),generateDRV(rv_Y)).set_axis_labels("X", "Y") CHAPITRE 2. VARIABLES ALÉATOIRES 67 Figure 2.15 – pmf jointe et marginales (code211.py) Exemple 16. Soient X et Y deux v.a.d représentant la durée de vie de deux composants connece−2 tés d’une machine donnée. La fonction de masse jointe est donnée par : pXY (x, y) = x!(y−x)! pour x ∈ N ∧ y ≥ x. Calculer : 1. La fonction de masse jointe de X et Y − X 2. La marginale de X, Y − X et Y Note : La somme de deux v.a Poisson X et Y de taux respectifs λ1 et λ2 est une v.a Poisson de taux λ1 + λ2 (ce résultat sera démontré dans le prochain chapitre). Solution Soit Z = Y − X pXZ (x, z) = P (X = x, Z = z) = P (X = x, Y − X = z) = P (X = x, Y = z + x) e−2 , pour tout x, z ∈ N x!z! ∞ ∞ X X e−2 e−1 e−1 Donc pX (x) = = pXZ (x, z) = = , de même pour pZ (z) = x!z! x! z! z=0 z=0 = pXY (x, z + x) = Donc, on a X, Z ; Pois(1) (elles suivent la même loi). Nous avons, P (X = x, Y − X = z) = e−2 e−1 e−1 = × = P (X = x) × P (Y − X = z) x!z! x! z! On déduit donc que X et Y − X sont indépendantes, et Y ; Pois(2). Définition 11. cas continu Soient X et Y deux v.a.c : 1- La fonction de densité jointe de X et Y est la fonction vérifiant : Z Z PXY (B1 × B2 ) = fXY (x, y)dxdy, ∀(B1 , B2 ) ∈ B 2 B1 B2 2- La relation entre cette fonction et la cdf jointe : ∂2 fXY (x, y) = FXY (x, y) ∂x∂y Z x Z y FXY (x, y) = fXY (x, y)dxdy −∞ −∞ 3- La fonction de densité marginale de X est : Z ∞ fX (x) = fXY (x, ∞) = fXY (x, y)dy −∞ CHAPITRE 2. VARIABLES ALÉATOIRES 68 4- La fonction de densité conditionnelle (c-pdf ) de X et Y est la fonction vérifiant : fX|Y (x, y) = fXY (x, y) fY (y) Exemple 17. Un point est choisi aléatoirement à l’intérieur d’un disque circulaire D de rayon r. Soit X la v.a représentant la longueur du segment allant du centre de ce disque vers le point choisi et Y la v.a mesurant l’angle (en radian) entre ce segment et l’axe horizontal. Quelle est la distribution jointe de X et Y ? Solution Les deux v.a X, Y sont définies sur le même espace de probabilité (Ω, F, P ), Ω est l’ensemble des points du disque, F une tribu définie sur cet ensemble et P la probabilité uniforme de choisir une zone sur ce disque (P (B) = |B|/|D|,où |Z| est la surface de la zone Z). FXY (x, y) = P (X ≤ x, Y ≤ y) correspond à la probabilité que le point choisi soit dans le segment de rayon x et 2 d’angle y dont la surface est yx2 . Donc la cdf et sa pdf correspondante : yx2 1[0,r]×[0,2π] (x, y) 2πr2 ∂2 x fXY (x, y) = FXY (x, y) = 2 1[0,r]×[0,2π] (x, y) ∂x∂y πr FXY (x, y) = 2.6.2 Covariance et coefficient de corrélation La covariance de deux v.a X et Y est une mesure qui donne une information sur la dépendance linéaire de X et de Y . C’est à dire comment les valeurs de X changent en fonction de celles de Y . Définition 12. La covariance entre X et Y est définie par : Cov(X, Y ) = E[(X − E(X))(Y − E(Y ))] = E(XY ) − E(X)E(Y ) Lorsque la Cov(X, Y ) = 0, X et Y sont dites non corrélées. Si Cov(X, Y ) est positive, elles sont dites positivement corrélées c.à.d soit X − E(X) > 0 et Y − E(Y ) > 0 ou bien X − E(X) < 0 et Y − E(Y ) < 0 ; alors que dans le cas contraire X et Y sont dites négativement corrélées. La covariance peut aussi être utilisée dans le calcul de la variance : V(X + Y ) = V(X) + V(Y ) + 2Cov(X, Y ). Donc si X et Y sont non corrélées (Cov(X, Y ) = 0) alors : V(X + Y ) = V(X) + V(Y ). Ce résultat peut être généralisé à plusieurs v.a deux à deux non corrélées. Les v.a indépendantes sont toujours non corrélées, mais l’inverse n’est pas nécessairement vrai. La corrélation est souvent mesurée par le coefficient de corrélation. Définition 13. Le coefficient de corrélation est le rapport défini par : Cov(X, Y ) p ρXY = p , V(X) V(Y ) Vérifiant : − 1 ≤ ρXY ≤ 1 Il est nul lorsque les deux v.a sont non corrélées, positif si elles sont positivement corrélées et négatif sinon. En fait, ρ est la version normalisée de la covariance. Il est obtenu en calculant la covariance des ) deux v.a X 0 = X−E(X) et Y 0 = Y −E(Y σX σY CHAPITRE 2. VARIABLES ALÉATOIRES 69 Proposition 6. Propriétés de la covariance : 1- Cov(X, X) = V(X) 2- Cov(X, Y ) = Cov(Y, X) 3- Cov(aX, bY ) = abCov(X, Y ) 5- Cov(X Z) +PCov(Y, Z) Pn+ Y, Z) = PCov(X, m n Pm 6-Cov( i=1 ai Xi , j=1 bj Yj ) = i=1 j=1 ai bj Cov(Xi , Yj ) Exemple 18. 1. Calculer la covariance et le coefficient de corrélation de X et Y de l’exemple 15. 2. Écrire le code Python correspondant. Solution 1. La covariance et le coefficient de corrélation de X et Y de l’exemple 15 : Cov(X, Y ) = E(XY ) − E(X)E(Y ) = 1/2 − 11/24 × 1 = 1/24 Cov(X, Y ) p ρXY = p = 0.109 V(X) V(Y ) 2. À vos claviers! #Code212,py import numpy as np from sympy.stats import FiniteRV from sympy.stats import E,variance import math XDensity,YDensity = {0:13/24,1:11/24},{0:7/24,1:5/12,2:7/24} X, Y = FiniteRV(’X’,XDensity ), FiniteRV(’Y’,YDensity ) JDensity = {(0,0):1/6,(0,1):1/4,(0,2):1/8,(1,0):1/8,(1,1):1/6,(1,2):1/6} ZDensity = {(k[0]-E(X))*(k[1]-E(Y)):v for k,v in JDensity.items()} cov = np.dot(list(ZDensity.keys()),list(ZDensity.values())) print("E(X)=",E(X)," E(Y)=",E(Y)) print("V(X)=",variance(X)," V(Y)=",variance(Y)) print("Cov(X,Y)=",cov) print("Correlation Coefficient=",cov/(math.sqrt(variance(X))*math.sqrt(variance(Y)))) #______________________________ Output ______________________________________ # E(X)= 0.458333333333333 E(Y)= 1.00000000000000 # V(X)= 0.248263888888889 V(Y)= 0.583333333333333 # Cov(X,Y)= 0.0416666666666667 # Correlation Coefficient= 0.109489780290272 Exemple 19. 1. Calculer la covariance et le coefficient de corrélation des deux v.a X et Y ayant la fonction jointe : fXY (xy) = 3x 0≤y≤x≤1 CHAPITRE 2. VARIABLES ALÉATOIRES 70 Solution Z +∞ fX (x) = x Z 3xdy = 3x2 fXY (x, y)dy = −∞ Z +∞ fy (y) = 0 Z 1 fXY (x, y)dx = −∞ +∞ Z 3xdx = y Z +∞ xyfxy (x, y)dxdy = E(XY ) = −∞ 1 −∞ Z E(X) = xfX (x)dx = 3 4 yfY (y)dy = 3 8 0 Z 1 E(Y ) = 0 3(1 − y 2 ) 2 3 51 3 [x ]0 = 10 10 3 Cov(X, Y ) = E(XY ) − E(X)E(Y ) = 160 Z 1 3 E(X 2 ) = x2 fX (x)dx = 5 0 Z 1 1 E(Y 2 ) = y 2 fY (y)dy = 5 0 3 V(X) = E(X 2 ) − E2 (X) = 80 19 2 2 V(Y ) = E(Y ) − E (Y ) = 320 Cov(X, Y ) p = 0.397 ρXY = p V(X) V(Y ) À vos claviers! #Code213.py from sympy import Symbol, integrate, Interval from sympy.stats import density, E, variance as V from math import sqrt x = Symbol(’x’); y = Symbol(’y’) fxy = 3*x fx = integrate(fxy,(y,0,x)) ; print("marginal of X:",fx) fy = integrate(fxy,(x,y,1)) ; print("marginal of Y:",fy) # Direct method Ex , Ey = integrate(x*fx,(x,0,1)) , integrate(y*fy,(y,0,1)) print("E(X)=",Ex," E(Y)=",Ey) Exy = integrate(integrate(x*y*fxy,(y,0,x)),(x,0,1)) ; print("E(X*Y)=",Exy) cov = Exy-Ex*Ey ; print("Cov(X,y)=",cov) Ex2 , Ey2 = integrate((x**2)*fx,(x,0,1)) , integrate((y**2)*fy,(y,0,1)) vx , vy = Ex2-Ex**2 , Ey2-Ey**2 print("V(X)=",vx) ; print("V(Y)=",vy) cor = cov/(sqrt(vx)*sqrt(vy)) ; print("Correlation coefficient:",cor) # ContinuousRV from sympy.stats import ContinuousRV X = ContinuousRV(symbol=x, density= fx, set=Interval(0, 1)) Y = ContinuousRV(symbol=y, density= fy, set=Interval(0, 1)) print("E(X)=",E(X), ",E(X^2)=", E(X**2),",Var(X)=", V(X)) print("E(Y)=",E(Y), ",E(Y^2)=", E(Y**2),",Var(Y)=", V(Y)) cov = Exy-E(X)*E(Y) ; print("Cov(X,y)=",cov) cor = cov/(sqrt(V(X))*sqrt(V(Y))) ; print("Correlation coefficient:",cor) #______________________________ # marginal of X: 3*x**2 # marginal of Y: 3/2 - 3*y**2/2 Output ______________________________________ CHAPITRE 2. VARIABLES ALÉATOIRES # # # # # # 71 E(X)= 3/4 E(Y)= 3/8 E(X*Y)= 3/10 Cov(X,y)= 3/160 V(X)= 3/80 V(Y)= 19/320 Correlation coefficient: 0.397359707119513 2.7 Fonction génératrice des moments Définition 14. (n) Le neme moment d’une v.a X est défini comme mX = E(X n ). (n) Le neme moment central de X est défini comme m̄X = E((X − E(X))n ). La fonction génératrice des moments (FGM) d’une v.a X est une fonction MX (t) qui associe à t l’espérance de la v.a etX . MX (t) = E(etX ) MX existe, s’il existe une constante positive c tel que E(etX ) est finie pour tout |t| ≤ c (voisinage de 0, t ∈ δ(0, c)). ∃c > 0, ∀|t| ≤ c, E(etX ) < ∞ =⇒ ∃MX (1) - Le premier moment est l’espérance : mX = mX = E(X). (2) - Le second moment central est la variance de X : m̄X = V(X). - La FGM de X nous donne tous les moment de X. Exemple 20. Trouver la FGM des v.a suivantes. a- X ∼ Ber(p) b- X ∼ Uni(0, 1) c- X ∼ Expo(λ) d- X ∼ Pois(λ) Solution nous avons MX (t) = E[etX ] a−X ∼ Ber(p) b−X ∼ Uni(0, 1) c−X ∼ Expo(λ) : MX (t) = et p + e0t (1 − p) = pet − p + 1 Z 1 1 et − 1 etx = : MX (t) = etx dx = s 0 t 0 Z ∞ Z ∞ : MX (t) = etx λe−λx dx = λ e−(λ−t)x dx = 0 d−X ∼ Pois(λ) : MX (t) = ∞ X k=0 2.7.1 0 ∞ λ λ−t X (et λ)k t λk = e−λ = eλ(e −1) etk e−λ k! k! k=0 Calcul des moments par la FGM (k) La substitution de etX par sa série de Taylor dans MX montre que mX représente le k eme coefficient de cette série qui peut etre determiné par la k eme dérivée de MX (t) en l’évaluant dans t = 0. ∞ ∞ ∞ X X X X k tk tk E[X k ] k MX (t) = E[etX ] = E[ ]= E[X k ] = t k! k! k! k d (k) MX (t) = MX (t) = dtk Nous avons donc : dk MX (t) dtk k=0 ∞ X n=k k=0 n E[X ] n−k E[X n+k+1 ] n t = E[X k ] + t( t ) (n − k)! (n + 1)! n=0 (k) (k) = E[X k ] = mX = MX (t) t=0 k=0 ∞ X t=0 CHAPITRE 2. VARIABLES ALÉATOIRES 72 Exemple 21. Pour les questions de l’exemple 20, trouver E[X] en utilisant MX (t). Solution Nous avons E(X) = d MX (t) dt a−X ∼ Ber(p) : E(X) = t=0 d (pet − p + 1) dt = pes t=0 =p t=0 règle de l’Hopital z (t − 1)et + 1 d et − 1 = = lim b−X ∼ Uni(0, 1) : E(X) = t→0 dt t t2 t=0 t=0 1 d λ λ = c−X ∼ Expo(λ) : E(X) = = dt λ − t t=0 (λ − t)2 t=0 λ t t d = λet eλ(e −1) =λ d−X ∼ Pois(λ) : E(X) = eλ(e −1) dt t=0 t=0 }| { et t − et + 1 1 = t2 2 Si MX existe, elle détermine de façon unique la distribution de X (FX ). Définition 15. Soient X et Y deux v.a Supposons qu’il existe une constante positive c tel que les FGMs de X et Y sont finies et identiques ∀|t| ≤ c. alors, FX (x) = FY (x), ∀x ∈ R ∃c > 0, MX , MY & ∀|t| ≤ c, MX (t) = MY (t) =⇒ FX (x) = FY (x), ∀x ∈ R Définition 16. La somme de v.a indépendantes avec la FGM : Supposons que X1 , X2 , ..., Xn sont n v.a indépendantes ∀1 ≤ i, j ≤ n, i 6= j, Xi ⊥ Xj =⇒ MPni=1 Xi = n Y MXi i=1 Démonstration. Pn MPni=1 Xi (t) = E[et( i=1 Xi ) ] = E[ n Y i=1 etXi ] = n Y MXi (t) i=1 Exemple 22. a- Pour X ∼ Bin(n, p) trouver sa FGM. b- Prouver que : X ∼ Bin(m, p) & Y ∼ Bin(n, p) & X ⊥ Y =⇒ X + Y ∼ Bin(m + n, p) Solution Soit X ∼ Bin(n, Pn p) Alors X = i=1 Xi tel que Xi ∼ Ber(p) & ∀1 ≤ i, j ≤ n, i 6= j, nous avons Xi ⊥ Xj MX (t) = E[et( Pn i=1 Xi ) ]= n Y MXi (t) = (MX0 (t))n i=1 MX+Y (t) = MX (t)MY (t) = (MX0 (t))n (MX0 (t))m = (MX0 (t))n+m X+Y ∼ Bin(n + m, p) 2.8 Transformation de variables aléatoires CHAPITRE 2. VARIABLES ALÉATOIRES 73 Définition 17. Changement de variable x1 x = ∈ R2 x2 Le changement de la variable x par y est une application bijective (transformation) φ : R2 → R2 tel que : y1 φ1 (x1 , x2 ) y = = φ(x) = y2 φ2 (x1 , x2 ) La transformation inverse de φ est φ−1 : R2 → R2 définie par : −1 x1 φ (y , y ) 1 2 1 x = = φ−1 (y) = x2 φ−1 (y , y ) 1 2 2 Définition 18. La règle de transformation d’uneloi de probabilité X1 Y1 Le vecteur de v.a est R2 , X = , Le vecteur Y = est la transformée de X avec X2 Y2 φ : Y = φ(X) si la loi de Y est donnée par ∀A ∈ Br, PY (A) = P (Y ∈ A) = P (X ∈ φ−1 (A)) = PX (φ−1 (A)) . Exemple 23. Soit la transformation suivante : y1 φ1 (x) x1 − x2 = y = φ(x) = = y2 φ2 (x) x1 + x2 Trouver sa transformation inverse et determiner P (Y2 < 1). Solution La transformation inverse : y1 +y2 −1 x φ (y) 1 1 = 2 x = φ−1 (y) = = y2 −y1 −1 x2 φ2 (y) 2 Y = φ(X) P (Y2 < 1) = P (Y ∈ R×] − ∞, 1[) = P (φ−1 1 (R×] − ∞, 1[)) = P (X1 + X2 < 1) Définition 19. Le Jacobien d’une transformation Soit la transformation φ sur Rm × Rn , alors le Jacobien de φ = (φ1 , · · · , φm )T est donné par : Jφ (x) = ∂φ(x) = ∂x ∂ ∂x1 φ1 (x) ∂ ∂x1 φ(x) ··· ∂ ∂xn φ(x) = ∂ ∂xn φ1 (x) .. . ··· .. . ∂ ∂x1 φm (x) ··· ∂ ∂xn φm (x) .. . Le cas de φ dans l’exemple 23 : Jφ (x) = ∂ ∂x1 φ1 (x) ∂ ∂x2 φ1 (x) ∂ ∂x1 φ2 (x) ∂ ∂x2 φ2 (x) = ∂y1 ∂y2 ∂y1 ∂y2 − =2 ∂x1 ∂x2 ∂x2 ∂x1 CHAPITRE 2. VARIABLES ALÉATOIRES 74 Le cas de φ−1 : Jφ−1 (y) = −1 ∂ ∂y1 φ1 (y) −1 ∂ ∂y1 φ2 (y) −1 ∂ ∂y2 φ1 (y) −1 ∂ ∂y2 φ2 (y) ∂x1 ∂x2 ∂x1 ∂x2 − = 1/2 ∂y1 ∂y2 ∂y2 ∂y1 = Théorème 1. La densité d’une transformée La densité d’un vecteur aléatoire Y transformé de X par φ est : fY (y) = fX (φ−1 (y))|Jφ−1 (y)| Exemple 24. Soit X et sa transformée Y de l’exemple précèdent. La densité de X sur le domaine A = {(x1 , x2 ) ∈ R2 |0 < x1 < x2 < ∞} est donnée par : fX (x) = e−x2 1A 1. Donner la densité de Y . 2. Calculer P (Y2 < 1). Solution Le domaine de Y est la transformée de A par φ : φ(A) = {(y1 , y2 ) ∈ R2 |0 < y2 − y1 < y1 + y2 < ∞} = {(y1 , y2 ) ∈ R2 |0 < y1 < y2 < ∞} fY (y) = fX (φ−1 (y))|Jφ−1 (y)| = e−(y1 +y2 )/2 1φ(A) Z 1/2 Z x2 P (Y2 < 1) = P (X1 + X2 < 1) = fX (x1 , x2 )dx1 dx2 0 Z 1/2 Z = 0 x2 1 1 = e−(y1 +y2 )/2 1φ(A) 2 2 0 e−x2 1A dx1 dx2 = 0 Z 1/2 x2 e−x2 dx2 = 0.09020 {z } |0 Intégration par partie Exemple 25. Soit φ une transformation invertible définie sur R2 x21 + x22 y = φ(x) = x1 /x2 Soit X un vecteur aléatoire avec la fonction de densité suivante : 2 fX (x) = fX (x1 , x2 ) = 2 e−(x1 +x2 )/2 2π et sa transformée Y par φ Y = φ(X) Donner la densité de Y . Solution La transformation inverse et son Jacobien : √ y1 y2 p 2 √1 + y2 x = φ−1 (y) = y1 p 2 1 + y2 √ y1 y2 − 3 √ p 2 2 2 y1 1 + y2 −1 (y2 + 1) 2 √ Jφ−1 (y) = y2 y1 = 2(1 + y22 ) 1 − 3 √ p 2 y1 1 + y22 (y22 + 1) 2 CHAPITRE 2. VARIABLES ALÉATOIRES 75 En utilisant le théorème précèdent, la densité de Y est : fY (y) = fX (φ−1 (y))|J(y)| = e−y1 /2 2 } | {z 1 π(1 + y22 ) | {z } Y1 ∼Expo( 12 ) Y2 ∼Cauchy Figure 2.16 – fX la densité de X Figure 2.17 – fY la densité de Y 2.9 Variables aléatoires indépendantes Le concept des variables aléatoires indépendantes est similaire à celui des événements indépendants. En effet, si X, Y sont deux v.a, alors les deux évènements EA = X ∈ A et EB = Y ∈ B ∀A, B ∈ B(R) peuvent être indépendants et dans ce cas on parle de l’indépendance des v.a’s. Définition 20. 1- Deux v.a X et Y sont indépendantes (⊥) si leur probabilité jointe est le produit des deux probabilités respectives : ∀A, B ∈ B(R), P (X ∈ A, Y ∈ B) = P (X ∈ A) × P (Y ∈ B) =⇒ X ⊥ Y. CHAPITRE 2. VARIABLES ALÉATOIRES 76 c.à.d PXY (A, B) = PX (A) × PY (B), ∀A, B ∈ B(R) FXY (x, y) = FX (x) × FY (y), ∀(x, y) ∈ RX × RY 2- le cas discret : pXY (x, y) = pX (x) × pY (y) 3- le cas continu : fXY (x, y) = fX (x) × fY (y) En général : PX1 ,X2 ,..Xn (x1 , x2 , · · · , xn ) = Qn P (Xi = xi ) fX1 ,X2 ,..Xn (x1 , x2 , · · · , xn ) = Qn fXi (xi ) i=1 i=1 Intuitivement, deux variables aléatoires sont indépendantes si le fait de savoir la valeur de l’une d’elles ne change pas les probabilités de l’autre. Tout comme pour les événements, il est parfois facile de voir que deux variables aléatoires sont indépendantes juste parce qu’elles n’ont pas d’interactions physiques entre elles. Si par exemple on lance une pièce 2N fois, et on définit X comme le nombre de piles obtenus dans les N premiers lancers et Y dans les N derniers lancers, comme X et Y sont le résultat des lancers indépendants alors elles sont indépendantes. Proposition 7. Si X et Y sont deux v.a indépendantes alors 1. f (X) et g(Y ) sont aussi indépendantes pour toutes fonctions f et g. 2. E(XY ) = E(X)E(Y ) 3. V(X + Y ) = V(X) + V(Y ) Exemple 26. Soient X1 et X2 deux v.a indépendantes de moyenne 0 et de variance σ 2 . Quelle est la covariance et le coefficient de corrélation de X1 + 2X2 et 3X1 − X2 ? Solution Soient U = X1 + 2X2 et V = 3X1 − X2 , en appliquant les propriétés de la covariance : Cov(U, V ) = Cov(X1 + 2X2 , V ) = Cov(X1 , V ) + 2Cov(X2 , V ) = [3Cov(X1 , X1 ) − Cov(X1 , X2 )] + 2[3Cov(X2 , X1 ) − Cov(X1 , X1 )] Cov(X1 , X2 ) = 0 et Cov(X1 , X1 ) = V(X1 ) = σ 2 (par indépendance) Cov(U, V ) = 3σ 2 − 2σ 2 = σ 2 Cov(U, V ) σ2 Corr(U, V ) = p =√ = 0.14 V(U )V(V ) 5σ 2 10σ 2 Exemple 27. Calculer la variance d’une v.a.d X ; Bin(n, p). Solution Puisque la v.a.d Binomiale représente le nombre de succès dansP n essais indépendants chacun de n paramètre de succès p, elle peut être écrite sous la forme : X = i=1 Xi tel que les Xi ; Ber(p) indépendantes. Donc : n n X X V(X) = V( Xi ) = V(Xi ) = n × p × (1 − p) i=1 2.10 i=1 Espérance et variance conditionnelle Définition 21. Soit un espace probabilisé (Ω, F, P ). CHAPITRE 2. VARIABLES ALÉATOIRES 77 1- Conditionnée par un évènement : l’espérance de X conditionnée par un évènement H non nul (P(H)>0) E(X|H) = E(1H X) X xP ({X = x} ∩ H) = P (H) P (H) x 2- Conditionnée par une v.a Y : l’espérance de X conditionnée par une v.a Y est une v.a notée E(X|Y ) de Ω vers R (ou une fonction f (Y ) de RY vers R) a- Y une v.a.d : X xP (X = x|Y = y) (P (Y = y) > 0) E(X|Y )(y) = E(X|Y = y) = RX b- Y une v.a.c : Z E(X|Y )(y) = xfX|Y (x, y)dx RX 3- La variance de X conditionnée par une v.a Y est définie : V(X|Y ) = E((X − E(X|Y ))2 |Y ) Exemple 28. Une boite contient 30 boules dont 5 sont blanches, 10 sont noires et 15 sont rouges. On tire aléatoirement trois boules. Soit les v.a X et Y représentants, respectivement, le nombre de boules blanches et noires tirées. 1. Trouver les pmf conditionnelles de X sachant Y et de Y sachant X. 2. Calculer E(Y |X = 0) Solution 1. pmf. P (X = x, Y = y) = P (X = x) = y 3−x−y C5x × C10 × C15 pour 0 ≤ x ≤ 3 et 0 ≤ y ≤ 3 − x 3 C30 3−x X P (X = x, Y = y) = 3−x C5x × C25 3 C30 P (X = x, Y = y) = y 3−y C10 × C20 3 C30 y=0 P (Y = y) = 3−y X x=0 P (X = x|Y = y) = 3−x−y P (X = x, Y = y) C x × C15 = 5 3−y pour 0 ≤ x ≤ 3 − y P (Y = y) C20 P (Y = y|X = x) = 3−x−y P (X = x, Y = y) C y × C15 = 10 3−x pour 0 ≤ y ≤ 3 − x P (X = x) C25 2. Espérance. E(Y |X = 0) = 3 X yP (Y = y|X = 0) = 1.2 y=0 Exemple 29. Soient deux v.a X et Y ayant la fonction jointe : fXY (x, y) = 12 xy(3 − x − y) pour 0 ≤ x et y ≤ 1 5 Calculer l’espérance conditionnelle de X sachant Y = y. CHAPITRE 2. VARIABLES ALÉATOIRES 78 Figure 2.18 – pdf jointe (exemple 29) Solution Z xfX|Y (x, y)dx E(X|Y = y) = RX fXY (x, y) fY (y) Z Z fY (y) = fXY (x, y)dx = fX|Y (x, y) = RX 0 1 2y (−3y + 7) 12 xy(3 − x − y)dx = 5 5 6x(3 − x − y) 7 − 3y Z 1 2 6x (3 − x − y) 9 − 4y E(X|Y = y) = dx = 7 − 3y 2(7 − 3y) 0 fX|Y (x, y) = 2.10.1 Loi de l’espérance totale Cette loi nous permet de calculer l’espérance inconditionnelle d’une v.a X en conditionnant X par rapport à une autre v.a Y Théorème 2. Soient X, Y deux v.a définies sur le même espace probabilisé, nous avons : E(X) = E(E(X|Y )) Le cas discret : E(X) = X E(X|Y = y)P (Y = y) y Le cas continu : Z E(X) = E(X|Y = y)fY (y)dy y Démonstration 1. CHAPITRE 2. VARIABLES ALÉATOIRES X E(X|Y = y)P (Y = y) = y 79 XX y xP (X = x|Y = y)P (Y = y) x X X P (X = x, Y = y) P (Y = y) x P (Y = y) y x XX = xP (X = x, Y = y) = y x X X = x P (X = x, Y = y) x = X y xP (X = x) x = E(X) En d’autres termes, l’espérance de X est considérée comme l’espérance de E(X|Y = y) par rapport à Y pour y ∈ RY (espérance de l’espérance conditionnée qui est une v.a) qui est une fonction de RY dans R . Exemple 30. Une personne doit présenter son travail dans une conférence, elle choisie l’Anglais avec une probabilité 2/3 et l’Espagnol avec une probabilité 1/3. Si le nombre d’erreurs linguistiques qu’elle peut faire en Anglais suit une loi U(3,12) et le nombre d’erreurs en Espagnol suit une loi U(4,20). Quelle est l’espérance du nombre des erreurs qu’elle va faire ? Solution Soit X la v.a du nombre d’erreurs commises. et Y la langue choisie. RX = N et RY = {0, 1} (0 :Anglais et 1 :Espagnol) E(X) = 1 X E(X|Y = y)P (Y = y) y=0 = E(X|Y = 0)P (Y = 0) + E(X|Y = 1)P (Y = 1) = 15/2 × 2/3 + 24/2 × 1/3 = 9 Exemple 31. Cet exemple illustre l’utilisation de la loi de l’espérance totale avec récurrence. Pour quitter une pièce vers l’extérieur, une personne a le choix entre trois sorties. La première sortie (choisie avec une probabilité 1/2) mène à l’extérieur avec un chemin de 10 mètres, la seconde (choisie avec une probabilité 1/4) le fait retourner à la même pièce avec un chemin de 7 mètres et la troisième (choisie avec une probabilité 1/4) le fait retourner à la même pièce avec une distance de 5 mètres. Quelle est l’espérance de la distance parcourue par cette personne pour quitter la pièce vers l’extérieur. Solution Soit X la v.a représentant la distance parcourue pour sortir vers l’extérieur, et Y la sortie choisie. RY = P{1, 2, 3}. E(X) = RY E(X|Y = y)P (Y = y) E(X|Y = 1) = 10 E(X|Y = 2) = 7 + E(X) Ceci est expliqué par le fait que lorsque cette personne retourne à la pièce, c’est la même expérience (indépendante des précédentes) qui se répète. E(X|Y = 3) = 5 + E(X) E(X) = 10 × 21 + (7 + E(X)) × 14 + (5 + E(X)) × 14 E(X) = 16. CHAPITRE 2. VARIABLES ALÉATOIRES 80 À vos claviers! # Code214.py import numpy as np from random import choices def go_out(): distance=0 while True: s=choices([1,2,3],prob)[0] distance+=10 if s==1 else(7 if s==2 else 5) if(s==1):break return distance n=100000 prob=[0.5,0.25,0.25] d=[go_out() for _ in range(n)] print("Expexted crossed distance: ",np.mean(d)) #______________________________ Output # Expexted crossed distance: 15.99408 ______________________________________ L’espérance de la loi géométrique Une autre façon pour calculer l’espérance d’une v.a géométrique de paramètre p est d’utiliser la récurrence. Soit X la v.a représentant le nombre de lancers de pièces nécessaires pour l’obtention du premier pile. p est la probabilité du succès. Soit Y la v.a représentant le résultat du premier lancer ( 1 si pile et 0 si face). A chaque fois qu’on obtient un échec (Y = 0), la même expérience se répète (récurrence sur X) avec un lancer de plus. Lorsqu’on obtient un succès (Y = 1), on s’arrête. E(X) = E(X|Y = 0)P (Y = 0) + E(X|Y = 1)P (Y = 1) E(X|Y = 0) = 1 + E(X) E(X|Y = 1) = 1 Donc : E(X) = (1 + E(X))(1 − p) + p, ce qui donne : E(X) = 1/p. Exemple 32. Chaque année, un parc ouvre ses portes pendant deux mois (60 jours) à condition qu’il ne pleuve pas. Pendant cette période, chaque jour, il pleut avec une probabilité p. Soient les deux v.a : Y le nombre de jours où le parc ouvre ses portes et X le nombre total de visiteurs pendant les Y jours. Si X|Y ; P oisson(100Y ) quelle est la distribution et l’espérance de Y . Calculer l’espérance de X. Solution Y ; Bin(60, 1 − p) et E(Y ) = n(1 − p) Puisque X|Y ; P oisson(100Y ) alors E(X|Y ) = 100Y. E(X) = E(E(X|Y )) = E(100Y ) = 100E(Y ) = 100 × 60 × (1 − p) = 6000(1 − p) À vos claviers! #Code215.py import numpy as np from sympy import * from sympy.stats import Poisson, Binomial, E from sympy import Symbol p, n, mu = Symbol("p"), Symbol("n"), Symbol("mu") Y = Binomial("Y",n,1-p); XgivenY = Poisson("X",mu*Y) print(’E(Y) = ’, E(Y)) print(’E(X|Y) = ’, E(XgivenY)) print(’E(X) = ’, E(E(XgivenY))) p0, mu0, n0 = 0.3, 100, 60 print(’Symbolic Result :’) print("Expectation of Y print("Expectation of X|Y N = 1000 : ", E(Y).subs([(n,n0),(p,p0)]).doit()) : ", E(E(XgivenY)).subs([(n,n0),(p,p0),(mu,mu0)]).doit()) CHAPITRE 2. VARIABLES ALÉATOIRES 81 Ye = np.random.binomial(n0 ,1-p0, N) XgivenYe = np.random.poisson(mu0*Ye, (N, len(Ye))) print(’Empirical result :’) print("Expectation of Ye print("Expectation of X|Ye : ", Ye.mean()) : ", XgivenYe.mean()) #______________________________ Output ______________________________________ # E(Y) = Sum(Piecewise((_k*p**(-_k + n)*(1 - p)**_k*binomial(n, _k), (_k >= 0) & (_k <= n)), (0, True)), (_k, 0, n)) # E(X|Y) = mu*Y # E(X) = Sum(Piecewise((_k*mu*p**(-_k + n)*(1 - p)**_k*binomial(n, _k), (_k >= 0) & (_k <= n)), (0, True)), (_k, 0, n)) # Symbolic Result : # Expectation of Y : 41.99 # Expectation of X|Y : 4199.99 # Empirical result : # Expectation of Ye : 41.83 # Expectation of X|Ye : 4183.97 L’espérance et la variance conditionnelle préservent les propriétés de l’espérance et la variance classiques. Certaines propriétés sont spécifiques à ce type (le conditionnel) : Proposition 8. Propriétés de l’espérance et la variance conditionnelle 1- X ⊥ Y =⇒ E(X|Y ) = E(X) 2- X ⊥ Y =⇒ E(XY |Z) = E(X|Z)E(Y |Z) 3- E(E(X|Y )|Y ) = E(X) 4- E(E(X|Y, Z)|Y ) = E(X|Y ) 5- V(X|Y ) = E(X 2 |Y ) − (E(X|Y ))2 6- V(X) = E(V(X|Y )) − (V(E(X|Y )) 2.11 2.11.1 Séquences de v.a et Convergence Séquence de v.a (s.v.a) Définition 22. Une séquence de v.a est une famille indexée (Xi )i>0 tel que ∀i, Xi est une v.a. La séquence est notée Xn∗ (pour une séquence finie de n termes où X ∗ = (Xi )i>0 pour une séquence infinie). Soit la suite de v.a’s Xn∗ = (Xi )1≤i≤n tel que Xi ∼ Ber(1/2), alors Xn∗ est une séquence aléatoire ∗ de nombres binaires. Par exemple X16 = 0111010101001001 (séquences de bits). Exemple 33. Soit la suite de v.a X ∗ = (Xi )i≥0 tel que Y ∼ Ber(2/3) et Xi = Y 1 1 1 + (1 − Y ) = i+1 i+2 i+2−Y ∗ a- Donner X10 b- Est ce que les Xn sont indépendantes ? c- Trouver la pmf (pXn ) et la cdf (FXn ) de Xn , pour n > 0. Solution a- Tout d’abord générons une suite de 10 v.a de Bernouli Yi i 0 1 2 3 4 5 6 7 8 9 Yi 0 0 1 0 1 1 1 0 0 1 Xi 1 2 1 3 1 3 1 5 1 5 1 6 1 7 1 9 1 10 1 10 CHAPITRE 2. VARIABLES ALÉATOIRES 82 a- Puisque ∀i 6= j, Xi 6⊥ Y ∨ Xj 6⊥ Y , alors Xi 6⊥ Xj . Par exemple pour X1 et X2 : P (X1 = 1/3, X2 = 1/4) = P (Y = 0) = 1 3 1 9 P (X1 = 1/3)P (X2 = 1/4) = P (Y = 0)P (Y = 0) = Donc X1 6⊥ X2 RXn pXn 1 1 { n+2 , n+1 } 1 1 3 1{ n+2 } 2.11.2 FXn 1 + 23 1{ n+1 } 1 1 1 3 1[ n+2 , n+1 [ 1 + 1[ n+1 ,∞[ Somme des suites de v.a indépendantes Soit la suite de v.a indépendantes X ∗ = (Xn )n>0 . Soit Sn la v.a qui est égale à la somme des n premières v.a Xi de X ∗ . Sn n X fSn (x) Xi E(Sn ) fX1 (x)∗fX2 (x)∗...∗fXn (x) i=1 n X V(Sn ) n X E(Xi ) i=1 V(Xi ) i=1 La distribution de probabilité de la somme d’une séquence de v.a indépendantes est la convolution de leurs distributions individuelles, cette dernière est notée par ∗. ∀X, Y X ⊥ Y =⇒ fX+Y = fX ∗ fY . Cas discret : X pX (z) ∗ pY (z) = X pX (w)pY (z − w) = w∈RX w∈RY ∞ Z pY (w)pX (z − w). Cas continu : Z fX (z) ∗ fY (z) = ∞ fX (w)fY (z − w)dw = −∞ fY (w)fX (z − w)dw. −∞ Exemple 34. Soient deux v.a X et Y . X représente le lancer d’un dé et Y le lancer d’une pièce de monnaie. Donner la pmf de S1 = X + Y et S2 = X + 2Y Solution X 1 2 3 4 5 6 Y 0 1 pX 1/6 1/6 1/6 1/6 1/6 1/6 pY 2/3 1/3 Le rang de PS1 est RS1 = {1, 2, 3, 4, 5, 6, 7} pS1 (k) = h px (k − h) × py (h), Tel que h ∈ RY et k − h ∈ RX pS1 (1) = px (1)py (0) = 1/6 × 2/3 = 1/9 pS1 (2) = px (1)py (1) + px (2)py (0) = 1/6 × 1/3 + 1/6 × 2/3 = 1/6 pS1 (7) = px (6)py (1) = 1/6 × 1/3 = 1/18 S1 1 2 3 4 5 6 7 pS1 1/9 1/6 1/6 1/6 1/6 1/6 1/18 CHAPITRE 2. VARIABLES ALÉATOIRES 83 S2 = X + 2Y = S1 + Y. Le rang de PS2 est RS2 = {1, 2, 3, 4, 5, 6, 7, 8} pS2 (k) = h pS1 (k − h) × py (h), Tel que h ∈ RY et k − h ∈ RS1 pS2 (1) = pS1 (1)py (0) = 1/9 × 2/3 = 2/27 pS2 (2) = pS1 (2)py (0) + pS1 (1)py (1) = 1/6 × 2/3 + 1/9 × 1/3 = 4/27 pS2 (3) = pS1 (3)py (0) + pS1 (2)py (1) = 1/6 pS2 (7) = pS1 (7)py (0) + pS1 (6)py (1) = 1/18 × 2/3 + 1/6 × 1/3 = 5/54 pS2 (8) = ps1 (7)py (1) = 1/18 × 1/3 = 1/54 S2 1 2 3 4 5 6 7 8 pS2 2/27 4/27 1/6 1/6 1/6 1/6 5/54 1/54 Exemple 35. Soient X et Y ; U(0, 1). Trouver la distribution de Z = X + Y Solution Z +∞ Z fX (z − y)fY (y)dy = fZ (z) = 1 fX (z − y)dy −∞ z 0 Z dy = z si 0 ≤ z ≤ 1 = 0 Z 1 dy = 2 − z si 1 < z ≤ 2 = z−1 = z1[0.1] (z) + (2 − z)1[1,2] Donc z ; T riang(0, 2, 1) 2.11.3 Convergence Soient une séquence de v.a’s X ∗ = (Xn )n>0 et une v.a X. Définition 23. d X ∗ converge en distribution vers X (notée Xn − → X) si lim FXn (x) = FX (x), n→∞ ∀x, FX (x) est continue Exemple 36. Soit X ∗ s.v.a tel que FXn (x) = 1{x>0} (1 − (1 − q/n)nx/p ). p, q > 0. d Montrer que Xn − → X ∼ Expo(q/p) Solution Soit v.a X ∼ Expo(q/p), i- Pour le cas x ≤ 0, nous avons FXn (x) = FX (x) = 0, ∀n ≥ 2 ii- Pour la cas x ≥ 0, nous avons lim FXn (x) = lim n→∞ n→∞ k q x q q nx/p 1 p = 1 − lim 1 − = 1 − e− p x = FX (x), 1− 1− k→∞ n k | {z } k=bn/qc ∀x CHAPITRE 2. VARIABLES ALÉATOIRES 84 Théorème 3. Soient X ∗ une s.v.a et une v.a.d X. Supposons que X et Xn (pour tout n) sont nonnégatives à valeurs entières, (RX ⊂ N, RXn ⊂ N, ∀n ∈ N∗ ). Alors, d Xn − → X ⇐⇒ lim pXn (k) = pX (k), ∀k ∈ N. n→∞ Démonstration Nous démontrons les deux sens de l’implication. i- Puisque X est une v.a à valeur entière (à.v.e), sa cdf, FX (x), est continue à chaque x ∈ R/N. d Si Xn − → X, Alors ∀x ∈ R/N. lim FXn (x) = FX (x), n→∞ Pour k ∈ N, nous avons 1 1 − FXn k − lim PXn (k) = lim FXn k + n→∞ n→∞ 2 2 {z } | Xn a.v.e 1 1 = lim FXn k + − lim FXn k − n→∞ n→∞ 2 2 1 1 = FX k + − FX k − 2 2 | {z } d → X) (puisque Xn − = PX (k) | {z } X a.v.e ∀k ∈ N. Alors ii- Supposons que : limn→∞ pXn (k) = pX (k), ∀x ∈ R, lim FXn (x) = lim P (Xn ≤ x) n→∞ n→∞ {0,1,··· ,bxc} fini xf ixe, z = lim n→∞ bxc X }| PXn (k) = k=0 { bxc X k=0 lim PXn (k) = n→∞ bxc X PX (k) k=0 | {z (hypothèse) } = P (X ≤ x) = FX (x). Exemple 37. Soit X ∗ une s.v.a tel que Xn ∼ Bin(n, λ/n), ∀n ∈ N, n > λ, et λ > 0 est d constante. Montrer que Xn − → X ∼ Pois(λ). Solution lim PXn (k) = lim Cnk n→∞ n→∞ k n−k λ λ 1− n n n −k n(n − 1)(n − 2)...(n − k + 1) λ λk λ 1− = . lim 1− . k! n→∞ nk n n | {z } | {z } | {z } 1(n→∞) −λ k = e λ = PX (k) donc X ∼ Pois(λ) k! e−λ (n→∞) 1(n→∞) CHAPITRE 2. VARIABLES ALÉATOIRES 85 Définition 24. p X ∗ converge en probabilité vers X (notée Xn − → X) si lim P |Xn − X| ≥ = 0, ∀ > 0 n→∞ . p Exemple 38. Soit X ∗ tel que Xn ∼ Expo(n), montrer que Xn − → 0. Solution Soit > 0, alors limn→∞ P |Xn − 0| ≥ = lim P Xn ≥ = lim e−n = 0 n→∞ n→∞ {z } | {z } | Xn ≥0 Xn ∼Expo(n) Définition 25. Xn∗ converge presque sûre vers X si n o P ω ∈ Ω : lim Xn (ω) = X(ω) = 1. n→∞ Exemple 39. Soient la séquence X ∗ et la v.a X définies sur l’espace probabilisé (Ω = [0, 1], P ([a, b]) = b − a) pour tout 0 ≤ a ≤ b ≤ 1 par : Xn (ω) = 1{0≤ω< n+2 } 3n et X(ω) = 1{0≤ω< 13 } Soit l’ensemble suivant : n o A = ω ∈ Ω : lim Xn (ω) = X(ω) n→∞ - Déterminer l’évènement A et sa probabilité. Quelle conclusion faites vous ? Solution 1 i − Soit ω ∈ [0, 31 [, ω ∈ [0, n+2 3n ] donc Xn (ω) = X(ω) = 1, alors [0, 3 [⊂ A 1 ii − Soit ω ∈] 3 , 1[ 1 < (3ω − 1)/2, ∃nω ∈ N, tel que nω | {z } proprite d0 Archimede ω +2 < ω donc Xnω (ω) = X(ω) = 0 alors ] 13 , 1[⊂ A on a n3n ω De i et ii, Ω = A ∪ { 13 } et P ( 13 ) = 0 alors P (A) = P (Ω) = 1 a.s. Donc Xn −−→ X Une séquence peut converger pour un type mais pas pour un autre. Certains de ces types de convergence sont plus forts que d’autres. Définition 26. Le type de convergence A est plus fort que le type de convergence B (B est plus faible que A), si le type A implique le type B. A B Xn∗ − → X =⇒ Xn∗ − →X Théorème 4. La convergence presque sûre est plus forte que celle de la probabilité qui est plus forte que celle de la distribution. Soit X ∗ une s.v.a. nous avons : p.s p d Xn −−→ X =⇒ Xn − → X =⇒ Xn − →X CHAPITRE 2. VARIABLES ALÉATOIRES 2.11.4 86 Loi des grands nombres Théorème 5. Loi faible des grands nombres Soit X ∗ une s.v.a tel que Xn sont i.i.d, de moyenne finie E(Xn ) = µ < ∞. Alors la moyenne p → µ). empirique X n = X1 +X2n+...+Xn tend en probabilité vers µ (X n − lim P |X n − µ| ≥ = 0, ∀ > 0 n→∞ À vos claviers! [language = Python]codes/chap2/Code216.py figure[h] À vos claviers! [language = Python]codes/chap2/Code217.py figure[h] 2.11.5 Théorème central limite Ce théorème est lié à la distribution Normale. Il indique que la somme de n v.a indépendantes ayant la même distribution de probabilité de moyenne µ et un écart √ type σ, a approximativement une distribution Normale de moyenne nµ et d’écart type σ n pour une valeur de n assez grande : Théorème 6. TCL Soit Xn∗ tel que Xi sont i.i.d de moyenne E(Xi ) = µ et de variance V(Xi ) = σ 2 finies, alors n −E(Sn ) n −nµ Ŝn (Sn centrée réduite : Ŝn = S√ = S√ ) converge en distribution vers une v.a qui nσ V(Sn ) CHAPITRE 2. VARIABLES ALÉATOIRES 87 suit la distribution normale standard. Xn∗ | Xi i.i.d, E(Xi ) < ∞, lim FŜn (x) = lim P ( n→∞ n→∞ d V(Xi ) < ∞ =⇒ Ŝn − → X ; N (0, 1). X1 + X2 + ... + Xn − nµ √ ≤ x) = FX (x) = φ(x) σ n ∀x À vos claviers! [language = Python]codes/chap2/Code218.py figure[H] Exemple 40. Soit Y le nombre de pile obtenus en lançant une pièce 40 fois. Trouver PY (20) la probabilité que Y = 20. Trouver la probabilité d’obtenir 20 piles en lançant une pièce 40 fois. Trouver la probabilité d’obtenir 30 piles en lançant une pièce 40 fois. Solution 1- Y = Sn est la somme de n v.a i.i.d (∀i, Xi ; Ber(1/2)). d Puisque Ŝn − → Z ; N (0, 1), alors PŜn (k) peut être approximée par P (|X − k| < c) tel que 2c la longueur de l’intervalle centré par k ne doit pas contenir d’autres valeurs de RŜn sauf le k. On choisit c = √0.5 . nσ 20 − (40 × 0.5) √ ) = PŜ40 (0) 40 × 0.5 = P (−0.158 ≤ Ŝ40 ≤ +0.158) PS40 (20) = PŜ40 ( ≈ P (−0.158 ≤ X ≤ +0.158) = P (|X| < 0.158) = φ(+0.158) − φ(−0.158) = 0.1272 20 Le calcul direct donne : P (Y = 20) = C40 × ( 12 )40 = 0.1268 30 − (40 × 0.5) √ ) = PŜ40 (3.16) 40 × 0.5 = P (3.16 − 0.158 ≤ Ŝ40 ≤ 3.16 + 0.158) = P (3.002 ≤ Ŝ40 ≤ 3.318) PS40 (30) = PŜ40 ( ≈ P (3.002 ≤ X ≤ 3.318) = P (|X − 3.16| < 0.158) = φ(3.318) − φ(3.002) = 0.0008 2.12 Application : régression linéaire La régression linéaire est très utilisée en apprentissage automatique (machine learning) et analyse des données. Elle consiste à établir une relation (modèle) linéaire entre une variable Y (dépendante) et une ou plusieurs variables X (indépendantes). Dans sa forme la plus basique une seule variable X est utilisée pour prédire la valeur de la variable Y . Dans le cas où X et Y sont Normal bivariées, le modèle de régression linéaire désigne un modèle dans lequel l’espérance conditionnelle de Y sachant que X est une fonction affine, on a l’équivalence suivante : E(Y |X) = a + bX ⇐⇒ Y = a + bX + tel que ∼ N (0, 1) CHAPITRE 2. VARIABLES ALÉATOIRES 88 La v.a représente l’erreur, elle est indépendante de X et E(|X) = 0 Cette équivalence est démontrée comme suit : 1. On suppose que Y = a + bX + tel que est une v.a normale représentant l’erreur, elle est independante de X et E(|X) = 0 donc : E(Y |X) = E(a|X) + E(bX|X) + E(|X) = a + bX 2. Nous avons : E(Y |X) = a + bX, on suppose que : = Y − (a + bX) Puisque X et Y sont Normal bivariees, alors est une v.a Normal verifiant : E(|X) = E(Y |X) − E(a + bX) = 0 Nous avons : E() = E(E(|X)) = 0 E(X) = E(E(X|X)) = E(XE(|X)) = 0 = E()E(X) Donc ⊥ X (indépendantes). Ce résultat permet de déterminer les valeurs de a et b en fonction de E(X), E(Y ), V(X) et Cov(X, Y ). Puisque et X sont non corrélées, alors : Cov(X, Y ) = Cov(X, a + bX + ) = Cov(X, a) + bCov(X, X) + Cov(X, ) = bV(X) Donc : b= Cov(X, Y ) V(X) Nous avons : E(Y ) = E(E(Y |X)) = E(a + bX) = a + bE(X) Donc : a = E(Y ) − Cov(X, Y ) E(X) V(X) Dans le code suivant nous appliquons le résultat obtenu dans cette section et le comparons au résultat obtenu par le module linear_model de la bibliothèque sklearn qui utilise la méthode des moindres carrés. À vos claviers! #Code219.py import numpy as np import matplotlib.pyplot as plt # sklinreg: performs linear regression using sklearn package def sklinreg(): import pandas as pd # To read data from sklearn.linear_model import LinearRegression data = pd.read_csv(’data.csv’) # load data set X = data.iloc[:, 0].values.reshape(-1, 1) # values converts it into a numpy array Y = data.iloc[:, 1].values.reshape(-1, 1) # -1 means that calculate the dimension of rows, but have 1 column linear_regressor = LinearRegression() # create object for the class m=linear_regressor.fit(X, Y) # perform linear regression Y_pred = linear_regressor.predict(X) # make predictions return X,Y,m.intercept_[0],m.coef_[0][0],Y_pred # analytic: performs linear regression using the results of the application def analytic(X0,Y0): X=[X0[i][0] for i in range(len(X0))] CHAPITRE 2. VARIABLES ALÉATOIRES Y=[Y0[i][0] for i in range(len(Y0))] Ex,Ey,Vx=np.mean(X),np.mean(Y),np.var(X) Cov=np.cov(X,Y)[0][1] b=Cov/Vx; a=Ey-Ex*b predictedY=a+b*np.array(X) return a,b,predictedY def plotter(X,Y,predictedY,col): plt.scatter(X, Y) plt.plot(X, predictedY, color=col) plt.show() X,Y,ska,skb,skY_pred=sklinreg() print("SKlearn results: a=",ska," b=",skb) anala,analb,analY_pred=analytic(X,Y) print("Analytic: ""a=",anala," b=",analb) plotter(X,Y,skY_pred,’red’) plotter(X,Y,analY_pred,’green’) #______________________________ Output ______________________________________ # SKlearn results: a= 9.908606190326537 b= 1.2873573700109313 # Analytic: a= 9.263291199945208 b= 1.3004936697049203 Figure 2.19 – Régression linéaire 89 CHAPITRE 2. VARIABLES ALÉATOIRES 2.13 90 Exercices Exercice 1. Deux faux billets ont été dissimulés dans un paquet de trois vrais billets. Pour les retirer, les billets sont vérifiés un par un dans un ordre aléatoire. Soit X la variable aléatoire représentant le nombre minimum de billets qu’on doit vérifier pour trouver les deux faux billets. 1. Donner la fonction de masse de X. 2. Calculer son espérance et sa variance. 3. Coder l’exercice en Python. Exercice 2. Soit la fonction suivante : f (x) = c(1 − x) pour 0 < x < 1 et 0 sinon. 1. Déterminer la valeur de c pour que f soit une fonction de densité. 2. Supposons que f est la fonction de densité de la v.a.c X qui représente le volume des précipitations annuelles sur une zone sur laquelle un barrage sera construit. Quelle capacité doit on prévoir pour ce barrage pour que la probabilité de débordement durant une année donnée ne dépasse pas 1% ? Exercice 3. Sachant que le nombre de séismes importants chaque année dans le monde suit une loi de poisson avec une moyenne de 4.2 séismes. Quelle est la probabilité qu’il y ait plus de 7 séismes importants dans le monde l’année prochaine ? Exercice 4. Soient X et Y ; U(a, b) 1. Trouver la distribution de Z = X + Y 2. Écrire le code correspondant. Exercice 5. Soient X, Y deux v.a suivant la loi de Ber(1/2). 1. Trouver la distribution de la v.a |X − Y |. 2. Trouver la distribution de la v.a |X − Y | lorsque X et Y suivent Ber(p). 3. Écrire le code correspondant. Exercice 6. Soient X1 ,X2 ,...,Xn n v.a exponentielles de taux respectifs Pn λ1 , λ2 ,...,λn . Montrer que min(X1 , X2 , ..., Xn ) est une v.a exponentielle de taux i=1 λi . Exercice 7. Soient X1 et X2 deux v.a exponentielles de taux respectifs λ1 et λ2 . Quelle est la probabilité que X1 soit inférieure à X2 ? Exercice 8. Une urne contient 10 boules numérotées de 1 à 10. On tire (avec remise) de façon répétée une boule à la fois. Soit la v.a X représentant le nombre de tirages jusqu’à l’apparition du nombre 3 et la v.a Y le nombre de tirages jusqu’à l’apparition du nombre 7. 1. Quelle est la fonction de masse jointe de P (X = x, Y = y). 2. Calculer P (X = 2|Y = 4) Exercice 9. L’expérience de Buffon consiste à lancer des aiguilles de longueur h sur un plan sur lequel des lignes parallèles séparées par la même distance l sont dessinées. Le nombre des aiguilles qui croisent ces lignes sont observées. 1. Soit X la v.a qui représente la distance du centre de l’aiguille de la ligne la plus proche ; et soit la v.a θ représentant l’angle de l’aiguille par rapport aux lignes du plan. Trouver la distribution jointe de X et θ. 2. Quelle est la probabilité qu’une aiguille croise une ligne ? Exercice 10. Un appareil électronique contient deux composants importants X et Y. L’appareil tombe en panne si un des deux composants tombe en panne. La fonction de densité jointe des 1 (1 + x + y) pour 0<x,y<2 et durées de vie (en années) des deux composants est : f (x, y) = 12 f (x, y) = 0 sinon. Quelle est la probabilité que l’appareil électronique tombe en panne dans la première année de sa mise en fonction. Exercice 11. Une pièce est lancée de façon répétée. Quel est le nombre de lancers moyen jusqu’à avoir PF pour la première fois ? même question pour PP. CHAPITRE 2. VARIABLES ALÉATOIRES 91 Exercice 12. 1. Soit la v.a.c X ∼ U([a, b]), vérifier que : V(X) ≤ (b − a)2 4 2. Soit la v.a X, montrer l’implication suivante : P (a ≤ X ≤ b) = 1 =⇒ V(X) ≤ (b − a)2 4 Exercice 13. Une personne saisie un texte composé de 2000 caractères. Elle peut saisir un caractère incorrecte pour chaque 200 caractères tapés. Supposons que les erreurs de la saisie sont indépendantes. 1. Quelle est la probabilité que le nombre des erreurs dépasse 50 ? 2. Quelle est la taille du texte (nombre de caractères) pour que la probabilité que le nombre des erreurs soit inférieur à 25 égale 0.9. Exercice 14. Soit Xn = X + Yn , tel que E(Yn ) = 1/n, V(Yn ) = σ 2 n, σ > 0 est une constante, p montrer que Xn − → X. Exercice 15. Considérons X ∗ une s.v.a : p → 0 1- Soit pXn (x) = n1 1{n2 } + (1 − n1 )1{0} , montrer que Xn − n 2- Soit Y ; Ber(1/3) et Xn = n+1 Y + n2n+1 (1 − Y ) a- Étudier la convergence de Xn (ω), ∀ω ∈ {H, T }. b- Trouver P ({ωi ∈ Ω : limn→∞ Xn (ωi ) = 0}) . p.s. 3- Soit pXn = 1/21{ −1 } + 1/21{ n1 } , montrer que Xn −−→ 0. n Exercice 16. Soit l’espace probabilisé (Ω = [0, 1], P ([a, b]) = 1/(b − a), ∀0 < a < b < 1), On definit X ∗ une s.v.a par Xn = 1[0, n+1 [ ∀n > 0 et une v.a X par X = 1[0,1/2[ . Montrer que 2n d Xn − → X. CHAPITRE 2. VARIABLES ALÉATOIRES 2.14 92 Solutions Solution 1. 1. Le rang de X, RX = {2, 3, 4}. Ω = {00111, 01011, 01101, 01110, 10011, 10101, 10110, 11001, 11010, 11100}. 0 représente un faux billet et 1 représente un bon billet C’est une permutation avec répétition de longueur 5 des éléments B et M (B est répété 3 fois 5! = 10 et M 2 fois), donc |Ω| = 2!3! 00111 01011 01101 01110 10011 10101 10110 11001 11010 11100 2 3 4 4 3 4 4 4 4 3 Xi est le nombre minimum de tests nécessaires pour trouver les faux billets. P (X = 2) = 1/10, P (X = 3) = 3/10, P (X = 4) = 6/10 On peut utiliser directement la règle de la chaîne comme suit : — P (X = 2) = P (M, M ) = 2/5 × 1/4 = 1/10 — P (X = 3) = P (B, M, M ) + P (M, B, M ) + P (B, B, B) = 3/5 × 2/4 × 1/3 + 2/5 × 3/4 × 1/3 + 3/5 × 2/4 × 1/3 = 3/10 — P (X = 4) = 1 − (P (X = 2) + P (X = 3)) = 6/10 2.Calcul de l’espérance et la variance de X : E(X) = 2P (X = 2) + 3P (X = 3) + 4P (X = 4) = 3.5 V(X) = (2 − 3.5)2 P (X = 2) + (3 − 3.5)2 P (X = 3) + (4 − 3.5)2 P (X = 4) = 0.45 Solution 2. 1 R1 1. 0 c(1 − x)dx = c(x − x2 /2) 0 = c/2 = 1 Donc c = 2 2. Soit x0 la capacité du barrage. La probabilité que le volume des précipitations dépasse la capacité de stockage : P (X > x0 ) = 1 − P (X ≤ x0 ) = 1 − F (x0 ) = x20 − 2x0 + 1 P (X > x0 ) ≤ 0.01 =⇒ x20 − 2x0 + 1 ≤ 0.01 =⇒ x20 − 2x0 + 0.99 ≤ 0 La solution de x20 − 2x0 + 0.99 = 0 est x0 = 0.9, donc la capacité du barrage doit être supérieure à 0.9 en milliers de m3 Solution 3. En utilisant une variable aléatoire X suivant P7 la loi de poisson de paramètre λ = 4.2, on peut calculer P (X > 7) = 1 − P (X ≤ 7) = 1 − k=0 e−4.2 4.2k /k! = 0.064 Solution 4. Z +∞ Z b fX (z − y)fY (y)dy = fZ (z) = −∞ Z z−a dy = z − 2a = fX (z − y)dy a si 2a ≤ z ≤ a + b a Z b dy = 2b − z = si b + a < z ≤ 2b z−b = (z − 2a)1[2a,a+b] (z) + (2b − z)1[a+b,2b] Donc Z ; T riang(2a, 2b, a + b) Solution 5. (X, Y ) (1,1) (1,0) (0,1) (0,0) |X − Y | 0 1 1 0 p|X−Y | 1/4 1/4 1/4 1/4 CHAPITRE 2. VARIABLES ALÉATOIRES 93 Donc le rang de |X − Y | est :{0, 1} et |X − Y | ; Ber(1/2). 2. (X, Y ) (1,1) (1,0) (0,1) (0,0) |X − Y | 0 1 1 0 p|X−Y | p2 p(1 − p) p(1 − p) (1 − p)2 Donc le rang de |X − Y | est {0, 1} et |X − Y | ; Ber(2p(1 − p)). Solution 6. P (min(X1 , X2 , ..., Xn ) > x) = P (∩ni=1 (Xi > x)) n Y = P (Xi > x) car les Xi sont indépendantes. = i=1 n Y e−λi x i=1 P −( n i=1 λi )x =e Pn Donc min(X1 , X2 , ..., Xn ) ; Expo( i=1 λi )) Solution 7. Cette probabilité est calculée facilement en conditionnant sur X1 : Z ∞ P (X1 < X2 ) = P (X1 < X2 |X1 = x)λ1 e−λ1 x dx Z0 ∞ = P (x < X2 )λ1 e−λ1 x dx 0 Z ∞ = e−λ2 x λ1 e−λ1 x dx 0 Z ∞ = λ1 e−(λ1 +λ2)x dx 0 = λ1 λ1 + λ2 Solution 8. 1. Soit k = min(x, y) 8 k−1 9 |y−x|−1 P (X = x, Y = y) = ( 10 ) × 1/10 × ( 10 ) × 1/10 P (X=2,Y =4) 2. P (X = 2|Y = 4) = P (Y =4) 1 9 y−1 P (Y = y) = ( 10 ) × 10 P (X = 2|Y = 4) = 8 1 9 1 10 × 10 × 10 × 10 9 3 1 ( 10 ) × 10 = 8 81 . Solution 9. 1. RX = [0, l/2] et Rθ = [0, π/2]. X ∼ U([0, l/2]) et θ ∼ U([0, π/2]) X et θ sont indépendantes car l’orientation de l’aiguille ne dépend pas de la position de son centre. 4 PX,θ (x, α) = P (X = x, θ = α) = P (X = x)P (θ = α) = lπ 2. L’aiguille inclinée d’un angle θ croise la ligne si X est inférieure à la longueur du côté opposé à l’angle θ dans le triangle rectangle dont l’hypoténuse est h/2 (voir figure 2.20). Z π/2 Z h/2 sin α P (X < h/2 sin θ) = PX,θ (x, α)dxdα 0 Z 0 π/2 Z = 0 0 h/2 sin α 4 4 dxdα = lπ lπ Z π/2 Z h/2 sin α dxdα = 0 0 2h lπ CHAPITRE 2. VARIABLES ALÉATOIRES 94 Figure 2.20 – Expérience de Buffon Solution 10. L’appareil tombe en panne au moment où le premier des deux composants tombe en panne. Donc la probabilité recherchée est : P (min(X, Y ) ≤ 1) = 1 − P (min(X, Y ) > 1). P (min(X, Y ) > 1) = P (X > 1, Y > 1). Z 2Z 2 1/12(1 + x + y)dxdy = 1 1 Z 2 = 1/12 Z dx 1 Z = 1/12 2 (1 + x + y)dxdy 1 2 (1 + x + 1.5)dx = 1/3. 1 Donc P (min(x, y) ≤ 1) = 2/3. Solution 11. 1. Dans la section de l’espérance totale, nous avons montré que l’espérance du nombre de lancers pour d’obtention du premier P dans des lancers successifs d’une pièce est égale à 1/p. Dans cette question, le nombre moyen de lancers nécessaires pour le premier PF est la somme du nombre moyen du premier P et le nombre moyen du premier F, il est donc égal à p1 + 1q . Pour p = 21 , il sera égal à 4. Une autre solution : soit X la v.a du nombre de lancers nécessaires pour l’obtention du premier PF, Y la v.a du résultat du premier lancer et Z la v.a du nombre de lancers nécessaires pour l’obtention du premier F. E(X) = E(X|Y = F ) 12 + E(X|Y = P ) 12 E(X) = (1 + E(X)) 12 + (2 × 12 + (2 + E(Z)) 12 ) 12 . E(Z) = 2 E(X) = 4 2. Soit X la v.a du nombre moyen de lancers nécessaires pour le premier PP, et Y la v.a du résultat du premier lancer. Si le premier lancer donne F, nous aurons perdu un lancer et on reprend l’expérience, dans le cas contraire, nous conditionnant sur le résultat du deuxième lancer. Si ce dernier est P, nous aurons obtenu PP sinon 2 lancers sont perdus et on reprend l’expérience du début. E(X) = E(X|Y = F ) 12 + E(X|Y = P ) 12 E(X) = (1 + E(X)) 12 + (2 × 12 + (2 + E(X)) 12 ) 12 E(X) = 6 Solution 12. 1. Soit X ∼ U([a, b]), alors (b − a)2 (b − a)2 ≤ 12 4 2. Nous avons P (a ≤ X ≤ b) = 1, donc P (0 ≤ X − a ≤ b − a) = 1 V(X) = CHAPITRE 2. VARIABLES ALÉATOIRES 95 V(X) = V(X − a) = E((X − a)2 ) − E2 (X − a) ≤ (b − a)E(X − a) − E2 (X − a) (b − a)2 (b − a) −( − (b − a)E(X − a) + E2 (X − a)) 4 2 (b − a)2 (b − a) ≤ −( − E(X − a))2 4 2 (b − a)2 ≤ 4 ≤ Solution 13. 1. Soit Xi ; Ber(p = 1/50) pour i = 1, ..n (n = 2000), égale à 1 si le caractère i est mal saisi et 0 sinon. Sn = X1 + X2 + ... + Xn le nombre de caractères erronés dans le message. E(Xi ) = p = 0.02 et V(Xi ) = p(1 − p) = 0.0196. En appliquant le théorème central limite : 50 − np Sn − np > √ ) P (Sn > 50) = P ( √ nσ nσ Sn − np 50 − 40 = P( √ > √ ) nσ 39.2 = 1 − φ(1.59) = 0.0559. 2. P (Sn < 65) = 0.95 65 − np Sn − np < √ ) P (Sn < 65) = P ( √ nσ nσ 65 − 0.02n = φ( √ ) = 0.9 = φ(1.65) n0.14 65 − 0.02n √ = 1.65 n0.14 n = 2655. Solution 14. P |Xn − X| ≥ = P |Yn | ≥ ≤ P (|Yn − E(Yn )| + |E(Yn )| ≥ ) | {z } inégalité triangulaire =P | Donc |Yn − E(Yn )| ≥ − {z 1 n ≤ inégalité de Chebychev V(Yn ) σ2 = 2 1 2 − n n − n1 } p lim P |Xn − X| ≥ = 0 , on peut conclure que Xn − →X n→∞ Solution 15. 1- Soit > 0, P |Xn − X| ≥ = P |Xn | ≥ = 1 − P |Xn | < < 1 − P |Xn | ≤ 0 = Donc p lim P |Xn − X| ≥ = 0 , on peut conclure que Xn − →X n→∞ 2- On sépare les cas selon ω : n a1- Pour ω = H, on a Y = 1 et Xn (ω) = n+1 donc limn→∞ Xn = 1 a2- Pour ω = T , on a Y = 0 et Xn (ω) = n2n+1 donc limn→∞ Xn = 0 b- P ({ωi ∈ Ω : limn→∞ Xn (ωi ) = 0}) = P (T ) = 2/3 1 n CHAPITRE 2. VARIABLES ALÉATOIRES 96 3- Soit Ω l’univers associé à X, ∀ω ∈ ω, On a les trois cas suivants : i1- Xn (ω) = n1 , avec une probabilité de 1/2, donc limn→∞ Xn (ω) = 0 i2- Xn (ω) = −1 n , avec une probabilité de 1/2, donc limn→∞ Xn (ω) = 0 i3- Xn (ω) ∈ R/{1/n, −1/n}, avec une probabilité de 0 p.s De i1 et i2 nous avons : P ({ω ∈ Ω : limn→∞ Xn (ω) = X(ω)}) = 1 donc Xn −−→ 0 Solution 16. p.s p.s d d Il suffit de démontrer que Xn −−→ X et puis utiliser −−→>>− → pour conclure que Xn − →X p.s Pour démontrer Xn −−→ X, on va procéder de la même façon que l’exemple 39 . i1- Soit ω ∈ [0, 21 [ 1 ω ∈ [0, n+1 2n ] donc Xn (ω) = X(ω) = 1, alors [0, 2 [⊂ A. i2- Soit ω ∈] 12 , 1[ ∃nω ∈ N, tel que n1ω < 2ω − 1, on a nω +1 2nω < ω donc Xnω (ω) = X( ω) = 0 alors ] 21 , 1[⊂ A De i1 et i2, Ω = A ∪ { 12 } et P ( 12 ) = 0 alors P (A) = P (Ω) = 1 p.s. d Donc Xn −−→ X et ce qui donne Xn − →X Deuxième partie Processus Stochastiques 97 98 Chapitre 3 Processus Stochastiques 3.1 Introduction Pour beaucoup de phénomènes complexes, les systèmes qui gouvernent leurs évolutions sont dynamiques et aléatoires (vu leur complexité). Cet aspect aléatoire ne se limite pas seulement à un moment donné mais il suit cette dynamique en devenant une fonction du temps. Afin d’étudier cette classe de phénomènes, nous devons modéliser mathématiquement ses différentes composantes et en particulier la partie aléatoire dynamique. Le processus stochastique est l’un des outils mathématiques pour réaliser cette modélisation. Il décrit l’évolution de l’état d’une entité aléatoire d’un système dynamique au cours du temps en déterminant ses lois de probabilité et ses caractéristiques statistiques. L’évolution du prix d’une action d’une compagnie côté dans la bourse ou celle de la température journalière durant l’année sont des exemples de phénomènes dynamiques qui peuvent être modélisés en utilisant les processus aléatoires. Définition 1. Un processus stochastique est une famille de variables aléatoires Xt indexées par t un paramètre à valeurs dans un ensemble T et définies sur un espace probablisé donné (Ω, F, P ) et son rang est RXt = S. X(T,S) = {Xt est une v.a sur (Ω, F, P ) à valeur dans S : ∀t ∈ T } T est appelé l’ensemble des paramètres/indexes, S est appelé l’espace d’état dont les éléments s sont des états de ce processus. Notation. - Dans le reste du document, nous abrégeons le processus stochastique par PS. - Si S est bien connu, alors X(T,S) sera noté tout simplement XT = (Xt )t∈T . X(t, ω), t ∈ T, ω ∈ Ω est une fonction à deux variables (T × Ω 7→ S), si on fixe : • t, Xt est une v.a Xt : Ω 7→ S • ω : Xt (ω) est une fonction de t appelée une réalisation du PS (une trajectoire) associée à ω. Selon la nature des éléments de l’ensemble T et de S (la propriété de la dénombrabilité), on peut subdiviser/partitionner l’ensemble des PS en plusieurs types. Le tableau 3.1 donne les familles de PS en fonction de cette nature : La figure 3.1 dans sa partie E montre les réalisations correspondantes aux éventualités ω1 , ω2 et ω3 et la v.a associée à l’instant t1 . La loi de distribution de Xt (PXt ) est fonction de t. Les sous figures A,B,C et D donnent la représentation graphique des classes de PS. 99 Le paramètre t représente souvent le temps, mais il peut représenter d’autres grandeurs (position dans l’espace, ou autre) CHAPITRE 3. PROCESSUS STOCHASTIQUES 100 T | Xt Discret Continue Discret PS à valeurs discrètes PS à valeurs continues et temps discret : B et temps discret : C Continue PS à valeurs discrètes PS à valeurs continues et temps continu : A et temps continu : D Table 3.1 – Types de processus stochastiques Figure 3.1 – (A,B,C,D) : types de PS. E : réalisations des PS Exemple 1. Plusieurs phénomènes se caractérisent par leur nature dynamique et stochastique qui peut faire l’objet d’une modélisation par les PS. On peut citer comme exemple : 1. La fortune d’un joueur après avoir joué n parties de pile ou face (en gagnant 1 dinar pour Face et en perdant 1 dinar pour Pile). PS X(N,Z) . 2. La température au nieme jour de l’année. PS X(N,R) . 3. Le nombre de requêtes arrivant dans un serveur à un instant donné t. PS X(R,N) . 4. La vitesse du vent à un instant donné t. PS X(R,R) . Mathématiquement, on peut intégrer l’aspect aléatoire dans n’importe quelle équation qui décrit une dynamique d’un système. Pour avoir un modèle stochastique on introduit un facteur perturbateur aléatoire (une ou plusieurs v.a). Comme exemple de cette catégorie : 1. si Y ∼ Ber(p) et RY = {+1, −1} et on définit Xn = Xn−1 + Y alors X(N,Z) est un PS (appelé une marche aléatoire). 2. si Y ∼ N(0, 1) et on définit Xn = aXn−1 + Y alors X(N,R) est un PS. À vos claviers! Les codes dans cette section vont utiliser certains helpers qui implémentent les fonctionnalités récurrentes (utils). # utils.py (Continuation) # generate_SP: generates a stochastic process X* one sample Path for T[0..999] def generate_SP(rvY, N=1000): spX, X_n = [0], 0 #stochastic process, random variable X_n for i in range(N): X_n = X_n + rvY() #current r.v X_n+1 spX.append(X_n) #newt step in SP X* return spX # plotSP: plots the SP’s sample paths def plotSP(generate_SP1, nbSP=5, N=100) : for i in range(nbSP): spX = generate_SP1(); #ith sample path plt.plot(spX[:N]) CHAPITRE 3. PROCESSUS STOCHASTIQUES 101 À vos claviers! Le code suivant montre comment générer un processus aléatoire simple modélisant la somme d’une séquence d’épreuves de Bernouli (modélisant la fortune d’un joueur jouant au pile ou face en gagnant 1 sur face et perdant 1 sur pile). #Code301.py import numpy as np import random import sys;sys.path.append(’../lib’) from utils import generate_SP,plotSP fY=lambda : 1 if random.randint(0, 1) else -1 def generate_BerSum1(): return generate_SP(fY) # generate_BerSum2: equavalent version of generate_BerSum1 using umpy.cumsum # (cummulative sum of the r.v values) def generate_BerSum2(): return np.cumsum([fY() for i in range(1000)]) plotSP(generate_BerSum2) Figure 3.2 – Plusieurs trajectoires du PS modélisant la somme d’une séquence d’épreuves de Bernouli (-1/1) 3.1.1 Fonctions CDF et statistiques de PS Il ne suffit pas de définir un PS par la loi des v.a Xt ou leurs CDFs (PXt ou FXt ) mais il faut intégrer le facteur d’interaction entre ses composantes en définissant les fonctions jointes de n’importe quel sous ensemble fini de ses v.a. Un PS est spécifié par la distribution jointe d’un ensemble fini de ses v.a. Pour décrire la relation entre les valeurs du PS à des instants différents, nous allons définir la fonction de distribution fini-dimensionnelle. Définition 2. Un PS est défini par sa CDF jointe fini-dimensionnelle suivante : ∀k ∈ N, {t1 , · · · , tk } ⊂ T, Ft1 ,t2 ,··· ,tk (x1 , x2 , · · · , xk ) = P (Xt1 ≤ x1 , · · · , Xtk ≤ xk ) Dans le contexte des PS, les grandeurs statistiques des v.a (E, V, · · · ) sont des fonctions paramétrées par t. Par la suite, elles seront l’outil nécessaire pour caractériser chaque PS étudié (il n’est pas toujours facile de déterminer la CDF jointe fini-dimensionnelle). Définition 3. Soient t, s deux instants différents dans T et k ∈ N∗ : - Fonction des moments d’ordre k : la fonction qui donne le moment d’ordre k de chaque v.a à chaque instant t. - Fonction moyenne (moment d’ordre 1 espérance mathématique ) : m(t) = E(Xt ) - Fonction variance (moment d’ordre 2) : v(t) = V(Xt ) - Fonction d’autocovariance : K(t, s) = Cov(Xtp , Xs ) - Fonction d’autocorrélation : φ(t, s) = K(t, s)/ v(t)v(s) CHAPITRE 3. PROCESSUS STOCHASTIQUES 102 ∗ Exemple 2. Soit X(N,N) défini par la somme de la séquence des v.a qui suivent la loi de Bernouli, on sait bien que cette somme est une v.a Binomiale (PS Binomiale) donc on connaît ses caractéristiques statistiques : — Soit Y ∼ Ber(p) et RY = {1, 0}, on définit Xn = Xn−1 + Y alors Xn ∼ Bin(n, p). — m(n) = E(Xn ) = np et v(n) = V(Xn ) = np(1 − p) sont fonction de n À vos claviers! Le code suivant montre la fonction moyenne m(t) et variance v(t) associées au PS Binomial. #Code302.py import numpy as np import random import matplotlib.pyplot as plt import sys;sys.path.append(’../lib’) from utils import generate_SP,plotSP # plotter: plots SP realisations and E and V functions def plotter(rgN, gen_SP, fE, fV): n = rgN plt.step(n, fE(n) , color=’red’) plt.step(n, fE(n) + fV(n)/2, color=’black’) plt.step(n, fE(n) - fV(n)/2, color=’black’) plotSP(gen_SP, 5, N) N, p = 30, 0.5; rgN = np.arange(0,N) fYBer = lambda : random.randint(0, 1) fnEBer = lambda n: n*p fnVBer = lambda n: n*p*(1-p) def generate_SP_Ber(): return generate_SP(fYBer) plotter(rgN, generate_SP_Ber, fnEBer, fnVBer) Figure 3.3 – PS modélisant la somme d’une séquence d’épreuves de Bernoulli (0/1) 3.1.2 Classes des processus stochastiques L’ensemble des v.a formant le PS présente certains aspects intéressants qui nous permettent de caractériser le PS (sa tendance, ses composantes, la relation entre ses éléments,...). Cette caractérisation sera utile pour simplifier l’analyse du comportement du PS. Définition 4. Soit un PS (Xt )t∈T , il est dit : 1. Indépendant et identiquement distribué iid si les v.a générées ont la même loi et sont indépendantes. (Xt )t∈T est iid ⇐⇒ ∀t, s ∈ T, t 6= s =⇒ Xt ⊥ Xs et PXt = PXs 2. Stationnaire au sens strict s.s.s : lorsque la distribution jointe d’un ensemble de ses v.a, (par exemple. du premier au quatrième) est la même que la distribution jointe d’un autre ensemble disjoint du même PS, (exemple du sixième au neuvième). Sa cdf CHAPITRE 3. PROCESSUS STOCHASTIQUES 103 fini-dimensionnelle dépend uniquement de la différence temporelle (l’écart entre les instants). (Xt )t∈T est stationnaire ⇐⇒ ∀s > 0, i 6= j, Xti +s , Xtj +s a la même CDF jointe que Xti , Xtj ou (Xt )t∈T est stationnaire =⇒ ∀s > 0, ∀k ∈ N, {t1 , · · · , tk } ⊂ T, Ft1 +s,··· ,tk +s (x1 , · · · , xk ) = Ft1 ,··· ,tk (x1 , · · · , xk ) 3. Stationnaire au sens faible s.s.f : L’espérance et la variance sont constantes et finies, et la fonction de la covariance ne dépend pas des instants t, mais l’écart relatif entre ces instants (PS dont les caractéristiques statistiques ne changent pas en fonction du temps). ∃c > 0, c0 > 0, E(Xt ) = c < ∞, V(Xt ) = c0 < ∞ et ∀t, s > 0, K(t, s) = f (t − s) 4. A incréments indépendants : on appelle incrément, la v.a qui donne la différence entre les deux valeurs prises par le PS Xt à l’instant s et t, ∆X(t,s) = Xt − Xs tel que s < t. (si s = 0 alors l’incrément sera noté ∆Xt ). On dit que Xt à incréments indépendants si les v.a incréments pour des paramètres qui ne chevauchent pas sont indépendants. ∀0 < t1 < t2 < s1 < s2 , ∆X(t1 ,t2 ) ⊥ ∆X(s1 ,s2 ) 5. A incréments stationnaires si ∀t > s > 0, c > 0, ∆X(t+c,s+c) suit la même distribution que ∆X(t,s) (la distribution est invariante par translation dans le temps). 6. Sans mémoire (Markovien) si son évolution future ne dépend pas du passé, mais seulement du présent. Dans le cas d’un PS à espace discret : ∀t1 < · · · < tn+1 , ∀n, P (Xtn+1 = xn+1 |Xt1 = x1 , · · · , Xtn = xn ) = P (Xtn+1 = xn+1 |Xtn = xn ) Exemple 3. 1- Le bruit blanc (Xt )t≥0 est un PS i.i.d (une séquence de v.a i.i.d) qui a une moyenne constante et une variance finie. Ce PS est stationnaire. E(Xt ) = µ V(Xt ) = σ 2 Pour t = s : K(s, t) = Cov(Xt , Xs ) = Cov(Xt , Xt ) = V(Xt ) = σ 2 Pour t 6= s : K(t, p s) = Cov(Xt , Xs ) = 0 φ(s, t) = K(s, t)/ v(s)v(t) Pour t = s : φ(s, t) = 1 Pour t 6= s : φ(s, t) = 0 2- La marche aléatoire (Xt )t≥0 est un PS, pour t > 1, Xt = Xt−1 + t tel que t est un bruit blanc de moyenne nulle et de variance σ 2 . E(Xt ) = E(Xt−1 + t ) = E(Xt−1 ) + E(t ) = 0 V(Xt ) = Cov(Xt , Xt ) = V(Xt−1 + t ) = V(Xt−1 ) + V(t ) = tσ 2 Pour t = s : K(s, t) = V(Xt ) = tσ 2 Pour s < t : K(t, s) = Cov(Xt , Xs ) = Cov(Xs + t X h , Xs ) h=s+1 = Cov(Xs , Xs ) + Cov( t X h=s+1 h , Xs ) CHAPITRE 3. PROCESSUS STOCHASTIQUES K(t, s) = sσ 2 + t X 104 Cov(h , Xs ) = sσ 2 h=s+1 Pour t = s : φ(s, t) = 1 Pour t = 6 s: p sσ 2 = φ(t, s) = K(t, s)/ v(s)v(t) = √ sσ 2 tσ 2 r s t 3- Soit un PS dont Xn = Xn−1 + Y et Y ∼ Ber(0.5) (-1,1), alors Xn ∼ Bin(n, p). m(n) = E(Xn ) = 0 et v(n) = 1 sont constantes et comme la fonction de covariance dépend de l’écart non des positions relatives, alors ce PS est stationnaire. Figure 3.4 – PS stationnaire vs non stationnaire 3.2 Processus de comptage Pour modéliser le changement d’état d’un système dont la dynamique est gouvernée par l’apparition d’un type particulier d’évènements aléatoires dans le temps, on s’intéresse parfois au nombre d’évènements durant la vie de ce système qui évolue par sauts d’amplitude d’une ou plusieurs unités. Définition 5. Un processus stochastique (Nt )t∈T est un processus de comptage (dénombrement) s’il est à valeurs entières non-négatives, croissant dont les valeurs représentent le nombre total des événements qui se sont produits jusqu’au temps t. Nt doit satisfaire aux conditions suivantes : 1- À valeur entière non-négative : RNt ⊂ N 2- Croissant : s < t alors Ns ≤ Nt 3- Saut (incrément) : pour s < t, ∆N(t,s) = Nt − Ns est égal au nombre d’événements ayant eu lieu dans l’intervalle [s, t] Le dernier évènement associé à l’instant t sera noté ENt = En , tel que n = Nt appelé la nieme arrivée. Exemple 4. 1- Les appels dans un central téléphonique, Et =’la réception d’un appel à l’instant t’ 2- Les émissions de particules radioactives, Et =’l’émission d’une particule radioactive’ 3- les clients qui se sont présentés devant un guichet jusqu’à un instant donné. Et =’l’arrivée d’un client devant le guichet’. CHAPITRE 3. PROCESSUS STOCHASTIQUES 105 4- Soit une suite d’épreuves de Bernoulli. Et =’Une expérience de Bernoulli qui donne succès’. Y ∼ Ber(p) et RY = {1, 0} et le PS définie par Xt = Xt−1 + Y . Xt représente le nombre des expériences de Bernouli ayant donné un succès après un certain nombre de réalisations. a- RXt ⊂ N b- ∀s, t > 0, s ≥ t, Xs ≥ Xt croissant. c- ∆X(t,s) est égale au nombre d’évènements Et correspondant à une expérience donnant succès dans l’intervalle [s, t]. Donc Xt est un PS de comptage. Figure 3.5 – Processus de comptage Les v.as qui apparaissent naturellement avec le processus de comptage est le temps de séjour (inter-arrivée) Sn entre l’évènement En et En+1 pour n ≥ 0. (Sn )n>0 est le PS du temps d’interarrivée des évènements. La quantité Nt peut être exprimée en fonction d’une autre v.a Tn le temps d’arrivée du nime évènement En . (Tn )n>0 est le PS associé à la variation de cette quantité. Par la suite on s’accorde sur la terminologie suivante : - Nt : nombre d’arrivées (évènements) jusqu’au temps t. - Tn : temps d’arrivée du nieme évènement En . - Sn : temps de séjour du processus dans l’état n.(le temps inter-arrivée entre En et En+1 ). Les relations entre ces grandeurs sont : Nt = ∞ X 1{Tk <t} k=0 {Tn < t} = {Nt ≥ n} et {Tn ≥ t} = {Nt ≤ n} Tn = S0 + S1 + · · · Sn−1 = n−1 X Sk k=0 3.3 Processus de Poisson L’un des processus de comptage les plus importants est le processus de Poisson. Définition 6. Le processus de comptage (Nt )t≥0 est un processus de poisson de taux λ > 0 si : 1. N0 = 0 2. Nt a des incréments indépendants et stationnaires. 3. P (Nh = 1) = λh + o(h) et P (Nh > 1) = o(h) lorsque h → 0+ Une fonction f (h) est dite o(h) si lim h→0 La troisième condition est équivalente au fait que la probabilité d’observer plus d’un événement dans un intervalle δt de longueur h tend vers 0 lorsque h tend vers 0. f (h) h = 0. CHAPITRE 3. PROCESSUS STOCHASTIQUES 106 Puisque Nt a des incréments stationnaires, alors sur l’intervalle [s, s + h] de longueur h, l’incrément est égal à sa valeur à l’instant h. ∆N(s,s+h) = ∆N(0,h) = Nh λ représente le nombre moyen d’évènements se produisant dans une unité de temps. Proposition 1. Si (Nt )t≥0 est un processus de poisson de taux λ > 0 alors : n 1- Nt ∼ Pois(λt) c.à.d pNt (n) = e−λt (λt) n! n−1 2- Tn ∼ Gamma(λ, n) c.à.d P (Tn ≤ t) = λe−λt (λt) (n−1)! 3- Sn ∼ Exp(λ) c.à.d P (Sn ≤ t) = 1 − e−λt 3.3.1 Loi de Nt La distribution Poisson est utilisée dans la modélisation des évènements rares. C’est la limite de la loi Binomiale de paramètres n et p lorsque n (le nombre de répétitions d’une expérience de Bernoulli) est très grand et p (la probabilité du succès) est très petite, le nombre total de succès suit la loi de Poisson. Nous avons : λ = np et X ; Bin(n, p). lim n→∞,p→0 P (X = k) = e−λ λk k! pour k = 0, 1, 2, ... Soit p = λ/n λ λ P (X = k) = Cnk ( )k (1 − )(n−k) n n λ n! λ λk (1 − )n ( k )(1 − )−k = k! n n (n − k)! n n! n(n − 1)...(n − k + 1) 1 k−1 = = (1 − )...(1 − ) k k n (n − k)! n n n Cette expression tend vers 1 lorsque n tend vers ∞ et le terme (1− nλ )−k aussi. Nous avons également : lim (1 + n→∞ 3.3.2 b n λ ) = eb ∀ b ∈ R, donc lim (1 − )n = e−λ n→∞ n n Loi de Sn On se place à l’instant Tn . Sn = temps d’attente jusqu’à la prochaine occurrence. P (Sn > t) = P (NTn +t − NTn = 0) P (Sn > t) = P (Nt = 0) (hypothèse d’indépendance temporelle) P (Sn > t) = e−λt P (Sn ≤ t) = 1 − e−λt Donc : Sn ; Expo(λ) CHAPITRE 3. PROCESSUS STOCHASTIQUES 3.3.3 107 Loi de Tn Soit Tn la date à laquelle survient le nieme événement. Tn − Tn−1 ; Expo(λ) n>0, T0 = 0, donc Tn est la somme de n variables exponentielles de paramètre λ et c’est la loi Gamma notée Γ(n, λ). La densité fTn (t) de la variable aléatoire Tn s’écrit : fTn (t) = λe−λt E(Tn ) = n λ (λt)n−1 (n − 1)! V(Tn ) = t≥0 n λ2 À vos claviers! #Code303.py import numpy as np import matplotlib.pyplot as plt # poisson_Proc: generates sampling for Poisson SP for different parameters def poisson_Proc(N,lambdas): X_T = [np.random.poisson(lam, size=N) for lam in lambdas] return [np.cumsum(X) for X in X_T] def plot_Poisson(N,S,lambdas): X = np.linspace(0, N, N) G = [plt.step(X, S[i], label="Lambda = %d"%lambdas[i])[0] for i in range(len(lambdas))] plt.legend(handles=G, loc=2) plt.title("Poisson Process", fontdict={’fontname’: ’Times New Roman’, ’fontsize’: 21}, y=1.03) plt.ylim(0); plt.xlim(0) plt.show() N , lambdas = 20 , [4, 7, 13] S = poisson_Proc(N,lambdas) plot_Poisson(N,S,lambdas) Figure 3.6 – Processus de Poisson Exemple 5. Dans une ville donnée, un volcan est estimé entrer en éruption, en moyenne, une fois tout les 400 ans. Quelle est la probabilité qu’une personne qui vient de naître et qui vit dans cette ville n’assiste pas à une éruption durant ses 20 premières années ? Solution La loi de Poisson peut être utilisée pour modéliser cet événement. λ = 1/400 (une éruption en 400 ans). Nt ; Pois(λt) et le temps entre deux éruptions successives Sn ; Exp(λ) L’évènement qu’une personne qui vient de naître n’assiste pas à une éruption est équivalent à {Sn > 20}. 1 P (Sn > 20) = 1 − P (Sn ≤ 20) = e−20λ = e− 400 ×20 = 0.9512 Une deuxième façon : durant les 20 premières années de vie de la personne, aucune éruption n’aura lieu ≡ {N20 = 0} P (N20 = 0) = e−20λ (20λ)0 = e−20λ = 0.9512 0! CHAPITRE 3. PROCESSUS STOCHASTIQUES 108 Exemple 6. Les gens immigrent vers une ville donnée suivant une loi de poisson de taux λ = 3 personnes/jour. 1- Quel est le temps moyen jusqu’à ce que la 10ieme personne arrive ? 2- Quelle est la probabilité que le temps entre l’arrivée de la 10ieme et la 11ieme personne dépasse 1 jour ? Solution 1- E(T10 ) = 10/λ = 3.33 jours 2- P (S10 > 1) = e−3×1 ≈ 0.049 À vos claviers! #Code304.py import numpy as np from numpy.random import exponential # Example3.6 N, lamda, dixieme, dixOnze =10000, 3, [], [] for j in range(N): T_n = exponential(1/lamda) for i in range(12): S_n = exponential(1/lamda) T_n += S_n if(i==9): dixOnze.append(S_n) if(i==8): dixieme.append(T_n) # question1 avg = np.array(dixieme).mean() print("Average time until 10th arrival:",np.round(avg,3),"\n") # question2 plusdunjour=[1 if i>1 else 0 for i in dixOnze] proba = np.array(plusdunjour).sum()/len(plusdunjour) print("Probability more than a day:",np.round(proba,3)) #______________________________ Output # Average time until 10th arrival: 3.325 # Probability more than a day: 0.053 3.3.4 ______________________________________ Somme et composition des processus de Poisson Proposition 2. Soient X et Y deux v.a indépendantes suivant la loi de Poisson de paramètres λ et µ respectivement. La v.a X + Y suit la loi de Poisson de paramètre λ + µ : P (X = k) = e−λ λk µk (λ + µ)k et P (Y = k) = e−µ =⇒ P (X + Y = k) = e−(λ+µ) k! k! k! X ∼ Pois(λ) et Y ∼ Pois(µ) =⇒ X + Y ∼ Pois(λ + µ) Démonstration. P (X + Y = k) = k X P (X = j)P (Y = k − j) j=0 = k X e−λ j=0 λj −µ µk−j e j! (k − j)! k e−(λ+µ) X j j k−j = Ck λ µ k! j=0 = e−(λ+µ) Le Binome de Newton : (a + b)k = démonstration. Pk j=0 (λ + µ)k pour k = 0, 1, ... k! Ckj aj bk−j est utilisé dans la dernière étape de la CHAPITRE 3. PROCESSUS STOCHASTIQUES 109 Proposition 3. Soit (Nt )t≥0 un processus de Poisson de taux λ, les évènements qui arrivent sont de deux types : type1 arrivent avec une probabilité p et type2 avec une probabilité 1 − p. Chaque évènement est indépendant de tous les autres. (1) (2) Soit Nt et Nt le nombre d’évènements de type1 et type2, respectivement, arrivant entre 0 et t. (1) (2) Nt = Nt + Nt (1) (2) (Nt )t≥0 et (Nt )t≥0 sont des processus de Poisson ayant respectivement le taux λp et λ(1 − p) et ils sont indépendants. Démonstration. (1) P (Nt (2) = j, Nt (1) = k) = P (Nt = (1) P (Nt (2) = j, Nt = (2) j, Nt = k, Nt = j + k) = k|Nt = j + k)P (Nt = j + k) λj+k (j + k)! j (λp) (λ(1 − p))k = e−λp × e−λ(1−p) pour j, k ≥ 0 j! k! k = Cj+k pj (1 − p)k e−λ (1) P (Nt (2) P (Nt = j) = = k) = ∞ X k=0 ∞ X j=0 (1) (2) = k) = e−λp (2) = k) = e−λ(1−p) = j, Nt (1) = j, Nt P (Nt (λp)j j! (2) (1) P (Nt (λ(1 − p))k k! Ce qui prouve que (Nt )t≥0 et (Nt )t≥0 sont des processus de Poisson ayant respectivement le taux λp et λ(1 − p) et ils sont indépendants. CHAPITRE 3. PROCESSUS STOCHASTIQUES 3.4 110 Exercices Exercice 1. Supposons que le temps qu’une personne passe dans la banque est exponentiellement distribué avec une moyenne de 10mns. 1- Quelle est la probabilité qu’un client passe plus de 15mns dans la banque ? 2- Quelle est la probabilité que le client passe plus de 15mns sachant qu’il a déjà passé 10mns dans la banque ? Exercice 2. Dans un quai, en moyenne, cinq navires arrivent par jour. Modélisons les arrivées des navires par un processus de poisson. Soit X la variable aléatoire qui mesure le temps entre minuit jusqu’à l’arrivée du premier navire. 1- Quelle est l’espérance de X ? 2- Quelle est la probabilité que plus de deux navires arrivent entre minuit et 6 heure du matin ? Exercice 3. Un serveur reçoit des requêtes suivant un processus de Poisson de taux 10 requêtes par minutes. Il y a une probabilité 1/12 que la requête soit erronée. Quelle est la probabilité que le serveur ne reçoit aucune requête erronée pendant 5 mns ? Exercice 4. [21] Une théorie scientifique suppose que les défauts de division d’une cellule se produisent suivant un processus de Poisson de taux 2.5 par ans, et qu’un individu meurt quand 196 tels défauts auront arrivés. Trouver : a. La durée de vie moyenne d’une personne, b. La variance de la durée de vie d’une personne. c. Quelle est la probabilité qu’une personne meurt avant l’âge de 67.2 ans. Exercice 5. [10] Dans un match de football entre deux équipes A et B, les buts sont marqués selon un processus de poisson avec un taux de 1/30 par minute. Le temps complet du match est 90mns. Chaque but marqué vient de l’équipe A avec une probabilité 12/25 et de l’équipe B avec une probabilité 13/25. 1. Quelle est la probabilité que le nombre de buts total soit 3 ou plus durant le match. 2. Quelle est la probabilité d’avoir exactement deux buts durant la première mi-temps et 1 but durant la deuxième mi-temps. CHAPITRE 3. PROCESSUS STOCHASTIQUES 3.5 111 Solutions Solution 1. 3 1 1/ X ; Exp(λ), λ = 1/10 P (X > 15) = 1 − P (X ≤ 15) = 1 − (1 − e− 10 ∗15 ) = e− 2 = 0.22 2/ Puisque la distribution exponentielle possède la propriété d’absence de mémoire, la probabilité que le client passe plus de 15mns sachant qu’il a déjà passé 10mns dans la banque est égale à la probabilité que le client passe au moins 5mns dans la banque, c.à.d :P (X > 5). P (X > 5) = e−5/10 = e−1/2 = 0.604 Solution 2. X ; Exp(λ), λ = E(X) = 1 λ 5 24 (une unité de temps=1 heure) = 4.8 heures P (N6 > 2) = 1 − P (N6 ≤ 2) = 1 − (P (N6 = 0) + P (N6 = 1) + P (N6 = 2)) −6λ P (N6 > 2) = 1 − (e−6λ + 6λe−6λ + (−6λ)2 e 2! ) = 0.1315 Solution 3. Soit T1 la v.a représentant le temps écoulé jusqu’à la prochaine requête erronée. Le processus de Poisson de réception des requêtes (de taux λ = 10) est composé de deux types d’évènements indépendants : requête erronée (avec une probabilité p1 = 1/12) et requête non erronée (avec une probabilité p2 = 11/12). Suivant la proposition 3, chaque type est un processus de Poisson de taux λpi . Donc, T1 ; Exp(λp1 ). La probabilité recherchée est égale à P (T1 > 5). 1 25 P (T1 > 5) = 1 − P (T1 ≤ 5) = e−10∗ 12 ∗5 = e− 6 Solution 4. Soit Nt ∼ P ois(2.5) a- Tn est la v.a qui représente le temps d’arrivée du nieme évènement, elle suit la loi Gamma(λ). E(T196 ) = 196 λ = 78, 4 ans. b- V(T196 ) = 196 λ2 = 31, 36. c- En appliquant le TCL : 196 X P (T196 < 67, 2) = P ( Si < 67, 2) i=1 P196 i=1 Si − 196/2.5 67.2 − 196/2.5 √ < √ ) 196/2.5 196/2.5 ≈ φ(2.035) = 0.9788 = P( Solution 5. 1 =3 Soit N (t) la v.a représentant le nombre de buts en un temps t. N (t) ; Pois(λ), λ = 90 × 30 (l’unité de temps est 90mns) 1. P (N1 ≥ 3) = 1 − P2 k=0 3k k! = 0.5768 2 −1.5 (1.5) e × e(−1.5) 2! e−3 × 2.P (N 12 = 2) × P (N 12 = 1) = × 1.5 = 0.084 Chapitre 4 Chaînes de Markov 4.1 Introduction Dans la science épidémiologique, par exemple, lors de la transmission des maladies dans une communauté, le nombre de personnes infectées à un moment donné peut augmenter ou baisser dépendamment des infections des individus sains et des guérisons des personnes infectées au moment présent. La personne peut être dans un des trois états : saine, infectée ou guérie. Sa future interaction avec les autres change son état courant et par conséquent le nombre de personnes infectées dans la population. Dans ce phénomène, l’état de la communauté et des individus dépend uniquement de leur état courant. Ce comportement contrôle le nombre d’infections futures, et son étude permet de prédire la tendance des maladies transmissibles. Dans le monde réel, beaucoup de systèmes présentent un comportement similaire : l’état futur dépend uniquement de l’état présent. Le modèle mathématique permettant de modéliser et d’étudier ce genre de systèmes est le processus stochastique Markovien. Dans le cas où le système a un nombre d’états dénombrable, ce processus est dit une Chaîne de Markov "CM". 4.2 Chaînes de Markov à temps discret Définition 1. Une CM à temps discret "CMTD" (Xn )n≥0 est un processus stochastique Markovien à temps discret (qui vérifie la propriété d’absence de mémoire) : ∀i, j, in−1 , in−2 , ...i0 ∈ S P (Xn+1 = j|Xn = i) = P (Xn+1 = j|Xn = i, Xn−1 = in−1 , Xn−2 = in−2 , ..., X0 = i0 ) Tel que S est l’ensemble de tous les états possibles. Si S est fini alors la CM est dite finie sinon elle est dite infinie. P (Xn+1 = j|Xn = i) est la probabilité de transition de l’état i vers l’état j à la nieme étape. La CM est dite homogène si les probabilités de transition ne dépendent pas de l’instant n en considération : P (Xn+1 = j|Xn = i) = P (Xn = j|Xn−1 = i) = ... = P (X1 = j|X0 = i) = pij pij est notée parfois π(i, j) ou πij . Notons que pij ne désigne pas la probabilité jointe mais la probabilité conditionnelle d’être dans l’état j sachant qu’on était dans l’état i. Elle est aussi appelée la probabilité de transition en une étape. Dans la suite de ce livre nous traitons seulement les CMTD homogènes. Une CMTD homogène est complètement déterminée par : • L’ensemble des états S. 112 CHAPITRE 4. CHAÎNES DE MARKOV 113 • Le vecteur de probabilités initiales π 0 qui contient la distribution des probabilités d’être P initialement dans chacun des états : π 0 (j) ∀j ∈ S en vérifiant : π 0 ×11 = j∈S π 0 (j) = 1 (11 est un vecteur de la même taille que π 0 et dont tous les éléments sont des 1). • Les probabilités de transition pij en une étape sous forme de matrice carrée P = (pij ). 4.2.1 Matrice et graphe de transitions La matrice de transitions P d’une CMTD homogène est une matrice composée des éléments pij , les probabilités d’aller de l’état i vers l’état j en une seule étape. Cette matrice est de taille |S| × |S| ; tous ses éléments sont des probabilités, donc entre 0 et 1, et la somme de chaque ligne est égale à 1, appelée aussi matrice stochastique. Le graphe de transition correspondant à la matrice P est composé de sommets représentants les états et d’arcs correspondants aux transitions possibles (ayant des probabilités non nulles). Exemple 1. Soit la CMTD modélisant les conditions de la météo d’une ville donnée, ayant l’ensemble des états S = {soleil, pluie}, le vecteur des probabilités initiales π 0 = [0, 1] et la matrice de transition P. 0.7 0.3 P= 0.5 0.5 Les éléments pij de la matrice sont les probabilités d’aller d’une journée de type i à une journée de type j, i, j ∈ S. la somme de chaque ligne est égale à 1. Le graphe suivant est le graphe de transition de la CMTD. 0.3 0.7 pluie Soleil 0.5 0.5 Figure 4.1 – Graphe de transition Exemple 2. Deux boites A et B, chacune contient r boules. Au total, il existe r rouges et r vertes. À chaque étape, une boule est choisie aléatoirement de A et une de B et chacune est déplacée de sa boite vers l’autre boite. - Définir une CMTD (avec sa matrice de transition) qui décrit le nombre de boules rouges et vertes dans chacune des boites. Solution Soit Xn le nombre de boules rouges dans la boite A après le nieme transfert. Le processus (Xn )n≥0 est une CMTD de l’ensemble d’états S = {0, 1, 2, ..., r}. La matrice de transition P (pij ) est définie par : 1. pi,i+1 = (r−i)2 r2 i2 r2 2i(r−i) r2 2. pi,i−1 = 3. pi,i = 4. pi,j = 0 sinon Le cas 1 se produit lorsqu’une boule verte est choisie de A avec une probabilité (r − i)/r et une boule rouge est choisie de B avec une probabilité (r − i)/r. Le cas 2 se produit lorsqu’une boule rouge est choisie de A avec une probabilité i/r et une boule verte est choisie de B avec une probabilité i/r. Le cas 3 se produit lorsqu’une boule rouge est choisie de A et de B ou bien une boule verte est choisie de A et de B. Le cas 4 ne peut pas se produire. CHAPITRE 4. CHAÎNES DE MARKOV 114 À vos claviers! Dans le code suivant, nous proposons une classe CMTD qui implémente une CMTD dont les attributs sont : l’ensemble des états S, la matrice de transition P et la distribution initiale pi0. Les principales méthodes de la classe seront implémentées au cours des prochaines sections de ce chapitre. #Code401.py import networkx as nx import numpy as np import sys;sys.path.append(’../lib’) from tools import is_distribution,makeGraf # CMTD Class class CMTD(object): # constructor def __init__(self,P ,S = None ,pi0 = None): n = len(P) pi0_default = np.zeros(n); pi0_default[0] = 1 # attributes of CMTD self.P = np.array(P) self.S = range(1,n+1) if S == None else S self.pi0 = pi0_default if pi0 == None else np.array(pi0) # checks if P and pi0 are stochastic if((len(self.pi0) != n) or (not is_distribution(self.pi0))): print("pi0 should be a stochastic vector") sys.exit(0) stoc = (len(self.P) == n) if(stoc): for i in range(n): if((len(P[i]) != n) or (not is_distribution(self.P[i]))): stoc = False;break if(not stoc): print("P should be a stochastic matrix") sys.exit(0) 4.2.2 Loi de probabilité de Xn Soit π n (j) = P (Xn = j) = PXn (j) pour n ≥ 0 et j ∈ S, la probabilité que le processus soit dans l’état j à l’instant (l’étape) n. Le vecteur π n = [πn (1), πn (2), πn (3), ...] est une distribution de probabilités (la somme des termes égale à 1). En connaissant π 0 le vecteur de probabilités initiales, on veut déterminer π n ∀n. Nous avons : X π 1 (j) = P (X1 = j ∩ X0 = k) théorème de probabilité totale, k∈S = X P (X1 = j|X0 = k) × P (X0 = k) k∈S = X π 0 (k) × pkj k∈S π1 = π0 × P De la même façon : π 2 = π 1 P = π 0P 2 De façon générale : π n = π (n−1)P π n est Loi de probabilité de Xn . π n = π0 × P n règle de la chaîne CHAPITRE 4. CHAÎNES DE MARKOV 4.2.3 115 Probabilités de transitions en n étapes (2) pij est la probabilité d’aller de i à j en 2 étapes. X (2) pij = P (X2 = j|X0 = i) = P (X2 = j|X1 = k, X0 = i) × P (X1 = k|X0 = i) k∈S = X P (X2 = j|X1 = k) × P (X1 = k|X0 = i) propriété de Markov k∈S = X pik × pkj k∈S (n) De façon générale : pij = P (Xn = j|X0 = i) est l’élément i, j de la matrice P(n) qui est la probabilité de transition en n étapes. 4.2.4 Équation de Chapman Kolmogorov Pour n ≥ 2 (n) pij = X (n−1) pik × pkj ∀i, j ∈ S k∈S La probabilité d’aller de i à j en n transitions est obtenue en sommant (pour tous les états k) les probabilités des événements mutuellement exclusifs d’aller de i à un certain état k en n − 1 étapes ensuite aller de k à j à la nieme étape. Sous forme matricielle : Soit P(n) la matrice des probabilités de transition en n étapes. P(n) = P(n−1) × P = P × P(n−1) Cette relation est appelée l’équation de Chapman Kolmogorov. Nous avons P(1) = P, en itérant la formule, on obtient : P(n) = P × P × ... × P = Pn Exemple 3. Dans chaque paquet de chocolat acheté on trouve une figurine de collection. La série complète comprend 4 figurines. Initialement, nous avons un paquet acheté. On cherche à obtenir la collection complète. 1. Représenter le processus de collection par une chaîne de Markov. 2. Établir la matrice de transition. Calculer le vecteur de distribution de probabilité après trois achats. Solution Soit Xn le nombre de figurines collectées après le nieme achat. Le processus (Xn )n≥0 est une CMTD définie par S={1,2,3,4} tel que chaque état représente le nombre de figurines différentes collectées. Les probabilités de transition sont les suivantes : pour i = 1, .., 3 • pi,i+1 = 4−i 4 • pi,i = 4i pour i = 1, .., 4 • pi,j = 0 sinon 0.25 0.75 0 0 0 0.5 0.5 0 P= 0 0 0.75 0.25 0 0 0 1 La distribution (vecteur de probabilités) initiale : π 0 = (1, 0, 0, 0). Après trois achats : 0.0156 0.3281 0.5625 0.0938 0 0.125 0.5938 0.2813 P3 = 0 0 0.4219 0.5781 0 0 0 1 CHAPITRE 4. CHAÎNES DE MARKOV Donc π 3 = π 0 P3 = (0.0156 0.3281 0.5625 116 0.0938) À vos claviers! Nous avons ajouté la méthode suivante qui permet de calculer les probabilités en n étapes à la classe CMTD. #Code401.py (Continuation) # nSteps probabilities def nSteps(self,n): return self.pi0.dot(np.linalg.matrix_power(self.P,n)) À vos claviers! Ce code montre son application à l’exemple précèdent. #Code402.py from CMTD import CMTD # Figurine example P = [[0.25, 0.75, 0.00, [0.00, 0.50, 0.50, [0.00, 0.00, 0.75, [0.00, 0.00, 0.00, 0.00], 0.00], 0.25], 1.00]] print(CMTD(P).nSteps(3)) #______________________________ Output #[0.015625 0.328125 0.5625 0.09375 ] ____________________________________ Exemple 4. Dans une ville donnée, le temps peut être ensoleillé, nuageux ou pluvieux. Le temps du lendemain dépend seulement du temps d’aujourd’hui et non pas des jours précédents. Si un jour le temps est ensoleillé, le lendemain sera ensoleillé, nuageux, pluvieux avec les probabilités respectives 0.7,0.1 et 0.2 ; quand il est nuageux, les probabilités sont 0.5,0.25,0.25 et les probabilités sont 0.4,0.3,0.3 pour une journée pluvieuse. Si un jour donné, le temps est pluvieux, quelle est la probabilité qu’il soit ensoleillé après trois jours ? Solution On considère la CM avec trois états : 1 (ensoleillé), 2 (nuageux) et 3 (pluvieux). Soit Xn la v.a représentant le temps à la nieme journée. Le processus stochastique X1 , X2 , ...Xn est une CMTD aux états S={1,2,3} et la matrice de transition P : 0.70 0.10 0.20 P = 0.50 0.25 0.25 0.40 0.30 0.30 Pour calculer la probabilité d’un temps ensoleillé après peut calculer la matrice P3 . 0.60150 0.16825 3 P = 0.59125 0.17525 0.58550 0.17975 trois jours d’une journée pluvieuse, on 0.23025 0.23125 0.23475 Et donc la probabilité recherchée est : 0.5855 Une autre façon de trouver cette probabilité est de calculer π 3 à partir de π 0 = (0, 0, 1) avec la relation : π 3 = π 2 P tel que : π 1 = π 0 P = (0.4000, 0.3000, 0.3000) π 2 = π 1 P = (0.5500, 0.2050, 0.2450) π 3 = π 2 P = (0.5855, 0.1797, 0.2347) et donc on obtient la même valeur : 0.5855 CHAPITRE 4. CHAÎNES DE MARKOV 4.2.5 117 Classification des états Soit (Xn )n≥0 une CMTD ayant l’ensemble des états S, le vecteur de probabilités initiales π 0 et la matrice de transition P. • On dit que l’état j est accessible à partir de l’état i si la probabilité d’aller de i à j est non nulle : (n) i → j ⇔ ∃n > 0 : pij > 0 Ceci signifie que dans le graphe de transition il existe un chemin entre i et j. • On dit que les états i et j communiquent si chacun d’eux est accessible à partir de l’autre : i↔j ⇔i→j∧j →i La relation de communication entre deux états est : • réflexive (par convention ∀i π 0 (i, i) = 1), • symétrique (par définition) • transitive (de l’équation de Chapman Kolmogorov) C’est donc une relation d’équivalence et il est possible de construire une partition des états de la CM en classes d’équivalence telle que tous les états d’une classe communiquent entre eux et que deux états appartenant à deux classes différentes ne communiquent pas. Ces classes sont deux à deux disjointes et leur réunion donne l’ensemble de tous les états. Deux types de classes existent : • Classe récurrente : Il est impossible de la quitter. C est recurrente ≡ ∀i ∈ C, ∀j ∈ S, i → j =⇒ j ∈ C • Classe transitoire : Il est possible d’en sortir sans pouvoir plus jamais y revenir. C est transitoire ≡ ∃i ∈ C, ∃j ∈ S, i → j ∧ j ∈ /C Exemple 5. Soit la CMTD décrite par le graphe de transition suivant : 1 3 2 8 4 5 6 7 Figure 4.2 – Classification des états Dans cet exemple, il existe 4 classes : C1={1,2} transitoire C2={3,4} transitoire C3={5} transitoire C4={6,7,8} récurrente Si la classe récurrente est composée d’un seul état, cet état est dit absorbant. Une chaîne de Markov pour laquelle il n’existe qu’une seule classe qui est récurrente (égale à l’ensemble des états) est dite irréductible. À vos claviers! La méthode classify() a été ajouté à la classe CMTD comme suit : CHAPITRE 4. CHAÎNES DE MARKOV 118 #Code401.py (Continuation) # classify def classify(self): graf, succ = makeGraf(self.S,self.P) cfcs=list(nx.strongly_connected_components(graf)) classes={"transitoire":[],"reccurente":[]} for i in range(len(cfcs)): cfc , voisins = cfcs[i] ,set() for s in cfc: voisins = voisins|succ[s]-cfc classes["transitoire" if(len(voisins)>0) else "reccurente"].append(cfc) return classes À vos claviers! La méthode suivante de la classe CMTD nous permet de tester si une CM est irreductible. #Code401.py (Continuation) # is_irreducible def is_irreducible(self): return(nx.is_strongly_connected(makeGraf(self.S,self.P)[0])) À vos claviers! Son application à l’exemple précèdent est dans le code suivant. #Code403.py from CMTD import CMTD # Classification example P = [[0.00, 1/2 , 1/2 , 0.00, [1/3 , 2/3 , 0.00, 0.00, [0.00, 0.00, 0.00, 1/4 , [0.00, 0.00, 1/2 , 0.00, [0.00, 0.00, 0.00, 0.00, [0.00, 0.00, 0.00, 0.00, [0.00, 0.00, 0.00, 0.00, [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1/2 , 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 2/3 , 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00], 0.00], 3/4 ], 0.00], 0.00], 0.00], 1/3 ], 0.00]] print(CMTD(P).classify()) print(CMTD(P).is_irreducible()) #______________________________ Output ______________________________________ #{’transitoire’: [{5}, {3, 4}, {1, 2}], ’reccurente’: [{8, 6, 7}]} 4.2.5.1 États récurrents et états transitoires Il est souvent utile de savoir si, partant d’un état i, le processus reviendra à cet état ou pas. Soit la v.a Ti = M in{n ≥ 0 : Xn = i} le temps du premier passage par l’état i. Soit la v.a Tji = Ti |X0 = j le temps du premier passage par l’état i sachant qu’il était initialement dans j Soit la v.a Tii = Ti |XP 0 = i le temps du premier retour à l’état i. ∞ La quantité E(Tii ) = k=0 kP (Tii = k) représente le temps moyen de retour à i. Soit fii = P (Tii < ∞), la probabilité que le processus revient à l’état i sachant qu’il était initialement dans i. Définition 2. Un état i d’une CMTD est dit : 1- récurrent si fii = P (Tii < ∞) = 1 2- transitoire si fii = P (Tii < ∞) < 1. 3- récurrent positif si E(Tii ) < ∞ 4- récurrent nul si E(Tii ) = ∞ Proposition 1. Soit Ni le nombre de visites à l’état i d’une CMTD avant de le quitter définitivement. Le CHAPITRE 4. CHAÎNES DE MARKOV 119 nombre moyen Ni verifie : E(Ni |X0 = i) = ∞ X (n) pii n=1 On peut exprimer la v.a Ni de la façon suivante : Ni = sa moyenne est donnée par : E(Ni |X0 = i) = E( = ∞ X 1Xn =i |X0 = i) = n=1 ∞ X P∞ ∞ X n=1 1Xn =i sachant que X0 = i tel que E(1Xn =i |X0 = i) n=1 1 × P (Xn = i|X0 = i) + 0 × P (Xn 6= i|X0 = i) n=1 E(Ni |X0 = i) = = ∞ X n=1 ∞ X P (Xn = i|X0 = i) (n) pii n=1 Si i est un état : 1- Récurrent : Partant de cet état, la probabilité d’y retourner est 1 et donc la probabilité d’y retourner encore une fois est toujours 1, ceci dit que l’état i sera visité une infinité de fois. P (Ni < ∞|X0 = i) = 0 P (Ni = ∞|X0 = i) = 1 Donc un état récurrent a la propriété que la moyenne du nombre de passage par i est infinie. E(Ni |X0 = i) = ∞ X (n) pii = 0 × E(Ni < ∞|X0 = i) + 1 × E(Ni = ∞|X0 = i) = ∞ n=1 donc i est un état récurrent si et seulement si P∞ n=1 (n) pii = ∞ Les états récurrents d’une CM à états finis sont tous positifs, ce qui n’est pas le cas pour les CM à états infinis. 2- Transitoire La probabilité d’y retourner fii est inférieure à 1 et donc la probabilité de ne plus jamais y (h) retourner est 1 − fii . Soit Tii le hieme retour à l’état i Proposition 2. Si i est un état transitoire alors la v.a Ni |X0 = i suit la loi géométrique de paramètre 1 − fii P (Ni = k|X0 = i) = P (( k−1 \ (h) (k) Tii < ∞) ∩ (Tii = ∞)) h=1 = k−1 Y (h) (k) P (Tii < ∞) × P (Tii = ∞) h=1 = (P (Tii < ∞))k−1 × (1 − P (Tii < ∞)) = fiik−1 × (1 − fii ) CHAPITRE 4. CHAÎNES DE MARKOV 120 Ceci veut dire que : Ni |X0 = i ; Geo(1 − fii ) et donc E(Ni |X0 = i) = ∞ X (n) pii = n=1 1 <∞ 1 − fii On a montré que le nombre moyen que le processus visite i est fini et égal à Donc, le temps moyen de retour est infini 1 1−fii E(Tii ) = ∞ La récurrence est une propriété de classe, ce qui veut dire que tous les états appartenant à une classe sont tous transitoires ou tous récurrents. 4.2.6 Cas des CMs infinies 1- Une CMTD finie a la propriété que l’ensemble des états récurrents est non vide et que le temps moyen de retour à chaque état récurrent est fini E(Tii ) < ∞. 2- Une CMTD infinie n’a pas nécessairement la même propriété qu’une CMTD finie. 1- Si on prend par exemple les CMTD avec les états et les transitions : S = N et pi,i+1 = 1, ∀i ∈ S, ∀k ≥ 1, P (Tii = k) = 0 < 1 Donc tous les états sont transitoires et on a E(Tii ) = ∞. 2- Soit le chaîne de Markov discrète infinie décrite par le graphe de transition suivant : T0 est la v.a.d du temps du premier passage par l’état 0. 1/5 1/4 1/3 0 1/2 1 1 2 1/2 2/3 3 4 3/4 Figure 4.3 – Graphe de transition Ti0 = T0 |X0 = i est la v.a.d du premier passage par l’état 0 partant de l’état i ( T00 temps du premier retour à 0). Pour déterminer le type de récurrence de la chaîne (positif ou nul), on doit calculer : a- La probabilité pour que T00 ait une valeur finie (P (T00 < ∞)). b- Le temps moyen de retour à 0 (E(T00 )). a- La probabilité pour que T00 < ∞ : Si le retour à 0 est impossible alors T00 = ∞ est un évènement possible (P (T00 = ∞) > 0). P (T00 ≥ 1) = 1 P (T00 ≥ 2) = 1 P (T00 ≥ 3) = 1 · P (T00 ≥ 4) = 1 · P (T00 ≥ k + 1) = 1 · ( 0 → 1) 1 2 1 2 1 2 ( 0 → 1 → 2) · 2 3 ··· Puisque limk→∞ P (T00 ≥ k) = limk→∞ donc P (T00 <∞) = f00 = 1 = 13 k−1 k = 1 k−1 = 0, alors P (T00 =∞) = 0 ( 0 → 1 → 2 → 3) 1 k ( 0 → 1 → · · · → k) CHAPITRE 4. CHAÎNES DE MARKOV 121 On conclut que la chaîne est récurrente. b- Le temps moyen de retour à 0 (E(T00 )). E[T00 ] = ∞ X k · P (T00 = k) k=1 = = ∞ X k X k=1 j=1 ∞ X P (T00 = k) = ∞ X ∞ X P (T00 ≥ j) = 1 + 1 + j=1 P (T00 = k) j=1 k=j 1 1 1 1 + + + + ··· = ∞ 2 3 4 5 Donc cette chaîne de Markov est récurrente nulle Elle retourne à 0 avec une probabilité 1, mais le temps moyen de retour est infini, E(Tii ) = ∞ 4.2.7 États périodiques Un état i est dit périodique, de période t, si un retour à cet état peut arriver seulement aux (n) étapes : t, 2t, 3t, ... tel que t = P GCD{n, pii ≥ 0} et t > 1. Sinon l’état i est apériodique. Deux états communiquant ont la même période donc la période est constante à l’intérieur des classes de communication. La période commune des éléments de la classe est appelée période de la classe. Si la période d’une classe est égale à 1, elle est dite une classe apériodique. À vos claviers! La méthode suivante de la classe CMTD nous permet de tester si une CM est aperiodique. #Code401.py (Continuation) # is_aperiodic def is_aperiodic(self): return(nx.is_aperiodic(makeGraf(self.S,self.P)[0])) 4.2.8 Temps moyen du premier passage Soit tij le nombre moyen d’étapes nécessaires pour atteindre, pour la première fois, l’état j à partir de l’état i. Si Tj = M in{n ≥ 0 : Xn = j} est le temps (nombre d’étapes) nécessaires pour que la chaîne visite l’état j pour la première fois alors, tij = E[Tj |X0 = i]. Nous avons : tii = 0 et ∀j 6= i : X tij = 1 + pik tkj k∈S/{i} Sous forme matricielle Ti = [tji ]j6=i , P̂(i) = [pjk ]k6=i,j6=i : Ti = 1 + P̂(i) Ti À vos claviers! #Code401.py (Continuation) # hitting_time : average time to hit for the first time the state given in the argument def hitting_time(self,state): n, i = len(self.S), self.S.index(state) I = np.identity(n); I[i,i] = 0; g = np.ones(n); g[i]=0; for k in range(n): if(self.P[k,k] == 1): I[k,k], g[k] = 0, 0 return np.matmul(np.linalg.inv(np.identity(n)-np.matmul(I,self.P)), g) CHAPITRE 4. CHAÎNES DE MARKOV 4.2.9 122 Temps moyen de retour Partant d’un état i, le nombre moyen d’étapes nécessaires pour y retourner est noté ri . Soit Ri = M in{n ≥ 1 : Xn = i} alors ri = E[Ri |X0 = i]. Nous avons : ri = 1 si i est absorbant sinon : X ri = 1 + pik tki k∈S tki est le temps moyen du premiers passage par l’état i partant de k. À vos claviers! #Code401.py (Continuation) # return_time : average return time to the state given in the argument def return_time(self,state): i = self.S.index(state) return 1 + ( 0 if self.P[i,i] == 1 else np.dot(self.P[i], self.hitting_time(state))) Exemple 6. Soit la CMTD définie par S = {1, 2, 3} 1/2 1/2 P = 0 1/3 1/2 1/2 et la matrice de transition suivante : 0 2/3 0 Soit tk1 le temps moyen du premier passage par l’état 1 partant de l’état k et r1 le temps moyen de retour à l’état 1. Calculer t21 , t31 et r1 . t2,1 et t3,1 sont obtenus par la résolution du système d’équations tel que t1,1 = 0 : t = 1 + 1t + 2t t21 1/3 2/3 t21 1 21 3 21 3 31 = T1 = 1 + P̂(1) T1 = = + 1 1/2 0 t t 1 t = 1 + t + 0t 31 31 2 21 31 31 Nous obtenons : [t21 , t31 ]T = [5, 7/2]. On remarque que si X0 = 1 alors X1 = 1 avec une probabilité 1/2 ou X1 = 2 avec une probabilité 1/2, donc : r1 = 1 + 1/2t11 + 1/2t21 = 7/2. À vos claviers! #Code404.py from CMTD import CMTD P = [[0.5, 0.5, 0.0], [0.0, 1/3, 2/3], [0.5, 0.5, 0.0]] print(CMTD(P).hitting_time(3)) print(CMTD(P).return_time(1)) #______________________________ # [3.5 1.5 0. ] # 3.499999999999999 4.2.10 Output ______________________________________ Probabilités d’absorption Dans la CM suivante les états 0 et 3 sont absorbants 2/3 1/3 1 0 1/2 1 2 1/2 Figure 4.4 – Probabilités d’absorption 3 1 CHAPITRE 4. CHAÎNES DE MARKOV 123 Soit dans cet exemple ai0 la probabilité d’être absorbé par l’état 0 partant de l’état i. a00 = 1 et a30 = 0 (car 3 est un autre état absorbant). En appliquant la loi de probabilités totale, on aura ai0 = d’équations tel que a00 = 1 et a30 = 0 : a = 1a + 2a 10 3 00 3 20 a = 1a + 1a 20 2 10 P k pik × ak0 ceci donne le système 2 30 Sa résolution donne les valeurs des ai0 : a10 = 1/2, a20 = 1/4. De façon générale, pour tout état j absorbant : P aij = k pik × akj si i est non absorbant ajj = 1 a = 0 si j 6= i est absorbant ij À vos claviers! La méthode de calcul des probabilités d’absorption. #Code401.py (Continuation) # absorption probability def absorbing_proba(self,state): n, j = len(self.S) , self.S.index(state) absorb = [i for i in range(n) if(self.P[i][i] == 1) ] if(j not in absorb): print("The state must be absorbant") sys.exit(0) A, B = np.zeros((n,n)), np.zeros(n) A[j][j], B[j] = 1 , 1 for i in range(n): if(i != j): if(i in absorb): A[i][i] = 1 else: for k in range(n): A[i][k] = self.P[i][k] if(k != i) else A[i][i]-1 return np.linalg.inv(A).dot(B) À vos claviers! Le code de l’exemple. #Code405.py from CMTD import CMTD P = [[1.0, [1/3, [0.0, [0.0, 0.0, 0.0, 1/2, 0.0, 0.0, 2/3, 0.0, 0.0, 0.0], 0.0], 1/2], 1.0]] print(CMTD(P).absorbing_proba(1)) #______________________________ Output #[1. 0.5 0.25 0. ] 4.2.11 ______________________________________ Temps moyen d’absorption Soit ni le temps moyen jusqu’à absorption en partant de l’état i. Il représente le temps moyen nécessaire pour que le processus soit absorbé étant donné que son état initial est i. ni = E[T |X0 = i] tel que T est le temps (nombre d’étapes) nécessaire pour que la chaîne arrive à un état absorbant. Les valeurs de ni sont obtenues par la résolution du système suivant (A est l’ensemble des états absorbants), si i ∈ A, alors ni = 0, sinon : X ni = 1 + pij nj j ∈A / CHAPITRE 4. CHAÎNES DE MARKOV 124 Ce système peut être écrit : NĀ = 1 + P̂Ā NĀ Tel que NĀ = [ni ]i∈Ā et P̂Ā = [pij ]i,j∈Ā À vos claviers! La méthode de calcul du temps moyen d’absorption. #Code401.py (Continuation) # average absorption time def absorbing_time(self): n = len(self.S) absorb = [i for i in range(n) if(self.P[i][i] == 1)] if(len(absorb) == 0): print("No absorbant state exists!") sys.exit(0) A, B = np.zeros((n,n)), np.zeros(n) for i in range(n): if(i in absorb): A[i][i]=1 else: B[i] = -1 for j in range(n): if(j not in absorb): A[i][j]=self.P[i][j] A[i][i] -= 1 return np.linalg.inv(A).dot(B) Exemple 7. Dans l’exemple 3, l’état 4 est absorbant et c’est l’état qui représente le fait de gagner. Si on veut calculer les probabilités d’absorption par cet état(probabilité de gagner), on doit tout simplement résoudre le système d’équations avec A = {4} : n1 = 1 + 1/4 × n1 + 3/4 × n2 1/4 3/4 0 n 1 1 NĀ = 1 + P̂Ā NĀ = 1 + 0 n2 = 1 + 1/2 × n2 + 1/2 × n3 1/2 1/2 n2 = n3 = 1 + 3/4 × n3 0 0 3/4 n3 1 Ce qui donne : n1 = 22/3, n2 = 6, n3 = 4 et n4 = 0 À vos claviers! La méthode de calcul des probabilités d’absorption. #Code406.py from CMTD import CMTD P = [[1/4, [0.0, [0.0, [0.0, 3/4, 1/2, 0.0, 0.0, 0.0, 1/2, 3/4, 0.0, 0.0], 0.0], 1/4], 1.0]] print(CMTD(P).absorbing_time()) #______________________________ #[7.33333333 6. 4. 4.2.12 Output 0. ______________________________________ ] Distributions stationnaires et limites Si on reprend l’exemple 4 et on calcule les puissances successives de la matrice P, on va se rendre compte qu’il existe une probabilité limite que le système soit dans un certain état après un grand nombre de transitions et cette probabilité est indépendante de l’état initial. Dans l’exemple nous avons : 0.7 0.1 0.2 0.62 0.155 0.225 P = 0.5 0.25 0.25 P2 = 0.575 0.1875 0.2375 0.4 0.3 0.3 0.55 0.205 0.245 CHAPITRE 4. CHAÎNES DE MARKOV 0.596 5 P = 0.595 0.595 0.171 0.172 0.172 0.231 0.231 0.231 125 0.596 0.172 0.231 P8 = P9 = ... = 0.596 0.172 0.231 0.596 0.172 0.231 On remarque bien qu’à partir de la puissance 8, les trois lignes ont des valeurs identiques, ceci implique que les probabilités d’avoir un temps donné après 8 jours sont indépendantes du temps que nous avons eu la journée initiale. En général, quand une CM contient des états transitoires et d’autres récurrents, après un grand nombre d’étapes, le processus passe à une classe récurrente et ne la quitte jamais. Donc si i (n) est transitoire, lim pij = 0 ∀j. Aussi, si i et j appartiennent à deux différentes classes n→+∞ (n) récurrentes, alors pij = 0 ∀n. Donc l’analyse du comportement à long terme prend son sens seulement pour les CM sans états absorbants ; pour cette raison on s’intéresse dans cette section aux CM irréductibles où tous les états appartiennent à la même classe récurrente. Si en plus d’être irréductible, la CM finie (un nombre fini d’états) est apériodique, alors elle est dite ergodique ; (n) et pour toute CM ergodique, la lim pij ∀i, j existe et elle est indépendante de i. n→+∞ À vos claviers! La méthode suivante de la classe CMTD nous permet de tester si une CM est ergodique. #Code401.py (Continuation) # is_ergodic def is_ergodic(self): return (self.is_irreducible() and self.is_aperiodic()) La propriété d’apériodicité est nécessaire car si on considère par exemple la CM décrite par la matrice de transition suivante : 0 1 P= 1 0 (n) Cette chaîne est irréductible mais périodique, ceci dit, que en fonction de n, pij prend alternativement les valeurs 0 et 1 donc , elle n’a pas de limite quand n tend vers l’infini. Toute CMTD finie et irréductible a une distribution stationnaire unique π = (π1 , π2 , π3 , .., π|S| ) 1. Les πj sont indépendante de l’état initial i et sont la solution unique du système d’équations linéaires : X X πj = πk × pkj ∀j ∈ S et πj = 1. j∈S k∈S (n) 2. Si de plus la CM est apériodique, alors, lim pij = πj n→+∞ ∀i, j ∈ S. Le système d’équations précèdent peut être écrit sous la forme : π ×P=π π ×1 = 1 À vos claviers! Le code suivant implémente la méthode qui calcule les probabilités à l’état stationnaire. #Code401.py (Continuation) # steady state probabilities def steady_prob(self): if(not self.is_ergodic()):return None n = len(self.S) A = np.vstack([self.P.T - np.identity(n),np.ones(n)]) B = np.append(np.zeros(n),1) return np.linalg.lstsq(A,B)[0] CHAPITRE 4. CHAÎNES DE MARKOV 126 Exemple 8. La distribution stationnaire dans l’exemple 4 est obtenue par la résolution du système d’équations : 0.7π1 + 0.5π2 + 0.4π3 = π1 0.1π + 0.25π + 0.3π = π 1 2 3 2 0.2π1 + 0.25π2 + 0.3π3 = π3 π +π +π =1 1 2 3 On obtient : π1 = 0.596 π2 = 0.172 π3 = 0.231. La chaîne étant apériodique, celles-ci donc correspondent aux probabilités limites. Dans ce cas, les πi peuvent avoir deux interprétations possibles : 1. Comme des probabilités : dans le futur lointain, une journée sera ensoleillée avec la probabilité 0.596, nuageuse avec une probabilité 0.172 et pluvieuse avec une probabilité 0.231 2. Comme des proportions : à long terme, 59.6% des journées seront ensoleillées, 17.2% nuageuses et 23.1% pluvieuses. Cependant, si la CM est périodique, les πi auront, seulement la deuxième interprétation. À vos claviers! #Code407.py from CMTD import CMTD P = [[0.70, 0.10, 0.20], [0.50, 0.25, 0.25], [0.40, 0.30, 0.30]] print(CMTD(P).steady_prob()) #______________________________ Output #[0.59602649 0.17218543 0.23178808] ______________________________________ Dans une CM à états finis irréductible, E(Tii ) = π1i . Ce résultat peut être expliqué par le fait que n’importe quel état récurrent i peut servir comme état de régénération c’est à dire un état à partir duquel le processus peut recycler. Si on prend un cycle comme le temps entre deux visites successives à l’état i, alors la longueur moyenne d’un cycle est E(Tii ), donc à long terme, le taux moyen de visites de l’état i par unité de temps est E(T1ii ) ce qui représente la proportion de temps que le processus passe à l’état i et qui est donnée par πi . En utilisant la distribution limite et stationnaire on peut déterminer la classe d’un état i d’une CMTD. — i est un état transitoire ou récurrents nul si : (n) lim p n→+∞ ij = 0 ∀i, j ∈ S — i est un état récurrent positif s’il existe une distribution limite donnée par le vecteur π = (π1 , π2 , π3 , ...) tel que : (n) πi = lim pij n→+∞ La distribution limite est obtenue par la résolution du système : π ×P=π π ×1 = 1 En pratique, nous cherchons le vecteur de probabilités stationnaires en résolvant le système précédent, si ce système a une solution unique alors la CMTD est récurrente positive et la distribution stationnaire est la distribution limite de la chaîne ; dans le cas contraire, on conclut que la chaîne est transitoire ou récurrente nulle. CHAPITRE 4. CHAÎNES DE MARKOV 127 Exemple 9. Est ce que la CMTD décrite par le graphe de transition suivant avec 0 < p < 1/2 possède une distribution limite ? p 1-p p 0 p 1 2 1-p 1-p 3 ... 1-p Figure 4.5 – Diagramme de transition Cette CMTD est irréductible et apériodique (puisque nous avons p00 > 0). La résolution du système d’équations : π × P = π et π × 1 = 1 π0 = (1 − p)π0 + (1 − p)π1 πi = pπi−1 + (1 − p)πi+1 Posant α = p 1−p ∀i > 0 : π1 = απ0 πi+1 = απi + πi − απi−1 ∀i > 0 Donc, on a : π1 = απ0 π2 = απ1 = α2 π0 π3 = απ2 = α3 π0 ··· πi+1 = απi = αi+1 π0 ∀i > 0 Puisque π est un vecteur de probabilité alors : ∞ X πk = π0 k=0 ∞ X αk = 1 k=0 La solution est : π0 = 1 − α et πi = α i π0 donne la distribution stationnaire π = (π1 , π2 , π3 , ...), on conclut donc que tous les états sont récurrents positifs (puisque 0 < p < 21 , α < 1) et π est la distribution limite de la CM. CHAPITRE 4. CHAÎNES DE MARKOV 4.3 128 Chaînes de Markov à temps continu Dans une CM à temps discret, le paramètre du temps t est discret (il prend les valeurs 0,1,2,..) et à chaque fois que le processus atteint un état il y passe une unité de temps avant de faire une autre transition. Le temps de séjour du processus dans un état i est égal à 1 si pii = 0 et suit une loi Geometric(1 - pii ) dans le cas contraire. Dans une CM à temps continu par contre, le temps que le processus passe dans un état i est une v.a exponentielle qui a la propriété d’absence de mémoire. Définition 3. Une CM à temps continu "CMTC" (Xt )t≥0 est un processus stochastique Markovien à temps continu (qui vérifie la propriété d’absence de mémoire) : ∀j, i, in−1 , in−2 , ..., i0 ∈ S t > s > tn−1 > tn−2 > ... > t0 P (Xt = j|Xs = i) = P (Xt = j|Xs = i, Xtn−1 = in−1 , Xtn−2 = in−2 , ..., Xt0 = i0 ) Tel que S est l’ensemble discret de tous les états possibles. Si S est fini alors la CM est dite finie sinon elle est dite infinie. 4.3.1 Probabilités de transition Soit la CMTC (Xt )t≥0 et S son ensemble des états : • Xt : est la v.a représentant l’état du système à l’instant t. • pij (t, s) : est la fonction de probabilité de transition en temps continu. Ça représente la probabilité que le processus passe de l’état i à l’état j en une durée de temps égale à t à partir de l’instant s. pij (t, s) = p(X(t+s) = j|Xs = i) Si les probabilités de transition sont indépendantes de s, elle sont dites homogènes pij (t) = pij (t, s) = p(X(t+s) = j|Xs = i) = p(Xt = j|X0 = i) ∀s ≥ 0 La matrice P(t) = [pij (t)] est la matrice de transition en une durée égale à t (la somme de chaque ligne de la matrice est égale à 1 et ses éléments entre 0 et 1,∀t ≥ 0). Lorsque t tends vers 0 la limite de la probabilité que le processus change d’état est nulle, c.à.d que la probabilité que le processus change d’état en une durée de temps infiniment petite est presque nulle. 1 si i=j lim pij (t) = t→0 0 si i 6= j Par conséquent, P(0) = I tel que I est la matrice identité. Exemple 10. Soit la matrice suivante : 1 + e−t N(t) = 1/2 1 − e−t 1 − e−t 1 + e−t Pour que N(t) soit une matrice de transition il faut que la somme de chaque ligne de la matrice soit égale à 1 et les éléments sont entre 0 et 1 : 1/2(1 + e−t + 1 − e−t ) = 1 Puisque 0 ≤ e−t ≤ 1, donc : 0 ≤ transition. 1+e−t 2 ≤ 1 et 0 ≤ 1−e−t 2 ∀t ≥ 0 ≤ 1, alors, N(t) est une matrice de CHAPITRE 4. CHAÎNES DE MARKOV 4.3.2 129 Temps de séjour Le temps que le processus passe dans un état i est appelé le temps de séjour, c’est une v.a qui est notée Ti . Proposition 3. Le temps de séjour Ti suit la loi exponentielle. Démonstration P (Ti > s + t|Ti > s) = P (Xr = i pour 0 ≤ r ≤ s + t|Xr = i pour 0 ≤ r ≤ s) = P (Xr = i pour s ≤ r ≤ s + t|Xr = i pour 0 ≤ r ≤ s) = P (Xr = i pour s ≤ r ≤ s + t|Xs = i) (propriété de Markov) = P (Xr = i pour 0 ≤ r ≤ t|X0 = i) (homogénéité) = P (Ti > t) Donc Ti suit une loi exponentielle. On note λi , le paramètre de la loi de Ti . Quand le processus entre dans l’état i, le temps qu’il passe dans i avant d’aller à l’état j 6= i (si aucune transition vers un autre état n’arrive avant la transition vers l’état j) est aussi une v.a exponentielle notée Tij de taux λij . Ti , le temps de séjour dans i est le minimum des Tij , ∀j 6= i. Si i est un état absorbant alors pii (t) = 1 et λi = 0 ce qui veut dire que le processus va passer un temps infini dans cet état. Quand le processus quitte l’état i, il passe à l’état j avec la probabilité pij (t) satisfaisant : X pii (t) = 0 et pij (t) = 1 j∈S L’état visité après i est indépendant du temps passé dans i. 4.3.3 Équation de Chapman Kolmogorov Pour t > 0, la transition de i vers j en un temps t + s est donné par : X pij (t + s) = pik (t) × pkj (s) k∈S Nous avons : pij (t + s) = P (Xt+s = j|X0 = i) X = P (Xt+s = j|Xt = k, X0 = i) × P (Xt = k|X0 = i) probabilités totales k∈S = X P (Xt+s = j|Xt = k) × P (Xt = k|X0 = i) propriété de Markov k∈S = X P (Xs = j|X0 = k) × P (Xt = k|X0 = i) homogénéité k∈S = X Pik (t) × Pkj (s) k∈S Sous forme matricielle : P(t + s) = P(t)P(s), ∀s, t ≥ 0 4.3.4 Matrice génératrice 1 pij (0) = 0 si i=j si i 6= j CHAPITRE 4. CHAÎNES DE MARKOV 130 Soit h un temps infiniment petit, on définit les quantités suivantes : qij = p0ij (0) = lim h→0 pij (h) − pij (0) pij (h) − 1i=j = lim h→0 h h Nous avons donc : pij (h) = 1i=j + qij h + o(h) Puisque : P j∈S pij (h) = 1 1= X pij (h) = 1 + j∈S X qij h + o(h) = 1 + qii h + j∈S X qij h + o(h) j6=i qii = − X qij j6=i La matrice Q construite des [qij ] est appelée la matrice génératrice (la somme de chaque ligne est égale à 0). P(h) − I Q = lim = P0 (0) h→0 h Tel que I est la matrice identité. Puisque h est suffisamment petit alors : P (Xh = i|X0 = i) = P (Ti > h) = e−λi h = 1 − λi h + o(h) 1 − pii (h) 1 − P (Xh = i|X0 = i) = lim = −qii h→0 h h • Le taux de transition de l’état i est λi = −qii , il représente le nombre moyen de fois que le processus quitte l’état i en une unité de temps passée dans i. λi = lim h→0 −qii = λi = 1 E(Ti ) • Similairement, qij est le taux de transition de l’état i à l’état j, c’est le nombre moyen de fois que le processus quitte l’état i vers l’état j en une unité de temps. Exemple 11. Soit une CMTC dont la matrice de transition est la suivante : 1 + e−t 1 − e−t P(t) = 1/2 1 − e−t 1 + e−t −t −t −e e P0 (t) = 1/2 e−t −e−t −1 1 Q = P0 (0) = 1/2 1 −1 4.3.5 Équations avant et arrière 0 Soit P (t) la dérivée de la matrice P(t) et Q la matrice génératrice de la CMTC. • Les équations avant sont données par : P0 (t) = P(t)Q équivalentes à : X p0ij (t) = pik (t)qkj ∀i, j ∈ S k∈S • Les équations arrière sont données par : P0 (t) = QP(t) équivalentes à : X p0ij (t) = qik pkj (t) ∀i, j ∈ S k∈S CHAPITRE 4. CHAÎNES DE MARKOV 131 Les équations avant : pij (t + s) = X pik (t)pkj (s) k∈S = pij (t)pjj (s) + X pik (t)pkj (s) k6=j ≈ pij (t)(1 + qjj s) + X pik (t)qkj s k6=j = pij (t) + pij (t)qjj s + s X pik (t)qkj k6=j X = pij (t) + s pik (t)qkj k∈S Donc, X pij (t + s) − pij (t) = p0ij (t) = pik (t)qkj s k∈S X p0ij (t) = −λj pij (t) + pik (t)qkj k6=j Les équations arrière : pij (t + s) = X pik (s)pkj (t) k∈S = pij (t)pii (s) + X pik (s)pkj (t) k6=i ≈ pij (t)(1 + qii s) + X qik spkj (t) k6=i = pij (t) + pij (t)qii s + X qik spkj (t) k6=i = pij (t) + s X qik (t)pkj (t) k∈S Ainsi, X pij (t + s) − pij (t) = p0ij (t) = qik pkj (t) s k∈S X p0ij (t) = −λi pij (t) + qik pkj (t) k6=i La solution du système d’équations différentielles P0 (t) = QP(t) = P(t)Q tel que P(0) = I est donnée par : P(t) = eQt + C eQt est la matrice exponentielle : Qt e = ∞ X k=0 Qk tk k! Dans le cas où Q est diagonalisable (Q = UDU−1 ), eQt peut être calculé de la façon suivante : eQt = UeDt U−1 = Udiag(ed1 t , ed2 t , ..., edn t )U−1 Tel que di , 1 ≤ i ≤ n sont les éléments de la matrice diagonale D et diag(ed1 t , ed2 t , ..., edn t ) est la matrice obtenue de l’application de la fonction ex aux éléments de la diagonale de D. CHAPITRE 4. CHAÎNES DE MARKOV 132 Exemple 12. Soit la CMTC (Xt )t≥0 dont la matrice génératrice est : −1/2 1/2 Q= 1/2 −1/2 La solution du système P0 (t) = P(t)Q est eQt + C : Puisque Q est diagonalisable, alors 1 −1 0 0 1 1 Q= 1 1 0 −1 2 −1 1 1 −t 1 1 1 −1 1 −1 0 0 e 1 = eQt = 2 −1 1 1 1 0 e−t 2 −1 1 1 −1 c c −t 11 12 + Donc P(t) = e 2 −1 1 c21 c22 On sait que P(0) = I 1 1 −1 c11 c12 1 0 P(0) = + = 2 −1 1 c21 c22 0 1 e−t 1 P(t) = 2 −1 1 1 + 2 1 1 −1 1 1 La matrice génératrice nous permet de trouver la distribution stationnaire de la CM en utilisant la proposition suivante : Proposition 4. Le vecteur de probabilités π est la distribution stationnaire de X(t) si et seulement si : πQ = 0 Démonstration 1. Si π est une distribution stationnaire, alors π = π P(t). En différentiant des deux côtés nous avons : 0 = π P0 (t) = π QP(t) Puisque P(t) 6= 0 alors π Q = 0 2. Soit π , un vecteur de probabilités qui satisfait π Q = 0. Nous avons P0 (t) = QP(t), donc π P0 (t) = π QP(t) = 0. Sachant que π P0 (t) est la dérivée de π P(t), donc π P(t) ne dépend pas de t. c’est à dire : π P(t) = π P(0) = π , (car P(0) = I), donc π est une distribution stationnaire. 4.3.6 Probabilités stationnaires Une CMTC est irréductible si : ∀i, j ∈ S ∃ t > 0 tel que pij (t) > 0 L’irréductibilité est satisfaite dans presque toutes les applications réelles. Pour les CMTC, la périodicité n’est pas un problème car les temps de transition entre états sont CHAPITRE 4. CHAÎNES DE MARKOV 133 des v.a continues. Si une CMTC est irréductible, alors : lim pij (t) = πj existe toujours et est indépendante de t→∞ l’état initial i. Les valeurs πj sont les probabilités stationnaires de la CM et satisfont : X πj = πi pij (t) ∀j ∈ S et t ≥ 0 i∈S Pour calculer les probabilités stationnaires, il est plus pratique de résoudre le système donné par : π ×Q=0 π ×1 = 1 et qui est équivalent à : π q =P πq j j i6=j i ij P j∈S πj = 1 ∀j ∈ S Les équations obtenues par la première ligne de ce système, sont souvent appelées les équations d’équilibre dans le sens où la partie gauche de l’équation πj qj représente le taux que le processus quitte l’état j à long terme (puisque πj est la probabilité stationnaire d’être dans l’état j et qj est le taux que le processus quitte l’état j), alors que la partie droite πi qij représente le taux que le processus entre dans l’état j (la somme à partir de tous les autres états i) ce qui revient à dire que les deux taux de sortie et d’entrée sont égaux. 4.3.7 Chaîne de Markov intégrée Quand le processus quitte l’état i après un temps exponentiel Ti , il passe à un autre état j avec une probabilité pij appelée la probabilité de saut (jump probability). Cette probabilité est q donnée par pij = λiji pour j 6= i et pii = 0. La matrice P dont les éléments sont les (pij ) est une matrice stochastique qui donne les probabilités de transition en une étape d’une chaîne de Markov discrète appelée la chaîne de Markov intégrée (embeded Markov chain) de la CMTC. La matrice de transition P détermine le comportement probabiliste de la CMTD intégrée, mais ne peut pas représenter le comportement du processus à temps continu car elle ne spécifie pas les taux de transitions du processus. La classification des état d’une CMTC est la même que la classification de sa CMTD intégrée. À vos claviers! #CMTC.py import sys import numpy as np from CMTD import CMTD # CMTD subclass of CMTD class CMTC(CMTD): # constructor def __init__(self,P, lambdas, S = None, pi0 = None ): super().__init__(P ,S ,pi0) n = len(P) self.lambdas=np.array(lambdas) if((len(self.lambdas) != n)or(len(list(filter(lambda x:x<0,self.lambdas))) != 0)): print("lambdas should have ",n," positive values") sys.exit(0) copyP = self.P.copy() np.fill_diagonal(copyP,-1) self.Q = np.matmul(self.lambdas * np.identity(n),copyP) # steady state probabilities def steady_prob(self): n = len(self.S) A = np.vstack([self.Q.T,np.ones(n)]) B = np.append(np.zeros(n),1) return np.linalg.lstsq(A,B)[0] CHAPITRE 4. CHAÎNES DE MARKOV 134 Exemple 13. Soit la CMTC (Xt )t≥0 dont la CM intégrée a le graphe de transition suivant : On suppose que : λ1 = 2, λ2 = 1 et λ3 = 3. 1 1 2 1/2 1 1/2 3 Figure 4.6 – Graphe de transition 1. Trouver la matrice génératrice de la CMTC. 2. Trouver la distribution limite correspondante. 1. La matrice génératrice Q est définie par : λp si i ij qij = −λ si i −2 2 Q= 0 −1 3/2 3/2 i 6= j i=j 0 1 −3 2. La distribution limite est obtenue par la résolution de : πQ = 0 et π1 = 1 Ce qui donne : π=( 3 12 4 , , ) 19 19 19 À vos claviers! #Code408.py from CMTC import CMTC p = [[0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1/2, 1/2, 0.0]] lambdas = [2,1,3] continuous = CMTC(p, lambdas) print(continuous.steady_prob()) #______________________________ Output #[0.15789474 0.63157895 0.21052632] 4.3.8 ______________________________________ Temps moyen du premier passage Soit la CMTC (Xt )t≥0 et soit k un état accessible à partir des autres états. On s’intéresse au temps du premier passage (visite) par l’état k à partir de l’état i. On définit Ti la v.a du temps du premier passage par k à partir de i. Hi (t) = P (Ti > t) = P (Xu 6= k pour 0 ≤ u ≤ t|X0 = i) pour t ≥ 0, i 6= k On définit la CMTC (X̄t )t≥0 tel que l’état k est un état absorbant et sa matrice génératrice : q̄ij = qij 1{i6=k} ∀i, j ∈ S CHAPITRE 4. CHAÎNES DE MARKOV 135 Sa matrice de probabilités de transition : p̄ij (t) = P (X̄t = j|X̄0 = i) = P (Xt = j|X0 = i) et i 6= k et p̄kk (t) = 1. Nous avons donc, Hi (t) = 1 − p̄ik (t). En appliquant l’équation arrière : Hi0 (t) = −p̄0 ik (t) = −(q̄ii p̄ik (t) + X q̄il p̄lk (t)) l6=i = −q̄ii p̄ik (t) − X q̄il p̄lk (t) − q̄ik p̄kk (t) l6=i,k = −qii (1 − Hi (t)) − X qil (1 − Hl (t)) − qik l6=i,k = qii Hi (t) + X l6=i,k = qii Hi (t) + X X qil Hl (t) − qii − qil − qik l6=i,k qil Hl (t) − (qii + l6=i,k Hi0 (t) = qii Hi (t) + X qil + qik ) l6=i,k X qil Hl (t) l6=i,k Ce système peut être écrit : H0 (t) = WH(t) W est la matrice dont les éléments sont (qij ) avec i 6= k et j 6= k. La solution de cette équation différentielle nous donne le complément de la fonction cumulative de la v.a Ti (1 − Hi (t) = FTi (t)). Pour obtenir le temps moyen du premier passage, on calcule son espérance : Z ∞ Z ∞ Z ∞ E(Ti ) = tfi (t)dt = − tHi0 (t)dt = −tHi |∞ + Hi dt 0 0 0 0 Exemple 14. Soit la CMTC (Xt )t≥0 dont la matrice génératrice est : −2 1 1 Q = 1 −2 1 0 2 −2 Trouver le temps moyen du premier passage à partir de tous les états vers l’état 2. H0 (t) = WH(t) −2 1 W= 1 −2 La solution de ce système : H(t) = c1 eλ1 t V1 + c2 eλ2 t V2 tel que λ1 , λ2 , V1 ,V2sont les valeurs propres et les vecteurs propres de W. λ1 = −1 : λ2 = −3 : 1 V1 = 1 −1 V2 = 1 1 −1 H(t) = c1 e−t + c2 e−3t 1 1 CHAPITRE 4. CHAÎNES DE MARKOV 136 Pour calculer c1 et c2 , on considère les conditions initiales : H(0) = 1 . Nous avons donc : c1 = 1 et c2 = 0 Pour calculer E(Ti ), nous avons H0 (t) = H1 (t) = e−t : Z ∞ Hi (t)dt = −(t + 1)e−t |∞ E(Ti ) = −tHi (t)|∞ + 0 = 1 i = 0, 1 0 0 Une méthode plus simple pour calculer le temps moyen du premier passage consiste à appliquer le raisonnement récursif. Soit µi la valeur du temps moyen de passage par l’état k partant de l’état i. Le temps de séjour dans l’état i est égal à 1/λi , le processus va ensuite passer à un autre état j avec une probabilité pij . À partir de j , il atteint l’état k en un temps moyen égal à µj . µi peut donc être obtenu par l’expression récursive suivante : µi = X 1 + pij µj λi pour i 6= k. j6=i,k Sa forme matricielle peut être écrite : Mk = −diag −1 (Q)11 + P(k) Mk Tel que Q est la matrice génératrice de CMTC, Mk le vecteur des Temps Moyens du Premier Passage des autres états vers l’état k et P(k) est la matrice des probabilités de la chaîne intégrée sans la ligne et la colonne k. Ce système a comme solution : Mk = −(I − P(k) )−1 diag −1 (Q)11 diag(Q) est une fonction qui retourne une matrice dont la diagonale est identique celle de Q et les autres éléments sont nuls. Le résultat obtenu par cette méthodes est : µ0 = 1 et µ1 = 1. Cette équation exprime que ce temps est composé de deux parties, la première représente le temps de séjour dans l’état actuel et la deuxième représente le temps moyen pour atteindre k à partir des autres états vers lesquels le processus a transité après l’expiration de son séjour dans l’état i. À vos claviers! #CMTC.py (Continuation) # hitting_time : average time to hit for the first time the state given in the argument def hitting_time(self,state): i = self.S.index(state) I = np.identity(len(self.S)-1); lambdas_inv = np.delete(np.reciprocal(self.Q.diagonal()),i) PK = np.delete(np.delete(self.P,i,0),i,1) return -np.matmul(np.linalg.inv(I-PK), lambdas_inv) À vos claviers! #Code409.py from CMTC import CMTC p = [[0.0, 0.5, 0.5], [0.5, 0.0, 0.5], [0, 1, 0.0]] lambdas = [2,2,2] continuous = CMTC(p, lambdas) print("Hitting time: ",continuous.hitting_time(3)) #______________________________ # Hitting time: [1. 1.] Output ______________________________________ CHAPITRE 4. CHAÎNES DE MARKOV 4.4 137 Application : PageRank Algorithm PageRank est un algorithme d’analyse des liens utilisés par le moteur de recherche Google pour le classement des pages web. PageRank modélise le web par un graphe orienté dont les sommets sont l’ensemble des pages web et les arcs sont les hyperliens entre elles, cette structure est appelée le graphe web. Les liens entrants (Ii ) et sortants (Oi ) de la page i déterminent l’importance de cette page. Les liens provenant des pages importantes apportent plus de poids que ceux provenant de pages moins importantes, et une page partage équitablement son poids sur ses successeurs. Soient : N le nombre total de pages. Ii l’ensemble des pages pointants vers i. Oi l’ensemble des pages vers lesquelles i pointe. Afin de représenter le processus de navigation dans le graphe web, Google l’a modélisé par une CMTD dont les états (l’ensemble S) sont l’ensemble des pages, et la matrice de transition est appelée la matrice de Google (G), et elle est construite de la façon suivante : G = dH + (1 − d)E Tel que : 0 < d < 1 une constante qui représente la probabilité de suivre les liens des pages (ne pas redémarrer la navigation). H est une matrice de taille N × N définie par : hij = |O1i | si i ∈ Ij et 0 sinon. E est une matrice de taille N × N définie par : eij = N1 ∀ 1 ≤ i, j ≤ N G est une matrice stochastique car : 1. Chaque élément de la ligne i de la matrice dH est égal à |Odi | 1j∈Oi , sa somme est égale à d. 2. La somme de chaque ligne de (1 − d)E est égale à 1 − d. Donc tous les éléments de G sont entre 0 et 1 et la somme de chaque ligne est 1. La CMTD définie par G est apériodique et irréductible, elle admet donc un vecteur de probabilités stationnaire unique [reference]. Le vecteur de probabilités stationnaire π de la chaîne est obtenu par le système d’équations : π = PN π g i j=1 j ji PN π = 1 i=1 i Nous avons : πi = N X j=1 πj gji = N X j=1 πj d 1−d X d 1−d X + πj = + πj N |Oj | N |Oj | j∈Ii j∈Ii On définit Ri le rang de la page i comme la quantité N πi . Ce qui vérifie la relation récurrente utilisée par Google pour déterminer le classement des pages web. Ri = (1 − d) + X j∈Ii Rj d |Oj | À vos claviers! #Code410.py import numpy as np from CMTD import CMTD def getRankPage(G,d): N = len(G) _output = list( map(lambda x: 0 if list(x).count(1) == 0 else 1/list(x).count(1) , G)) M = np.identity(N) - d * np.multiply(np.array(_output), G.T).T CHAPITRE 4. CHAÎNES DE MARKOV M = np.vstack([M.T ,np.ones(N)]) B = np.hstack([np.ones(N)*(1-d), N]) return np.linalg.lstsq(M,B)[0] # Test with getRankPage d = 0.85 A = np.array([[0, 1, 1], [1, 0, 0], [0, 1, 0]]) print(’R : ’, getRankPage(A,d)) # Test with the steady state computation G = [[0.050, 0.475, 0.475], [0.900, 0.050, 0.050], [0.050, 0.900, 0.050]] print( ’R : ’, CMTD(G).steady_prob()*3) #______________________________ Output # R : [1.16336914 1.19219898 0.64443188] # R : [1.16336914 1.19219898 0.64443188] ______________________________________ 138 CHAPITRE 4. CHAÎNES DE MARKOV 4.5 139 Exercices Exercice 1. Pour la prévision de la température d’une ville donnée, à la fin de chaque journée elle est enregistrée. Si elle a augmenté, la probabilité qu’elle augmente demain est 0.6, si elle a baissé, la probabilité qu’elle augmente demain est 0.7. 1. Représenter ce système par une CMTD 2. Supposons que le modèle a changé de sorte que la température de demain dépend de celle d’hier et d’aujourd’hui : elle augmente avec une probabilité 0.8 si elle a augmenté aujourd’hui et hier. Si elle a augmenté aujourd’hui et baissé hier, elle augmente demain avec une probabilité 0.4. Si elle a baissé aujourd’hui et augmenté hier, alors elle augmente demain avec une probabilité de 0.5 et si elle a baissé aujourd’hui et baissé hier alors elle augmente demain avec une probabilité de 0.3. Représenter le système par une CMTD. 3. Coder l’exercice en Python. Exercice 2. Soit un joueur qui possède 2 dinars initialement ; à chaque étape du jeu, il peut gagner 1 dinar avec une probabilité p ou en perdre 1 dinar avec une probabilité 1 − p. Il s’arrête lorsqu’il a gagné 4 dinars ou lorsqu’il a tout perdu. 1. Représenter cette expérience par une CMTD. 2. Donner la classification des états de cette CMTD. 3. Avec p=1/3, calculer la probabilité que le joueur perd tout. 4. Déterminer la valeur de p pour que la probabilité de tout perdre soit égale à 1/2. 5. Écrire le Code Python qui détermine les classes de cette CMTD pour p=1/3. Exercice 3. Pour l’obtention d’un certificat, chaque candidat doit réussir deux tests (test du niveau1 et test du niveau2). Pour passer le test du niveau2 il faut réussir celui du niveau1. En cas d’échec, il est possible de refaire chaque test une seule fois. Quelqu’un qui refait un test et l’échoue, est automatiquement exclu. Chaque participant a une probabilité p de réussir chaque test (q = 1−p est la probabilité d’échec). 1. Modéliser par une CMTD le parcours de chaque candidat. 2. Après avoir passé deux tests, quels sont les états possibles dans lesquels un candidat peut se retrouver ? 3. Pour p = 2/3, quelle est la probabilité qu’un candidat obtienne son certificat. 4. Écrire le code qui détermine le temps moyen de réussite. Exercice 4. Avec des amis vous jouez au jeu suivant : trois bougies numérotées de 1 à 3 sont sur une table. Un dé est lancé de façon répétée. Si le résultat est 1 ou 6 alors la première bougie est allumée si elle est éteinte ou éteinte si elle est allumée. La même chose est faite avec la deuxième bougie si le résultat obtenu est 2 ou 5 et avec la bougie 3 si le résultat est 3 ou 4. Initialement, les trois bougies sont éteintes, soit N le nombre de lancers de dé nécessaires jusqu’à ce que les trois bougies soient allumées (la fin du jeu). Calculer E(N ). Exercice 5. Soit (Xn )n≥0 une CMTD définie S = {1, 2, 3, 4, 5} 1/4 0 1/4 1/2 P = 1/3 0 0 0 0 0 par : 3/4 0 1/4 0 1/3 0 0 0 0 1 0 0 1/3 1 0 1. Classer les états de cette chaîne et calculer leur période. 2. Quel est le temps moyen du premier passage par l’état 4 ? 3. Écrire le code Python qui détermine les classes de cette CMTD et calcule le temps moyen du premier passage par l’état 4. CHAPITRE 4. CHAÎNES DE MARKOV 140 Exercice 6. Soit (Xn )n≥0 une CMTD définie par S = {1, 2, 3, 4} et P : 1 0 0 0 1/4 0 3/4 0 P= 0 1/3 0 2/3 0 0 0 1 1. Dessiner le graphe de transition et classer les états de cette chaîne. 2. Calculer la probabilité et le temps moyen d’absorption partant de l’état 2 ? 3. Coder la question 2 en Python. Exercice 7. Soit la CM décrite par la matrice de transition suivante. 1/4 3/4 0 P = 0 1/2 1/2 1/3 2/3 0 1. Trouver tk1 , le temps moyen du premier passage par l’état 1 partant de l’état k (pour k = 2, 3). 2. Trouver r1 , le temps moyen de retour à l’état 1. 3. Écrire le code Python qui calcule le temps moyen de retour à l’état 1. Exercice 8. On suppose que le revenu d’une personne dépends du revenu de ses parents, la relation est donnée par la matrice suivante. Par exemple si le père a un revenu élevé, son fils aura un revenu moyen avec une probabilité 0.4. S = {F, M, E} : 0.5 0.3 0.2 P = 0.2 0.6 0.2 0.1 0.4 0.5 F : faible, M : moyen, E : élevé 1. Quelle est la probabilité que le revenu du petit fils d’une famille de faible revenu, soit élevé. 2. À long terme quel est le pourcentage de la population à faible revenu. 3. Coder en Python la question 2. Exercice 9. Soit un système informatique client/serveur : - le client envoie des requêtes et le serveur retourne la réponse correspondante. - le serveur peut avoir une mémoire tampon pour stocker les requêtes dont la taille peut être illimitées. Le système a trois composantes Client(Requête), Mémoire Tampon et Serveur sera noté : [λ, m = 1, k = 1, µ, n = 1] - λ : taux d’arrivée des requêtes. - m : nombre de requêtes envoyées (par défaut 1) - k : mémoire tampon de taille k (* infinie) (par défaut 1) - n : nombre de serveurs (par défaut 1) - µ : taux de service des serveurs disponibles Quand un élément est omis, il prend la valeur par défaut. Dans le cas d’une mémoire de taille 0, les requêtes reçues lorsque le serveur est occupé, sont perdues. Soient les cas suivants : 01 − [λ, , 0, µ, ] 02 − [λ, , , µ, ] 03 − [λ, , 2, µ, ] 04 − [λ, , k − 1, µ, ] 05 − [λ, , ∗, µ, ] 06 − [λ, , 0, µ, 2] 07 − [λ, , , µ, 2] 08 − [λ, , 2, µ, 2] 09 − [λ, , k, µ, 2] 10 − [λ, , ∗, µ, 2] 11 − [λ, , 0, µ, n] 12 − [λ, , k, µ, n] 13 − [λ, , ∗, µ, n] 1- Modéliser chaque cas comme une CMTC en donnant les états et le diagramme de transition. CHAPITRE 4. CHAÎNES DE MARKOV 141 Exercice 10. Soit un système de production dont les éléments sont : - Le producteur (P ) : est l’entité qui produit k unités d’un produit A (par défaut 1) - Le stockage (S) : est une zone de stockage intermédiaire de taille M où le produit A est déposé ou retiré. - Le consommateur(C) : est l’entité qui consomme A en retirant h unités (par défaut 1) Le système est noté [λ, k, S, µ, h] - λ : taux de production. - k : nombre d’unités de A produites simultanément par P (un lot). - S : la capacité max du stockage temporaire (par défaut 1). - µ : taux de consommation. - h : nombre d’unités A retirées et consommées simultanément par C (par défaut 1). Soient les cas suivants : 1 − [λ, 1, 1, µ, 1] 2 − [λ, 1, 4, µ, 1] 3 − [λ, 2, 6, µ, 1] 4 − [λ, 2, 8, µ, 3] 1- Modéliser chacun de ces cas par une CMTC en donnant le diagramme de transition. Exercice 11. Soit la matrice P(t) suivante : P(t) = D + f (t)A - D est une matrice de transition constante de même dimension que P . - A est une matrice constante de même dimension que P . - f est une fonction positive. 1- En donnant D, quelles sont les conditions sur f et A pour que P(t) soit une matrice de transition pour une CMTC. 2- Trouver les matrices A entières non nulles pour f (t) = e−t /2 tel que : a b 1/2 1/2 A= D= c d 1/2 1/2 Exercice 12. Soit une population de n individus. On considère initialement qu’il existe une personne infectée d’une maladie contagieuse, et que les temps entre le contact de n’importe quels deux individus de la population suit une loi exponentielle de taux λ et que les temps entre les différents contacts sont indépendants les uns des autres. Si une personne saine contacte une personne infectée, elle devient infectée elle aussi. Une fois infectée, une personne le reste toujours. Modéliser la propagation de la maladie par une CMTC. Exercice 13. Les clients arrivent suivant un processus de poisson de taux λ à un distributeur automatique de boisson. Chaque client prend une seule unité. Lorsque le distributeur est vide, toutes les demandes qui arrivent sont perdues. Le distributeur est rempli seulement lorsqu’il est vide ; et son remplissage arrive suivant un processus de poisson de taux µ qui est indépendant de celui des arrivées des demandes. Le temps de remplissage est négligeable et la quantité remplie est toujours égale à N unités. Proposez un modèle de CMTC à cette description. Exercice 14. Un système électronique utilise une unité d‘opération, et possède n-1 autres unités de remplacement. La durée de vie de chaque unité est exponentiellement distribuée de taux λ. Si l’unité en opération tombe en panne, elle est immédiatement remplacée par une autre unité qui fonctionne si disponible. Il existe suffisamment de réparateurs, et chaque unité en panne passe directement en réparation. Le temps de réparation est exponentiellement distribué de taux µ. Une unité réparée est aussi bonne qu’une nouvelle unité. Modéliser le nombre d’unités en réparation par une CMTC. Exercice 15. Soit la CMTC (Xt )t≥0 dont la CM intégrée a le graphe de transition suivant : On suppose que : λ1 = 1, λ2 = 2, λ3 = 1 et λ4 = 1. 1. Trouver la matrice génératrice de la CMTC. 2. Trouver la distribution limite correspondante. 3. Calculer le temps moyen du premier passage par l’état 4. 4. Coder en Python la question 2 et 3. CHAPITRE 4. CHAÎNES DE MARKOV 142 1/3 1 1 1/3 4 2 1/3 1 1 3 Figure 4.7 – Graphe de transition 4.6 Solutions Solution 1. 1- Soit S = {0, 1} l’ensemble des états. • L’état 0 représente l’augmentation de la température • L’état 1 représente la baisse de la température. La matrice de transition de cette chaîne est définie par : 0.6 0.4 P= 0.7 0.3 2- Si on garde le même ensemble d’états que la question 1, la propriété d’absence de mémoire sera perdue car le futur dépendra du présent et aussi du passé. Pour retrouver cette propriété, nous définissons un nouvel ensemble d’états S = {0, 1, 2, 3} tel que : • L’état 0 : la température a augmenté aujourd’hui et hier • L’état 1 : la température a augmenté aujourd’hui et baissé hier • L’état 2 : la température a baissé aujourd’hui et augmenté hier • L’état 3 : la température a baissé aujourd’hui et baissé hier Nous obtenons la matrice de transition suivante : 0.8 0 0.2 0 0.4 0 0.6 0 P= 0 0.5 0 0.5 0 0.3 0 0.7 Le premier élément de la deuxième ligne par exemple : représente la probabilité que la température augmente demain et aujourd’hui sachant qu’elle a augmenté aujourd’hui et baissé hier, ceci n’est rien que la probabilité d’augmenter demain sachant qu’elle a augmenté aujourd’hui et baissé hier qui est égale à 0.6. La probabilité est égale à 0 dans le cas ou il y a des événements contradictoires. Solution 2. 1- Soit (Xn )n≥0 la v.a représentant le nombre de dinars que le joueur possède à l’instant n. l’ensemble des états est : S = {0, 1, 2, 3, 4}. La matrice de transition est la suivante : 1 0 0 0 0 1 − p 0 p 0 0 P= 0 1−p 0 p 0 0 0 1 − p 0 p 0 0 0 0 1 CHAPITRE 4. CHAÎNES DE MARKOV 143 p p 1-p 1 p 0 1 2 3 1-p 4 1 1-p Figure 4.8 – Graphe de transition 2- Les classes de cette chaîne sont : - {0} est une classe récurrente (0 est état absorbant) - {4} est une classe récurrente (4 est état absorbant) - {1, 2, 3} est une classe transitoire (puisqu’il existe une probabilité non nulle d’aller des états de cette classe vers les états absorbants). 3- La probabilité que le joueur perd tout est la probabilité d’être absorbé par l’état 0 partant de l’état 2 : a20 et qui peut être calculée par le système suivant : a = 23 + 31 × a20 10 a20 = 23 × a10 + 31 × a30 a = 2 ×a 30 3 20 a20 = 54 4- On résout le système d’équations de la question 3 avec p quelconque (q = 1 − p) : a = q + pa20 10 a20 = qa10 + pa30 a = qa 30 Donc : a20 = Pour : a20 = On a : p = 21 p2 2p2 −2p+1 p2 1 2 =⇒ 2p2 −2p+1 = 20 1 2 Solution 3. 1- S = {t1 , r1 , t2 , r2 , R, E} 1. t1 : passer le premier test la première fois. 2. r1 : répéter le premier test. 3. t2 : passer le deuxième test la première fois. 4. r2 : répéter le deuxième test. 5. E : être exclu 6. R : réussir (obtention du certificat) La matrice de transition est : 0 q 0 0 0 0 P= 0 0 0 0 0 0 p 0 0 p 0 q 0 q 0 0 0 q 0 0 1 0 0 0 2- π 0 = (1, 0, 0, 0, 0, 0), π 2 = π 0 P2 Après deux tests, le candidat peut se retrouver dans : - R avec une probabilité p2 , 0 0 p p 0 1 CHAPITRE 4. CHAÎNES DE MARKOV 144 p 1 p q 2 3 q 5 q p 4 q p 6 1 1 Figure 4.9 – Graphe de transition - E avec une probabilité q 2 , - t2 avec une probabilité qp, - r2 avec une probabilité pq 3- Le système suivant doit être résolu tel que aER = 0 et aRR = 1 : 2 1 at1 R = 3 ar1 R + 3 at2 R 1 2 a r1 R = 3 at2 R + 3 aER at2 R = 13 ar2 R + 32 aRR 1 2 a r2 R = 3 aER + 3 aRR at1 R = 16 27 Solution 4. On peut définir une CM avec l’ensemble des états S={0,1,2,3}, chaque état représente le nombre de bougies allumées. Le 3 est donc un état absorbant, et la matrice de transition est la suivante : 0 1 0 0 1/3 0 2/3 0 P= 0 2/3 0 1/3 0 0 0 1 2/3 1 0 1/3 1 2 1/3 3 1 2/3 Figure 4.10 – Graphe de transition Pour trouver E(N ), qui est , en fait, le temps moyen d’absorption de la chaîne par l’état 3 partant de l’état 0 ; on doit résoudre le système suivant tel que n3 = 0 : n0 = 1 + n1 n1 = 1 + 13 n0 + 23 n2 n = 1 + 2n + 1n 2 E(N ) = n0 = 10 Solution 5. 1. C1 = {1, 3} : transitoire, période=1 C2 = {2} : transitoire, période=1 3 1 3 3 CHAPITRE 4. CHAÎNES DE MARKOV 145 3/4 1/4 1 1/4 1/3 3 1/3 1/4 1/3 1 1/2 2 5 4 1 Figure 4.11 – Graphe de transition C3 = {4, 5} : récurrente, période=2 2. Pour trouver le temps moyen du premier passage, on doit résoudre le système d’équations suivant : X ti4 = 1 + pik tk4 tel que t44 = 0 et t54 = 1 + t44 = 1 t 14 t24 t = 1 + 14 t14 + 34 t34 = 1 + 14 t14 + 12 t24 + 41 t34 = 1 + 13 t14 + 13 t34 + 31 t54 34 Nous avons donc : t14 = 20 3 t24 = 8 t34 = 16 3 t54 = 1 Solution 6. 1. Les classes de cette CMTD sont : 3/4 1 1 1/4 2 3 2/3 4 1 1/3 Figure 4.12 – Graphe de transition C1 = {1} : absorbant, C2 = {2, 3} : transitoire, C4 = {4} : absorbant 2. Cette chaîne contient deux états absorbants : 1 et 4. La probabilité d’absorption à partir de l’état 2 est donc la somme des probabilités d’absorption par 1 et par 4 partant de 2. On doit résoudre les deux systèmes d’équations suivants tel que a1 = 1, a4 = 0, b1 = 0 et b4 = 1 : a = 1a + 3a 2 4 1 4 3 a = 1a + 2a 3 La solution est : a1 = 1 a2 = 1 3 a3 = b 2 b 3 3 2 1 9 3 4 a4 = 0 = 41 b1 + 34 b3 = 13 b2 + 23 b4 La solution est : b1 = 0 b2 = 23 b3 = 89 b4 = 1 a2 + b2 = 1, donc partant de 2, la chaîne sera certainement absorbée soit par l’état 1 avec une probabilité 1/3 ou bien par l’état 4 avec une probabilité 2/3. CHAPITRE 4. CHAÎNES DE MARKOV 146 Solution 7. 1. Pour calculer t21 et t31 on utilise la loi de probabilité totale avec récursion tel que t11 = 0 : t = 1 + 1t + 1t 21 2 21 2 31 t = 1 + 1t + 2t 31 La solution est t21 = 9 et t31 = 7 2. r1 = 1 + 14 t11 + 34 t21 = 1 + 34 × 9 = 3 11 3 21 31 4 Solution 8. 1. Nous avons S = {F, M, E}, π0 = (1, 0, 0) et π2 = π0 P 2 = (0.33, 0.41, 0.26). La probabilité que le revenu du petit fils d’une famille de faible revenu, soit élevé est : 0.26 2. Cette CM est ergodique : 1) irréductible car tous les états communiquent, et 2) apériodique car la période est égale à 1 (p00 >0). Elle admet donc une distribution stationnaire limite qui peut être calculée par le système : π P = π et π 1 = 1 23 2 et qui donne comme solution : π = ( 12 49 , 49 , 7 ) Le pourcentage de la population à faible revenu est : 24.48% Solution 9. Les états de la CMTC représentent le nombre de requêtes dans le système. λ 0 1. [λ, , 0, µ, ] 1 µ λ λ 0 1 µ µ λ λ 0 λ 1 2 µ λ 1 µ 2 3 µ µ λ λ λ 1 µ λ 4. [λ, , k − 1, µ, ] k k-1 λ 3 ... k µ ... k+1 5. [λ, , ∗, µ, ] µ λ 0 1 6. [λ, , 0, µ, 2] 2 µ 2µ λ λ 0 λ 1 2 2µ 2µ λ λ λ 1 2 µ λ 1 2µ λ 3 2µ 8. [λ, , 2, µ, 2] 4 2µ λ 2 2µ λ 3 2µ λ 7. [λ, , , µ, 2] 3 µ 0 µ ... µ 2 µ 0 λ λ µ 0 3. [λ, , 2, µ, ] 3 µ λ 0 2. [λ, , , µ, ] 2 ... k+1 k+2 2µ ... 9. [λ, , k, µ, 2] CHAPITRE 4. CHAÎNES DE MARKOV λ λ 0 1 µ λ λ 2 2µ λ 1 3 ... 10. [λ, , ∗, µ, 2] n n-1 nµ 3µ λ 0 147 λ λ λ 2 3 ... n n-1 µ 2µ 3µ nµ nµ λ λ λ λ λ 0 1 2 3 µ 2µ 3µ λ λ λ 0 1 µ n n-1 nµ 3 ... n+1 ... n+k 12. [λ, , k, µ, n] n+k-1 nµ λ n n-1 nµ 3µ λ nµ λ 2 2µ ... 11. [λ, , 0, µ, n] n+1 n+1 ... 13. [λ, , ∗, µ, n] nµ Solution 10. λ 0 1 µ λ λ 0 1 3 µ 0 λ 2 µ 4 µ µ λ λ λ λ λ 1 2 3 4 5 µ 0 λ µ µ µ 6 µ µ λ λ λ λ λ λ λ 1 2 3 4 5 6 7 µ µ µ µ µ 8 µ Solution 11. 1. Pour que P(t) soit une matrice de transition, il faut qu’elle soit stochastique. A et f doivent donc satisfaire les conditions suivantes : 1.1. La somme de chaque ligne de A soit égale à 0. 1.2. Les éléments de P(t) doivent être des entre 0 et 1, donc : 0 ≤ dij + f (t)aij ≤ 1 =⇒ 0 ≤ f (t) ≤ max(− dij 1 − dij , ) aij aij ∀t, i, j si aij 6= 0 −t 1 2. De 1.1 et 1.2 on peut déduire que a = −b, c = −d donc 0 ≤ e 2 ≤ 2|a| puisque 0 ≤ e−t ≤ 1 1 donc |a| ≥ 1 =⇒ |a| ≤ 1 donc a ∈ {−1, 0, 1} De la même façon on obtient |c| ≤ 1 donc c ∈ {−1, 0, 1} avec a 6= 0 et c 6= 0 simultanément. Solution 12. Soit (Xt )t≥0 la séquence qui représente le nombre d’individus infectés à l’instant t. S = {1, .., n} Si nous avons i personnes infectées alors le temps jusqu’à ce qu’une des n − i personnes susceptibles de devenir infectée est le min des (n − i) ∗ i v.a exponentielles de taux λ. qi,i+1 = (n − 1) × i × λ pour i = 1, 2, ..., n − i. CHAPITRE 4. CHAÎNES DE MARKOV 148 λ(n − 1)2 λ(n − 1) 2λ(n − 1) 1 2 3 ... n n-1 Figure 4.13 – Graphe de transition Solution 13. Soit (Xt )t≥0 la séquence qui représente le nombre d’unités de boissons dans le distributeur à l’instant t. S = {0, 1, ..., N }. La propriété de Markov est satisfaite du fait que les processus de Poisson sont sans mémoire, c.à.d qu’à n’importe quel moment, le temps passé depuis l’arrivée du dernier événement, n’affecte pas l’arrivée des futurs événements. qi,i−1 = λ, qi,j = 0 pour j 6= i − 1 et q0,N = µ, q0,j = 0 pour j 6= N . µ 0 1 2 λ 3 λ ... N N-1 λ λ Figure 4.14 – Graphe de transition Solution 14. Soit (Xt )t≥0 la séquence qui représente le nombre d’unités en réparation à l’instant t. S = {0, 1, ..., n}. Le minimum de i v.a de taux µ suit une loi exponentielle de taux i×µ. Si à un instant donné t, il existe i unités en réparation, alors qi,i−1 = i×µ pour 1 ≤ i ≤ n. et qi,i+1 = λ pour 0 ≤ i ≤ n−1. λ 0 λ 1 µ λ λ 2 ... i i-1 2µ ... nµ iµ Figure 4.15 – Graphe de transition Solution 15. 1. La matrice génératrice Q est définie par : λp i ij qij = −λ i −1 0 Q= 0 1 si i 6= j si i = j 1/3 1/3 −2 2 0 −1 0 0 1/3 0 1 −1 2. La distribution limite est obtenue par la résolution de : πQ = 0 et π1 = 1 Ce qui donne : π=( n n-1 6 1 4 6 , , , ) 17 17 17 17 CHAPITRE 4. CHAÎNES DE MARKOV 149 3. On calcule le temps moyen de passage par l’état 4 par la méthode récursive : µi = X 1 + pij µj λi pour j6=i,k µ = 1 + 13 µ2 + 13 µ3 1 µ2 = 12 + µ3 µ =1 3 3 ce qui donne la solution : (µ1 , µ2 , µ3 ) = ( 11 6 , 2 , 1) i 6= 4. Chapitre 5 Application aux modèles de files d’attente 5.1 Introduction Les files d’attente est une classe de modèles permettant d’étudier les systèmes offrant des services. La formation d’une file d’attente commence lorsque la demande au service dépasse la capacité des serveurs (entités offrant le service). Vu l’aspect non déterministe (aléatoire) d’arrivée des demandes, les décideurs s’affrontent souvent à la problématique de prédire le temps qui sera nécessaire pour servir les demandes, ce qui permettra de décider du nombre et/ou de la fréquence nécessaire des serveurs. Pouvoir prendre ces décisions aide d’un côté à éviter d’offrir un excès de service, chose qui engendre des coûts non nécessaires (coûts de serveurs inoccupés) ; et de l’autre côté, ça évite les attentes trop longues aux services ce qui engendre la perte des demandes (souvent des clients) ou parfois des coûts sociaux inutiles. L’objectif est donc de trouver le bon compromis entre le coût de service et le coût d’attente. L’utilisation des modèles de files d’attente aide à calculer certaines mesures de performance du système, comme le temps d’attente moyen des clients que les décideurs utilisent pour trouver ce compromis. Dans cette classe de modèles le système à étudier est appelé station où les clients (demandes) arrivent pour recevoir un service. Si les serveurs sont occupés, ils attendent leur tour pour être servi ; et une fois servi, ils quittent le système. Un exemple courant de ce type de systèmes est le service d’urgence dans un hôpital, où les patients (clients) arrivent pour recevoir un traitement (le service) par un médecin (le serveur). Quand le médecin est entrain de traiter un patient, les malades qui viennent doivent attendre leur tour (file d’attente). Le directeur de l’hôpital doit décider du nombre de médecins à mettre en service pour limiter le temps d’attente des patients tout en limitant les heures oisives des médecins. La figure 5.1 schématise un système de file d’attente. La même description s’applique à beaucoup d’autres systèmes tel que les systèmes de services administratifs, commerciaux, de transport, informatique... Figure 5.1 – Un système de file d’attente élémentaire 150 CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 5.2 151 Composants d’un système de files d’attente Les éléments qui constituent un système de file d’attente sont : • La file d’attente : peut être finie ou infinie. Quand un client essaye d’entrer dans la station dont la file d’attente est pleine et limitée, on considère qu’il est perdu. • Le client : c’est l’entité qui reçoit le service offert par le système. • Le serveur : on parle d’un mono serveur lorsqu’il y a un serveur qui traite les clients les uns après les autres. On parle de multiserveurs quand plusieurs clients sont servis en même temps par plusieurs serveurs. • La discipline de service : c’est l’ordre dans lequel les clients dans une file seront servis. La discipline par défaut est FIFO (First In First Out : premier arrivé premier servi). Si une autre discipline est utilisée, il faut la préciser (Round Robin, LIFO,...) • Le processus d’arrivée : décrit le temps entre deux arrivées successives de clients. Ce temps peut être déterministe (il faut donner sa valeur) ou bien aléatoire (il faut préciser la loi et les paramètres qui permettent de la définir) • Le processus de service : décrit le temps que met un serveur pour traiter un client. (même remarque que le processus d’arrivée) 5.3 Notation de Kendall A/B/C/K/P/D Les différents modèles des files d’attente peuvent être classés et caractérisés par les propriétés des systèmes qu’ils modélisent et du type et du contexte de l’application. En 1958, Kendall a proposé une notation pour représenter chaque type de ces modèles qui a été standardisé par la suite. Le schema de la notation actuelle comporte 6 références de classification et il a la forme suivante A/B/C/K/P/D (P et D sont souvent omises) tel que : — A et B : processus d’arrivée et de service. Peuvent prendre les valeurs : — M : Distribution exponentielle (Markovienne) — D : Distribution dégénérée (prenant une valeur constante). — Ek : Distribution Erlang (de paramètre k). — G : Distribution Générale. — C : Nombre de serveurs. — K : Capacité du système (omise si infinie). — P : Population (omise si infinie). — D : Politique du service (FIFO par défaut). Le modèle M/M/s par exemple considère le temps inter-arrivées et le temps de service de distribution exponentielle, le nombre de serveurs est s et la taille de la file est infinie. Le modèle M/G/1 a un temps inter-arrivées exponentiel, mais il n’y a aucune restriction sur la distribution du temps de service, seules l’espérance et la variance de cette distribution sont nécessaires à connaître (ou à estimer), il existe un seul serveur et la file est de taille infinie. Dans le cas du M/D/s, le temps inter-arrivées est exponentiellement distribué et le temps de service est constant et le système possède s serveurs. 5.4 Étude de station L’étude d’une station donnée permet de déterminer ses performances. Afin de les trouver analytiquement, nous utilisons les notations suivantes : CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 152 λ : Taux moyen d’arrivées (nombre moyen des arrivées par unité de temps) µ : Taux moyen de service (nombre moyen de clients complétant le service par unité de temps) πn : Probabilité d’avoir n clients dans le système. L : Nombre moyen de clients dans la station (clients en attente+clients entrain d’être servis). Lq : Nombre moyen de clients dans la file d’attente(excluant les clients entrain d’être servis). W : Temps moyen de réponse à un client (entre l’entrée et la sortie de la station). Wq : Temps d’attente moyen dans la file d’attente. ρ : Facteur d’utilisation. C’est à dire la fraction de temps moyen pendant lequel les serveurs individuels sont occupés. ρ= B λ = B+I sµ B est la durée de temps d’occupation du serveur pendant la période d’exploitation. I est la durée de temps pendant laquelle le serveur est libre. Si, en une unité de temps, chaque serveur peut servir µ clients et que le système en reçoit λ clients clients alors chacun des serveurs aura un taux d’occupation moyen égal à λ/s µ clients = ρ. 5.4.1 Loi de Little Soient les processus suivants : L(t) le nombre de clients dans le système à l’instant t. A(t) le nombre de clients qui sont arrivés dans le système à l’instant t. D(t) le nombre de clients qui ont quitté le système (après avoir reçu le service) à l’instant t. Wk le temps total passé par le client k dans le système. L(t) = A(t) − D(t) λ = lim t→∞ A(t) t Figure 5.2 – Loi de Little H(t) est la surface comprise entre la courbe A(t) et celle de D(t). Elle est égale à la somme du temps total passé par les clients qui sont arrivés avant l’instant t. Z H(t) = A(t) t L(s)ds = 0 X Wi i=1 En divisant par t on aura : 1 t Z t L(s)ds = 0 PA(t) A(t) Wi 1X A(t) Wi = × i=1 t i=1 t A(t) CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 1 lim t→∞ t Z t 0 A(t) L(s)ds = lim ( × t→∞ t 153 PA(t) Wi ) A(t) i=1 Quand ces limites existent, nous obtenons L=λ×W De la même façon on peut démontrer que : Lq = λ × Wq 1 W = Wq + µ ( 1 est le temps moyen de service) µ Pour connaître les performances L, Lq ,W et Wq , il faut et il suffit de calculer πn pour n ∈ N : la probabilité d’avoir n clients dans la station. Les relations entre les indicateurs de performance. - Le nombre moyen de clients dans le système : L= ∞ X nπn n=0 - Le nombre moyen de clients dans la queue (il y a s serveurs dans le système) : Lq = ∞ X (n − s)πn = n=s ∞ X nπn − s n=s ∞ X πn = L − s(1 − n=s s−1 X πn ) n=0 - Le temps de réponse moyen : L λ - Le temps d’attente moyen dans la file (le temps de réponse - temps de service) : W = Wq = W − 1 µ À vos claviers! #Code501.py from math import factorial # Queueing Class class Queueing(object): # constructor def __init__(self, model=’MM1’, self.model = model A=’M’ ,B=’M’ ,C=1, K=-1, P=None, D=’FIFO’, laws =None): self.s, self.k = C, K self.lamda, self.mu = A[’params’][’lambda’], B[’params’][’mu’] self.rho = 1.0 * self.lamda/(self.s*self.mu) self.p0 = laws[self.model][’p0’](rho1=self.rho, s=self.s , k=self.k) self.pk = self.pn(self.k) if self.k > 0 else 0; self.lamdae = (1 - ( 0 if self.k == -1 else self.pk)) * self.lamda self.rhoe = 1.0 * self.lamdae/(self.s* self.mu) # self.Lq = laws[self.model][’Lq’](rho1=self.rhoe, s=self.s , k=self.k, p0=self.p0) self.L = self.Lq + self.s * self.rhoe self.W = lambda q : (self.L if q == ’’ else self.Lq)/self.lamdae # isErgodic def isErgodic(self): return self.rho <1 # getStationaryProb CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 154 def pn(self,n): pn0 = lambda n: self.s**min(self.s,n)/factorial(min(self.s,n)) * self.rho**n * self.p0 if n == 0 : return self.p0 if self.k != -1 and n > self.k : return 0 return pn0(n) # show perforamnces def test(self): print(’==================’ + self.model + ’ =======================’) print("p0* :{:.5f}".format(self.p0)) print("p1* :{:.5f}".format(self.pn(1))) print("Lq :{:.2f}".format(self.Lq)) print("L :{:.2f}".format(self.L)) print("W :{:.2f}".format(self.W(’’))) print("Wq :{:.2f}".format(self.W(’q’))) 5.4.2 La station M/M/1 Dans ce système les arrivées sont poissonniennes de taux λ (nombre moyen de clients arrivant pendant une unité de temps) et le service est exponentiel de taux µ (nombre moyen de clients servis pendant une unité de temps, donc µ1 est le temps moyen de service d’un client). Il y a un seul serveur et la taille de la file est illimitée. On suppose que la discipline est FIFO. Si (Xt )t≥0 représente le nombre de clients dans le système à l’instant t, alors S = {0, 1, 2, ...}. On passe d’un état i à i + 1 si un client arrive, on passe de l’état i à i − 1 si un client est servi. Ceci est décrit par le graphe 5.3. Il correspond à une CMTC dont la matrice génératrice est Q. λ 0 1 2 µ λ λ λ ... n n-1 µ n+1 µ ... µ Figure 5.3 – Système M/M/1 0 0 −λ 1 2 3 ... i-1 i i+1 ... λ 0 0 ... 0 0 0 ... 1 µ −(λ + µ) λ 0 ... 0 0 0 ... Q= 2 .. . 0 µ −(λ + µ) λ ... 0 0 0 ... i .. . 0 0 0 0 ... µ −(λ + µ) λ ... Nous cherchons πn , la probabilité d’avoir n clients dans le système à l’état stationnaire. On sait que dans cet état : πQ = 0 π1 = 1 Ce qui donne le système d’équations : µπ1 − λπ0 = 0 λπi−1 + µπi+1 − (λ + µ)πi = 0 pour i ≥ 1 P∞ π = 1 i=0 La solution de ce système donne : i CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE π1 = πi+1 − 155 λ π0 µ λ λ λ πi = πi − πi−1 = π1 − π0 = 0 pour i ≥ 1 µ µ µ donc πi+1 = λ πi µ pour i ≥ 1 On en déduit que : πn = ρn × π0 tel que ρ = λ µ. Ce qui peut être vérifié par induction. P∞ Pour calculer π0 on utilise la relation i=0 π0 = πi = 1. On aura : 1 1+ρ+ ρ2 + ρ3 + ... L’expression au dénominateur est une progression géométrique de raison ρ. Elle est convergente si ρ < 1 et est égale à : 1/(1 − ρ). La condition ρ < 1 est essentielle pour la stabilité du système, elle est dite condition d’ergodicité du système. ρ < 1 veut dire que le taux d’arrivées est inférieur au taux de départ, dans le cas contraire, il y aura un débordement du nombre de clients dans le système. On déduit que : π0 = 1 − ρ πn = ρn (1 − ρ) = ρn π0 et pour n ≥ 1 Les performances. • Le nombre moyen de clients dans le système : L= ∞ X nπn = ∞ X n n(1 − ρ)ρ = ρ(1 − ρ) = ρ(1 − ρ) ∞ X !0 ρn = ρ(1 − ρ) n=1 Donc : L= nρn−1 n=1 n=0 n=0 ∞ X 1 (1 − ρ)2 ρ λ ρπ0 = = 1−ρ µ−λ (1 − ρ)2 • Nombre moyen de clients en attente dans la file : Lq = nombre moyen de clients dans la station - le nombre moyen de clients entrain d’être servis. ∞ ∞ ∞ X X X Lq = (n − 1)πn = nπn − πn = L − (1 − π0 ) = L − ρ n=1 n=1 n=1 • Le temps de réponse moyen : W = 1 L = λ µ−λ • Le temps d’attente moyen dans la file (le temps de réponse - temps de service) : Wq = W − 1 µ Exemple : Pour un système M/M/1 avec les paramètres λ = 4c/h et µ = 6c/h, nous avons : - Temps moyen de service : 1/µ = 1/6 = 10 min par client - Taux d’utilisation du serveur : ρ = λ/µ = 4/6 = 2/3 = 0.666 CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE - 156 Probabilité d’avoir 0 client dans le système : π0 = (1 − ρ) = 1/3 = 0.333 Probabilité que le serveur soit occupé : 1 − π0 = ρ = 0.666 Probabilité d’avoir un seul client dans la queue : π1 = ρπ0 = 2/3 × 1/3 = 2/9 = 0.2222 Probabilité d’avoir 0 client dans la queue : π0 + π1 = 0.333 + 0.222 = 0.555 Nombre moyen des clients dans le système : L = ρ/(1 − ρ) = 2/3 × 3/1 = 2 Nombre moyen des clients dans la queue : Lq = L − ρ = 2 − 0.666 = 1.333 Temps moyen d’attente dans le système : W = L/λ = 2/4 = 1/2h = 30 min Temps moyen d’attente dans la queue : Wq = 0.333 = 20 min Les paramètres et les indicateurs de performance de ce système indiquent que : - 66.6% du temps le serveur est occupé. - 33.3% du temps le système est libre. - 22.2% du temps un seul client dans le système. - 55.5% du temps la queue est vide. - En moyenne 2 clients dans ce système. - En moyenne 1.333 clients dans la file. - Chaque client attend en moyenne 30 min. - Chaque client attend dans la queue en moyenne 20 min. Pour un système M/M/1 avec un taux d’arrivées λ = 8c/h : Pour que le taux d’utilisation soit supérieur à 80%, il faut que son taux de service µ = λ/ρ = 8/0.8 = 10c/h. À vos claviers! #Code502.py from Code501 import Queueing # getMM1 def getMM1(lamda, mu): # laws ={ ’MM1’ : { ’p0’ : lambda **p: (1 - p[’rho1’]), ’Lq’ : lambda **p: p[’rho1’] / (1 - p[’rho1’]) - p[’rho1’], }, } # p0 = 1 - rho, # Lq = L - rho #========================================================================= # Tests qs = Queueing( model = ’MM1’, A ={’D’:’Pois’ , ’params’: { ’lambda’: lamda}}, B ={’D’:’Expo’ , ’params’: { ’mu’: mu}}, laws = laws) qs.test() if __name__ == "__main__": getMM1(4,6) # ==================MM1 ======================= # p0* :0.33333 # p1* :0.22222 # Lq :1.33 # L :2.00 # W :0.50 # Wq :0.33 5.4.3 La station M/M/1/K λ 0 1 µ λ λ 2 µ ... K K-1 µ Figure 5.4 – Système M/M/1/K CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 157 Dans ce système les arrivées sont poissonniennes de taux λ (nombre moyen de clients arrivant pendant une unité de temps) et le service est exponentiel de taux µ (nombre moyen de clients servis pendant une unité de temps, donc µ1 est le temps moyen de service d’un client). Il y a un seul serveur et la taille de la file est limitée à K −1 clients. On suppose que la discipline est FIFO. Dans ce système, le taux d’arrivée λ est significatif durant la période où la taille de la queue est inférieure à K − 1, après cette étape tous les clients qui arrivent au système seront rejetés, le système ne voit pas ces clients. Le taux d’arrivées perçu par un observateur dans le système est inférieur à λ et égale au taux réel multiplié par la fraction de temps où le système n’a pas encore atteint sa capacité maximale (K). On l’appelle le taux effectif et il sera noté λe . Si (Xt )t≥0 représente le nombre de clients dans le système à l’instant t, alors S = {0, 1, 2, ..., K}. On passe d’un état n à n + 1 si un client arrive, on passe de l’état n à n − 1 si un client est servi. Ceci est décrit dans le graphe 5.4. Il correspond à une CMTC dont la matrice génératrice est la suivante : Q= 0 1 2 3 ... K-2 K-1 K 0 −λ λ 0 0 ... 0 0 0 1 µ −(λ + µ) λ 0 ... 0 0 0 2 .. . 0 µ −(λ + µ) λ ... 0 0 0 K-1 0 0 0 0 ... µ −(λ + µ) λ K 0 0 0 0 ... 0 µ −µ Nous cherchons πn , la probabilité d’avoir n clients dans le système à l’état stationnaire. Les équations de balance de ce système sont : µπ1 − λπ0 = 0 λπ n−1 + µπn+1 − (λ + µ)πn = 0 pour 2 ≤ n ≤ K − 1 µπ − λπ K K−1 = 0 P ∞ n=0 πn = 1 La solution de ce système donne (de la même façon que M/M/1) : πn = ρn × π0 pour 1 ≤ n ≤ K P∞ Pour calculer π0 on utilise la relation i=0 πi = 1. On aura : 1 1−ρ = 1 + ρ + ρ2 + ρ3 + ... + ρK 1 − ρK+1 L’expression au dénominateur est une progression géométrique de raison ρ finie à K termes. On déduit que : 1−ρ πn = ρn pour 0 ≤ n ≤ K 1 − ρK+1 Les performances. π0 = Comme expliqué plus haut le système perçoit un autre taux d’arrivées : λe qui sera utilisé pour déterminer les facteurs de performance au lieu de λ. λe sera égal à λ fois la probabilité que le système n’est pas dans l’état K (πK ). ρe est le taux effectif d’utilisation. λe = λ(1 − πK ). ρe = λe = ρ(1 − πK ) µ CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 158 • Le nombre moyen de clients dans le système : K 1 − ρ X n−1 1−ρ n ρ = ρ nρ 1 − ρK+1 1 − ρK+1 n=1 n=0 n=0 !0 0 K X 1 − ρK+1 1−ρ 1−ρ n =ρ ρ =ρ 1 − ρK+1 n=1 1 − ρK+1 1−ρ K K+1 −(1 − ρ)(K + 1)ρ + 1 − ρ 1−ρ =ρ 1 − ρK+1 (1 − ρ)2 L= K X nπn = K X n Donc : 1−ρ −(1 − ρ)(K + 1)ρK + 1 − ρK+1 ρ L=ρ = −π0 (K + 1)ρK + 1 2 K+1 (1 − ρ) 1−ρ (1 − ρ) • Nombre moyen de clients en attente dans la file : Lq = nombre moyen de clients dans la station - le nombre moyen de clients entrain d’être servis. Lq = L − (1 − π0 ) = L − ρ(1 − ρK π0 ) = L − ρ(1 − πK ) = L − ρe • Le temps de réponse moyen : Les arrivées dans le système sont effectives lorsque ce dernier n’est pas saturé. Ce cas se produit avec une probabilité 1 − πK L = λW (1 − πK ) = W λe W = 1 L = λe µ − λe • Le temps d’attente moyen dans la file (le temps de réponse - temps de service) : Wq = W − 1 µ Exemple : Pour un système M/M/1/12 avec les paramètres λ = 5c/h et µ = 10c/h, nous avons : - Temps moyen de service : 1/µ = 1/10 = 6 min par client - Taux d’utilisation du serveur : ρ = λ/µ = 5/10 = 0.5 - Probabilité d’avoir 0 client dans le système : π0 = 0.5 - Probabilité que le serveur soit occupé : 1 − π0 = 0.5 - Probabilité d’avoir un seul client dans la queue : π1 = 0.25 - Probabilité d’avoir 0 client dans la queue : π0 + π1 = 0.5 + 0.25 = 0.75 - Nombre moyen des clients dans le système : L = 1 - Nombre moyen des clients dans la queue : Lq = 0.5 - Temps moyen d’attente dans le système : W = 0.2h = 12 min - Temps moyen d’attente dans la queue avant le service : Wq = 0.10 = 6 min Cas particulier : ρ = 1 πn = π0 pour 1 ≤ i ≤ K PK Pour calculer π0 on utilise la relation i=0 π0 = (K + 1)π0 = 1. Donc : π0 = À vos claviers! #Code503.py from Code501 import Queueing 1 K +1 CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 159 # p0 def getP0(**p): rho, k = p[’rho1’], p[’k’] return (1 - rho)/(1 - rho**(k+1)) # Lq def getLq(**p): rho, k, p0 = p[’rho1’], p[’k’], p[’p0’] # return rho/(1-rho) * ( 1 - p0 * (k*rho**k + 1)) # laws ={ ’MM1K’ : { ’p0’ : getP0, ’Lq’ : getLq, }} #========================================================================= # Tests def getMM1K(mu, lamda, K): qs = Queueing( model = ’MM1K’, A ={’D’:’Pois’ , ’params’: { ’lambda’: lamda}}, B ={’D’:’Expo’ , ’params’: { ’mu’: mu}}, C = 1, K = K, laws=laws) qs.test() if __name__ == "__main__": getMM1K(10, 5, 12) # ==================MMS ======================= # p0* :0.50006 # p1* :0.25003 # Lq :0.50 # L :1.00 # W :0.20 # Wq :0.10 5.4.4 La station M/M/s Lorsque le nombre de serveurs s est supérieur à 1 (multi-serveurs), le diagramme du modèle devient comme suit : λ 0 λ 1 µ 2 2µ λ λ 3 3µ ... S-2 (s-1)µ λ λ S S-1 sµ S+1 ... sµ Figure 5.5 – Système M/M/s Dans ce diagramme, le taux de sortie de l’état i est iµ pour i < s et sµ pour i ≥ s. Ceci vient du fait que le passage de l’état i vers l’état i − 1 se produit lorsque le premier des serveurs occupés termine son service. C’est à dire que la v.a T du temps de passage de i vers l’état i − 1 est le minimum des v.a du temps de service de tous les i serveurs occupés et qui (voir l’exercice 6 du chapitre 2) suit une loi exponentielle de taux iµ. À partir de l’état s, tous les serveurs sont occupés et donc le taux de service est sµ. La condition pour que le système de file d’attente de ce modèle admette un état stationnaire CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE (condition d’ergodicité) est que ρ = λ sµ 160 <1 0 1 2 3 ... s-1 s s+1 ... 0 −λ λ 0 0 ... 0 0 0 ... 1 µ −(λ + µ) λ 0 ... 0 0 0 ... 2 . Q = .. 0 2µ −(λ + 2µ) λ ... 0 0 0 ... s-1 0 0 0 0 ··· −(λ + (s − 1)µ) λ 0 ... s 0 0 0 0 ··· sµ −(λ + sµ) λ ... s+1 .. . 0 0 0 0 ··· .. sµ −(λ + sµ) . . . Les équations de balance de ce système sont : µπ1 − λπ0 = 0 λπi−1 + min(s, i + 1)µπi+1 − (λ + min(s, i)µ)πi = 0 pour i ≥ 1 P ∞ π =1 i=0 donc i π = µλ π0 1 i −λπi−1 πi+1 = (λ+min(s,i)µ)π min(s,i+1)µ P∞ π = 1 i=0 pour i ≥ 1 i Si i > s, cette partie du diagramme est similaire à celle du M/M/1, et on applique la même méthode d’analyse avec πs comme état initial. πn = ρ(n−s) × πs Si i ≤ s, on a : πi+1 = (λ + i)µπi − λπi−1 (i + 1)µ pour i ≥ 1 λ i λ πi + πi − πi−1 pour i ≥ 1 (i + 1)µ (i + 1) (i + 1)µ i λ λ πi = πi − πi−1 pour i ≥ 1 πi+1 − (i + 1)µ (i + 1) iµ πi+1 = Par substitution des autres termes : πi+1 − 1 λ πi = (i + 1)µ (i + 1) λ π1 − π0 = 0 pour i ≥ 1 µ D’après la première équation de balance, nous avons : πi+1 = donc : λ πi (i + 1)µ pour i ≥ 1 i+1 1 λ πi+1 = π0 pour i ≥ 1 (i + 1)! µ n 1 λ sn n πn = π0 = ρ π0 pour 1 ≤ n ≤ s n! µ n! CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 161 smin(n,s) n ρ π0 pour 1 ≤ n ≤ s min(n, s)! P∞ Pour calculer π0 on utilise la relation i=0 πi = 1. On aura : πn = ∞ X ρ(n−s) πs + n=s+1 πs ∞ X s X sn n ρ π0 = 1 n! n=0 ρ(n−s) + π0 n=s s−1 n X s n ρ =1 n! n=0 On déduit que : 1 π0 = Ps−1 sn n n=0 n! ρ + ss s 1 s! ρ 1−ρ Les performances. • Nombre moyen de clients en attente dans la file : Lq = nombre moyen de clients dans la station - le nombre moyen de clients entrain d’être servis. La formation de la queue commence à partir de l’arrivée du (s + 1)eme client qui va trouver tous les serveurs occupés alors il rejoint la queue. Lq = ∞ X (n − s)πn = n=s s = ∞ X (n − s) n=s ss n ρ π0 s! ∞ X ∞ X s ss π0 ρs (n − s)ρn−s = π0 ρs+1 kρk−1 s! s! n=s k=0 Donc : Lq = 1 ss π0 ρs+1 s! (1 − ρ)2 Exemple : Pour un système M/M/4 avec les paramètres λ = 10c/h et µ = 5c/h, nous avons : - Temps moyen de service : 1/µ = 1/5 = 0.2h/c = 12 min par client - Taux d’utilisation du serveur : ρ = λ/sµ = 10/(4 × 5) = 1/2 = 0.5 - Probabilité d’avoir 0 client dans le système : π0 = 0.13043 - Probabilité que le serveur soit occupé : 1 − π0 = 0.86957 - Probabilité d’avoir un seul client dans la queue : π1 = 0.26087 - Nombre moyen des clients dans le système : L = 2.17 - Nombre moyen des clients dans la queue : Lq = 0.17 - Temps moyen d’attente dans le système : W = 0.22 - Temps moyen d’attente dans la queue avant le service : Wq = 0.02 À vos claviers! #Code504.py from Code501 import Queueing from math import factorial # fsum01 = lambda rho,s, n : 1 if n == 0 else fsum01(rho,s, n-1) + (s**n/factorial(n))*rho**n # p0 : def getP0(**p): rho,s = p[’rho1’], p[’s’] return 1/( fsum01(rho,s , s-1) + (s**s/factorial(s)) * rho**s * (1/(1 - rho))) # Lq CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE def getLq(**p): rho, s, p0 = p[’rho1’], p[’s’], p[’p0’] return (s**s /factorial(s)) * p0 * rho**(s+1)/(1-rho)**2 # laws ={ ’MMS’ : { ’p0’ : getP0, ’Lq’ : getLq }} #========================================================================= # Tests def getMMS(mu, lamda, S): qs = Queueing( model = ’MMS’, A ={’D’:’Pois’ , ’params’: { ’lambda’: lamda}}, B ={’D’:’Expo’ , ’params’: { ’mu’: mu}}, C = S, laws=laws) qs.test() if __name__ == "__main__": getMMS(5,10,4) # ==================MMS ======================= # p0* :0.13043 # p1* :0.26087 # Lq :0.17 # L :2.17 # W :0.22 # Wq :0.02 162 CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 5.4.5 163 La station M/M/s/K 0 1 ... s-1 s s+1 ... K-1 K 0 −λ λ ··· 0 ... 0 ··· 0 0 1 µ −(λ + µ) · · · 0 ... 0 ··· 0 0 2 .. . 0 2µ ··· 0 ... 0 ··· 0 0 0 0 ··· −(λ + (s − 1)µ) λ 0 ··· 0 0 s 0 0 ··· sµ −(λ + sµ) λ ··· 0 0 s+1 .. . 0 0 ··· 0 sµ −(λ + sµ) · · · 0 0 K-1 0 0 ··· 0 0 0 ··· −(λ + sµ) λ K 0 0 ··· 0 0 0 ··· sµ −sµ Q = s-1 Lorsque le nombre de serveur s est supérieur à 1 (multi-serveurs), le diagramme du modèle devient comme suit : λ 0 λ 1 µ 2 2µ λ λ λ 3 ... S S-1 sµ 3µ λ S+1 sµ ... K-1 K sµ Figure 5.6 – Système M/M/s/K Dans ce diagramme, le taux de sortie de l’état i est iµ pour i < s et sµ pour i ≥ s. Ceci vient du fait que le passage de l’état i vers l’état i − 1 lorsque le premier des serveurs occupés termine son service c’est à dire que la v.a T du temps de passage de i vers l’état i − 1 est le minimum des v.a du temps de service de tous les i serveurs occupés et qui suit une loi exponentielle de taux iµ. A partir de l’état s, tous les serveurs sont occupés et donc le taux de passage est sµ. Le même raisonnement que pour la station M/M/s est suivi pour obtenir les performances des différents systèmes de files d’attente. Les équations de balance de ce système sont : µπ1 − λπ0 = 0 λπi−1 + min(s, i + 1)µπi+1 − (λ + min(s, i)µ)πi = 0 pour 1 ≤ i ≤ K PK π = 1 i=0 i En suivant le même raisonnement que le M/M/s, on obtient : πn = smin(n,s) n ρ π0 min(n, s)! pour 1 ≤ n ≤ K On calcule π0 : K X ρ(n−s) πs + n=s+1 πs K X s X sn n ρ π0 = 1 n! n=0 s−1 n X s n ρ =1 n! n=0 ρ(n−s) + π0 n=s On déduit que : π0 = Ps−1 sn n n=0 n! ρ 1 + ss s 1−ρK−s+1 s! ρ 1−ρ CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE πK = 164 ss K ρ π0 s! Les performances. • Nombre moyen de clients en attente dans la file : Lq = nombre moyen de clients dans la station - le nombre moyen de clients entrain d’être servis. Lq = K X (n − s)πn = n=s = K X (n − s) n=s ss n ρ π0 s! K X K−s X ss ss π0 ρs (n − s)ρn−s = π0 ρs+1 kρk−1 s! s! n=s = k=0 Donc : ss Lq = π0 ρs+1 s! ss π0 ρs+1 s! 1 + (K − s)ρK−s+1 − (K − s + 1)ρK−s (1 − ρ)2 1 − ρK−s+1 1−ρ 0 On peut calculer les autres indicateurs de performance : L, W , Wq de la même façon que pour le cas M/M/1/K. Exemple : Pour un système M/M/2/15 avec les paramètres λ = 5c/h et µ = 4c/h, nous avons : - Temps moyen de service : 1/µ = 1/6 = 10 min par client - Taux d’utilisation du serveur : ρ = λ/sµ = 4/2.5 = 1/5 = 0.2 - Probabilité d’avoir 0 client dans le système : π0 = 0.23092 - Probabilité que le serveur soit occupé : 1 − π0 = ρ = 0.76907 - Probabilité d’avoir un seul client dans la queue : π1 = 0.28865 - Probabilité d’avoir 0 client dans la queue : π0 + π1 = 0.51957 - Nombre moyen des clients dans le système : L = 2.04 - Nombre moyen des clients dans la queue : Lq = 0.79 - Temps moyen d’attente dans le système : W = 0.41 - Temps moyen d’attente dans la queue avant le service : Wq = 0.16 Cas particulier : ρ = 1 πn = smin(n,s) π0 min(n, s)! π0 = Ps sn n=0 n! pour 1 ≤ n ≤ K 1 s + ss! (K − s) À vos claviers! #Code505.py from Code501 import Queueing from math import factorial # fsum = lambda rho,s, n : 1 if n == 0 else fsum(rho,s, n-1) + (s**n/factorial(n))*rho**n # p0 def getP0(**p): rho, s, k = p[’rho1’], p[’s’], p[’k’] return 1/( fsum(rho,s , s-1) + ((s**s/factorial(s)) * rho**s * (1/(1 - rho))) * (1 - rho**(k-s +1))) # Lq def getLq(**p): rho, s, k, p0 = p[’rho1’], p[’s’], p[’k’], p[’p0’] return (s**s /factorial(s)) * rho**(s+1) * p0 * ((1 + (k-s)*rho**(k-s+1) - (k-s+1)*rho**(k-s)) /(1 - rho)**2) # laws ={ ’MMSK’ : { ’p0’ : getP0, ’Lq’ : getLq}} CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE #========================================================================= # Tests def getMMSK(mu, lamda, S, K): qs = Queueing( model = ’MMSK’, A ={’D’:’Pois’ , ’params’: { ’lambda’: lamda}}, B ={’D’:’Expo’ , ’params’: { ’mu’: mu}}, C = S, K = K, laws=laws) qs.test() if __name__ == "__main__": getMMSK(4, 5, 2, 15) # # # # # # # ==================MMSK ======================= p0* :0.23092 p1* :0.28865 Lq :0.79 L :2.04 W :0.41 Wq :0.16 165 M/M/1 π0 πn Lq L Wq W 1−ρ M/M/S (S>1) s−1 n X s n ss s 1 ρ + ρ n! s! 1 − ρ n=0 M/M/1/K !−1 ( 1 K+1 smin(n,s) n ρ π0 min(n, s)! ρn π0 ρ2 π0 (1 − ρ)2 ρs+1 ss π0 s! (1 − ρ)2 1−ρ 1−ρK+1 M/M/S/K (S>1) ρ 6= 1 Ps−1 ρ=1 Ps sn n n=0 n! ρ s n=0 n! + s K−s+1 ss s 1−ρ s! ρ 1−ρ −1 s s! (K − s) ρ K 1−ρ (1 − π0 (Kρ π0 K(K−1) 2 + 1)) ρ 6= 1 ρ=1 ρs+1 ss s! π0 (1−ρ)2 (1 + (K (K−s+1)(K−s) ss s! π0 2 Lq + ρe Lq + sρe Lq λ Lq λ Lq λe Lq λe Wq + 1 µ Wq + ρ=1 ρ=1 Lq + sρ 1 µ ρ 6= 1 − s)ρK−s+1 − (K − s + 1)ρK−s ) ρ 6= 1 Lq + ρ Wq + −1 smin(n,s) n ρ π0 min(n, s)! ρn π0 n + 1 µ Wq + CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE Le tableau suivant résume les résultats précédents : λe = λ(1 − πK ) et ρe = (1 − πK )ρ 1 µ 166 CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 5.5 167 Exercices Exercice 1. Dans un magasin ayant une seule caisse, les clients y arrivent (à la caisse) suivant la loi de poisson. Donner la notation de Kendal, si : 1. Le temps pour servir un client suit une loi exponentielle, la file est de taille infinie. 2. Le temps de service est fixe, la file est de taille n 3. Le temps de service suit la loi uniforme, la file est de taille 1. Exercice 2. Dans un département de l’université, il existe 60 étudiants. Pendant le déjeuner entre midi et 14h00, chaque étudiant utilise les distributeurs de boissons en moyenne 2 fois. Le temps moyen de service est 2.5 mns (Les temps inter-arrivées des étudiants et de service suivent une loi exponentielle). Il existe trois distributeurs. 1. Calculer le taux d’utilisation des serveurs dans ce système et le temps d’attente moyen dans la file. 2. Un nouveau distributeur de même caractéristiques est acquis. Calculer le nouveau taux d’utilisation et le temps d’attente moyen dans la file. Exercice 3. Dans un magasin les clients arrivent à la caisse suivant la loi de poisson de taux λ. Le nombre d’articles dans le panier de chaque client est en moyenne 10, et le service est exponentiel de taux µ clients par minute. Soit A le nombre moyen d’articles saisis par minute par le caissier. Déterminer la valeur minimale de A pour que le temps d’attente moyen ( que le client passe dans la file d’attente + le temps de la saisie des articles) ne dépasse pas T0 . Exercice 4. Un système de télécommunication possède une ligne de transmission de vitesse V = 1800bit/s. Chaque message a une taille de L bits qui est une v.a exponentielle de moyenne 900bits. L’arrivée des messages est poissonnienne. On cherche le taux d’arrivée maximum (messages/s) que le système peut supporter pour que le temps d’attente de chaque message dans la file soit moins de 2s. Exercice 5. Dans un bureau de poste, il existe un seul guichet qui peut servir en moyenne 6 clients par heure. Les arrivées des clients sont poissonnienne de taux 5 clients par heure. 1. Calculer le nombre moyen de clients et le temps d’attente moyen dans le système. 2. Le gérant veut ajouter un deuxième guichet avec une file d’attente indépendante (séparée) de celle du premier guichet. Recalculer les même performances dans le nouveau système. 3. Supposons que les clients choisissent le premier guichet avec une probabilité p = 2/3. Trouver le nombre moyen de clients et le temps d’attente moyen dans ce système. Exercice 6. Dans un salon de coiffure, il existe un seul coiffeur qui opère. Les clients arrivent selon un processus de poisson avec une moyenne de 32 clients en 8 heures. La durée d’une coupe suit une loi exponentielle de moyenne égale à 10 mns pour chaque client. Les clients sont servis suivant l’ordre de leur arrivée et il n’y a pas de limite de places dans le salon. 1. Calculer la probabilité qu’il arrive exactement 4 clients entre 8h et 9h du matin. 2. Calculer la probabilité qu’un client soit servi pendant plus de 20 mns. 3. Calculer πn la probabilité qu’il y ait n clients dans le salon à un instant donné (en régime stationnaire). 4. Calculer le nombre moyen de clients et le temps d’attente moyen dans le salon. Exercice 7. Dans un système de file d’attente, les clients arrivent suivant un processus de poisson de taux λ = 10 par heure et le temps de service est exponentiel de moyenne égale à 4 minutes si le nombre de clients dans le système est inférieur à 3 sinon le temps de service moyen est de 2 minutes. 1. Dessiner le diagramme de transition de ce système. 2. En déduire les probabilité à l’état stationnaire. 3. Trouver les performances de ce système. Exercice 8. Soit une station avec des arrivées Poissonniennes de taux λ. Le service est exponentiel de taux µ. Si le nombre de clients dans la station est inférieur à sL , le taux de service est baissé à µL , et lorsqu’il atteint sH (sH ≥ sL ), le taux de service est augmenté à µH . 1. Dessiner le diagramme de transition. 2. Trouver l’expression de πn en fonction de π0 . CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 168 Exercice 9. Soit un système de file d’attente avec un seul serveur et une file de taille infinie. Les arrivées sont poissonienne de taux λ et le service est exponentiel de taux kµ quand le système est dans l’état k pour k = 0, 1, 2, ... (le serveur augmente le taux de service en fonction du nombre de clients dans la file). Calculer le nombre moyen de clients et le temps d’attente moyen dans ce système. Exercice 10. Une station de service a une seule pompe à essence. Les voitures arrivent suivant un processus de poisson de taux de 15 voitures par heure. Si la pompe est occupée, les clients peuvent partir sans se servir. En particulier s’il y a n voitures dans la station, la probabilité qu’un client quitte sans service est n/3. Le temps de service suit une loi exponentielle de moyenne 4 minutes. Si X(t) représente le nombre de voitures dans la station : 1. Construire le graphe de transition de ce système de file d’attente. 2. Trouver les probabilités d’états au régime stationnaire. 3. Le nombre moyen de clients dans la station. 4. Le temps d’attente moyen dans la station. CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 5.6 169 Solutions Solution 1. 1. M/M/1 2. M/D/1/n+1 3. M/G/1/2 Solution 2. λ = 60e/h, µ = 24e/h 1. s = 3, ρ = 60/(3 × 24) = 5/6 = 83.33%, Wq = 3.51min 2. s = 4, ρ = 60/(4 × 24) = 5/8 = 62.5%, Wq = 0.53min Solution 3. Le caissier peut servir A/10 clients par minutes (µ = A/10). 1 < T0 =⇒ µ > (T0−1 + λ) =⇒ A > 10(T0−1 + λ) W = µ−λ Solution 4. Dans ce système la ligne de transmission représente le serveur. En moyenne, un message nécessite L/V secondes pour être transmis, µ = V /L = 2messages/s. On veut que Wq soit inférieur à 2s, donc : 1 1 µ−λ − µ < 2 ce qui implique : λ < 8/5. Solution 5. ρ 1 1. λ = 5, µ = 6, le système est M/M/1, donc ρ = 65 , L = 1−ρ = 5, W = µ−λ = 1. 2. Dans le nouveau système, chaque client choisit la file d’attente avec une probabilité 1/2. Donc le taux d’arrivée pour chaque serveur est λ/2. Nous calculons les performances M/M/1 avec ce taux d’arrivée, ce qui donne : 5 : λ = 5/2, µ = 6, le système est M/M/1, donc ρ = 12 ρ L = 2 × 1−ρ = 10/7. 1 1 + 12 × µ−λ = 2/7. W = 21 × µ−λ 3. λ1 = 10/3, λ2 = 5/3, donc : ρ1 = 95 et ρ2 = 5/18 ρ2 ρ1 = 5/4 et L2 = 1−ρ = 5/13 ; L = L1 + L2 = 1.63 L1 = 1−ρ 1 2 1 1 = 3/13 ; W = 2/3 × W1 + 1/3 × W2 = 0.32 W1 = µ−λ1 = 3/8 et W2 = µ−λ 2 Solution 6. 1- La station est M/M/1, λ = 4 et µ = 6, donc ρ = 32 . k N (t) est le nombre de clients arrivant pendant un intervalle de temps t. P (N (t) = k) = e−λt (λt) k! 4 P (N (1) = 4) = e−4 44! = 0.195. 2- Soit Ts le temps de service : P (Ts > t) = e−µt P (Ts > 13 ) = s−2 = 0.135 . 3- πn = ρn (1 − ρ) = 13 ( 32 )n . 4- L = ρ 1−ρ 1 µ−λ = 2 clients, W = = 1 2 heure=30 mns. Solution 7. λ = 10, µ1 = 15, µ2 = 30 110 0 10 1 15 10 2 15 3 30 10 10 4 ... n 30 Figure 5.7 – Diagramme exercice 7 n+1 30 ... CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 170 2. Les équations de balance : µ1 π1 = λπ0 λπ0 + µ1 π2 = (λ + µ1 )π1 λπ1 + µ2 π3 = (λ + µ1 )π2 ∀n > 3 λπn−2 + µ2 πn = (λ + µ2 )πn−1 , Donc : π1 = Nous avons : P∞ i=0 λ π0 , µ1 πn = ( ∞ X λ λ λ π0 + ( )n−2 ( )2 π0 = 1 µ1 µ2 µ1 n=2 π0 = Donc : π1 = ∀n > 1 πi = 1 π0 + 2 7, λ n−2 λ 2 ) ( ) π0 , µ2 µ1 π2 = 4 21 et πn = 1+ 4 1 n−1 7(3) 1 3 = 7 + ( µλ1 )2 ( 1−1 λ ) λ µ1 µ2 pour n>2 P∞ 8 + 7 ( 11 2 − 53 ) = 1 3. L = π1 + 2π2 + 47 n=3 n( 13 )n−1 = 72 + 21 P∞ P∞ P∞ 4 (1− 3 ) Lq = n=1 (n − 1)πn = n=1 nπn − n=1 πn = L − (1 − π0 ) = Lq 1 3 W =L λ = 10 ; Wq = λ = 70 3 7 Solution 8. 0 λ λ λ 1 ... L L-1 µL µL λ λ L+1 ... H H-1 µ µ H+1 µH Figure 5.8 – Diagramme exercice 8 λπn = µL πn+1 si n < sL si sL ≤ n < sH λπn = µπn+1 si n ≥ sH λπn = µH πn+1 ( λ )n π0 µL πn = ( µλ )n−sL +1 ( µλL )sL −1 π0 ( λ )n−sH +1 ( λ )sH −sL ( µH µ si n < sL si sL ≤ n < sH λ sL −1 π0 µL ) si n ≥ sH Solution 9. λ 0 λ λ 1 µ 2 2µ 3 3µ λ λ ... s S-1 sµ S+1 (s+1)µ Figure 5.9 – Diagramme exercice 9 ... ... CHAPITRE 5. APPLICATION AUX MODÈLES DE FILES D’ATTENTE 171 Le système d’équations à l’état stationnaire est le suivant : π Q = 0 et π 1 = 1 −λπ0 + µπ1 = 0 λπk−1 − (λ + kµ)πk + (k + 1)µπk+1 = 0, ∀n > 0 P ∞ π =1 i i=0 De ce système d’équations nous avons la relation suivante qui peut être vérifiée par récurrence. πi = De P∞ i=0 ρi π0 i! tel que ρ = λ µ πi = 1 et sous la condition que ρ < 1, nous avons : π0 = 1+ρ+ 1 2 2ρ 1 + ... + i!1 ρi + ... i Donc : π0 = e−ρ et πn = ρi! e−ρ On peut remarquer que l’expression de πn correspond à la loi de Poisson de paramètre ρ. On peut donc en déduire que : L= ∞ X iπi = ρ l’espérance de la loi de Poisson. i=0 W = L 1 = λ µ Solution 10. L’ensemble des états possibles est S = {0, 1, 2, 3}, chaque état représente le nombre de clients dans la station. Le taux de passage de l’état i à l’état i + 1 est égal à : λ × (1 − 3i ) 15 0 10 1 15 5 2 15 3 15 Figure 5.10 – Diagramme Exercice 10 P3 2. À l’état stationnaire π × Q = 0 et i=0 πi = 1, ce système d’équations donne : 9 9 3 1 π = ( 26 , 26 , 13 , 13 ) P 27 3. Le nombre moyen de clients dans la station : L = n∈S n × πn = 26 4. Le temps d’attente moyen dans la station. Vu que le taux d’arrivée change d’un état a un autre,P on doit appliquer la loi de Little en utilisant le λe qui est égal a l’espérance des λi : 3 λe = i=0 λi πi = 9.80 et W = λLe = 0.1059 Troisième partie Simulation 172 173 Chapitre 6 Génération des variables aléatoires 6.1 Introduction Les générateurs de nombres aléatoires sont à la base de la simulation de n’importe quelle loi de probabilité. Contrairement aux méthodes manuelles (pile ou face, dé, cartes,...), les tables de nombres aléatoires et les processus physiques ; les générateurs algorithmiques produisent des nombres pseudo-aléatoires (car issus d’algorithmes déterministes), mais ils ont l’avantage d’être simples à réaliser sur ordinateur. Ils permettent de réaliser un très grand nombre d’expériences en un temps très réduit. Ils peuvent reproduire exactement la même séquence plusieurs fois, chose qui est importante dans le contexte du déboggage et de la vérification des programmes, la comparaison des systèmes par simulation ainsi que la réduction de variance. 6.2 Génération des nombres aléatoires Définition 1. [15] Le générateur des nombres pseudo-aleatoires (PRNG) est la structure (S, P0 , f, U, g) tel que : - S : un ensemble fini d’états (Espace d’états) s0 , s1 , · · · , sn - P0 : distribution de probabilité sur S pour séléctioner l’état initial s0 (seed) - f : fonction de transition f : S → S - U : espace des nombres générés (sortie) (souvent [0, 1]) - g : fonction des sorties g : S → U Les éléments de cette structure permettent de réaliser les étapes de la génération des nombres aléatoires qui sont : 1- Sélectionner s0 en utilisant P0 , puis générer le premier nombre aléatoire u0 = g(s0 ) 2- À chaque étape i ≥ 1, la fonction de transition change l’état du générateur et ensuite la fonction des sorties donne le nombre aléatoire associé au nouvel état. si = f (si−1 ) & ui = g(si ) Ces deux fonctions expriment la dynamique de ce système. On peut exprimer l’état courant en fonction de l’état initial s0 : si = f (n) (s0 ) & ui = (g ◦ f (n) )(s0 ) 174 CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 175 Figure 6.1 – Générateur de nombres aléatoires La séquence u0 , u1 , · · · retournée par g est la séquence des nombres aléatoires générés par le RNG. Puisque S est fini et f est de S dans S, alors il existe p ∈ N et sk ∈ S tel que sk = f (p) (sk ) c.à.d que sk+p = sk . Le plus petit nombre p qui vérifie cette propriété est appelé la période du PRNG. À partir de cet état, la séquence devient cyclique de cycle de longueur p. Ce nombre est majoré par la cardinalité de S (p ≤ |S| sa borne supérieure). Une longue période est meilleure qu’une petite mais elle n’assure pas la bonne qualité du générateur. Plusieurs méthodes de génération de nombres aléatoires existent qui se définissent par la spécification des éléments de la structure RNG. Elles commencent toutes de la valeur initiale s0 graine (seed) et calculent les valeurs successives sn récursivement. L’implémention de beaucoup de générateurs est optimisée pour plus d’efficacité sur la plateforme cible sur laquelle il va être exécuté. Souvent, la taille du mot mémoire de cette plateforme est considéré comme un facteur important pour le choix des paramètres et pour rendre le calcul optimal et plus efficace. Dans la suite de cette section nous allons présenter les RNG les plus utilisés. 6.2.1 Générateurs congruentiels linéaires LCG(a,m) sont utilisés par la plupart des langages de programmation à cause de leur simplicité et de leur rapidité. Ils sont définis sur l’ensemble (Zm ) (générateur congruentiel CG) avec m = |S| et ils définissent f comme une fonction linéaire définie sur Zm , et g est le quotient du résultat de f par m : xn = f (xn−1 ) = (axn−1 )[m] et un = g(xn ) = xn m a est le multiplicateur et m est le module. La valeur un est le nombre pseudo aléatoire généré. Il est considéré comme l’approximation de la valeur de la variable aléatoire uniforme dans [0,1]. 6.2.2 Méthodes congruentielles mixtes MCM(a,c,m) est un générateur congruentiel avec f une fonction affine définie sur Zm avec m = |S| et a, c ∈ Zm : xn = f (xn−1 ) = (axn−1 + c)[m] et un = g(xn ) = xn m dont c est appelé l’incrément. Exemples : 1- MCM(a,c,m)=(128, 1, 235 ), xn = f (xn−1 ) = (axn−1 + c)[m] = (27 xn−1 + 1)[235 ] 2- MCM(a,c,m)=(69069, 1327217885, 232 ), xn = (69069xn−1 + 1327217885)[232 ] 3- LCG(a,m)=(216 , 231 ), xn = (216 xn−1 )[231 ] 4- LCG(a,m)=(75 , 231 − 1), xn = (75 xn−1 )[231 − 1] periode p = 231 − 2 5- MCM(a,c,m)=(25214903917, 11, 48), xn = (25214903917xn−1 + 11)[48] CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 176 Théorème 7. Hull-Dobell Thoerem [22] Le générateur MCM spécifié par (a, c, m) a comme période m (période complète) ssi : 1- pgcd(c, m) = 1 (c et m sont relativement premiers) 2- ∀p ∈ P ∗ , p|m =⇒ p|(a − 1) 3- 4|m =⇒ 4|(a − 1) P ∗ est l’ensemble des nombres premiers et x|y désigne que x divise y. Soit X la v.a.d uniforme simulée par le générateur congruentiel. Son espérance et sa variance sont : X 1 X 1 m−1 (m − 1)2 m2 − 1 k = k2 − E[X] = et V[X] = = m 2 m 4 12 k∈Zm k∈Zm 1 et E[U ] = −m ) et V[U ] = Soit U une v.a.c tel que U = U ∼ U[0, 1] Le choix de a, c est crucial pour la qualité du RNG. X m 6.2.3 1 2 (1 1 12 (1 − 1 m2 ), lorsque m >>, Générateurs récursifs multiples MRG est une équation récursive d’ordre supérieur à 1 (le terme courant est en fonction des termes précédents.). xn = (a1 xn−1 + a2 xn−2 + ... + ak xn−k + c)[m] pour k > 1, le temps de la génération augmente et améliore les propriétés de la période et de l’aléatoire. Pour certains cas, le MRG peut être simplifié à la forme : xn = (ar xn−r + ak xn−k ) [ m] tel que r < k. Exemples : RNG1 = M RG(k = 3, a = 143580, b = −810728, m1 = 232 − 209) Xn = (143580Xn−2 − 810728Xn−3 )[(232 − 209)] RN G2 = M RG(k = 3, a = 527612, b = −1370589, m2 = 232 − 22853) Yn = (527612Yn−1 − 1370589Yn−3 )[(232 − 22853)] À vos claviers! # Code601.py from functools import partial # number of generated values N=200 # plot the random number points in a grid def plotRNG(x,y, title): import matplotlib.pyplot as plt fig, axs = plt.subplots(1, 2, constrained_layout=True, figsize=(10,5)) axs[0].scatter(x, y) axs[1].plot(range(N-1),x) fig.suptitle(title, fontsize=16) # Congruential Generator # conGen is a Python generator that yields a random number each time next() is called def congGen(rng_function, seed, m, **params): x_n = seed while True: yield x_n[0] s = rng_function(x_n, **params) % m x_n = x_n[1:]; x_n.append(s) CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 177 # a_1 x_n-1 + a_2 x_n-2 + .... + a_k x_n-k + c def sumRNG(x, **p): s = 0 for i in range(p[’k’]): s += p[’a’ + str(i)] * x[i] return s + p[’c’] # partial congruential generator pcg = partial(congGen, lambda x, **p : sumRNG(x,**p)) # test RNG def test(smas): for sma in smas: seed,m , abc = sma[0], sma[1], sma[2] cgi = pcg(seed, m, **abc); rs = [ next(cgi) for _ in range(N)] plotRNG(rs[:-1],rs[1:], sma[3]) # Random number generators test([ [[1], 2**10, {’k’:1,’a0’:99, ’c’:0}, ’Congruentiel Lineaire’], [[1], 2**10, {’k’:1,’a0’:99, ’c’:1}, ’Congruentiel Mixte’], [[1,2,3], 2**10, {’k’:3,’a0’:99, ’a1’:2, ’a2’:3, ’c’:1}, ’Congruentiel Recursif’], [[1], 2**10, {’k’:1,’a0’:95, ’c’:0}, ’Congruentiel Lineaire’], [[1], 2**10, {’k’:1,’a0’:95, ’c’:1}, ’Congruentiel Mixte’], [[1,2,3], 2**10, {’k’:3,’a0’:95, ’a1’:2, ’a2’:3, ’c’:1}, ’Congruentiel Recursif’] ]) Figure 6.2 – Générateur congruentiel linéaire à gauche a=99, et à droite a=95 Figure 6.3 – Générateur congruentiel mixte à gauche a=99, et à droite a=95 Figure 6.4 – Générateur congruentiel récursif. à gauche a=99, et à droite a=95 Les nombres générés par les LCG créent parfois une structure uniforme appelée lattice (qui a l’apparence de lignes, plans ou hyperplans parallèles) si on plotte la séquence de paires (xn , xn+1 ). Il a été démontré que plus les plans sont éloignés plus le générateur est de mauvaise qualité CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 178 [8]. On peut bien remarquer que pour cet exemple, quand le paramètre a=95, le générateur congruentiel récursif donne une séquence de caractère aléatoire plus apparent que les deux autres générateurs. Aussi, pour les trois générateurs, les séquences générées avec une valeur de a=99 sont plus aléatoires que celles générées avec la valeur 95. Le test spectral compare les distances entre les plans de la structure lattice, plus elles sont grandes, plus le générateur est mauvais. [5] 6.2.4 Mersene Twister RNG (MT) Mersene Twister RNG (MT) [16] est un RNG bien conçu et puissant caractérisé par sa longue période (219937 ). Il s’agit d’un registre à décalage à rétroaction avec fonction de torsion (TFSR). il a w bits comme longueur de mot et Z2w −1 comme ensemble de sortie. Son algorithme est basé sur la relation de récurrence pour l’initialisation de la graine (seed) et la transformation (torsion) d’état. Il se compose de deux étapes, la première essaie de parcourir l’état et de le tordre de manière récursive (réflexion de bit d’état), et la seconde génère le nombre aléatoire en tempérant la sortie actuelle. L’algorithme de Mersenne Twister manipule une matrice de relations de récurrence linéaire sur le champ binaire fini (F2 , ⊕, ⊗) (⊕ est xor et ⊗ est la multiplication. Les deux opérations sont dans Z2 ) où chaque nombre est représenté comme une séquence de Pw−1 bits (bw−1 · · · b1 b0 ) et il pourrait être écrit comme polynome dans ce champ i=0 bi 2i . Il est caractérisé par les paramètres suivants : - w : la taille du mot en bits - n : dégré de récurrence - m : un décalage utilisé pour définir la séries x, 1 ≤ m < n - r : limite de séparation pour un mot (nombre de bits du masque-bit inférieur) - a : matrice de twist - b, c : masque de transformation - s, t : coefficients de décalage - u, d, l : coefficients de transformation et le décalage. Afin de faciliter le calcul et le test, ces paramètres sont choisis de telle sorte que 2nw−r − 1 est un nombre premier de Mersenne. Relation de récurrence de torsion : (concaténation de r−LSB&(w−r)−M SB) }| { z xi+n = xi+m ⊕ ( msb(xi , w − r) | lsb(xi+1 , r) )A tel que LSB(resc MSB) sont les r bits les moins (resc w − r plus) significatifs du mot courant xi et A est une matrice appelée "matrice de transformation de torsion", définie comme : 0 Iw−1 A= aw aw−1 . . . a1 La multiplication par la matrice A est "la matrice relationnelle de forme normale", elle est simplifiée par la relation suivante : xA = (x 1) ⊕ si(x0 = 1, a, 0w ) La fonction de transformation φg : φg (z, t, m) = z ⊕ ((z t)&m) φl (z, t, m) = z ⊕ ((z t)&m) y = φ(x) = φg (φl (φl (φg (xi , u, d), s, b), t, c), l, 1w ) tel que t, m sont le décalage et le masque. “&” est le "ET" logique binaire (opération bit-wiseand) et est l’opérateur de décalage. y = φ(x) sera la sortie (nombre aléatoire) de l’algorithme dans Z2w −1 , afin d’obtenir un nombre aléatoire uniforme dans [0, 1], nous choisissons g comme fonction φ(x) u= w 2 −1 CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 179 Il existe deux variantes de cet algorithme basées sur la plateforme de l’implémentation 32 bits appelée MT19937 et 64 bits appelée MT19937-64. leurs paramètres sont : Implementation MT19937-32bits MT19937-64bits (w, n, m, r) (32, 624, 397, 31) (64, 312, 156, 31) (l,a) (18, 9908B0DF16) (43, B5026F5AA96619E916) (u, d) (11, FFFFFFFF16) (29, 555555555555555516) (s, b) (7, 9D2C568016) (17, 71D67FFFEDA6000016) (t, c) (15, EFC6000016) (37, FFF7EEE00000000016) f 1812433253 6364136223846793005 Étant donné une graine spécifique, nous commençons par initialiser l’état de l’algorithme (un tableau de n éléments dans Z2w −1 ) en utilisant la relation de récurrence suivante en commençant par x0 = seed : xi = (f ∗ (xi−1 ⊕ xi−1 >> (w − 2))) + i) Algorithm 1 Mersene Twister Generator Input : seed i, (xi )i:0..n−1 = 0, initialize(seed) while True : y = (xi ∧ u) ∨ (x(i+1)[n] ∧ l) xi = (x(i+m)[n] ⊕ (y >> 1) ⊕ si(LSN (y) = 0, 0, a) 6: yield tempering(xi ) 7: i = (i + 1)[n] 1: 2: 3: 4: 5: 8: 9: 10: 11: function initialize(s) z0 = s for i ∈ {1..n − 1} : zi = (f ∗ (zi−1 ⊕ zi−1 >> (w − 2))) + i) 12: return (zi )i:0..n−1 13: 14: 15: 16: 17: function tempering(x) z = x ⊕ (x >> q) z = z ⊕ ((z << s) ∧ b)) z = z ⊕ ((z << t) ∧ c)) 18: return z ⊕ (z >> p) Le code suivant donne l’implémentation python des variantes MT19937. À vos claviers! # Code601_1.py # algo MT19937 def algo_MT19937(seed=0): # coefficients for MT19937 (w, n, m, r) = (32, 624, 397, 31) a = 0x9908B0DF (u, d) = (11, 0xFFFFFFFF) (s, b) = ( 7, 0x9D2C5680) (t, c) = (15, 0xEFC60000) (l, f) = (18, 1812433253) (lower_mask, upper_mask)= (0xFFFFFFFF, 0x00000000) # The state of the generator array of n elements MT = [0 for i in range(n)] CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 180 index = n+1 # initialize the generator from a seed def initialize_mt(seed): MT[0] = seed for i in range(1, n): MT[i] = (f * (MT[i-1] ^ (MT[i-1] >> (w-2))) + i) & 0xffffffff # Generate a random number def generate_number(): # do a twist on every n numbers nonlocal index if index >= n: for i in range(0, n): x = (MT[i] & upper_mask) + (MT[(i + 1) % n] & lower_mask) xA = x >> 1 if (x % 2) == 0 else (x >> 1) ^ a MT[i] = MT[(i + m) % n] ^ xA index = 0 # y y y y y Extract a tempered value based on MT[index] = MT[index] = y ^ ((y >> u) & d) = y ^ ((y << s) & b) = y ^ ((y << t) & c) = y ^ (y >> l) index += 1 return y & 0xffffffff # Generator core initialize_mt(seed) while True: yield generate_number() # generate 10 random numbers if __name__ == ’__main__’: g_MT= algo_MT19937() for _ in range(10): print(next(g_MT)) # ===================================================================== 2357136044 2546248239 3071714933 3626093760 3729171009 3684848379 3480577985 2632805477 679261451 3685339089 6.2.5 RNG Combinés Un RNG combiné est constitué de plusieurs RNGs composés par l’application d’une opération qui combine les différents résultats des LCG. L’addition, xor ou toute autre opération peut être utilisée pour cette combinaison. Ce processus permet d’améliorer la qualité de ces générateurs en créant un générateur équivalent de longues périodes et peut être avec des propriétés statistiques meilleures. 6.2.5.1 Somme/Différence Cette technique consiste à sommer les résultats générés par les CG en se basant sur les deux propositions suivantes : Proposition 1. Si (Wi )1≤i≤n est une collection de v.a.d indépendantes tel que W1 est uniforme sur Zd , alors la v.a de la somme de cette collection dans Zd est uniforme sur cet ensemble. n X W1 ∼ U(Zd ) =⇒ Wi ∼ U(Zd ) 1 CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 181 Proposition 2. Si (Li )1≤i≤n est une famille de LCG tel que Lj de période pj et de fonction de transition sj,i = fj (sj,i−1 ) et le seed de démarrage est s0 = (s1,0 , s2,0 , · · · , sn,0 ) et p est la période de la séquence si = (s1,i , s2,i , · · · , sn,i ) générées par cette famille alors p = P P M C(p1 , p2 , · · · , pn ) 6.2.5.2 (plus petit multiple commun) Wichmann-Hill La methode Wichmann-Hill [4] consiste à générer deux ou plusieurs réels uniformes Uj,i = sur [0, 1] en utilisant les CGs et en prenant la partie décimale de la somme de Uj,i . Xj,i mj Vn = h( X1,n X2,n Xk,n + + ··· + ) m1 m2 mk tel que h(x) = x − bxc est la fonction qui donne la partie décimale d’un nombre réel. Le générateur de Wichmann-Hill L1 = LCG(171,30629) de sortie Xn = L1 (Xn−1 ) L2 = LCG(172,30307) de sortie Yn = L2 (Yn−1 ) L3 = LCG(170,30323) de sortie Zn = L3 (Zn−1 ) Un = h( Yn Zn Xn + + ) m1 m2 m3 Ces trois générateurs L1 , L2 et L3 ont la période maximale (mi − 1) et les périodes respectives sont 30268, 30306 et 30322. La période du générateur combiné est le plus petit multiple commun (PPMC) de ces trois périodes : 6953607871644 [4]. 6.2.6 Critères de qualité Un bon générateur de nombres aléatoires doit : 1- avoir une très longue période (qui doit être prouvée mathématiquement) pour éviter de tourner rapidement en boucle lorsqu’on l’utilise, 2- être efficace en temps d’exécution et utilisation de mémoire. 3- les séquences générées doivent être reproductibles, 4- et évidement, le critère le plus important dans un générateur de nombres aléatoires est le caractère aléatoire des séquences générées. En d’autres termes, la séquence générée doit être des v.a uniformes sur (0,1), indépendantes et identiquement distribuées. Les nombres obtenus des générateurs algorithmiques présents dans la plupart des langages de programmation sont des v.a qui suivent la loi uniforme, soit dans l’intervalle [0, 1] ou bien [0, M ax] tel que M ax est la borne maximale donnée par le programmeur. Dans la prochaine section, nous verrons comment transformer ces v.a uniformes en des v.a d’autres distributions. 6.3 Tests statistiques des générateurs de nombres aléatoires Le domaine des tests statistiques des RNG reste un champs de recherche actif, et à ce jour plusieurs tests ont été proposés, parmi ceux-ci nous allons voir le test de fréquence pour l’uniformité et le test d’autocorrelation pour l’indépendance. L’uniformité et l’indépendance sont les propriétés les plus testées pour les RNGs. Les tests que nous allons voir sont basés sur les tests d’hypothèse connus en statistique. L’idée consiste d’avoir deux hypothèses : 1. H0 : l’hypothèse nulle, dans le cas de l’uniformité par exemple, cette hypothèse stipule que le RNG est uniformément distribué. 2. H1 : l’hypothèse alternative qui stipule que le RNG n’est pas uniformément distribué. Le résultat décide si le test rejette H0 ou bien échoue de la rejeter (on parle d’échec de rejet au lieu d’acceptation car pour accepter une hypothèse on doit tester un nombre infini de cas. Un échec du rejet veut dire qu’aucune preuve de non conformité n’a été détectée). CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 182 Deux types d’erreurs doivent aussi être définies : • Erreur type I : consiste à rejeter H0 alors qu’elle est vraie. • Erreur type II : consiste à ne pas rejeter H0 alors qu’elle est fausse. Le résultat du test est toujours établi avec un seuil de signification α qui est la probabilité de rejeter H0 alors qu’elle est vraie (erreur type I) P(rejet H0 | H0 est vraie). Nous cherchons une probabilité petite, mais la réduction de α augmente la probabilité de l’erreur de type II, donc un équilibre entre les deux est nécessaire. 6.3.1 Tests de Fréquence Deux tests de fréquence existent : le test Kolmogorov-Smirnov et le test Chi-square. 6.3.1.1 Test Kolmogorov-Smirnov (K-S) Ce test est utilisé pour décider si une séquence suit une distribution (théorique) spécifique. Soit une séquence de N données ordonnées (du plus petit au plus grand) : Y1 , Y2 , ..., Yn . La fonction de distribution empirique est définie par : En (Yi ) = n(i)/N tel que n(i) est le nombre de valeurs inférieures ou égales à Yi . Les valeurs n(i) sont aussi ordonnées du plus petit au plus grand. Le test K-S est basé sur la distance maximale entre la distribution théorique et la distribution cumulative empirique. On défini les hypothèses : H0 : les données suivent une distribution spécifique H1 : les données ne suivent pas la distribution spécifique. Soit la statistique DKS = max |F (Yi ) − En (Yi )| i=1..N F est la fonction cumulative de la distribution théorique à tester qui doit être continue et complètement spécifiée (tous ses paramètres sont connus). La valeur Dα est déterminée de la table statistique K-S (voir annexe C) pour le niveau de signification α et N . Si DKS > Dα , l’hypothèse nulle H0 est rejetée sinon il n’y a pas d’évidence pour la rejeter. Exemple 1. On veut savoir (α = 0.05) si la série suivante suit une loi Normale : 4, 5, 5, 1, 1, 3, 2, 2, 4, 10, 7, 5, 5, 4, 8, 9, 7, 6 La méthode consiste à trier les valeurs par ordre croissant, ensuite les centrer et réduire, calculer la statistique DKS décrite plus haut et enfin chercher la valeur dans la table K-S (??) correspondante à N et à α pour décider si on rejette l’hypothèse ou pas. DKS = 0.148 < D18,0.05 = 0.30936, donc H0 n’est pas rejetée. CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 183 À vos claviers! #Code602.py from scipy import stats from scipy.stats import ksone # stats.kstest: returns the calculeted KS statistic # ksone.ppf: returns the KS table value correspondent to alpha and n def testKS(data,alpha,F,p): n = len(data) DKS = stats.kstest(data, lambda x: F(x,**p))[0]; print(’DKS :’, DKS) DA = ksone.ppf(1-alpha/2, n); print(’Dalpha :’, DA) return(DKS<DA) # Test, loc is the sequence average and scale is its standard deviation x = [4,5,5,1,1,3,2,2,4,10,7,5,5,4,8,9,7,6] alpha = 0.05 print(’H0 : ’,testKS(x, alpha, stats.norm.cdf, {’loc’:4.88,’scale’:2.60})) #______________________________ # DKS : 0.14826048100509914 # Dalpha : 0.30936031179258944 # H0 : True 6.3.1.2 Output ______________________________________ Test Chi-square (χ2 ) Ce test se base sur la même idée que le test K-S sauf que la statistique utilisée est l’espérance de la différence entre la fréquence théorique et la fréquence observée. Soit un échantillon de n observations indépendantes supposées appartenir à une distribution quelconque. Cette séquence d’observation peut être regroupée en k intervalles ou classes. Le nombre d’observations à l’intérieur de la ieme classe est appelé la "fréquence observée Oi ". Le nombre d’observations théoriques à l’intérieur de cette classe est appelé "fréquence théorique Ei " (Expected). n X (Oi − Ei )2 χ2c = Ei i=1 Cette valeur est appelée la statistique du Chi-square calculée. Pour une question d’exactitude, le nombre de fréquences observées dans chaque classe doit être supérieur à 5. Exemple 2. Soit une séquence de 100 nombres aléatoires compris entre 0 et 9. Les hypothèses testées sont : H0 : la séquence générée suit une loi uniforme dans l’intervalle [0,9] H1 : la séquence générée ne suit pas une loi uniforme dans l’intervalle [0,9] La probabilité d’apparition de chaque entier est 1/10. La fréquence théorique attendue étant 100 ∗ 1/10, soit 10. On obtient les résultats suivants : Comme χ2c = 8 est inférieur à celle de la table χ29,0.05 = 16.9, on ne rejette pas l’hypothèse H0 (que la séquence générée suit une loi uniforme dans l’intervalle[0,9]). Les générateurs de nombres pseudo-aléatoires peuvent également produire des séquences "trop aléatoires", les tests empiriques dans ce cas donnent des valeurs χ2c très faibles, voir proches de 0. Il est donc recommandé d’effectuer un test à gauche : H0 est rejetée si χ2c < χ2(k−1,1−α) . Dans CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 184 cet exemple, χ2c = 8.0 n’est pas inférieur à celle de la table χ2(9,0.95) = 3.32, on ne rejette donc pas H0 . À vos claviers! #Code 603.py from scipy.stats import chisquare from scipy.stats import chi2 # chisquare: returns the calculeted Chi2 statistic # chi2.ppf: returns the chi2 table value correspondent to alpha and df def testChi2(data_obs, data_expected=None, alpha=0.05): df = len(data_obs) - 1 Dc2 = chisquare(data_obs, data_expected) if data_expected else chisquare(data_obs) print(’DChi2 :’, Dc2[0]) DA = chi2.ppf(1-alpha, df); print(’Dalpha :’, DA) return(Dc2[0]<DA) # Test, loc is the sequence average and scale is its standard deviation x = [8,12,13,14,9,6,8,7,14,9] alpha = 0.05 print(’H0 : ’,testChi2(x)) #______________________________ # DChi2 : 8.0 # Dalpha : 16.918977604620448 # H0 : True 6.3.2 Output ______________________________________ Test d’autocorrélation On considère une séquence Y1 , Y2 , ...Yn de nombres aléatoires. Le coefficient d’autocorrélation sérielle (coefficient de corrélation de Pearson) est défini par : Pn Pn n( i=1 Yi Yi+1 + Yn Y1 ) − ( i=1 Yi )2 C= Pn Pn n( i=1 Yi 2 ) − ( i=1 Yi )2 Il mesure la dépendance entre deux nombres successifs. Il prend toujours une valeur entre −1 et +1. Une valeur proche de 0 signifie que les nombres aléatoires sont indépendants, alors qu’une valeur proche de −1 ou +1 indique une dépendance linéaire entre les nombres et donc l’absence de l’aléatoire. À vos claviers! # Code604.py # Pearson correlation coefficient def autocorrelation(data): n=len(data) nextData = [data[i]*data[(i+1)%n] for i in range(n)] squareData = [data[i]**2 for i in range(n)] autocorrel = (n*sum(nextData) - sum(data)**2 ) / ( n*sum(squareData) - sum(data)**2) return autocorrel data1 = [96, 929, 192, 833, 288, 737, 384, 641, 480, 545, 576, 449, 672, 353, 768, 257, 864, 161, 960,65, 32, 993, 128, 897, 224, 801, 320, 705, 416, 609, 512, 513, 608, 417, 704, 321, 800, 225,896, 129, 992, 33, 64, 961, 160, 865, 256, 769, 352, 673, 448, 577, 544, 481, 640, 385, 736,289, 832, 193, 928, 97, 0, 1, 96, 929, 192, 833, 288, 737, 384, 641, 480, 545, 576, 449, 672,353, 768, 257, 864, 161, 960, 65, 32, 993, 128, 897, 224, 801, 320, 705, 416, 609, 512, 513,608, 417, 704, 321, 800] print(’Data1 : ’, autocorrelation(data1)) data2 = [100, 685, 232, 441, 652, 37, 592, 241, 308, 797, 56, 425, 92, 917, 672, 993, 4, 397, 392, 921,44, 261, 240, 209, 212, 509, 216, 905, 508, 117, 320, 961, 932, 109, 552, 377, 460, 485, 912,177, 116, 221, 376, 361, 924, 341, 992, 929, 836, 845, 712, 857, 876, 709, 560, 145, 20, 957, 536, 841, 316, 565, 640, 897, 740, 557, 872, 313, 268, 933, 208, 113, 948, 669, 696, 297, 732,789, 288, 865, 644, 269, 8, 793, 684, 133, 880, 81, 852, 381, 856, 777, 124, 1013, 960, 833,548, 1005, 168, 249, 76] print(’Data2 : ’, autocorrelation(data2)) #______________________________ # Data1 : -0.6533458794659233 # Data2 : -0.023560372803231835 Output ______________________________________ CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 6.4 185 Simulation des variables aléatoires 6.4.1 Simulation de v.a discrètes 6.4.1.1 Méthode de transformation inverse Supposons que nous voulons générer la valeur d’une v.a discrète X ayant la fonction de probabilité : X P (X = xj ) = pj j = 0, 1, .. et pj = 1 j Nous devons générer un nombre aléatoire u uniformément distribué sur [0, 1] ensuite on définit : x0 si u < p0 x si p0 ≤ u < p0 + p1 1 ... X= j−1 j P P xj si pi ≤ u < pi i=0 i=0 ... Et puisque pour 0 < a < b < 1, p(a ≤ u < b) = b − a, nous avons P (X = xj ) = P ( j−1 X pi ≤ u < i=0 j X pi ) = pj i=0 Donc X a la distribution voulue. Algorithmiquement ce processus se traduit par : Algorithm 2 Méthode de transformation inverse pour v.a.d Input : xi , pi i ≥ 0 u = RNG() for i = 0 toPN do i 4: if (u < k=0 pk ) then 5: return xi 1: 2: 3: Tel que RN G() est le générateur utilisé pour avoir une valeur d’une distribution uniforme. Si les valeurs de xi , i ≥ 0 sont triées par ordre croissant x0 < x1 < x2 <..... et si F est la i P fonction de distribution cumulative de X, alors F (xi ) = pk et donc X sera égale à xi si k=0 F (xi−1 ) ≤ u < F (xi ). En d’autres termes, après avoir généré un nombre aléatoire u, nous déterminons la valeur de X en cherchant l’intervalle [F (xi−1 ), F (xi )] où se trouve u (en trouvant l’inverse de F (u)). Le temps nécessaire pour générer une v.a discrète par cette méthode est proportionnel aux nombre d’intervalles qu’on doit chercher. Pour cette raison, il est parfois préférable de considérer les valeurs possibles xi de X par ordre décroissant de pi Exemple 3. Simuler une v.a.d X tel que : p1 = 0.20, p2 = 0.15, p3 = 0.25, p4 = 0.40 pj = P (X = j). méthode 1. 1. Générer u CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 2. 3. 4. 5. 186 Si u<0.20 alors, X=1. Si u<0.35 alors, X=2. Si u<0.60 alors, X=3. Sinon X=4. Une méthode plus efficace consiste à considérer les probabilités par ordre décroissant : 1. Générer u 2. Si u<0.40 alors, X=4. 3. Si u<0.65 alors, X=3. 4. Si u<0.85 alors, X=1. 5. Sinon X=2. À vos claviers! #Code 605.py import random from itertools import accumulate from operator import itemgetter # def transformation_inverse(prob,indices): u = random.random() for i in range(len(prob)): if(u<prob[i]): return indices[i] return indices[-1] # returns the frequencies in N generated rv def generate(prob, N=100000): indices, prob = zip(*sorted(enumerate(prob), key=itemgetter(1),reverse=True)) prob = list(accumulate(prob)) freq = {k:0 for k in range(len(prob))} for _ in range(N): gen = transformation_inverse(prob,indices) freq[gen] += 1 return {k:v/N for k,v in freq.items()} # test prob = [0.2,0.15,0.25,0.4] print(generate(prob)) #______________________________ Output ______________________________________ #{1: 0.19671, 2: 0.1498, 3: 0.25018, 4: 0.40331} Dans le cas où la v.a suit une loi uniforme discrète, il n’est pas nécessaire de chercher l’intervalle approprié où le nombre aléatoire se trouve. En effet, si on veut générer la valeur de X qui prend des valeurs de 1..n : P (X = j) = 1/n j = 1, ...n En utilisant les résultats précédents, nous pouvons accomplir ceci en générant u et mettre : j−1 j X = j si ≤u< =⇒ x = j si (j − 1) ≤ n × u < j n n En d’autres termes X = b(n × u) + 1c tel que bxc est la partie entière de x. 6.4.1.2 Méthode d’acceptation-rejet Supposons que nous avons une méthode efficace pour simuler une v.a Y ayant la fonction de probabilité {qj , j ≥ 0}, nous pouvons l’utiliser comme une base pour simuler une v.a X ayant la distribution {pj , j ≥ 0} en simulant Y , ensuite accepter la valeur obtenue avec une probabilité p proportionnelle à qyy . Cette méthode est aussi appelée la méthode du rejet. Soit c une constante tel que : pj qj ≤ c, ∀j. La technique du rejet est la suivante : Exemple 4. Soit la v.a X qui prend les valeurs dans {1, 2, 3, ..., 10} avec les probabilités respectives : 0.11, 0.12, 0.09, 0.08, 0.12, 0.10, 0.09, 0.09,0.10, 0.10. Il est préférable d’utiliser la méthode du rejet avec q la densité uniforme discrète ; c.à.d : p qj = 1/10 ∀j = 1, .., 10. Pour ce choix de qj , nous pouvons prendre C = M ax qjj = 1.2, et l’algorithme de simulation est comme suit : CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 187 Algorithm 3 Méthode de rejet pour v.a.d 1: 2: 3: 4: 5: 6: Input : c, pj , qj ∀j while True do y ← simuler la v.a Y ayant la fonction de probabilité qj générer un nombre aléatoire u p if u < cqyy then return y (1) Générer un nombre aléatoire u1 , mettre, y = Int(10u1 ) + 1 (2) Générer un second nombre aléatoire u2 py alors X = y ; sinon aller à (1). (3) Si u2 < 0.12 La valeur 0.12 vient du fait que cqj = 1.2/10. Cette méthode prend en moyenne seulement 1.2 itérations pour avoir la valeur générée de X. À vos claviers! #Code606.py import random # acceptance-rejection method def acceptationRejet(pj, qj, genY, **p): c = max([pj[k]/qj[k] for k in pj.keys()]) while (True): y = genY(qj, **p) u = random.random() if(u < pj[y]/(qj[y]*c)): return y return -1 # def generate(pj,qj,N=100000): freq = {k:0 for k in pj.keys()} for _ in range(N): gen = acceptationRejet(pj, qj, lambda qi : int(random.random()*10)+1 , **{}) freq[gen] += 1 return {k:v/N for k,v in freq.items()} # test pj = {1:0.11,2:0.12,3:0.09,4:0.08,5:0.12,6:0.10,7:0.09,8:0.09,9:0.05,10:0.15} qj = {1:0.1 ,2:0.1,3:0.1,4:0.1,5:0.1,6:0.1,7:0.1,8:0.1,9:0.1,10:0.1} print(generate(pj,qj)) #______________________________ Output ______________________________________ #{1: 0.10696, 2: 0.1202, 3: 0.09187, 4: 0.07928, 5: 0.11926, 6: 0.09927, # 7: 0.09127, 8: 0.09055, 9: 0.0494, 10: 0.15194} 6.4.2 Simulation de v.a continues 6.4.2.1 Méthode de transformation inverse Soit une v.a continue ayant la fonction de distribution F . La méthode de transformation inverse est basée sur la proposition suivante : Proposition 3. Soit U une v.a uniforme sur [0, 1]. Pour n’importe quelle fonction de distribution continue F , la v.a X définie par X = F −1 (U ) a la distribution F . (F −1 (U ) est définie pour être la valeur de x tel que F (x) = U ). Preuve. Soit FX la fonction de distribution de X = F −1 (U ) (croissante et monotone, a ≤ b est équivalente à F (a) ≤ F (b)) donc : X ≤ x =⇒ F −1 (U ) ≤ x =⇒ F (F −1 (U )) ≤ F (x) =⇒ U ≤ F (x) alors, FX (x) = P (X ≤ x) = P (F −1 (U ) ≤ x) = P (U ≤ F (x)) = FU (F (x)) = F (x) CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 188 FX (x) = F (x) car U est uniforme sur [0, 1] Cette proposition montre que nous pouvons générer une v.a X d’une fonction de distribution F en générant un nombre aléatoire u et mettre X = F −1 (u) Algorithm 4 Méthode de transformation inverse pour v.a.c 1: 2: 3: Input : FX générer un nombre aléatoire u ∈ [0, 1] −1 return FX (u) Exemple 5. Utiliser cette méthode pour générer une v.a ayant une fonction de distribution F (x) = xn , 0 < x < 1. Si on considère x = F −1 (u) alors, u = F (x) = xn et de façon équivalente, x = u1/n Nous pouvons donc générer une telle v.a X en simulant une v.a uniforme U ensuite mettre X = U 1/n Exemple 6. Si X est une v.a exponentielle de taux 1, alors sa fonction de distribution est donnée par : F (x) = 1 − e−x Si x = F −1 (u), alors u = F (x) = 1 − e−x 1 − u = e−x =⇒ x = −log(1 − u) Nous pouvons donc, simuler une v.a exponentielle de paramètre 1 en simulant une v.a uniforme U et mettre : X = −log(1 − U ) Nous pouvons remplacer 1 − U par U car les deux sont des v.a uniforme sur [0,1]. Une v.a exponentielle X de taux λ est simulée en simulant une v.a uniforme U et mettre : 1 X = − log(U ) λ À vos claviers! #Code607.py from sympy import symbols, solveset,S from sympy.functions import exp import random import matplotlib.pyplot as plt import numpy as np # def plot_fc(x,y): plt.plot(x,y) plt.show() # to find the inverse of f we solve the equation y =f(x) using def inverse(f): expr1 = solveset(f-y,x, domain=S.Reals) return(expr1.args[1].args[0]) # def generate_inverse(f,l,N=1000): fc = inverse(f).subs(lamda,l) p = np.sort([random.random() for _ in range(N)]) r = [ fc.subs(y,u) for u in p] return {’x’:r, ’y’:p} # symbols x ,y ,lamda = symbols(’x ,y ,lamda’) if __name__== ’__main__’: f = 1-exp(-lamda*x) plot_fc(**generate_inverse(f,1)) solveset of sympy CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 189 Figure 6.5 – CDF générée 6.4.2.2 Méthode d’acceptation-rejet La méthode d’acceptation-rejet est exactement la même que dans les cas des v.a discrètes, avec la seule différence que les fonctions de densités remplacent les fonctions de masse. Soit X une v.a de densité fX , Y une autre v.a de densité fY et C une constante. On définit . Soit la v.a U de loi uniforme sur [0,1]. h = ffX Y fY (x|U < En effet : fY (x|U ≤ h(Y ) C ) = P (U ≤ h(Y ) C |Y =x)fY h(Y ) C ) h(Y ) ) = h(x)fY (x) = fX (x) C (x) P (U ≤ h(x) ) = P (U ≤ h(x) P (U ≤ h(Y C |Y = x) C )= C R R h(x) R ) h(Y ) 1 P (U ≤ h(Y C ) = R P (U ≤ C |Y = x)fY (x)dx = R C fY (x)dx = C R fX (x)dx = Donc : h(Y ) fY (x|U ≤ ) = fX (x) C On choisit la constante C = max{h(x)} et on applique l’algorithme suivant : 1 C Algorithm 5 Méthode de rejet pour v.a.c Input : C, fX , fY while True do générer y de la fonction de probabilité fY 4: générer un nombre aléatoire u fX (y) then 5: if u < Cf Y (y) 6: return y 1: 2: 3: Le nombre moyen d’itérations nécessaires à cette méthode pour simuler la v.a X est égal à C. fX (y) Comme la condition d’arrêt de l’algorithme u < Cf dépend des v.a X et Y , le nombre de Y (y) ses itérations N est une v.a. L’algorithme est similaire à une expérience de Bernoulli tel que une condition fausse est considérée comme un échec et vrai comme un succès qui termine l’algorithme, N suit donc la loi Geometrique de paramètre C1 . En effet : Z +∞ Z +∞ fX (y) fX (y) 1 fX (Y ) )= P (U ≤ )fY (y)dy = dy = P (U ≤ CfY (Y ) CfY (y) C C −∞ −∞ Donc : E(N ) = C Exemple 7. Utilisons cette méthode pour générer une v.a ayant la fonction de densité : f (x) = 3 2 x (2 − x) 4 pour 0 < x < 2 CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 190 On considère la méthode de rejet avec : g(x) = x/2 0<x<2 (x) ≤ C, on doit déterminer la valeur Pour déterminer la valeur de la constante C tel que fg(x) maximale de f (x) 3 h(x) = = x(2 − x) g(x) 2 ( f (x) 0 ) = 3 − 3x = 0 =⇒ x = 1 g(x) f (x) 3 ≤ h(1) = = c g(x) 2 Le nombre moyen d’itérations nécessaires est c = 23 . À vos claviers! #Code609.py from sympy import diff, simplify import random import numpy as np from sympy.solvers import solve from Code607 import inverse, plot_fc, x, y # def reject(h, g, c): nb_iter = 0 while True: v = inverse(g).subs(y,random.random()) u = random.random() nb_iter += 1 if u <= h.subs(x,v)/c: return v,nb_iter # def generate_reject(f,g,h,c,N=1000): res = [reject(h,g,c) for _ in range(N)] freq = sum([v[1] for v in res])/N ;print("average iterations number",freq) r = np.sort([v[0] for v in res]) p = [ f.subs(x,u) for u in r] return {’x’:r, ’y’:p} #symbols f = (3/4)*x**2*(2-x) g = (1/2)*x h = f/g hp = simplify(diff(h)); print("derivative:",hp) sols = solve(hp); print("solutions:",sols) c = h.subs(x,sols[0]); print("C:",c) plot_fc(**generate_reject(f,g,h,c)) #______________________________ # derivative: 3.0 - 3.0*x # solutions: [1.00000000000000] # C: 1.50000000000000 # average iterations number 1.53 Output ______________________________________ Figure 6.6 – PDF générée CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 6.5 191 Exercices Exercice 1. Donnez les trente premiers nombres générés par les RNG suivants (seed=1) : 1- xn = (5xn−1 )[7] 2- xn = (6xn−1 + 4)[11] 3- xn = (xn−1 + xn−2 )[9] 4- xn = (2xn−1 + 3xn−2 )[9] Exercice 2. Soit la suite des nombres aléatoires suivante : 92, 550, 238, 40, 110, 520, 615, 493, 369, 507 1. En utilisant les test K-S avec un seuil α = 0.05 vérifier si cette séquence suit une loi exponentielle de paramètre λ égal à 1e tel que e est la moyenne empirique de l’échantillon. 2. En calculant le coefficient de corrélation de Pearson vérifier si cette suite est aléatoire ? Exercice 3. Soit le générateur congruentiel linéaire de paramètres a, m et seed = x0 . 1. Montrer que xn = an x0 [m]. 2. Quelle est la période de ce générateur ? (utiliser le théorème d’Euler : si m et a sont des entiers positives premiers entre eux alors la relation suivante est vérifiée : aφ(m) = 1 mod m tel que φ est la fonction d’Euler qui donne le nombre des nombres relativement premiers avec m). 3. Quelle est la valeur de cette période si m est premier ? donner sa valeur pour m = 11. b 4. Montrer que la période du RNG est m 4 si m = 2 , ∀ b > 2. Exercice 4. Soit le générateur congruentiel mixte de paramètres a,m et c. n −1 )[m]. 1. Montrer que xn+1 = (an+1 x0 + c aa−1 2. Quelle est la période de ce générateur ? Exercice 5. Deux dés sont lancés 150 fois, les fréquences observées de la somme des valeurs obtenues sont données dans le tableau suivant : i 2 3 4 5 6 7 8 9 10 11 12 Oi 5 6 10 16 18 32 20 13 16 9 5 En appliquant le test χ2 (α = 0.05), tester l’hypothèse suivante : H0 : les deux dés ne sont pas truqués. H1 : les deux dés sont truqués. Exercice 6. Soit X une v.a.c ayant la fonction de densité fX (x) = 3x2 pour 0 < x < 1. En utilisant la méthode de transformation inverse, écrire l’algorithme qui permet de simuler cette v.a. Exercice 7. Soit la v.a.c. X de densité f (x) = 30x2 (1 − x)2 pour 0 ≤ x ≤ 1 et Y de densité g(y) = 1 pour 0 ≤ y ≤ 1. Écrire l’algorithme qui simule la v.a X par la méthode du rejet. Exercice 8. 1. Simuler la génération des valeurs d’une v.a X qui suit la loi Bin(5, 0.2). 2. Écrire le code Python correspondant. −1 3. Plotter fX , FX et FX . Exercice 9. ln(U ) Soit la v.a X qui suit la loi Geo(p). Monter que X = b ln(1−p) c+1 CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 6.6 192 Solutions Solution 1. 1. [1, 5, 4, 6, 2, 3, 1, 5, 4, 6, 2, 3, 1, 5, 4, 6, 2, 3, 1, 5, 1, 5, 4, 6, 2, 3, 1, 5, 4, 6] la période=6. 2. [1, 10, 9, 3, 0, 4, 6, 7, 2, 5, 1, 10, 9, 3, 0, 4, 6, 7, 2, 5, 1, 10, 9, 3, 0, 4, 6, 7, 2, 5] la période=10. 3. [1, 1, 2, 3, 5, 8, 4, 3, 7, 1, 8, 0, 8, 8, 7, 6, 4, 1, 5, 6, 2, 8, 1, 0, 1, 1, 2, 3, 5, 8] la période= 24. 3. [1, 1, 5, 8, 7, 1, 8, 8, 4, 1, 2, 8, 1, 1, 5, 8, 7, 1, 8, 8, 4, 1, 2, 8, 1, 1, 5, 8, 7, 1] la période= 12. Solution 2. λ = 1/353.4 F (x) = 1 − e−λx 1- Puisque D10,0.05 > DKS alors la séquence suit la loi exponentielle. 2- Le coefficient d’autocorrélation C = 0.1014, donc la suite est aléatoire. Solution 3. 1. xn+1 = axn [m] = a2 xn−1 [m] = a3 xn−2 [m] = ... = an+1 x0 [m] (par induction). 2. Soit p la période de ce générateur congruentiel linéaire. xn+p = an+p x0 [m] = xn =⇒ ap = 1[m] donc p = φ(m) d’après le théorème d’Euler. 3. Puisque m est premier alors, p = φ(m) = m − 1, φ(11) = 10. Lorsque m est premier, la période est maximale. 4. xn = axn−1 [m]2b = an x0 [2b ] b On montre par induction sur b que 24 est la période : On suppose que : a 2b+1 4 2b 4 b−2 = a2 = 1[2b ] et on démontre que : b−1 a = a2 = 1[2b+1 ] 2b−2 2 2 b (a ) = 1 [2 ] = (k2b + 1)2 = k 2 22b + 2k2b + 1 b−1 a2 = 2k2b (k2b−1 + 1) + 1 = 1[2b+1 ] Solution 4. 1. xn+1 = (axn + c)[m] = (a2 xn−1 + ac + c)[m] = (a3 xn−2 + a2 c + ac + c)[m] = ... = (an+1 x0 + c n X ai )[m] i=0 n+1 = (a an − 1 x0 + c )[m] a−1 CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES 193 2. Soit p la période de xn+1 = an+1 x0 [m] n+p−1 xn+p = (an+p x0 + c a a−1 −1 )[m] = xn p est aussi la période du générateur congruentiel mixte. Solution 5. i 2 3 4 5 6 7 8 9 10 11 12 Oi 5 6 10 16 18 32 20 13 16 9 5 pi 1 36 1 18 1 12 1 9 5 36 1 6 5 36 1 9 1 12 1 18 1 36 Ei 4 8 12 16 20 24 20 16 12 8 4 (Oi −Ei )2 Ei 1 4 1 2 1 3 0 1 5 8 3 0 9 16 4 3 1 8 1 4 2 Pn i) = 6.22083 χ2c = i=1 (Oi −E Ei La valeur χ210,0.05 = 3.94 < χ2c , donc l’hypothèse H0 est rejetée. Solution 6. fX (x) = 3x2 , donc FX (x) = x3 pour 0 < x < 1 −1 FX (x) = x1/3 , ainsi, le pseudo algorithme de simulation est le suivant : 1. générer un nombre aléatoire u ∈ [0, 1]. −1 2. retournerFX (u). Solution 7. (x) Soit h(x) = fg(x) et C = max{h(x)}. 15 C = 8 . L’algorithme de simulation est comme suit : 1. générer y de la fonction g. 2. générer un nombre aléatoire u ∈ [0, 1]. 3. si u < h(u) alors return y sinon aller à 1. c Solution 8. pX (k) = Cnk pk (1 − p)n−k −1 X = FX (U ) = min{x|FX (x) < U } 1. 2. 3. 4. 5. 5. 6. X 0 1 2 3 4 5 FX (x) 0.32768 0.73728 0.94208 0.99328 0.99968 1.000 Générer u Si u < 0.32768 Si u < 0.73728 Si u < 0.94208 Si u < 0.99328 Si u < 0.99968 Sinon X=5. alors, alors, alors, alors, alors, X=0. X=1. X=2. X=3. X=4. CHAPITRE 6. GÉNÉRATION DES VARIABLES ALÉATOIRES Figure 6.7 – Simulation d’une distribution binomiale Solution 9. FX (k − 1) Pk−1 k−2 p n=0 (1 − p) < U ≤ < U ≤ FX (k) Pk p)k−1 p < U ≤ n=0 (1 − k p 1−(1−p) 1−(1−p) k−1 < U ≤ 1 − (1 − p)k (1 − p)k ≤ 1−U < (1 − p)k−1 k−1 p 1−(1−p) 1−(1−p) 1 − (1 − p) kln(1 − p) ≤ ln(1 − U ) < k−1 Donc X = < ) b ln(1−U ln(1−p) c ln(1−U ) ln(1−p) +1 ≤ (k − 1)ln(1 − p) k 194 Chapitre 7 Simulation en Python 7.1 Introduction En Python, différents packages de simulation existent, ils permettent de simuler des expériences aléatoires prédéfinies telles que le lancer de pièce ou de dé, les tirage de cartes, de boules des urnes, ainsi que des expériences définies par l’utilisateur. Ils permettent également de définir et simuler des variables aléatoires avec leurs distributions, des processus aléatoires et aussi la représentation graphique de leurs résultats. Le package simpy par exemple offre la possibilité de simuler des systèmes en modélisant leurs composants sous forme de processus et des ressources partagées. Dans ce qui suit nous présentons les API de ces bibliothèques ainsi des codes montrant leur utilisation en simulation. 7.2 7.2.1 Outils de simulation Python Python est un langage de programmation interprété qui favorise la programmation impérative structurée, fonctionnelle et orientée objet (multi-paradigme) et il est de typage dynamique, open source et multi-platefomes. Il est apprécié pour la simplicité de sa syntaxe. En 1991, la première version du langage Python est lancée par son créateur Guido van Rossum. Actuellement il est maintenu par Python Software Foundation sous sa propre licence (PSF License). La communauté Python a adopté une convention de style d’écriture du code qui est standardisé sous l’appellation PEP8. À partir de 2009 et afin d’éliminer les faiblesses des versions 2.x du langage la version 3 a été introduite sans garder une compatibilité avec sa précédente. La version Python 3.11.0a5, la plus récente a été lancée en Février 2022. Les environnements de développement intégrés (IDE : integrated development environment) les plus utilisés pour le développement Python sont VS Code, Pycharm, Jupyter, Spyder, PyDev et Eclipse. En plus de l’IDE, et afin de renforcer la productivité des développeurs, Python intègre deux utilitaires qui facilitent le processus de développement et qui sont pip et venv. pip est un gestionnaire de package qui permet de gérer les dépendances des projets logiciels. Comme Python est utilisé dans beaucoup de systèmes comme langage de script pour les tâches d’administration, lors de son utilisation pour le développement il est préférable de l’isoler du reste du système, un environnement virtuel est crée pour assurer cette isolation en créant un environnement contrôlé (avec des dépendances spécifiques au projet en cours). le module venv (virtual environment) permet de faire ça. 7.2.1.1 Python Standard Library La bibliothèque standard de Python (PSL : Python Standard Library) regroupe une collection de packages et de modules qui implémentent le noyau du langage et les bibliothèques de base (Éléments intégrés (Fonctions, types, Exceptions), String, Math, Fonctionnel, IO, Parallélisme, Internet Reseaux, XML JSON, I18,..). Le 31 mars 2022, la version 3.10.4 a été lancée enrichie avec plusieurs fonctionnalités. Dans ce qui suit nous allons exposer les modules qui servent de 195 CHAPITRE 7. SIMULATION EN PYTHON 196 support pour les packages de la statistique et la simulation. Le module random random génère les nombres pseudo-aléatoires en implémentant les générateurs des différentes distributions et en fonction des types désirés (entier, séquence ou réel). Python utilise l’algorithme Mersenne Twister comme générateur de base dont la période est 219937 − 1 et 53bits de précision pour les réels. La fonction random() joue le rôle d’un PRNG des v.a.c X de distribution uniforme [0.0, 1.0[, elle est utilisée par les autres fonctions pour la génération des autres distributions. Pyhthon 3.9/Lib/random.py : class Random(_random.Random) 1- Core init(x=None) seed(a=None, version=2) get/setState([value]) random() 2- Générateurs discrèts randbytes(n) randrange([start,] stop[, step]) randint(a, b) getrandbits(k) choice(seq) choices(pop, weights=Nn, *, cum_weights=Nn, k=1) sample(pop, k, *, counts=Nn) shuffle(x, random=Nn) 3- Générateurs continus distribution(parametres) Constructeur de Random, x est le seed Initialise le générateur de nombres aléatoires. Renvoie un objet capturant l’état interne du générateur ou le modifier. Renvoie un nombre aléatoire à virgule flottante dans la plage [0,1[. Génère n octets aléatoires. Renvoie un élément sélectionné aléatoirement de rang(start, stop, step). Renvoie un entier N tel que a ≤ N ≤ b. Alias pour randrange(a,b+1). Renvoie un entier non négatif de k bits aléatoires Renvoie un élément de la séquence seq. Renvoie une liste de k éléments choisis dans la population p avec remise. Renvoie une liste de k éléments uniques dans la population sans remise. Mélange la séquence x sans créer une nouvelle instance. qui sont : betavariate(alpha, beta) ; expovariate(lambd) ; gammavariate(alpha, beta) ; gauss(mu, sigma) ; lognormvariate(mu, sigma) ; normalvariate(mu, sigma) ; paretovariate(alpha) ; triangular(low=0.0, high=1.0, mode=None) ; uniform(a, b) ; vonmisesvariate(mu, kappa) Le module Itertools Itertools contient les fonctions permettant de créer des iterateurs pour des boucles efficaces. Certaines sont très utilisées dans le domaine de la probabilité, des statistiques et du calcul combinatoire : Pyhthon 3.9/Lib/itertools.py 1- Itérateurs finis accumulate(p[,func]) chain(p,q,..) compress(d,s) dropwhile(pred,seq) filterfalse(pred,seq) groupby(iteraable[,key]) islice(seq,[start,]stop[,step]) startmap(func,seq) takewhile(pre,seq) 2- Itérateurs infinis count(start[,step]) cycle(p) repeat(e[,n]) renvoie p0 , p0 + p1 , p0 + p1 + p2 , · · · (φ([1,2,3])=1 3 6). renvoie p0 , p1 , · · · , pl , q0 , q1 , · · · , (φ(ABC,DE)=A B C D E d : data, s : selectors, renvoie (di if si )i≥0 , (φ(ABCD,[1,0,1,0])=A C renvoie seq[n], seq[n+1], commençant lorsque pred échoue, (φ(lambda x : x<5, [1,4,6,4,1])=6 4 1 renvoie éléments de seq pour lesquels pred(elem) est faux, (φ(lambda x : x%2, range(10))=0 2 4 6 8 renvoie sous-itérateurs groupés par la valeur de key(v) renvoie éléments de seq[start :stop :step], (φ(ABCDEF, 2, Nn)=C D E F renvoie func(*seq[0]), func(*seq[1]), ..., (φ(pow, [(2,5), (3,2)])=32 9 renvoie seq[0], seq[1], jusqu’à ce que pred échoue, (φ(lambda x : x<5, [1,4,6,4])=1 4 start, start+step, start+2*step, (φ(10)=10, 11, 12, 13, 14 ...) p0 , p1 , · · · plast , p0 , p1 · · · , (φ(’ABCD’)=A B C D A B C D ...) e, e, e, · · · à ∞ ou jusqu’à n fois, (φ(8,3)=8 8 8) 3- Itérateurs combinatoires product(p, q,...[repeat=1]) Produit cartésien, (φ(AB,repeat=2)=AA, AB, BA, BB permutations(p[,r]) Arrangements de n éléments parmi r, sans remise. φ(AB,2)=AB,BA combinations(p, r) n-uplets de longueur r, non ordonnés, sans répétition. φ(AB,2)=AB combinations_with_replacement(p,r) n-uplets de longueur r, ordonnés, avec répétition. φ(AB,2)=AA,AB,BB CHAPITRE 7. SIMULATION EN PYTHON 7.2.1.2 197 Écosystème de Python Le module numpy numpy est une bibliothèque open source qui permet de manipuler les structures multidimensionnelles (matrice, vecteur) basée sur la structure ndarray. NumPy 1.22.0 est apparue en décembre 2021. Numpy 1.22/Lib/core.py 1- Methods all/any([x, o, k, w]) argmax/min([x, o]) astype(t[, s, cast, subok, cp]) copy([order]) cumprod/sum([x, t, o]) diagonal([offset, x1 , x2 ]) fill(value) flatten([order]) max/min([x, o, k, init, w]) mean([x, t, o, k, w]) nonzero() prod/sum([x, t, o, k, init,w]) ravel([S]) repeat(repeats[, X]) reshape(shape[, S]) resize(newshape[, refcheck]) round([decimals, out]) sort([X, kind, S]) std/var([x, t, o, ddof, k, w]) tolist() tostring([s]) trace([offset, x1 , x2 , t, out]) transpose(*axes) view([dtype][,type]) 2- Attributs T : ndarray dtype : dtype flat : flatiter real : ndarray itemsize : int ndim : int Retourne True si tous/au moins un élément égal True. Retourne les indices des valeurs maximales/minimales sur l’axe donné. Retourne une copie du tableau converti au type spécifié. Retourne une copie du tableau. Retourne le produit/somme cumulative des éléments de l’axe donné. Retourne les diagonales spécifiées. Remplie le tableau avec un scalaire. Retourne une copie du tableau projeté sur une seule dimension. Retourne le maximum/minimum de l’axe donné. Retourne la moyenne des éléments du tableau sur l’axe donné. Retourne les indices des éléments non nuls. Retourne le produit/somme des elements du tableau sur l’axe donné Retourne le tableau aplati. Répéter les éléments d’un tableau. Redimensionner un tableau. Change la dimension et la taille d’un tableau. Chaque élément est arrondi au nombre de décimaux donné. Tri un tableau. Retourne l’écart type/variance des éléments d’un tableau sur l’axe donné. Transforme un tableau en liste emboîtée. Un alias de compatibilité de tobytes. Retourne la somme des diagonales d’un tableau. Retourne une vue du tableau avec les axes transposés. New view of array with the same data. Le tableau transposé. Type de données des éléments. Un itérateur 1-D du tableau. La partie réelle du tableau. La taille d’un seul élément en octets. Nombre des dimensions du tableau. data : buffer flags : dict imag : ndarray size : int nbytes : int shape : tuple Pointeur vers le début du tableau. Information sur l’occupation mémoire. La partie imaginaire du tableau. La taille du tableau. La taille du tableau en octet. Tuple des dimensions du tableau. Numpy 1.22, Numpy.random.Generator 1- Sampling rand(d_0, d_1, · · · , d_n) randn(d_0, d_1,· · · , d_n) randint(lw[, hi, sz, dtp]) random_integers(lw[, hi, sz]) random_sample([sz]) random([sz]) ranf([sz]) sample([sz]) choice(a[, sz, replace, p]) bytes(length) shuffle(x) permutation(x) 2- Distributions distribution(parametres) Valeurs aléatoires de la forme donnée. Génère un échantillon(s) de la distribution normale standard. Génère des entiers aléatoires entre lw (inclusif) et hi (exclusif). Des entiers aléatoires de type np.int entre low et high, inclusif. Retourne des floats aléatoires dans [0.0, 1.0[. Retourne des floats aléatoires dans [0.0, 1.0[. Retourne des floats aléatoires dans [0.0, 1.0[. Retourne des floats aléatoires dans [0.0, 1.0[. Génère un échantillon aléatoire du tableau 1D donné Retourne des octets aléatoires. Modifie une séquence en mélangeant son contenu. Permute aléatoirement une séquence. beta(a, b), binomial(n, p), chisquare(df), dirichlet(alpha), exponential() sc, f(dfnum, dfden), gamma(sh) sc, geometric(p), gumbel() lc, sc, hypergeometric(ngood, nbad, nsample) laplace() lc sc, logistic() lc sc, lognormal([mean, sigma]), multinomial(n, pvals), normal() lc sc, pareto(a), poisson([lam]) triangular(left, mode, right), uniform([low, high]) CHAPITRE 7. SIMULATION EN PYTHON 198 Toutes les fonctions de distributions prennent comme paramètres optionnels les parametres size, local et scale (notés respectivement lc, sc, sz). Ce module contient aussi les fonctions du générateur (initialisation seed([s0 ]) et gestion de son état RandomState([s0 ]), get/set([state])). Le module sympy sympy est une bibliothèque conçue pour le calcul symbolique (formel). Elle est utilisée dans le calcul arithmétique, algébrique, différentiel ainsi que d’autres domaines tel que la mécanique quantique. Le mois de mars 2022, la version 1.10.1 a été lancée distribuée sous licence BSD. sympy.stats. 1.10 1- Methodes JointRV(symbol, pdf, _set=Nn) marginal_distribution(rv, *indices) P(condition, given_condition=Nn, numsamples=Nn, evaluate=True, **kw) class Probability(prob, condition=None, **kw) E(expr, condition=None, numsamples=Nn, evaluate=True, **kw) class Expectation(expr, condition=Nn, **kw) density(expr, condition=Nn, evaluate=True, numsamples=Nn, **kw) given(expr, condition=Nn, **kw) where(condition, given_condition=Nn, **kw) variance(X, condition=Nn, **kw) class Variance(arg, condition=Nn, **kw) covariance(X, Y, condition=Nn, **kw) class Covariance(arg1,arg2,condition=Nn,**kw) median(X, evaluate=True, **kw) std(X, condition=Nn, **kw) sample(expr, condition=Nn, size=(), library=’scipy’, numsamples=1, seed=Nn, **kw) correlation(X, Y, condition=Nn, **kw) Crée une v.a jointe dont chaque composant est continu. Fonction de distribution marginalle d’une v.a jointe. Probabilité qu’une condition est vraie sachant une autre condition L’expression symbolique de la probabilité. L’espérance d’une expression aléatoire L’expression symbolique de l’espérance. La densité d’une expression aléatoire sachant une seconde condition. Conditionne une expression aléatoire. Retourne le domaine où une condition est vraie. Variance d’une expression aléatoire. Expression symbolique de la variance. Covariance de deux expressions de v.a. Expression symbolique de la covariance. Calcule la médiane de la distribution de probabilité. Écart type d’une expression aleatoire. Une réalisation de l’expression aleatoire. Corrélation de deux expressions aléatoires. Le module sciPy sciPy est une bibliothèque destinée au calcul scientifique et basée sur les structures de numpy. Ses modules sont très diverses incluant l’algèbre linéaire, l’optimisation, le traitement d’images et de signal,... La version la plus récente est 1.8.0 de Février 2022. Le module stats contient une collection de routines statistiques qui peuvent être classées selon leur fonction dans l’une des catégories suivantes : a- Fonctions génériques : - rv_continuous([momtype, a, b, xtol, . . . ]) : Une v.a.c générique. - rv_discrete([a, b, name, badvalue, . . . ]) : Une v.a.d générique. - rv_histogram(histogram, *args, **kwargs) : Génère une distribution. b- Distribution continues/discrètes Elle contient presque toutes les distributions usuelles. Ces fonctions prennent la même forme de définition des paramètres, la collection des paramètres positionels et celles des paramètres nommés (*args, **kwargs). c- Multivariate distributions d- Statistiques et fonctions de corrélation e- Statistique descriptive f- Tests Statistiques 7.2.2 Symbulate Symbulate est un framework pour la simulation des modèles de probabilité. Il permet de spécifier, exécuter, analyser et visualiser les résultats de la simulation. Les fonctions les plus importantes nous permettent de : 1. Définir des espaces de probabilités : ceci est possible en utilisant BoxModel() et draw() qui permet de simuler un tirage du BoxModel ; ou bien en écrivant des fonctions les spécifiant. CHAPITRE 7. SIMULATION EN PYTHON 199 Il est aussi possible de créer des espaces de probabilité indépendants en multipliant deux espaces de probabilités. 2. Définir des variables aléatoires sur des espaces de probabilité déjà définis en utilisant la classe RV. Pour définir une fonction g d’une variable aléatoire X on peut utiliser la méthode X.apply(g). Si g est une fonction mathématique connue(log,exp,sin,...), on peut l’appeler directement sans utiliser apply : g(X). D’autres fonctions très utiles existent comme : mean() pour calculer l’espérance des simulations de la v.a, sd() pour le calcule de l’écart type et standardize() pour la normalisation de la v.a (espérance=0 et variance=1). 3. Utiliser les modèles de probabilités les plus fréquents : qu’il s’agisse des distributions discrètes, continues, jointes ou même quelques processus aléatoires, Symbulate offre un ensemble riche et facile de méthodes à utiliser. Des méthodes telles que : DiscreteUniform(), Bernoulli(), Binomial(), Hypergeometric() , Poisson(), Geometric() ainsi que d’autres méthodes sont disponibles pour les distributions discrètes ; et il reste toujours possible de définir sa propre distribution discrète grace au BoxModel. La même chose est possible pour les distributions continues avec les méthodes Uniform(), Normal(), LogNormal(), Exponential(), Gamma(),... Pour les deux types de distributions, des méthodes très utiles sont à utiliser : pdf(x) retourne la valeur f(x) (fonction de densité), cdf(x) retourne la fonction cumulative F(x), mean(), var(), sd(),median() et quantile() retournent respectivement les valeurs de l’espérance, la variance, l’écart type, la médiane et les quantiles. D’un autre côté, la méthode MarkovChain(TransitionMatrix, InitialDistribution, states) permet de créer une CM discrète et de la simuler efficacement avec la méthode sim(). La même chose est possible pour les CM continues en utilisant la méthode ContinuousTimeMarkovChain(Q, InitialDistribution, states), et le processus de Poisson d’un taux de transition donné avec la méthode PoissonProcess(rate = 2). Les probabilités conditionnelles sont possibles avec Symbulate en utilisant le signe "|" (sachant que) et qui peut être appliqué aux v.a comme aux événements. Un autre outils de Symbulate à ne pas négliger est l’outil graphique plot() qui permet de visualiser les résultats de la simulation sous plusieurs formes possibles. Quand le nombre de simulations est petit, on peut visualiser les valeurs individuelles obtenues avec le paramètre type="rug". Par défaut plot() affiche les valeurs des résultats avec leurs fréquences relatives. On peut aussi afficher les résultats sous forme d’histogramme ou bien de densité (continue), nuage de points (scatter plot) ainsi que d’autres types personnalisés. 4. Simuler : les même outils de simulation permettent de simuler des espaces de probabilité, des variables aléatoires et des processus stochastiques. La méthode draw() déjà évoquée permet de simuler un seul résultat d’un espace de probabilité ; pour en simuler plusieurs, la méthode sim() est utilisée en lui spécifiant le nombre de simulations voulu. La méthode apply() permet d’appliquer une fonction donnée à chaque résultat de la simulation. Il est aussi possible de définir une méthode écrite en Python et de la faire passer en paramètre à la méthode apply(). La méthode tabulate() présente sous forme tabulaire les résultats de la simulation en comptant le nombre d’apparition de chaque résultat. Avec le paramètre normalize=True, le nombre d’occurrences est transformé en probabilité. Pour obtenir un sous ensemble de simulations égales à un résultat particulier, la méthode filter_eq() peut être utilisée. CHAPITRE 7. SIMULATION EN PYTHON 200 Symbulate 1- Distributions discrete(parametres) Bernouli(p), Binomial(n, p), Hypergeometric(n,N0,N1), Geometric(p), NegativeBinomial(), Pascal(r,p), Poisson(lam), DiscretUniform(a=0,b=1p) continu(parametres) Uniform(a=0.0,b=1.0]), Normal(mean=0.0, sd=1.0, var=None), Exponential(rate=1.0, scale=Nn), Gamma(shape, rate=1.0, scale=Nn), Beta(a, b), StudentT(df), chisquare(df), F(dfN, dfD), Lognormal([mean, sigma]), Pareto(b=1.0,scale=1.0), Triangular(left, mode, right), multivariate(parametres) MultivariateNormal([mean, cov]), MultiNormal([n,p]) 2- Processes Gaussian Brownian Poisson Markov GaussianProcessProbabilitySpace(mean_func, cov_func, index_set=Reals()) ; GaussianProcess(mean_func, cov_func, index_set=Reals()) BrownianProcessProbabilitySpace(drift=0, scale=1), BrownianProcess(drift=0, scale=1) ProcessProbabilitySpace(rate), PoissonProcess(rate) MarckovChainProbabilitySpace(transiton_matrix, initial_dist, state_labels=None), MarckovChain(transiton_matrix, initial_dist, state_labels=None), ContinuousTimeMarckovChainProbabilitySpace(generator_matrix, initial_dist, state_labels=None), ContinuousTimeMarckovChain(generator_matrix, initial_dist, state_labels=None), À vos claviers! #code701.py from symbulate import BoxModel # Die sampling # this line could be replaced by :list(range(1, 6+1)) die = [1, 2, 3, 4, 5, 6] roll = BoxModel(die) print(roll.draw()) # draws 10 samples from [’A’, ’B’, ’C’, ’D’] with probabilities [0.22, 0.27, 0.41, 0.10] print(’’.join(list(BoxModel([’A’, ’B’, ’C’, ’D’], probs=[0.22, 0.27, 0.41, 0.10], size=10).draw()) )) #______________________________ # 2 # CACCCCBAAB Output ______________________________________ Dans plusieurs situations élémentaires, l’espace de probabilité peut être défini par un BoxModel. La méthode draw() permet de simuler un tirage du BoxModel. Les options du BoxModel : box : une liste de tickets utilisés pour le tirage. size : le nombre de tickets à tirer du box. replace : True si le tirage est fait avec remplacement et False sinon. probs : probabilités de sélection des tickets. Par défauts ils sont équiprobables. order_matters : True si l’ordre est important et False sinon. Une autre façon de définir le modèle de probabilité est de définir une fonction permettant de décrire comment le tirage doit s’effectuer, ensuite donner cette fonction en paramètre à la méthode ProbabilitySpace tel que décrit dans l’exemple suivant : À vos claviers! #code702.py from symbulate import BoxModel, ProbabilitySpace, Poisson, Exponential #1 probabaility space with user defined function def gender_hobbies_sim(): gender = BoxModel(["male", "female"], probs=[.2, .8]).draw() if gender == "male": hobbies = BoxModel(["science", "art", "sport"], probs=[.3, .3, .4]).draw() else: hobbies = BoxModel(["science", "art", "sport"], probs=[.2, .5, .3]).draw() CHAPITRE 7. SIMULATION EN PYTHON 201 return gender, hobbies P = ProbabilitySpace(gender_hobbies_sim) print(P.draw()) #2 independants probability spaces die6, die4 = list(range(1,7,1)), list((1,5,1)) lancers = BoxModel(die6)*BoxModel(die4) print(lancers.draw()) #3 independants probability spaces three = BoxModel([’P’,’F’])*Poisson(lam=3)*Exponential(rate=4) print(three.draw()) #______________________________ #(’female’, ’art’) #(5, 1) #(F, 1, 0.029286540827854368) 7.2.2.1 Output ______________________________________ Simulation des variables aléatoires L’exemple suivant montre la définition de v.a à partir d’un BoxModel, sa simulation avec la méthode sim(), en précisant le nombre de simulations en paramètres, ainsi que la représentation tabulaire du résultat avec la méthode tabulate(). À vos claviers! #Code703.py from symbulate import BoxModel, RV, Normal, exp # 5 Bernoulli trials and successes number P = BoxModel([0,1],size=5); X = RV(P,sum) tab = (X>3).sim(10000).tabulate() print("Tabulate without normalization: ",tab) tab = (X>3).sim(10000).tabulate(normalize=True) print("Tabulate with normalization: ",tab) X.sim(10000).plot() # function of rv X = RV(Normal(mean=0, var=1)); Y = exp(X) # could be replaces with: X.apply(exp) Y.sim(10000).plot() #______________________________ Output ______________________________________ # Tabulate without normalization: {True: 1826, False: 8174} # Tabulate awith normalization: {True: 0.1842, False: 0.8158} La v.a X dans cet exemple peut être considérée comme le nombre de piles obtenus dans 5 lancers successifs d’une pièce. Ensuite 10000 simulations sont effectuées pour simuler X > 0. Ce qu’il faut noter ici est que la simulation est répétée autant de fois que nécessaire pour obtenir 10000 résultats tel que X > 3 et non pas (comme on peut le penser) de 10000 simulations on ne garde que celles ayant X > 3. L’utilisation de normalize=True dans la méthode permet d’avoir les résultats sous forme de fréquences. La représentation graphique est aussi possible avec la méthode plot(). Figure 7.1 – Simulation de la loi Normale (gauche) et Exponentielle (droite) (code703.py) CHAPITRE 7. SIMULATION EN PYTHON 202 À vos claviers! #Code704.py from symbulate import RV, Normal, Exponential X = RV(Exponential(rate=1/4)) simX = X.sim(10000) print("Expected value:", simX.mean()) print("Variance:", simX.var()) print("Standard deviation:", simX.sd()) #Normalization X = RV(Normal(mean=3,sd=2)) simX = X.sim(10000) print("Before normalization. mean and sd:", round(simX.mean(),2), round(simX.sd(),2)) simX.plot() z = simX.standardize() print("After normalization. mean and sd:", round(z.mean(),2), round(z.sd(),2)) z.plot() #______________________________ Output ______________________________________ # Expected value: 3.9628993353781383 # Variance: 15.587130335771537 # Standard deviation: 3.9480539935228265 # Before normalization. mean and sd: 3.03 2.0 # After normalization. mean and sd: -0.0 1.0 Dans cet exemple la moyenne, la variance et l’écart type sont calculés à partir des résultats de la simulation et non pas théoriquement. La normalisation consiste à modifier la v.a afin que son espérance soit égale à 0 et son écart type égal à 1. La modification consiste à soustraire l’espérance de chaque valeur et la diviser par l’écart type. Avec symbulate, ceci peut être effectué par la méthode standardize() qui normalise les valeurs obtenues par la simulation. Figure 7.2 – Loi Normale avant vs après normalisation (code704.py) 7.2.3 Simpy Simpy est un framework Python de simulation à événements discrets basé sur les processus. Les processus sont crées par les environnements en utilisant des fonctions génératrices (retournant un itérateur) et peuvent modéliser des composants actifs comme des clients, des véhicules ou des agents. Simpy offre aussi le concept de ressources partagées permettant de modéliser les interactions entre processus ; elles représentent des points de congestions où les processus doivent attendre dans une file pour les utiliser. En Simpy, il existe aussi la notion des événements qui sert à traiter les différents types d’événements du simulateur. Les exceptions quand à elles, sont utilisées pour synchroniser les différents processus. 7.2.3.1 Environnements Appartenant au package simpy.core (le noyau des composants de Simpy), BaseEnvironment est la classe de base qui permet principalement de gérer le temps de la simulation, de planifier CHAPITRE 7. SIMULATION EN PYTHON 203 les événements et de les traiter. Parmi les méthodes principales : simpy.core 1- API core C : BoundClass C : StopSimulation<Exception> C : BaseEnvironment a : now a : active_process m : schedule(ev, priority=NORMAL, delay=0) m : step() m : run(until=None) C : Environment<BaseEnvironment> m : peek() 7.2.3.2 Permet aux classes de se comporter comme des méthodes. Arrête la simulation. Classe de base pour les environnements de traitement des évènements. Le temps courant de l’environnement. Le processus actuellement actif de l’environnement. Planifie un *évènement* avec la priorité donnée *priority* et un *delay* Traite l’évènement suivant. Exécutes step() jusqu’à ce que le critère *until* est satisfait. Un environnement d’exécution. Renvoie le temps de l’évènement suivant planifié. Évènements Les principaux événements sont gérés par le module simpy.events. Event est la classe de base de tous les types d’événements : Events 1- API events C : Event(env) p : triggered() p : processed() p : ok() p : defused([value]) p : value() m : trigger(event) m : succeed(value=None) m : fail(exception) C : class Timeout<Event>(env, delay, value=None) C : class Initialize<Event>(env, p) C : Interruption<Event>(process, cause) C : Process<Event>(env, generator) p : target() p : is_alive() m : interrupt(cause=None) C : class ConditionValue(object) C : class Condition<Event>(env, evaluate, evts) sm : all_events(ev, count) sm : any_events(evts, count) C : class AllOf<Condition>(env, events) C : class AnyOf<Condition>(env, events) C : class Interrupt<Exception> m : cause() Un évènement qui peut survenir à un point donné dans le temps. Prend la valeur True si l’évènement a été déclenché et sa fonction est sur le point d’être évoquée. Prend la valeur True si l’évènement a été traité. True si l’évènement a été lancé avec succès. Prend la valeur True quand l’exception d’un évènement échoué a été "désamorcée". La valeur de l’évènement s’il est disponible. Déclenche l’évènement avec l’état donné. Modifie la valeur de l’évènement à succès. Modifie la valeur de l’évènement à échec. Un évènement qui est déclenchée après une durée écoulée. Initialise un processus p. Planifie immédiatement une interruption. Traite un générateur source d’un évènement. L’évènement que le processus est entrain d’attendre. True jusqu’à ce que le générateur quitte. Interrompe ce processus en retournant une cause. Le résultat d’une Condition. Un évènement qui est déclenché une fois la fonction de la condition retourne True. Une fonction qui retourne lancés. Une fonction qui retourne été lancé. L’évènement qui est lancé chés. L’évènement qui est lancé déclenchés. "True" si tous les evenements *events* ont été "True" si au moins un des évènements *events* a si tous les évènements d’une liste ont été déclensi au moins un des évènements de la liste a été L’exception envoyée au processus lorsqu’il est interrompu. La cause de l’interruption. CHAPITRE 7. SIMULATION EN PYTHON 7.2.3.3 204 Ressources partagées Trois types de ressources peuvent être utilisées pour synchroniser les processus avec Simpy dans le module simpy.resources en utilisant les trois classes suivantes : 1- resource : pour les ressources qui permettent les priorités et la préemption. 2- container : pour le partage des ressources homogènes (discrètes ou continues). 3- store : pour stocker un nombre d’objets illimités. permet les requêtes sélectives sur des objets spécifiques. Resources 1- API resources C : Put<Event>(resource) m : cancel(self) C : Get<Event>(resource) m : cancel(self) C : BaseResource<object>(e, cap) PutQueue = list GetQueue = list p : capacity(self) put = BoundClass(Put) get = BoundClass(Get) C : Preempted(by, usage_since, resource) C : Request<base.Put>(exc_type, value, traceback) C : Release<base.Get>(resource, request) C : PriorityRequest<Request>(rsc, priority=0, preempt=True) C : SortedQueue(maxlen=None) m : append(self, item) C : Resource<BaseResource>(env, capacity=1) p : def count(self) request = BoundClass(Request) release = BoundClass(Release) C : PriorityResource<Resource>(env, capacity=1) PutQueue = SortedQueue GetQueue = list request = BoundClass(PriorityRequest) release = BoundClass(Release) C : PreemptiveResource<PriorityResource> Containers Évènement générique pour une demande de dépôt d’une entité dans le buffer resource. Annuler la requête put. Évènement générique pour une demande de tirage d’une entité du buffer ressource. Annuler la requête get. Classe de base abstraite de la ressource partagée. Type de la file put. Type de la file get. La capacité max de la ressource. Demande de mettre un objet dans la ressource et retourner un évènement Put déclenché une fois la demande satisfaite. Demande de retirer un objet de la ressource et retourner un évènement Get déclenché une fois la demande satisfaite. Cause une préemption, events.Interrupt contient l’information sur la préemption. Demander l’utilisation de la ressource. L’événement est déclenché une fois l’accès accordé. Libère l’utilisation de la ressource accordée sur demande. Cet événement est déclenché immédiatement. Demander l’utilisation de la ressource avec une priorité donnée. File d’attente pour trier les événements par leur attribut PriorityRequest.key. Trier l’élément dans la file d’attente. Déclencher une erreur RuntimeError si la file d’attente est pleine. Ressource avec capacité pouvant être demandée par les processus. Nombre d’utilisateurs utilisant actuellement la ressource. retourne len(self.users). Demander un emplacement d’utilisation. Libérer un emplacement d’utilisation. Une ressource prenant en charge les demandes prioritaires. Type de la file d’attente de dépôt. Type de la file d’attente de retrait. Demander un emplacement avec la priorité donnée. Libérer un emplacement. Une Ressource avec priorité et préemptive. CHAPITRE 7. SIMULATION EN PYTHON 1- Containers API C : ContainerPut<base.Put>(c, a) C : ContainerGet<base.Get>(c, a) C : Container<base.BaseResource>(env, capacity=float(’inf’), init=0) p : level() a : put = BoundClass<ContainerPut> a : get = BoundClass<ContainerGet> 205 Demander de mettre une quantité ’a’ dans le conteneur ’c’. Demander de retirer une quantité ’a’ du conteneur ’c’. Ressource à capacité limité contenant une entité continue ou discrète. La quantité courante disponible. Demander de mettre une quantité dans le conteneur. Demander de retirer une quantité du conteneur. Stores 1- Stores APIs C : StorePut<base.Put>(store, item) C : StoreGet<base.Get>(resource, filter=lambda item : True) C : FilterStoreGet<StoreGet> C : Store<base.BaseResource>(env, capacity=float(’inf’)) a : put = BoundClass<StorePut> a : get = BoundClass<StoreGet> C : PriorityItem(namedtuple(’PriorityItem’, ’priority item’)) C : PriorityStore<Store> C : FilterStore<Store> a : put = BoundClass<StorePut> a : get = BoundClass<FilterStoreGet> 7.2.3.4 Demander de mettre un objet ’i’ dans le store ’s’. Demander de retirer un objet du "store". Demander de retirer un objet correspondant au filtre du "store". Ressource d’une capacité donnée pour stocker des objets. Demander de mettre un objet dans le "store". Demander de retirer un objet du "store". Associer une priorité à un objet. Ressource d’une capacité donnée pour stocker des objets par ordre de priorité. Ressource d’une capacité donnée pour stocker des objets admettant des demandes avec filtre. Demander de mettre un objet dans le "store". Demander de retirer un objet du "store" correspondant au filtre donné. Exceptions Le module simpy.exceptions contient la classe de base SimPyException pour toutes les exceptions spécifiques. Il y a Interrupt(cause) qui retourne l’exception lancée au processus s’il est interrompu pour la cause donnée et StopProcess(value) lancée pour arrêter un processus Simpy. 7.3 Simulation des processus stochastiques 7.3.1 Simulation du processus de Poisson Le processus de Poisson N (t) est considéré comme une séquence d’arrivées dont le temps d’inter-arrivées (TIA) est une v.a exponentielle de paramètre λ (on connaît la procédure de sa génération ). Donc pour générer le nombre d’arrivées jusqu’au temps T, on procède à la génération des TIA jusqu’à ce que leur somme dépasse T. Le nombre des TIA générés représente la valeur générée pour N (T ). À vos claviers! # Code705.py from scipy.stats import expon import matplotlib.pyplot as plt def generatePoissonSP(lamda=1, T=1): t, N, tim = expon.rvs(scale=1/lamda), 0, [] while (t<T): tim.append(t) N, t = N+1, t+expon.rvs(scale=1/lamda) return N,tim def plotPP(lamda): n,tim = generatePoissonSP(lamda,20) return plt.step(tim,range(n)) lamdas = [0.25,0.5,1,2] plt.legend([plotPP(l)[0] for l in lamdas],["lambda="+str(l) for l in lamdas]) CHAPITRE 7. SIMULATION EN PYTHON 206 plt.xlabel(’Time’); plt.ylabel(’arrivals number’) plt.show() Figure 7.3 – Simulation du processus de Poisson (code705.py) 7.3.2 Simulation de chaîne de Markov à temps discret Comme le montre le code suivant, la simulation d’une CMTD consiste à générer l’état suivant à partir de l’état courant en utilisant la méthode de transformation inverse ayant en paramètre sa distribution. À vos claviers! # Code 706.py from itertools import accumulate from random import random import sys;sys.path.append(’../chap4’) from CMTD import CMTD def simulateCM(P,S,steps,cs): CM = CMTD(P,S) ls = [] indices = range(len(CM.S)) for i in range(steps): ls.append(CM.S[cs]) prob = list(accumulate(P[cs])) cs=transformation_inverse(prob,indices) return (CM, "".join(ls)) def transformation_inverse(prob,indices): u = random() for i in range(len(prob)): if(u<prob[i]): return indices[i] return indices[-1] def compareToSteadyState(P,S,n,s0): res = simulateCM(P,S,n,s0) ana_p = res[0].steady_prob(); print("Analytical prob : ", ana_p) emp_p = [res[1].count(s)/n for s in S]; print("Empirical prob : ", emp_p) # Test n = 10000 print(’Ergodic’) P = [[1/3, 1/3, 1/3], [3/5, 0.0, 2/5], [3/4, 1/8, 1/8]] S = [’R’,’N’,’S’] compareToSteadyState(P,S,n,1) n = 50 print("CMTD1: ",simulateCM(P,S,n,1)[1]) print(’Not ergodic’) P = [[1.0, 0.0, 0.0], CHAPITRE 7. SIMULATION EN PYTHON 207 [3/5, 0.0, 2/5], [3/4, 1/8, 1/8]] print("CMTD2: ",simulateCM(P,S,n,1)[1]) #______________________________ Output ______________________________________ # Ergodic # Analytical prob : [0.50769231 0.20512821 0.28717949] # Empirical prob : [0.5065, 0.2072, 0.2863] # CMTD1: NRNRSRSRNSRRRNRSRNRNRSRRSNRRNRSRRSRNSNRSSRRNRSRNRR # Not ergodic # CMTD2: NRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR Vu la nature non déterministe du code, il est évident que le résultat obtenu peut changer d’une exécution à une autre. 7.3.3 Simulation de chaîne de Markov à temps continu Dans cette section, nous allons voir comment simuler une CMTC. Pour cela nous avons besoin en entrée de la matrice de transition P de la CM intégrée et de la valeur λi de chaque état de la CMTC. La simulation va se dérouler durant un temps Tmax . Le code python proposé est le suivant : À vos claviers! # Code 707.py from itertools import accumulate from random import random import math import sys;sys.path.append(’../chap4’) from CMTC import CMTC expo = lambda lamda : (-1/lamda)*math.log(random()) def transformation_inverse(prob,indices): U = random() for i in range(len(prob)): if(U < prob[i]): return indices[i] return indices[-1] def simulateCM(P,lamdas,S,T_max,cs): CM = CMTC(P,lamdas,S) indices = range(len(CM.S)) ls, tc = [], 0 while tc < T_max: tps = expo(lamdas[cs]) ls.append((CM.S[cs], round(tps,2))) tc = tc + tps prob = list(accumulate(P[cs])) cs = transformation_inverse(prob,indices) return (CM , ls) def compareToSteadyState(res,T): ana_p = [ round(p,2) for p in res[0].steady_prob()] print("Analytical prob : ", ana_p) emp_p = [ round(sum(map(lambda r: r[1], filter(lambda r: r[0]==s, res[1])))/T,2) for s in S] print("Empirical prob : ", emp_p) S = [’R’,’N’,’S’] P = [[0.0, 2/3, 1/3], [3/5, 0.0, 2/5], [3/4, 1/4, 0.0]] lamdas = [4, 5, 6] T_max = 500 res = simulateCM(P,lamdas, S,T_max,1) compareToSteadyState(res, T_max) print("CMTC : ",simulateCM(P,lamdas,S,5,1)[1]) #______________________________ Output ______________________________________ # Analytical prob : [0.47, 0.32, 0.21] # Empirical prob : [0.46, 0.33, 0.22] # CMTC : [(’N’, 0.05), (’R’, 0.0), (’S’, 0.03),..., (’S’, 0.09), (’R’, 0.19)] CHAPITRE 7. SIMULATION EN PYTHON 7.3.4 Simulation des files d’attente 7.3.4.1 Simulation la station M/M/1 208 La simulation d’une station M/M/1 prend en entrée le taux moyen des arrivées λ (tau1), le temps moyen de service µ (tau2) et le temps de simulation maximum(maxT) ; après ce temps on ne traite que les départs des clients déjà reçus dans la station et aucune arrivée n’est possible. Nous utilisons une variable clock pour suivre l’évolution du temps. Nous avons également besoin de deux variables : t1 qui représente le temps de la prochaine arrivée dans le système et t2 le temps du prochain départ. La variable n calcule le nombre de clients dans la station, elle est incrémentée à chaque événement d’arrivée et décrémentée à chaque départ. Les autres variables sont utilisées pour le calcul des statistiques de la simulation à savoir le temps de réponse moyen des clients dans la station et le temps de réponse moyen. À vos claviers! # Code708.py import random import math import matplotlib.pyplot as plt import sys;sys.path.append(’../chap5’) from Code502 import getMM1 expo = lambda lmbd : (-1/lmbd)*math.log(random.random()) # def simul(lamda,mu,maxT): clock, n, nb = 0, 0, {} t_arv, t_dep = expo(lamda), maxT arv, dep = [], [] n_arv, n_dep = 0, 0 # # # # n is customers number in the system next arrival/departure/max time Arrival/Departure times Arrivals/Departures number # def departure(): nonlocal n_dep, dep, n, t_dep, mu, maxT, clock n_dep += 1; dep.append(t_dep) if(n >= 0): nb[n] = (nb[n] if n in nb else 0) + t_dep - clock n, clock = n-1, t_dep t_dep = clock + expo(mu) if n>0 else maxT stats = [] # while(clock < maxT): stats.append((clock,n)) if(t_arv < t_dep): # add event id and time # arrival event n_arv += 1; arv.append(t_arv) nb[n] = (nb[n] if n in nb else 0) + t_arv - clock n, clock = n+1, t_arv t_arv = clock + expo(lamda) if(n == 1): t_dep = clock + expo(mu) else: # departure event departure() # while(n_arv > n_dep): stats.append((clock,n)) departure() prob = {s:nb[s]/clock for s in nb} avg_nb_clients = sum(s*prob[s] for s in prob) wait = list(map(lambda x, y: x - y, dep, arv)) avg_time = sum(wait)/len(wait) return(avg_nb_clients,avg_time, stats) # print(’Analytical performances : ’); getMM1(2,3) print(’Empirical performances : ’); nb, tps, stats =simul(2,3,10) print("Average number of clients in the station: "+str(round(nb,2))) print("Average response time: " + str(round(tps,2))) # Plot plt.step([t[0] for t in stats], [t[1] for t in stats]) plt.xlabel(’Time’); plt.ylabel(’clients number’) CHAPITRE 7. SIMULATION EN PYTHON 209 plt.show() #______________________________ Output ______________________________________ # Performances ananlytiques : # ==================MM1 ======================= # p0* :0.33333 # p1* :0.22222 # p3* :0.09877 # L :2.00 # Lq :1.33 # W :1.00 # Wq :0.67 # Performances empiriques : # Nombre moyen de clients dans la station:1.97 # Temps de reponse moyen:0.98 Figure 7.4 – Simulation de M/M/1 (code708.py) 7.3.4.2 Simulation des stations de files d’attente avec simpy Pour simuler des files d’attente, les serveurs sont modélisés comme des ressources partagées et les clients comme des processus. Un autre processus responsable de la génération des processus clients doit être ajouté. La simulation est lancée par l’instruction run(). Lorsqu’un processus client est créé, il commence par demander une ressource (un serveur), si aucun serveur n’est disponible, le processus est suspendu (inséré dans la file d’attente) jusqu’à la libération d’un serveur. À ce moment, le processus client quitte la file d’attente et se bloque le temps du service, ensuite, il termine son exécution, ce qui rend la ressource libre. Par défaut la simulation se termine lorsqu’aucun événement n’est en attente, mais d’autre conditions d’arrêts peuvent être utilisées comme un temps de simulation maximum par exemple. Le module suivant est un utilitaire qui regroupe les fonctions et les variables communes utilisées par les codes des sections suivantes. Les variables globales sont initialisées par les classes de Simpy telles que simpy.Environment et simpy.Resource,... Parmi les fonctions on trouve les lambda expressions qui définissent les lois des générateurs aléatoires et celles qui collectent et plottent les statistiques de la simulation ainsi que le diagramme de Gant utilisé dans l’application de ce chapitre. À vos claviers! # Code709.py import random import simpy from simpy.resources import resource # e P R Shared = simpy.Environment() = e.process = e.run # Resources RSC = simpy.Resource RSC_withCapacity = lambda cap: simpy.Resource(e, capacity=cap) CHAPITRE 7. SIMULATION EN PYTHON RSC_Prempt = lambda cap: resource.PreemptiveResource( e , capacity = cap ) RSC_Prio = lambda cap: resource.PriorityResource( e , capacity = cap ) RQT_prio = resource.PriorityRequest TO = e.timeout SETO = simpy.events.Timeout # load datastructures ld = { ’Ls’:[], # ’L’:[0], # ’Q’:[0], # ’tl’:[0], # ’tq’:[0], # ’Nfs’:[1] # } Load historique in the system current load current queue time when updating the load time when updating the queue Number of servers # updateLoad L/Q def updateLoad(E, te, h,k, stationId=0): global ld ld[E][stationId] = ld[E][stationId] + h; # number of client in Queue Q or System L ld[’Ls’].append((round(e.now - ld[te][stationId],4), ld[E], k)); ld[te][stationId] =e.now # rexpo = lambda mu : random.expovariate(mu) rinverse = lambda probas : random.choices(range(len(probas)), probas)[0] runif = lambda a,b : random.randint(a, b) randColor = lambda:(random.random(),random.random(),random.random()) # iterator for the loop def geti(): i=0; while True: i=i+1; yield i g = geti() # on Event Arrival + Sertvice + Departure def onEvent(event, id, stats, stationId=0): typEvent = event[0] # update system load if typEvent != ’S’: updateLoad(’L’ ,’tl’ ,(1 if typEvent=="A" else -1) ,0, stationId) # update system queue if ((typEvent == ’A’ and ld[’Nfs’][stationId] == 0) or (typEvent == ’S’ and ld[’Q’][stationId] > 0)) : updateLoad(’Q’ ,’tq’ ,(1 if typEvent=="A" else -1) ,1, stationId) # update number of available servers if typEvent != ’A’: ld[’Nfs’][stationId]= ld[’Nfs’][stationId] + (1 if typEvent=="D" else -1) #statistic array [’E’, time, ’ID’, servers , L ,Q ,Station] stats.append( [ typEvent, # Event type Arrival, Service and Departure round(e.now,4), # time id, # client id ’ClientID’ ld[’Nfs’][stationId], # number of available servers ld[’L’][stationId], # station load ld[’Q’][stationId], # station queue stationId # station id ] ) # =========================================================================== # wait_queue + wait_system + def process_output(psim): wait_queue, wait_system, N = 0, 0, len(psim) for evt in psim: wait_queue += evt[2] - evt[1] wait_system += evt[3] - evt[1] wait_queue = round(wait_queue /N,4) wait_system = round(wait_system/N,4) return (wait_queue, wait_system) # def plot_state(stats0): import matplotlib.pyplot as plt nbstations = len(stats0) for i in range(nbstations): plt.step([v[0] for v in stats0[i].values()], [v[3] for v in stats0[i].values()]) plt.xlabel(’Time’); plt.ylabel(’clients number’) plt.show() # Statistics def collect_stats(psim, pld, show, nbstations=1): stats0 =[{} for _ in range(nbstations)] stats1 =[{} for _ in range(nbstations)] 210 CHAPITRE 7. SIMULATION EN PYTHON 211 eprev, L, Lq = 0, 0, 0 for currentStation in range(len(stats0)): stats = stats0[currentStation]; statsW = stats1[currentStation] psim0 = [e for e in psim[’staE’] if e[6] == currentStation] # filter stats for the current station # collect stats [time, [(’E’, ’ID’),...], Server, Q, L, Station] for evt in psim0: # stats for the system based on time as key if not evt[1] in stats.keys(): # evt[1] time stats[evt[1]] = [evt[1], [],0, 0, 0,0] stats[evt[1]][2] = evt[3] # Available servers stats[evt[1]][3] = evt[4] # L stats[evt[1]][4] = evt[5] # Q else: stats[evt[1]][2] = min(stats[evt[1]][2], evt[3]) stats[evt[1]][3] = min(stats[evt[1]][3], evt[4]) stats[evt[1]][4] = min(stats[evt[1]][4], evt[5]) stats[evt[1]][1].append((evt[0], evt[2])) # stats for the system queue : W based on client_ID [ID, A, S, D] if evt[2] != ’None’: # evt[2] Client ID if not evt[2] in statsW.keys(): statsW[evt[2]] = [evt[2], 0, 0, 0] if evt[0]==’A’: statsW[evt[2]][1] = evt[1] if evt[0]==’S’: statsW[evt[2]][2] = evt[1] if evt[0]==’D’: statsW[evt[2]][3] = evt[1] L += (evt[1] - eprev)*evt[4] Lq += (evt[1] - eprev)*evt[5] eprev = evt[1] wqs = process_output(statsW.values()) lds = (round(L/psim[’T_sim’],4), round(Lq/psim[’T_sim’],4)) return wqs, lds, stats0 # show_statistics def show_statistics(psim, pld, show, nbstations=1): wqs, lds, sta = collect_stats(psim, pld, show, nbstations)# if show : for e in sta: for v in e.values() : print(v) print("Empirical performances :") print("Average time in the queue print("Average time in the system print("Average number of clients in the queue print("Average number of clients in the system plot_state(sta) : : : : ", ", ", ", wqs[0]) wqs[1]) lds[1]) lds[0]) # =========================================================================== # method that plots the gant chart of the application def gant(cpus, tasks,l, H=50, M=5 ): import matplotlib.pyplot as plt fig, axi = plt.subplots() axi.set_ylim(0, H); axi.set_xlim(0, l) axi.set_xlabel(’Time’); axi.set_ylabel(’Processor’) axi.grid(True) # Setting ticks on y-axis dx = int((H - 2*M)/ len(cpus)) axi.set_yticks([dx + i*dx for i in range(len(cpus))]) axi.set_yticklabels(cpus) # Declaring a bar in schedule for k,task in tasks.items(): posH=(task[’cpu’]+1)*dx-M/2 axi.broken_barh(task[’length’], (posH, M) , facecolors = task[’color’]) for t in task[’length’]: axi.annotate(k, (1,1), xytext=(t[0]+t[1]/2-1, posH+M+1)) plt.show() 7.3.4.3 Exemple de station de lavage auto Le code suivant nous permet de simuler plusieurs configurations (M/M/1, M/M/S/K,...) d’une station de lavage auto qui possède un nombre limité de machines automatiques de lavage auto et qui reçois des voitures pour être lavées. Les machines à laver sont modélisées comme des ressources, et le lavage comme un processus. Quand une voiture arrive, elle demande une machine à laver, lorsqu’elle l’obtient, elle lance le processus de lavage et attends qu’il termine, ensuite elle libère la machine et quitte le système. CHAPITRE 7. SIMULATION EN PYTHON 212 Si aucune machine n’est disponible, elle reste en attente. Les voitures et les processus de lavage sont générés par un processus setup. CHAPITRE 7. SIMULATION EN PYTHON 213 À vos claviers! # Code710.py from Code709 import e,P,R,TO, RSC, rexpo, g, show_statistics, ld, onEvent import sys;sys.path.append(’../chap5’) # ========================================================================= # station entity model class Station(object): def __init__(self, psim): self.machines = RSC(e, psim[’S’]); self.mu = psim[’mu’]; self.sd = psim[’SD’] def wash(self, voit): yield TO(self.sd(self.mu)) # car entity model def Car(name, station, psim): # event Arrival, Service, Departure onCarEvent = lambda E: onEvent(E, name, psim[’staE’]) # core onCarEvent(’Arrival’) # onArrival event with station.machines.request() as machine: yield machine; onCarEvent(’Service’) # onService event yield P(station.wash(name)); onCarEvent(’Departure’) # onDeparture event # simulation setup def setup(psim): station = Station(psim) ld[’Nfs’]= [psim[’S’]] psim[’staE’].append([’I’, 0.0, ’None’, psim[’S’] ,0 ,0 ,0]) while True: yield TO(psim[’AD’](psim[’lambda’])) if psim[’K’]==-1 or len(station.machines.queue) < psim[’K’]: if(e.now > psim[’T_sim’]): break P(Car(’C%d’ % next(g), station, psim)) # initilize statistics # Queue Capcity limit # Simulation time limit # new arrival process # ============================================================================= def run_sim(sim, show=False): P(setup(sim)); R() show_statistics(sim, ld, show) # def sim_mmsk(show=False): from Code505 import getMMSK # simulation examples sim = { ’T’ : ’MMSK’, ’mu’ : 4, ’lambda’: 10, ’S’ : 3, ’K’ : 30, ’SD’ : rexpo , ’AD’ : rexpo, ’T_sim’ : 1000, ’staE’ : [] } # # # # # # # # # # Simulation # Statistic type of the model service rate arrival rate number of servers Queue capacity service distribution arrival distribution Simulation time Statistics array run_sim(sim, show) getMMSK(sim[’mu’],sim[’lambda’],sim[’S’], sim[’K’]) # simulation # Theory sim_mmsk() # def sim_md1(show=False): # simulation de la station M/D/1 # sim = { # ’T’:’MDS’, # type of the model # ’mu’:8, # service rate # ’lambda’:6, # arrival rate # ’S’:1, # number of servers # ’K’:-1, # Queue capacity # ’SD’: lambda x:1/x , # service distribution # ’AD’:rexpo, # arrival distribution # ’T_sim’:10000, # Simulation time # ’staE’:[] } # Statistics array # # # # run_sim(sim, show) print("Performances analytiques :") D , rho = 1/sim[’mu’], sim[’lambda’]/sim[’mu’] Wq = rho/((2/D)*(1-rho)); # simulation CHAPITRE 7. SIMULATION EN PYTHON # # # # # # # W = D + Wq ; Lq = 1/2*rho**2/(1-rho); L = rho + Lq; print("Temps d’attente moyen dans la file print("Temps d’attente moyen dans la station print("Nombre moyen de clients dans la file print("Nombre moyen de clients dans la station 214 : : : : ", ", ", ", Wq) W) Lq) L) # sim_md1() Figure 7.5 – Résultats empiriques vs analytiques (code710.py) 7.3.4.4 Simulation des réseaux de files d’attente avec simpy Dans cette section nous simulons les réseaux de files d’attente (voir annexe B.2). Le réseau est décrit par la structure topo qui contient une liste de tuples, chacun décrit une station connectée au réseau de la façon suivante : 1. Le nombre de serveurs (considérés homogènes) dans la station et leur vitesse (nombre de clients par unité de temps). 2. La liste des stations successeurs (où les clients sortants peuvent se diriger). 3. Pour chaque station successeur, la probabilité qu’un client sortant s’y dirige. Si les clients sortants peuvent quitter le système, une probabilité supplémentaire est ajoutée. Si aucun successeur n’existe, la valeur None est utilisée. La méthode setup() créée le réseau à partir de la structure topo, ensuite procède à la génération continue (jusqu’à un temps max T) des clients entrants aux stations initiales. Chaque client créée est dirigé vers sa stations pour acquérir un serveur (ou joindre la file d’attente le cas échéant), lorsqu’il termine son service, il passe à la station suivante ou bien quitte le système selon la topologie du réseau. À vos claviers! #Code711.py import heapq # heapqueue allows to allocate servers in round robin policy from Code709 import e,P,R,TO, rexpo, g, rinverse, RSC_withCapacity, SETO # =============================================================================================== # show def show(cz, args): if cz == 2 : print(’%7.2f \t %s \t %s \t %s \t %s’ % tuple([e.now] + args)) else : print(’%7.2f \t %s \t %s \t\t %s’ % tuple([e.now] + args)) # main method def carwash(T, topology): class Station(object): def __init__(self, id, infos): self.id=id; self.S= infos[’S’] CHAPITRE 7. SIMULATION EN PYTHON 215 self.M = infos[’Mu’] self.nextStations= infos[’nextS’] self.probas=infos[’probas’] self.Indices = list(range(self.S)); self.Servers = RSC_withCapacity(self.S); def pf_svc(self, c): X =rexpo(self.M); yield TO(X) # onService def onService(self, id): if len(self.Indices) > 0: svr = heapq.heappop(self.Indices); show(2, [id, ’S’, svr, self.id]) return svr # onDeparture def onDeparture(self,id, svr): heapq.heappush(self.Indices, svr); show(1, [id, ’D’,self.id]) # pop in queue # push from queue # pf_getin : when access a station def pf_getin(self, id): show(1, [id, ’A’, self.id]) with self.Servers.request() as s: yield s; svr = self.onService(id) yield P(self.pf_svc(id)); self.onDeparture(id, svr) if self.nextStations != None: i = rinverse(self.probas) if(i<len(self.nextStations)): P(self.nextStations[i].pf_getin(id)) # go to # Arrival # Service # Departure next station # create_system : create the topology def create_system(topo): stations = [ Station(i, # the station’s ID { ’S’: topo[i][0][0], # number of servers ’Mu’: topo[i][0][1], # service rate ’nextS’:None , # list of next stations ’probas’: topo[i][2] # probabilities to go to next stations }) for i in range(len(topo)) if i!=0] # create next stations for station in stations: if(topo[station.id][1]!=None): station.nextStations = [stations[v-1] for v in topo[station.id][1]] # returns initial stations with their arrival rates return [stations[i-1] for i in topo[0][1]] , topo[0][2] # setup the simulation def setup(): def firstS(lamdas): t=min(times) first=times.index(t) for k in range(len(times)): times[k]-=t times[first]=rexpo(lamdas[first]) return first,t initStations, lamdas = create_system(topo) times=[0 for i in range(len(initStations))] for i in range(len(times)): times[i]= rexpo(lamdas[i]) while e.now<T: indf, t=firstS(lamdas) car = yield SETO(e, delay=t, value=’C%d’ % next(g)) P(initStations[indf].pf_getin(car)) P(setup()); # Test topo = [ #(Svr_Nb,mu) ((None,None), ((2 ,4 ), ((1 ,3 ), ((1 ,6 ), R() [successors], [Probavility] [1,3], [6,2]), [2,3], [0.6,0.2,0.2]), [3] , [0.5,0.5]), None , None)] carwash(5,topo) 7.3.4.5 Simulation des files d’attente avec priorités Dans cette section, nous simulons une station de file d’attente dont les clients arrivants ont des priorités. Les priorités peuvent être préemptives ou pas. Nous utilisons PreemptiveResource et CHAPITRE 7. SIMULATION EN PYTHON 216 PriorityResource de Simpy. Nous considérons un temps de service exponentiel (sans mémoire), donc dans le cas de priorités préemptives, lorsqu’un client est interrompu par un autre plus prioritaire que lui, il est inséré dans la file d’attente du serveur, et lorsqu’il acquiert le serveur de nouveau, il reprend son exécution du début (absence de mémoire). Le cas d’un service sans absence de mémoire est traité dans l’application de ce chapitre. À vos claviers! # Code712.py from simpy import Interrupt from Code709 import e,P,R,TO, rexpo, RSC_Prempt, RQT_prio, RSC_Prio # def station(nbClients,serveurs,lamdas,mu,stat, preemption=True): times = [ rexpo(l) for l in lamdas ] # arrival times initialization for id in range(nbClients): t = min(times) # selects the earlier arrival priority = times.index(t) # gets its priority times = [ tc - t for tc in times ] # updates the arrival times times[priority] = rexpo(lamdas[priority]) # generate the next arrival of this priority yield TO(t) stat[priority][id]=[0,0,0] P(client(id,priority,serveurs,mu,stat, e.now, preemption)) # def client(id,priority,serveurs,mu,stat, beginTime, preemption=True): try: stat[priority][id][0] = beginTime with RQT_prio(serveurs,priority, preempt=preemption) as req: req.time=beginTime yield req stat[priority][id][1] = e.now yield TO(rexpo(mu)) stat[priority][id][2] = e.now except Interrupt: # in case of preemptive priority P(client(id,priority,serveurs,mu,stat, beginTime, preemption)) # def statistiques(stat): rgs = range(len(stat)) wait_queue, wait_system = [0 for _ in rgs], [0 for _ in rgs] for priority in rgs: for k in stat[priority].keys(): wait_queue[priority] += stat[priority][k][1] - stat[priority][k][0] wait_system[priority] += stat[priority][k][2]- stat[priority][k][0] print("Wq : Average waiting time in the queue") print("W : Average waiting time in the station") print("priority \t Wq \t\t W ") for p in rgs: twq = round(wait_queue[p]/len(stat[p]),2) tw = round(wait_system[p]/len(stat[p]),2) print(p," \t\t\t ", twq, " \t ", tw) # nbClients, nbServeurs, mu, lamdas, preemption = 100, 1 ,10, [3,4,2], False stat = [{} for p in range(len(lamdas))] serveurs = (RSC_Prempt if preemption else RSC_Prio)(nbServeurs) P(station(nbClients, serveurs, lamdas, mu, stat, preemption)); R() # print("Empirical performances:") statistiques(stat) 7.4 Application : Ordonnancement Un problème d’ordonnancement consiste à planifier l’exécution d’un ensemble de tâches en leur allouant les ressources requises et en fixant leurs dates de début. Dans le contexte des systèmes multi-processeurs, les tâches sont les processus à exécuter sur des processeurs parallèles qui représentent les ressources dans ce système. CHAPITRE 7. SIMULATION EN PYTHON 217 Dans l’application suivante on considère un système multi-processeurs ayant n processeurs avec des caractéristiques (vitesse) et des files d’attente différentes, et une séquence de tâches à exécuter sur ce système. Le scheduler (ordonnanceur) est le composant qui affecte les tâches soumises aux processeurs suivant une politique donnée. Dans ce qui suit nous considérons que les tâches sont indépendantes les unes des autres et elles ont des tailles (nombre d’instructions élémentaires) et des priorités différentes. La politique d’ordonnancement adoptée considère des priorités préemptives (une tâches plus prioritaire interrompe l’exécution d’une tâches moins prioritaire en cours d’exécution). Le temps d’exécution est calculé en fonction de la taille de la tâche et de la vitesse du processeur alloué. Le diagramme de Gant est l’outil utilisé pour visualiser le résultat de l’ordonnancement et notamment l’occupation des processeurs. À vos claviers! # method that plot the gant chart of the application def gant(cpus, tasks,l, H=50, M=5 ): import matplotlib.pyplot as plt fig, axi = plt.subplots() axi.set_ylim(0, H); axi.set_xlim(0, l) axi.set_xlabel(’Time’); axi.set_ylabel(’Processor’) axi.grid(True) # Setting ticks on y-axis dx = int((H - 2*M)/ len(cpus)) axi.set_yticks([dx + i*dx for i in range(len(cpus))]) axi.set_yticklabels(cpus) # Declaring a bar in schedule for k,task in tasks.items(): posH=(task[’cpu’]+1)*dx-M/2 axi.broken_barh(task[’length’], (posH, M) , facecolors = task[’color’]) for t in task[’length’]: axi.annotate(k, (1,1), xytext=(t[0]+t[1]/2-1, posH+M+1)) plt.show() Le code suivant utilise Simpy pour implémenter le système en question. La méthode schedule assure le rôle de l’ordonnanceur en générant les tâches suivant un taux lamda et en allouant les processeurs suivant une politique donnée en paramètre. Cette politique est définie comme méthode qui implémente la stratégie à étudier. Dans notre cas nous avons opté pour la stratégie qui sélectionne le processeur ayant la file d’attente la moins chargée lessLoaded. Nous avons implémenté les processeurs comme des ressources Simpy avec priorités préemptives. À vos claviers! #Code713.py import simpy from Code709 import (e,P,R,TO, rexpo, runif, g, RSC_Prempt, SETO, RQT_prio, gant, randColor) remain = lambda X,start,speed: X - (e.now - start)*speed # remaining time in the server # show def show(evt, s, task, X): print(round(e.now,3), " \t " + evt + " \t ",task[0], " \t ", X , " \t ", s.id, " \t ", task[2], " \t ", end=’’) class Station(object): def __init__(self, id, infos): self.id = id; self.Speed = infos[’Speed’] self.Servers = RSC_Prempt(1); def update(self, task, X, dicTask, evnt, start): X = int(remain(X,start,self.Speed)) dicTask[task[0]][’length’].append((round(start,3),round(e.now-start,3))) show(evnt, self, task, X) return X def pf_svc(self, X): delay = X/self.Speed ; yield TO(delay) def pf_run(self, task, stations, X, dicTask, preemption=True): if X>0: CHAPITRE 7. SIMULATION EN PYTHON try: with RQT_prio(self.Servers,task[2], preempt=preemption) as s: print([len(s.Servers.queue) for s in stations]) yield s; start = e.now show(’S’, self, task, X) ; print() yield P(self.pf_svc(X)) X = self.update(task, X, dicTask, ’D’, start) print([len(s.Servers.queue) for s in stations]) except simpy.Interrupt: if remain(X,start,self.Speed)>0: X = self.update(task, X, dicTask, ’I’, start) P(self.pf_run(task,stations, X, dicTask, preemption)) # create the system: one station for each processor def create_system(proc): stations = [ Station(i,{’Speed’: proc[i]}) for i in range(len(proc))] return stations # def schedule(T,lamda, procs, pmin, pmax, policy, dicTask): print(’Time \t Event \t Task \t Remain \t Server \t Priority \t Queues’) stations = create_system(procs) while e.now<T: t = rexpo(lamda) # next arrival # creates a new task (Id, length, priority) task = yield SETO(e, delay=t, value=(’T%d’ % next(g), runif(pmin,pmax)*10, runif(1,3))) proc = policy(stations) # calls the specified policy to selects a processor # intialize execution structure of the task dicTask[task[0]] = {’length’:[], ’cpu’:proc, ’color’:randColor()} show(’A’, stations[proc] , task, task[1]) # creates the station process associated to the current task P(stations[proc].pf_run(task, stations, task[1], dicTask )) # lessLoaded policy def lessLoaded(stations): lp = list( map(lambda s: s.Servers.count, stations)) if(min(lp) == 0): return lp.index(min(lp)) lq = list( map(lambda s: len(s.Servers.queue), stations)) return lq.index(min(lq)) # processors speeds, tasks dictionary processors, dicTask = [3,2,4], {} # pmin, pmax: minimum and maximum length of tasks, T: simulation time lamda, pmin, pmax, T = 5, 1, 9, 2 P(schedule(T,lamda,processors, pmin, pmax, lessLoaded, dicTask)); R() for k,t in dicTask.items(): print(k," cpu:",t[’cpu’],’ length:’,t[’length’]) lastD = max([d[0]+d[1] for t in dicTask.values() for d in t[’length’]]) gant(range(len(processors)),dicTask, int(lastD)+10) #______________________________ Output ______________________________________ # T1 cpu: 0 length: [(0.232, 1.872), (25.438, 21.333)] # T2 cpu: 1 length: [(0.33, 0.647), (50.976, 24.0)] # T3 cpu: 2 length: [(0.655, 22.5)] # T4 cpu: 0 length: [(5.438, 20.0)] # T5 cpu: 1 length: [(0.976, 20.0)] # T6 cpu: 2 length: [(23.155, 12.5)] # T7 cpu: 0 length: [(46.771, 6.667)] # T8 cpu: 1 length: [(20.976, 30.0)] # T9 cpu: 2 length: [(35.655, 15.0)] # T10 cpu: 0 length: [(2.104, 3.333)] 218 CHAPITRE 7. SIMULATION EN PYTHON Figure 7.6 – Diagramme de Gant : occupation des processeurs (code713.py) 219 CHAPITRE 7. SIMULATION EN PYTHON 7.5 220 Exercices Exercice 1. Écrire le code qui simule le problème des anniversaires décrit dans le chapitre 1. Exercice 2. Écrire le code qui simule l’exercice 23 du chapitre 1 en considérant le nombre k erreurs et n testeurs. Exercice 3. Simuler l’exemple 25 du chapitre 2. Exercice 4. Vérifier empiriquement (en utilisant la simulation) les inégalités de Markov et de Chebychev vues dans le chapitre 2. Exercice 5. 1.Simuler l’exercice 9 du chapitre 2. 2. Trouver une approximation du nombre π en utilisant le résultat de la simulation. Exercice 6. Simuler la marche aléatoire (chapitre 3) dans un plan (2D) et dans un espace 3D. Exercice 7. Simuler l’exercice 5 du chapitre 3. Exercice 8. Simuler l’exemple 2 du chapitre 4. Exercice 9. Simuler l’exercice 4 du chapitre 4. Exercice 10. Soit le modèle de Polya qui consiste en une urne contenant w boules blanches et b boules noires. A chaque étape on tire aléatoirement une boule et on la remet dans l’urne en ajoutant une boule de la même couleur. Simuler ce modèle. Exercice 11. Écrire le code qui simule et compare les deux systèmes décrits dans l’exercice 5 du chapitre 5. Exercice 12. Écrire le code qui simule le système décrit dans l’exercice 7 du chapitre 5 et comparer les résultats de la simulation avec les résultats analytiques. Exercice 13. Implémenter le code qui calcule les résultats analytiques des réseaux de Jackson en annexe et comparer les avec ceux obtenus par le code711. Exercice 14. Dans le code de l’application : 1.Implémenter la politique qui consiste à affecter chaque priorité à un processeur diffèrent (par exemple processeur1 aux tâches de priorité 1, processeur2 aux tâches de priorité 2 et processeur3 aux tâches de priorité 3). 2. Comparer le temps total d’exécution (le temps de terminaison de la dernière tâche exécutée) et la charge des processeurs avec lessLoaded(). 3. Modifier le code713 de sorte qu’on augmente la priorité (en fait on baisse sa valeur pour la rendre plus prioritaire) de la tâche à chaque fois qu’elle est interrompue. 4. Comparer le temps d’attente moyen des tâches de chaque priorité avec les stratégies précédentes. Appendices 221 Annexe A Dénombrement La résolution de beaucoup de problèmes de probabilité nécessitent des techniques de comptage permettant de compter le nombre de résultats possibles dans une expérience aléatoire donnée. A.1 Principe de multiplication On considère k expériences aléatoires {Ei }1..k tel que Si est l’ensemble des résultats possibles de la ieme expérience (Ei ) et |Si | = ni . L’expérience aléatoire E qui consiste à effectuer cette suite {Ei }1..k d’expériences a k Y SE = Si i=1 dont le nombre de résultats possibles est égale à |SE | = n = k Y ni i=1 Exemple 1. On lance une pièce de monnaie et un dé, quel est le nombre de résultats possibles pour cette expérience E ? E est une expérience composée de la séquence des expériences aléatoires E1 lancer une pièce de monnaie et E2 lancer un dé. E1 a comme résultats possibles S1 = {T, H}, |S1 | = n1 = 2, E2 a comme résultats possibles S2 = {1, 2, 3, 4, 5, 6}, |S2 | = n2 = 6, Alors SE = S1 ×S2 = {(T, 1), (T, 2), (T, 3), (T, 4), (T, 5), (T, 6), (H, 1), (H, 2), (H, 3), (H, 4), (H, 5), (H, 6)} |SE | = n1 × n2 = 2 × 6 = 12. Le dénombrement dans le contexte de la probabilité dépend de la description de l’expérience aléatoire et de ses caractéristiques décrites par la façon dont on effectue l’expérimentation. L’échantillonnage (sampling) est l’opération de tirer aléatoirement à partir d’un ensemble un ou plusieurs de ses éléments. L’ensemble des résultats possibles de cette expérience dépend de la façon dont on effectue le tirage. 1. Avec ou sans remplacement (remise) : dans le cas où le tirage est effectué avec remplacement, un élément donné peut être tiré plusieurs fois dans le même échantillon car l’élément tiré est remis après chaque tirage. 2. Avec ou sans ordre : si le tirage est effectué avec ordre, les éléments du même échantillon sont tirés l’un après l’autre (séquence) sinon on dit qu’ils sont choisi simultanément. En d’autres termes, le résultat {a1 , a2 , a3 , a4 } est différent de {a3 , a2 , a4 , a1 } dans le cas d’un tirage ordonné, mais identiques si le tirage est sans ordre. 222 ANNEXE A. DÉNOMBREMENT 223 Donc, quatre types de tirages sont possibles : ordonné avec remplacement, ordonné sans remplacement, non ordonné avec remplacement et non ordonné sans remplacement. A.2 Liste (Tirage Avec Ordre et Remplacement) Dans cette expérience, on possède un ensemble de n objets, et on veut tirer k objets de sorte que l’ordre est important et qu’après chaque tirage, l’objet est remis dans l’ensemble. Le résultat est appelé une liste. Ici, la liste à choisir comporte k positions, et il y a n options pour chaque position et comme l’ordre est important, le nombre total de façons pour choisir k éléments d’un ensemble de n éléments est : |SE | = n × n × ... × n = nk {z } | k positions Exemple 2. Soit A = {1, 2, 3}. Le nombre de listes de taille 2 choisies parmi les éléments de A est : |SE | = 32 = 9 différentes possibilités : SE = {(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)} A.3 Arrangement et permutation (Tirage avec Ordre et sans remplacement) Une liste de k éléments parmi n éléments où le remplacement n’est pas autorisé est appelée k-permutations ou arrangement de n éléments et notée Akn . Elle est interprétée encore comme le nombre d’applications injectives d’un ensemble de k éléments vers un ensemble de n éléments. Ici, la liste comporte k positions, pour la première, nous avons n possibilités, la 2eme position, nous avons n − 1 possibilités (car le premier élément tiré n’est pas remis),..., et pour la k eme position, il y en a n − k + 1. Ainsi, le nombre total de façons possibles est : Akn = n × (n − 1) × (n − 2) × ... × (n − k + 1) = n! , (n − k)! pour 0 ≤ k ≤ n Si k = n, on l’appelle simplement permutation et Pn = n!. Elle peut être interprétée encore comme le nombre de bijections d’un ensemble de n éléments vers lui même. Exemple 3. Soit A = {1, 2, 3}. Le nombre de permutations de taille 2 choisies parmi les 3! éléments de A est |SE | = A23 = (3−2)! = 3×2 1 = 6 différentes possibilités : SE = {(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)} A.4 Combinaison (Tirage sans ordre et sans remplacement) Ici, nous avons un ensemble de n éléments, et nous tirons un sous-ensemble (l’ordre n’est pas important) de k éléments. Cette expérience est appelée une combinaison de k éléments parmi n et notée Cnk . Le nombre des parties de 2Ω de cardinalité k est le nombre des combinaisons de k éléments choisis parmi n éléments : n n! , for 0 ≤ k ≤ n Cnk = = (n − k)!k! k Cnk est appelé aussi le coefficient binomial qui est le nombre de partitions binaires (binômes de parties complémentaires de cardinalité k et n − k éléments). Il peut être interprété comme le nombre de façons possibles de diviser n objets en deux groupes de tailles k et n − k. Il représente aussi les coefficients des termes développés du binôme de Newton. (a + b)n = n X 0 Cnk an−k bk ANNEXE A. DÉNOMBREMENT 224 Exemple 4. Soit A = {1, 2, 3}. Le nombre des combinaisons de taille 2 choisies parmi les éléments de A est |SE | = C32 = 3 × 2/2 = 3 différentes possibilités : SE = {{1, 2}, {1, 3}, {2, 3}} Le coefficient multinomial est une généralisation du coefficient binomial et qui représente le nombre de façons possibles de diviser n objets en m groupes (parties) de tailles k1 , k2 ,...,km (une partition ordonnée) et qui est égal à : n n! Cnk1 ,k2 ,...,km = = k1 !k2 !...km ! k1 , k2 , ..., km Il peut être considéré comme le nombre des permutations de n éléments pris de l’ensemble {e1 , e2 , · · · , em } où chaque élément ei est répété ki fois. Le nominateur n! est le nombre des permutations totales si on considère que les n éléments sont discernables. Pour éliminer les arrangements répétés, on divise par le nombre de permutations possibles de chaque élément). C’est le nombre de m-partitions (m-tuplets de parties de taille k1 , k2 , ..., km éléments). Il représente aussi les coefficients des termes développés du multinôme de Newton. X Cnk1 ,k2 ,...,kr ak11 ak22 · · · akmm (a1 + a2 + · · · + am )n = k1 +k2 +···+km =n Exemple 5. Soit le mot ’RECHERCHER’ quel est le nombre de dispositions des lettres de ce mot (mots qu’on peut construire) ? Une disposition est formée de 3 E, 3 R, 2 C, 2 H. Il existe donc 4 partitions E,R,C,H de tailles respectives 3, 3, 2, 2, donc le nombre de ces partitions est le nombre de permutations avec répétition des 10 caractères de ce mot ; alors le coefficient multinomial correspondant est : 3,3,2,2 C10 = 10! = 25200 3!.3!.2!.2! un mot de 10 lettres avec repetition RECHERCHE : z }| { 3 E RRREEEHHCC : | {z } 2 H z }| { | {z } 3 R A.5 2 C z }| { Combinaison avec répétition (Tirage sans ordre avec remplacement) k-Combinaison avec remplacement est un échantillonnage d’un ensemble A = {a1 , a2 , · · · , an }, k fois de telle façon que le remplacement est permis et l’ordre est sans importance. Le nombre de résultats de cette expérience est égal au nombre de solutions de l’équation : x1 + x2 + · · · + xn = k, tel que xi ∈ N est le nombre de fois que ai apparaît. Ce nombre est égal à k Cn+k−1 = (n + k − 1)! k!(n − 1)! Une méthode intuitive qui justifie ce résultat est de considérer k boules blanches et n − 1 boules noires. Chaque arrangement de ces boules représente une combinaison avec répétition dont le nombre de boules blanches entre la ieme et la (i + 1)eme boule noire représente la répétition de l’élément ai . La k-combinaison sans répétition des positions des boules noires parmi {1, 2, · · · , n + k − 1} représente de façon unique la k-combinaison avec répétition de n éléments. nieme partition xn ··· ··· | {z } ieme partition xi z }| { ANNEXE A. DÉNOMBREMENT 225 Exemple 6. Nous avons 10 millions de DA on veut investir cette somme dans 5 projets, quel est le nombre de possibilités de cet investissement ? xi est la somme investie dans le projet pi . On a : x1 +x2 +x3 +x4 +x5 = 10, tel que xi ∈ N. donc 10 on cherche le nombre de solutions de cette équation qui est égal à C5+10−1 = 14!/10!.4! = 1001 Exemple 7. Soit l’expérience aléatoire du lancer de 8 dés, et le résultat est le tuplet du nombre d’occurrences de chaque face, quel est la cardinalité de l’univers de cette expérience ? Le tuplet (o1 , o2 , o3 , o4 , o5 , o6 ) où oi est le nombre d’occurrences de la face i. Puisque nous avons P6 8 dés lancés alors i=1 oi = 8, un tuplet représente 8-combinaison avec répétition de 6 éléments. La figure suivante montre deux combinaisons la première représente le tuplet (1, 0, 4, 1, 2, 0) et la deuxième (2, 2, 0, 1, 0, 3). 2 des face 5 z | {z 4 des face 3 }| { } 2 des face 1 3 des face 6 z }| { z }| { | {z } 0 des face 3 dont le nombre total est : 8 C6+8−1 = 13! 13.12.11.10.9 = = 1287 8!5! 5.4.3.2 Un tableau récapitulatif des quatre cas précédents : Echantillonnage Avec remplacement Avec ordre nk Sans ordre k Cn+k−1 = Sans remplacement Pnk = (n+k−1)! k!(n−1)! n! (n−k)! cas k = n, Pn = n! Cnk = Table A.1 – Analyse Combinatoire k!(n−k)! n! Annexe B Autres types de modèles de files d’attente B.1 Modèles de files d’attente avec priorité Dans certains systèmes, les clients ont différentes priorités, par exemple, dans un système d’ordonnancement des tâches, les tâches sont exécutées selon leurs importances. Les serveurs servent les clients les plus prioritaires en premiers et si plusieurs clients dans la file ont la même priorité alors la discipline FIFO est appliquée. On définit N classes de priorité, la première est la plus prioritaire et la dernière est la moins prioritaire. Dans le cas de priorité préemptive le client qui est en train d’être servi est interrompu si un client plus prioritaire arrive au système. Alors que dans le cas de priorité non préemptive le service du client courant est complété avant de passer au client le plus prioritaire. Avec un temps de service de distribution exponentielle (qui a la propriété d’absence de mémoire), on ne se préoccupe pas du temps de service restant d’un client interrompu. Le temps d’attente moyen de la classe de priorité k dans un système de priorités non préemptive est : 1 Wq(k) = pour k = 1, ..., N. U Vk−1 Vk Tel que : s−1 sµ − λ X ρi U = s! + sµ ρs i=0 i! Pk λi et V0 = 1 Vk = 1 − i=1 sµ λi : taux d’arrivées des clients de priorité i. λ= N X λi (λ < sµ à l’état stationnaire.) i=1 L, Lq , W (k) peuvent être obtenus par les mêmes relations vues précédemment. Dans le cas d’un système de priorités préemptives, le temps d’attente moyen dans la file de la classe k est : 1/µ 1 Wq(k) = − pour k = 1, ..., N. Vk−1 Vk µ Dans certains systèmes les temps de service moyen diffèrent d’une classe à l’autre, s’il existe un seul serveur et que le système est non preemptif, alors le temps d’attente moyen est donné par : Uk Wq(k) = pour k = 1, ..., N. Vk−1 Vk 226 ANNEXE B. AUTRES TYPES DE MODÈLES DE FILES D’ATTENTE 227 Tel que : Uk = k X λi µ2 i=1 i Vk = 1 − k X λi i=1 µi et V0 = 1 µi : taux de service des clients de priorité i. B.2 Réseaux des files d’attente Un réseau de files d’attente est un système où plusieurs files individuelles sont interconnectées. Le système de files d’attente en série est le modèle le plus simple de cette classe. Un réseau de files d’attente est dit ouvert si les clients quittent le système après avoir reçu les services désirés, sinon il est dit fermé (les clients circulent entre les stations). La propriété d’équivalence stipule que si les arrivées des clients à une station sont poissonniennes de taux λ, alors le taux de départ à l’état stationnaire est aussi poissonnien de taux λ. La conséquence directe de cette propriété est que si à l’issue de cette station, les clients doivent passer directement par une autre station, alors cette dernière aura aussi des arrivées poissonniennes de même taux. B.2.1 Files d’attente en série Soit un ensemble de m stations de type M/M/S connectées linéairement et chaque station satisfait si × µi > λ tel-que si est le nombre de serveurs dans la station i, µi est le taux de service de la station i, λ est le taux d’arrivée des clients. Chaque client visite les m stations dans le même ordre de leurs connexion. Ce système est une série de files d’attente infinies. Chaque station est étudiée comme un système M/M/S indépendant, et la série complète des files d’attente est étudiée comme suit : La probabilité jointe π(n1 ,n2 ,...,nm ) d’avoir n1 clients dans la station 1, n2 clients dans la station 2,...,nm clients dans la station m à l’état stationnaire est le produit des probabilités individuelles : m m Y Y (1 − ρi )ρni i πn1 1 πn2 2 ...πnmm = π(n1 ,n2 ,...,nm ) = i=1 i=1 Le nombre moyen de clients L dans le système est la somme des Li dans toutes les stations ; et le temps d’attente moyen W dans le système est la moyenne des Wi pour i = 1, ..., m. Si les stations ont des files de taille limitée, elles ne sont pas considérées comme indépendantes, donc les résultats précédents ne s’appliquent pas. B.2.2 Réseaux de Jackson Un réseau de Jackson est un réseau de file d’attente ouvert décrit par un ensemble de stations indépendantes M/M/S, et la probabilité à l’état stationnaire est calculée par le produit des probabilités individuelles. La différence principale avec le cas des files en série est que dans un réseau de Jackson les clients peuvent visiter les stations dans un ordre différent et peuvent ne pas visiter toutes les stations. Donc chaque station peut recevoir des clients venant de n’importe quelle autre station ou bien de l’extérieur. Le taux d’arrivée des clients à la station i est : λi = ei + m X λj pji j=1 tel que : ei est le taux de clients qui arrivent directement de l’extérieur à la station i. pji est la probabilité qu’un client sortant de la station j se dirige vers la station i. ANNEXE B. AUTRES TYPES DE MODÈLES DE FILES D’ATTENTE 228 Pm qj = 1 − i=1 pji est la probabilité que le client quitte le système en sortant de la station j. Cette formule vient du fait que le processus d’arrivée à la station i est la somme de plusieurs processus de Poisson, c’est donc un processus de Poisson dont le paramètre est la somme des paramètres des processus qui le composent (extérieur+autres stations), et puisque le taux de départ de chaque station j est le même que son taux d’arrivée alors le taux d’arrivée à la station i de la station j est λj pji . Pour l’état stationnaire, la condition λi < si µi doit être satisfaite. si est le nombre de serveurs de la station i et µi son taux de service. Les valeurs des λi pour 1 ≤ i ≤ m sont obtenues par la résolution du système d’équations linéaires : Λ = e + ΛP . Tel que : Λ = (λ1 , λ2 , ..., λm ). e = (e1 , e2 , ..., em ) P = [pij ]1≤i,j≤m . La solution de ce système est : Λ = e(I − P)−1 La matrice I − P est inversible car les réseaux de Jackson sont des systèmes ouverts. Les performances du système sont calculées de la même façons décrite pour les stations en série. Exemple 8. Soient deux stations de files d’attente connectées par un réseau. Le temps de service est exponentiel de taux 8 pour le serveur de la première station et de taux 10 pour la deuxième. Les clients arrivent de l’extérieur suivant le processus de Poisson de taux 4 vers la première station et de taux 5 vers la seconde. Les clients sortant de la station1 se dirigent vers la deuxième station avec une probabilité 0.5, et ceux sortants de la deuxième se dirigent vers la première avec une probabilité 0.25. Déterminer les probabilités d’états du réseau à l’état stationnaire, le nombre de clients moyen dans le système et le temps d’attente moyen. Solution e = (4, 5), µ = (8, 10) 0 P= 0.25 Λ = e + PΛ = (6, 8) 3 4 ρ=( , ) 4 5 1 3 n1 4 n2 π(n1 , n2 ) = ( ) ( ) 20 4 5 λ1 λ2 L=( , ) = (3, 4), µ1 − λ1 µ2 − λ2 B.3 et 0.5 0 λ = Λ1 = λ1 + λ2 = 14 L = L1 + L2 = 7 et W = L λ = 1 2 Modèles avec des distributions non exponentielles Dans beaucoup de systèmes, la distribution exponentielle ne peut pas être utilisée pour décrire les temps inter-arrivées et les temps de services. C’est par exemple le cas où les arrivées sont préalablement programmées (planifiées) et que le service est similaire pour tous les clients. Cependant, la méthode analytique appliquée à ce type de modèles est plus difficile que ceux basés sur les processus poissonniens. B.3.1 Service de distribution générale Dans ce genre de systèmes, les temps de service des clients sont indépendants et de même distribution de probabilité. Cette distribution peut être de n’importe quelle loi, mais seules la moyenne µ et la variance σ 2 de la distribution doivent être connues. Pour le cas du modèle M/G/1, les arrivées sont poissonniennes de taux λ, le service est de ANNEXE B. AUTRES TYPES DE MODÈLES DE FILES D’ATTENTE 229 distribution générale et il existe un seul serveur et une file de taille infinie. L’état stationnaire est atteint si ρ = µλ < 1, et les performances de ce système sont : π0 = 1 − ρ Wq = λ σ 2 + 1/µ2 2(1 − ρ) Notons que le modèle M/M/1 est un cas spécial du M/G/1 où σ 2 = µ12 . Pour le cas du M/G/s, les performances sont encore inconnues et restent un problème de recherche ouvert. B.3.2 Service de distribution dégénérée (déterministe) Ce modèle est utilisé dans le cas des systèmes caractérisés par un temps de service fixe (déterministe) et identique pour tous les clients. Dans le modèle M/D/1, les arrivées sont poissonniennes de taux λ et le temps de service est déterministe de valeur D avec un seul serveur et une file de taille infinie. Le taux de service 1 µ= D . Les performances de ce système sont : Wq = B.3.3 ρ 2µ(1 − ρ) Service de distribution Erlang La distribution Erlang est définie par la fonction de densité suivante : f (x) = (µk)k k−1 −kµx x e (k − 1)! pour x ≥ 0. k est un entier, appelé le paramètre de forme. Il permet de spécifier le degré de variabilité des temps de service par rapport à leur moyenne. µ est un réel appelé le paramètre d’intensité. Quand k = 1, cette loi se réduit à la loi Exponentielle ; et quand k prend des valeurs réelles supérieures à 1, elle se généralise à la loi Gamma. Son espérance est µ1 et son écart type σ = √1kµ . Notons que 0 < σ < µ1 tel que 0 est l’écart type de la distribution dégénérée (déterministe) et 1 µ est celui de la loi exponentielle, ce qui permet à la distribution Erlang de représenter tous les cas des temps de service intermédiaires entre les deux. 1 La somme de k v.a Exponentielle de moyenne kµ est une v.a Erlang de paramètres µ et k. La distribution Erlang peut être utilisée dans le cas où le service de chaque client nécessite l’exécution de la même tâche (de temps exponentiel) k fois. Un autre avantage majeur de la distribution Erlang est qu’elle peut être utilisée comme approximation aux temps de service de distribution empirique. En effet, après l’estimation des valeurs de l’espérance et la variance de la distribution empirique, celles-ci sont utilisées pour choisir la valeur de k qui correspond au mieux à cette estimation. Pour le système M/Ek /1, les performances sont les suivantes : Wq = λ(1 + k) 2kµ(µ − λ) Aucune solution générale pour les performances du système M/Ek /S (S>1), n’existe jusqu’à présent. Pour les autres types de systèmes où les arrivées sont non poissoniennes, il existe très peu de résultats établis ce qui nous a emmené à les omettre de cette section. Le lecteur peut se référer à [12] pour plus de détails. Annexe C Tables statistiques 230 ANNEXE C. TABLES STATISTIQUES 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 0.0 0.5000 0.5398 0.5793 0.6179 0.6554 0.6915 0.7257 0.7580 0.7881 0.8159 0.8413 0.8643 0.8849 0.9032 0.9192 0.9332 0.9452 0.9554 0.9641 0.9713 0.9772 0.9821 0.9861 0.9893 0.9918 0.9938 0.9953 0.9965 0.9974 0.9981 0.9987 0.9990 0.9993 0.9995 0.9997 0.9998 0.9998 0.9999 0.0 0.5040 0.5438 0.5832 0.6217 0.6591 0.6950 0.7291 0.7611 0.7910 0.8186 0.8438 0.8665 0.8869 0.9049 0.9207 0.9345 0.9463 0.9564 0.9649 0.9719 0.9778 0.9826 0.9864 0.9896 0.9920 0.9940 0.9955 0.9966 0.9975 0.9982 0.9987 0.9991 0.9993 0.9995 0.9997 0.9998 0.9998 0.9999 0.0 0.5080 0.5478 0.5871 0.6255 0.6628 0.6985 0.7324 0.7642 0.7939 0.8212 0.8461 0.8686 0.8888 0.9066 0.9222 0.9357 0.9474 0.9573 0.9656 0.9726 0.9783 0.9830 0.9868 0.9898 0.9922 0.9941 0.9956 0.9967 0.9976 0.9982 0.9987 0.9991 0.9994 0.9995 0.9997 0.9998 0.9999 0.9999 0.0 0.5120 0.5517 0.5910 0.6293 0.6664 0.7019 0.7357 0.7673 0.7967 0.8238 0.8485 0.8708 0.8907 0.9082 0.9236 0.9370 0.9484 0.9582 0.9664 0.9732 0.9788 0.9834 0.9871 0.9901 0.9925 0.9943 0.9957 0.9968 0.9977 0.9983 0.9988 0.9991 0.9994 0.9996 0.9997 0.9998 0.9999 0.9999 231 0.0 0.5160 0.5557 0.5948 0.6331 0.6700 0.7054 0.7389 0.7704 0.7995 0.8264 0.8508 0.8729 0.8925 0.9099 0.9251 0.9382 0.9495 0.9591 0.9671 0.9738 0.9793 0.9838 0.9875 0.9904 0.9927 0.9945 0.9959 0.9969 0.9977 0.9984 0.9988 0.9992 0.9994 0.9996 0.9997 0.9998 0.9999 0.9999 0.1 0.5199 0.5596 0.5987 0.6368 0.6736 0.7088 0.7422 0.7734 0.8023 0.8289 0.8531 0.8749 0.8944 0.9115 0.9265 0.9394 0.9505 0.9599 0.9678 0.9744 0.9798 0.9842 0.9878 0.9906 0.9929 0.9946 0.9960 0.9970 0.9978 0.9984 0.9989 0.9992 0.9994 0.9996 0.9997 0.9998 0.9999 0.9999 0.1 0.5239 0.5636 0.6026 0.6406 0.6772 0.7123 0.7454 0.7764 0.8051 0.8315 0.8554 0.8770 0.8962 0.9131 0.9279 0.9406 0.9515 0.9608 0.9686 0.9750 0.9803 0.9846 0.9881 0.9909 0.9931 0.9948 0.9961 0.9971 0.9979 0.9985 0.9989 0.9992 0.9994 0.9996 0.9997 0.9998 0.9999 0.9999 Table 1 Distribution Normale 0.1 0.5279 0.5675 0.6064 0.6443 0.6808 0.7157 0.7486 0.7794 0.8078 0.8340 0.8577 0.8790 0.8980 0.9147 0.9292 0.9418 0.9525 0.9616 0.9693 0.9756 0.9808 0.9850 0.9884 0.9911 0.9932 0.9949 0.9962 0.9972 0.9979 0.9985 0.9989 0.9992 0.9995 0.9996 0.9997 0.9998 0.9999 0.9999 0.1 0.5319 0.5714 0.6103 0.6480 0.6844 0.7190 0.7517 0.7823 0.8106 0.8365 0.8599 0.8810 0.8997 0.9162 0.9306 0.9429 0.9535 0.9625 0.9699 0.9761 0.9812 0.9854 0.9887 0.9913 0.9934 0.9951 0.9963 0.9973 0.9980 0.9986 0.9990 0.9993 0.9995 0.9996 0.9997 0.9998 0.9999 0.9999 0.1 0.5359 0.5753 0.6141 0.6517 0.6879 0.7224 0.7549 0.7852 0.8133 0.8389 0.8621 0.8830 0.9015 0.9177 0.9319 0.9441 0.9545 0.9633 0.9706 0.9767 0.9817 0.9857 0.9890 0.9916 0.9936 0.9952 0.9964 0.9974 0.9981 0.9986 0.9990 0.9993 0.9995 0.9997 0.9998 0.9998 0.9999 0.9999 ANNEXE C. TABLES STATISTIQUES dl 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 22 24 26 28 30 35 40 45 50 60 70 80 90 100 120 χ20.005 .0000 .0100 .0717 .207 .4117 .6757 .9893 1.344 1.735 2.156 2.603 3.074 3.565 4.075 4.601 5.142 5.697 6.265 6.844 7.434 8.643 9.886 11.16 12.46 13.79 17.19 20.71 24.31 27.99 35.53 43.28 51.17 59.20 67.33 83.85 χ20.01 .0002 .02010 .1148 .2971 .5543 .8721 1.239 1.646 2.088 2.558 3.053 3.571 4.107 4.660 5.229 5.812 6.408 7.015 7.633 8.260 9.542 10.86 12.20 13.56 14.95 18.51 22.16 25.90 29.71 37.48 45.44 53.54 61.75 70.06 86.92 χ20.025 .0010 .0506 .2158 .4844 .8312 1.237 1.690 2.180 2.700 3.247 3.816 4.404 5.009 5.629 6.262 6.908 7.564 8.231 8.907 9.591 10.98 12.40 13.84 15.31 16.79 20.57 24.43 28.37 32.36 40.48 48.76 57.15 65.65 74.22 91.57 χ20.05 .0039 .1026 .3518 .7107 1.145 1.635 2.167 2.733 3.325 3.940 4.575 5.226 5.892 6.571 7.261 7.962 8.672 9.390 10.12 10.85 12.34 13.85 15.38 16.93 18.49 22.47 26.51 30.61 34.76 43.19 51.74 60.39 69.13 77.93 95.70 232 χ20.1 .0158 .2107 .5844 1.064 1.610 2.204 2.833 3.490 4.168 4.865 5.578 6.304 7.042 7.790 8.547 9.312 10.09 10.86 11.65 12.44 14.04 15.66 17.29 18.94 20.60 24.80 29.05 33.35 37.69 46.46 55.33 64.28 73.29 82.36 100.6 χ20.9 2.706 4.605 6.251 7.779 9.236 10.64 12.02 13.36 14.68 15.99 17.28 18.55 19.81 21.06 22.31 23.54 24.77 25.99 27.2 28.41 30.81 33.20 35.56 37.92 40.26 46.06 51.81 57.51 63.17 74.40 85.53 96.58 107.6 118.5 140.2 χ20.95 3.841 5.991 7.815 9.488 11.07 12.59 14.07 15.51 16.92 18.31 19.68 21.03 22.36 23.68 25.00 26.30 27.59 28.87 30.14 31.41 33.92 36.42 38.89 41.34 43.77 49.80 55.76 61.66 67.50 79.08 90.53 101.9 113.1 124.3 146.6 Table 2 Distribution Chi-square χ20.975 5.024 7.378 9.348 11.14 12.83 14.45 16.01 17.53 19.02 20.48 21.92 23.34 24.74 26.12 27.49 28.85 30.19 31.53 32.85 34.17 36.78 39.36 41.92 44.46 46.98 53.20 59.34 65.41 71.42 83.30 95.02 106.6 118.1 129.6 152.2 χ20.99 6.635 9.210 11.34 13.28 15.09 16.81 18.48 20.09 21.67 23.21 24.72 26.22 27.69 29.14 30.58 32.00 33.41 34.81 36.19 37.57 40.29 42.98 45.64 48.28 50.89 57.34 63.69 69.96 76.15 88.38 100.4 112.3 124.1 135.8 159.0 χ20.995 7.879 10.60 12.84 14.86 16.75 18.55 20.28 21.95 23.59 25.19 26.76 28.30 29.82 31.32 32.80 34.27 35.72 37.16 38.58 40.00 42.80 45.56 48.29 50.99 53.67 60.27 66.77 73.17 79.49 91.95 104.2 116.3 128.3 140.2 163.6 ANNEXE C. TABLES STATISTIQUES Nombre d’essais, n 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 Niveau de signification, 0.1 0.05 0.02 0.95000 0.97500 0.99000 0.77639 0.84189 0.90000 0.63604 0.70760 0.78456 0.56522 0.62394 0.68887 0.50945 0.56328 0.62718 0.46799 0.51926 0.57741 0.43607 0.48342 0.53844 0.40962 0.45427 0.50654 0.38746 0.43001 0.4796 0.36866 0.40925 0.45662 0.35242 0.39122 0.43670 0.33815 0.37543 0.41918 0.32549 0.36143 0.40362 0.31417 0.34890 0.38970 0.30397 0.33760 0.37713 0.29472 0.32733 0.36571 0.28627 0.31796 0.35528 0.27851 0.30936 0.34569 0.27136 0.30143 0.33685 0.26473 0.29408 0.32866 0.25858 0.28724 0.32104 0.25283 0.28087 0.31394 0.24746 0.27490 0.30728 0.24242 0.26931 0.30104 0.23768 0.26404 0.29516 0.23320 0.25907 0.28962 0.22898 0.25438 0.28438 0.22497 0.24993 0.27942 0.22117 0.24571 0.27471 0.21756 0.24170 0.27023 0.21412 0.23788 0.26596 0.21085 0.23424 0.26189 0.20771 0.23076 0.25801 0.20472 0.22743 0.25429 0.20185 0.22425 0.26073 0.19910 0.22119 0.24732 0.19646 0.21826 0.24404 0.19392 0.21544 0.24089 0.19148 0.21273 0.23786 0.18913 0.21012 0.23494 Table 3 Distribution Kolmogorov-Smirnov 233 α 0.01 0.99500 0.92929 0.82900 0.73424 0.66853 0.61661 0.57581 0.54179 0.51332 0.48893 0.46770 0.44905 0.43247 0.41762 0.40420 0.39201 0.38086 0.37062 0.36117 0.35241 0.34427 0.33666 0.32954 0.32286 0.31657 0.31064 0.30502 0.29971 0.29466 0.28987 0.28530 0.28094 0.27677 0.27279 0.26897 0.26532 0.26180 0.25843 0.25518 0.25205 Bibliographie [1] Rational sequence increasing to real number. https://proofwiki.org/wiki/ Rational_Sequence_Increasing_to_Real_Number. [2] A.Aissani. Modelisation et simulation. OPU, Algerie, 2007. [3] W.D.Kelton A.M.Law. Simulation, Modeling and analysis, 2nd edition. McGraw-Hill, Inc., 1991. [4] I. D. Hill B.A. Wichmann. Algorithm as183 an efficient and portable pseudo-random number generator. Journal of the Royal Statistical Society, 31(2) :188–190, 1982. [5] D.Knuth. The Art of Computer Programming volume 2 : Seminumerical algorithms, Generating Uniform Random Numbers. Addison-Wesley, 1981. [6] G.J.Lieberman F.S.Hillier. Introduction to operations research, 6th edition. McGraw-Hill, Inc., 1995. [7] S.Lafortune G.C.Cassandras. Introduction to discrete event systems, 2nd edition. Springer, 2008. [8] G.Marsaglia. Random numbers fall mainly in the planes. PNAS, 61(1) :25–28, Sept 1, 1968. [9] H.Pishro-Nik. Introduction to probability, statistics and random processes. https:// www.probabilitycourse.com, 2014. [10] H.Tijms. Probability : a lively introduction. Cambridge University Press, 2017. [11] M. j. Neely. On probabilty axioms and sigma algebras. https://ee.usc.edu/ stochastic-nets/docs/probability-axioms-sigma-algebras.pdf, 2019. [12] D.Gross C.M.Harris J.F.Shortle, J.M.Thompson. Fundamentals of queueing theory, 5th edition. Wiley, 2017. [13] J.Unpingco. Python for Probability, Statistics ans Machicne Learning. Springer, 2019. [14] K.Siegrist. Random services. https://www.randomservices.org. [15] P. L’Ecuyer. Uniform Random Number Generation. Springer, Annals of Operations Research 53(1) :77-120, 1994. [16] T. Nishimura M. Matsumot. Mersenne twister : a 623-dimensionally equidistributed uniform pseudo-random number generator. ACM Transactions on Modeling and Computer Simulation, 1(1) :3–30, Jan 1, 1998. [17] M.Harchol-Balter. Performance Modeling and Design of Computer Systems. Queueing theory in Action. Cambridge University Press, 2013. [18] T. Oliphant. Numpy project. https://www.numpy.org. [19] G. Van Rossum. Python api. http://www.python.org/doc/api/api.html. [20] S.M.Ross. A first course in probability, 5th edition. Prentice Hall, Inc., 1998. [21] S.M.Ross. Introduction to probability models, 10th edition. Academic Press. Elsevier, 2009. [22] A. R. Dobell T. E. Hull. Random number generators. SIAM Review, 4(3) :230–254, 1962. 234 BIBLIOGRAPHIE 235 À l’ère de l’intelligence artificielle, de la robotique, des systèmes intelligents et de l’apprentissage automatique, qui prennent de plus en plus de place dans pratiquement tous les domaines ; et depuis l’émergence des applications intelligentes sur lesquelles s’appuient la plupart des grands acteurs de l’informatique ; dans ce grand tourbillon technologique, on demande à l’informaticien de savoir, de créer et d’innover toujours plus. Cependant, le développement des compétences nécessaires pour la maîtrise de ces technologies récentes ne peut se concrétiser sans avoir les bases essentielles en probabilités qui est l’un de leurs piliers fondamentaux. La maîtrise des fondements de ce pilier est ainsi devenue chose incontournable. C’est dans cette optique que nous proposons cet ouvrage sur les probabilités, les processus stochastiques et la simulation, et dont le pari est de simplifier les concepts de bases par l’exemple et par la pratique. Cet ouvrage est destiné en premier lieu aux informaticiens, mais peut évidemment servir toute personne désirant apprendre les concepts élémentaires en probabilités avec leur côté pratique pour pouvoir par la suite, aborder d’autres sujets plus avancés tels que l’apprentissage automatique et l’intelligence artificielle. La particularité de cet ouvrage réside dans le nombre important d’exemples, d’exercices et de codes offerts dans le but de faciliter l’assimilation des différents concepts présentés. Les codes sont écrits en langage de programmation Python et permettent d’exposer les APIs et les bibliothèques les plus courantes et les plus efficaces pour la probabilités, les processus stochastiques et la simulation. View publication stats