Tutoriel sur les lois de probabilité en Python

Loi uniforme continue

L’une des lois les plus simples et utiles est la loi uniforme. La fonction de densité de probabilité de la loi uniforme continue est :

Comme tout intervalle de même largeur a la même probabilité d’être observé, la courbe représentant la distribution est un rectangle, de hauteur constante sur l’intervalle et nulle ailleurs. Puisque l’aire sous la courbe doit être égale à 1, la longueur de l’intervalle détermine la hauteur. La figure suivante illustre une loi uniforme sur l’intervalle (a,b). Remarquez que, pour que l’aire vaille $1$, la hauteur est fixée à $1/(b-a)$.

Loi uniforme en Python

Vous pouvez visualiser une loi uniforme en Python à l’aide d’un générateur de nombres aléatoires sur un intervalle (a,b). Importez la fonction uniform depuis le module scipy.stats.

# import uniform distribution\nfrom scipy.stats import uniform\nPropulsé par

La fonction uniform génère une variable continue uniforme sur l’intervalle défini par ses arguments loc et scale. La distribution est constante entre loc et loc + scale. L’argument size indique le nombre de réalisations aléatoires. Pour assurer la reproductibilité, fournissez un random_state fixé à une valeur numérique.

# random numbers from uniform distribution\nn = 10000\nstart = 10\nwidth = 20\ndata_uniform = uniform.rvs(size=n, loc = start, scale=width)\nPropulsé par

Vous pouvez utiliser distplot de Seaborn pour tracer l’histogramme de la distribution créée. distplot accepte de nombreux arguments de personnalisation. Vous créez d’abord un objet de tracé ax. Vous pouvez préciser le nombre de bins de l’histogramme, la color des barres, activer la courbe de densité avec kde et régler l’épaisseur avec hist_kws. Vous pouvez aussi définir les étiquettes des axes x et y avec xlabel et ylabel.

ax = sns.distplot(data_uniform,\n                  bins=100,\n                  kde=True,\n                  color='skyblue',\n                  hist_kws={\"linewidth\": 15,'alpha':1})\nax.set(xlabel='Uniform Distribution ', ylabel='Frequency')\nPropulsé par

[Text(0,0.5,u'Frequency'), Text(0.5,0,u'Uniform Distribution ')]\nPropulsé par

Loi normale

La loi normale, ou loi gaussienne, est omniprésente en data science. Vous la retrouverez souvent, notamment en inférence statistique. De nombreux algorithmes de data science l’assument également.

Une loi normale a une courbe en cloche décrite par sa moyenne $μ$ et son écart-type $σ$. La courbe est symétrique et centrée sur sa moyenne, l’étalement étant déterminé par l’écart-type : les données proches de la moyenne sont plus fréquentes que celles qui en sont éloignées. La fonction de densité d’une loi normale de moyenne $μ$ et d’écart-type $σ$ au point $x$ est donnée par :

Voici la forme typique de cette distribution :

Environ 68 % des données se situent à une distance d’un écart-type de la moyenne de part et d’autre, et 95 % dans un intervalle de deux écarts-types. À noter également : une distribution de moyenne $0$ et d’écart-type $1$ s’appelle une loi normale centrée réduite.

Loi normale en Python

Vous pouvez générer une variable aléatoire normalement distribuée avec la méthode norm.rvs() du module scipy.stats. L’argument loc correspond à la moyenne, scale à l’écart-type et size au nombre de réalisations. Pour la reproductibilité, utilisez l’argument random_state.

from scipy.stats import norm\n# generate random numbers from N(0,1)\ndata_normal = norm.rvs(size=10000,loc=0,scale=1)\nPropulsé par

Vous pouvez visualiser la distribution comme pour l’uniforme, avec la fonction distplot de Seaborn. Les arguments ont la même signification que précédemment.

ax = sns.distplot(data_normal,\n                  bins=100,\n                  kde=True,\n                  color='skyblue',\n                  hist_kws={\"linewidth\": 15,'alpha':1})\nax.set(xlabel='Normal Distribution', ylabel='Frequency')\nPropulsé par

[Text(0,0.5,u'Frequency'), Text(0.5,0,u'Normal Distribution')]\nPropulsé par

Loi gamma

La loi gamma est une famille à deux paramètres de distributions de probabilité continues. Elle est rarement utilisée telle quelle, mais des lois très répandues comme les lois exponentielle, khi-deux ou Erlang en sont des cas particuliers. La loi gamma peut être paramétrée par un paramètre de forme $α = k$ et un paramètre d’échelle inverse $β = 1/θ$, appelé paramètre de taux. Le symbole $Γ(n)$ désigne la fonction gamma, définie par $(n-1)!$ :

Voici l’allure typique d’une loi gamma :

Loi gamma en Python

Vous pouvez générer une variable aléatoire suivant une loi gamma avec la méthode gamma.rvs() du module scipy.stats, qui prend comme argument le paramètre de forme $a$. Lorsque $a$ est un entier, la gamma se réduit à la loi d’Erlang, et lorsque $a=1$ à la loi exponentielle. Utilisez loc pour décaler la distribution, scale pour la mettre à l’échelle, et size pour le nombre de réalisations. Pour la reproductibilité, utilisez random_state.

from scipy.stats import gamma\ndata_gamma = gamma.rvs(a=5, size=10000)\nPropulsé par

Vous pouvez visualiser la distribution comme pour l’uniforme, avec la fonction distplot de Seaborn. Les arguments ont la même signification que dans la section dédiée à l’uniforme.

ax = sns.distplot(data_gamma,\n                  kde=True,\n                  bins=100,\n                  color='skyblue',\n                  hist_kws={\"linewidth\": 15,'alpha':1})\nax.set(xlabel='Gamma Distribution', ylabel='Frequency')\nPropulsé par

[Text(0,0.5,u'Frequency'), Text(0.5,0,u'Gamma Distribution')]\nPropulsé par

Loi exponentielle

La loi exponentielle décrit le temps entre des événements d’un processus de Poisson, c’est-à-dire un processus où les événements surviennent de manière continue et indépendante à un taux moyen constant. Elle possède un paramètre $λ$, appelé paramètre de taux, et son équation s’écrit :

Une loi exponentielle décroissante ressemble à ceci :

Loi exponentielle en Python

Vous pouvez générer une variable aléatoire exponentielle avec la méthode expon.rvs() du module scipy.stats, qui prend comme argument le paramètre scale correspondant à 1/lambda dans l’équation. Utilisez loc pour décaler, size pour le nombre de réalisations. Pour la reproductibilité, utilisez random_state.

from scipy.stats import expon\ndata_expon = expon.rvs(scale=1,loc=0,size=1000)\nPropulsé par

La visualisation avec Seaborn produit la courbe suivante :

ax = sns.distplot(data_expon,\n                  kde=True,\n                  bins=100,\n                  color='skyblue',\n                  hist_kws={\"linewidth\": 15,'alpha':1})\nax.set(xlabel='Exponential Distribution', ylabel='Frequency')\nPropulsé par

[Text(0,0.5,u'Frequency'), Text(0.5,0,u'Exponential Distribution')]\nPropulsé par

Loi de Poisson

La variable de Poisson sert généralement à modéliser le nombre d’occurrences d’un événement sur un intervalle de temps. Par exemple, le nombre d’utilisateurs visitant un site sur un intervalle peut être modélisé par un processus de Poisson. La loi de Poisson est décrite par le taux ($μ$) auquel les événements se produisent. Un événement peut survenir 0, 1, 2, … fois sur un intervalle. Le nombre moyen d’événements dans un intervalle est noté $λ$ (lambda). $\lambda$ est le taux d’événements, aussi appelé paramètre de taux. La probabilité d’observer $k$ événements dans un intervalle est donnée par :

Remarque : la loi normale est un cas limite de la loi de Poisson lorsque $λ →∞$. De plus, si les temps entre événements aléatoires suivent une loi exponentielle de taux $λ$, alors le nombre total d’événements sur une durée $t$ suit une loi de Poisson de paramètre $λt$.

La figure suivante illustre une distribution de Poisson typique :

Loi de Poisson en Python

Vous pouvez générer une variable aléatoire discrète de Poisson avec la méthode poisson.rvs() du module scipy.stats, qui prend $μ$ comme paramètre de forme (équivalent de $λ$ dans l’équation). Utilisez loc pour décaler la distribution. size fixe le nombre de réalisations. Pour la reproductibilité, utilisez random_state.

from scipy.stats import poisson\ndata_poisson = poisson.rvs(mu=3, size=10000)\nPropulsé par

Vous pouvez visualiser la distribution comme pour l’uniforme, avec la fonction distplot de Seaborn. Les arguments ont la même signification.

ax = sns.distplot(data_poisson,\n                  bins=30,\n                  kde=False,\n                  color='skyblue',\n                  hist_kws={\"linewidth\": 15,'alpha':1})\nax.set(xlabel='Poisson Distribution', ylabel='Frequency')\nPropulsé par

[Text(0,0.5,u'Frequency'), Text(0.5,0,u'Poisson Distribution')]\nPropulsé par

Loi binomiale

Une distribution où deux issues seulement sont possibles, par exemple succès/échec, gain/perte, victoire/défaite, et où la probabilité de succès et d’échec est identique pour toutes les épreuves, s’appelle une loi binomiale. Toutefois, les issues n’ont pas besoin d’être équiprobables et chaque épreuve est indépendante des autres. Les paramètres de la loi binomiale sont $n$ et $p$ où $n$ est le nombre total d’épreuves et $p$ la probabilité de succès à chaque épreuve. Sa fonction de probabilité est :

où :

Loi binomiale en Python

Vous pouvez générer une variable aléatoire discrète binomiale avec la méthode binom.rvs() du module scipy.stats, qui prend $n$ (nombre d’épreuves) et $p$ (probabilité de succès) comme paramètres de forme. Utilisez loc pour décaler la distribution. size définit le nombre de répétitions des épreuves. Pour la reproductibilité, utilisez random_state.

from scipy.stats import binom\ndata_binom = binom.rvs(n=10,p=0.8,size=10000)\nPropulsé par

La visualisation avec distplot de Seaborn produit l’histogramme suivant :

ax = sns.distplot(data_binom,\n                  kde=False,\n                  color='skyblue',\n                  hist_kws={\"linewidth\": 15,'alpha':1})\nax.set(xlabel='Binomial Distribution', ylabel='Frequency')\nPropulsé par

[Text(0,0.5,u'Frequency'), Text(0.5,0,u'Binomial Distribution')]\nPropulsé par

Remarque : puisque la probabilité de succès est supérieure à $0.5$, la distribution est asymétrique vers la droite. Par ailleurs, la loi de Poisson est un cas limite de la loi binomiale sous les conditions suivantes :

\n
1. Le nombre d’épreuves est indéfiniment grand, $n → ∞$.
\n
2. La probabilité de succès à chaque épreuve est la même et tend vers 0, $p → 0$.
\n
3. $np = λ$ est fini.
\n

La loi normale est un autre cas limite de la loi binomiale lorsque :

\n
1. Le nombre d’épreuves est indéfiniment grand, $n → ∞$.
\n
2. $p$ et $q$ ne sont pas indéfiniment petits.
\n

Loi de Bernoulli

Une loi de Bernoulli n’a que deux issues possibles, $1$ (succès) et $0$ (échec), et une seule épreuve, par exemple un lancer de pièce. La variable aléatoire $X$ qui suit une loi de Bernoulli prend la valeur $1$ avec la probabilité de succès $p$, et la valeur $0$ avec la probabilité d’échec $q$ ou $1-p$. Les probabilités de succès et d’échec n’ont pas besoin d’être égales. La loi de Bernoulli est un cas particulier de la loi binomiale avec une seule épreuve ($n=1$). Sa fonction de masse est :

Loi de Bernoulli en Python

Vous pouvez générer une variable aléatoire discrète de Bernoulli avec la méthode bernoulli.rvs() du module scipy.stats, qui prend $p$ (probabilité de succès) comme paramètre de forme. Utilisez loc pour décaler la distribution. size définit le nombre de répétitions. Pour la reproductibilité, utilisez random_state.

from scipy.stats import bernoulli\ndata_bern = bernoulli.rvs(size=10000,p=0.6)\nPropulsé par

En visualisant la distribution, on observe bien qu’il n’y a que deux issues possibles :

ax= sns.distplot(data_bern,\n                 kde=False,\n                 color=\"skyblue\",\n                 hist_kws={\"linewidth\": 15,'alpha':1})\nax.set(xlabel='Bernoulli Distribution', ylabel='Frequency')\nPropulsé par

[Text(0,0.5,u'Frequency'), Text(0.5,0,u'Bernoulli Distribution')]\nPropulsé par

Conclusion

Félicitations, vous êtes arrivé au bout de ce tutoriel ! Vous avez passé en revue plusieurs lois de probabilité courantes et appris à les créer et les tracer en Python. Même s’il en existe bien d’autres, cela suffit pour démarrer. N’oubliez pas d’explorer la bibliothèque scipy de Python, qui propose de nombreuses fonctionnalités statistiques. Bonne exploration !

Pour aller plus loin sur les probabilités en Python, suivez le cours Statistical Simulation in Python de DataCamp.

Consultez aussi notre tutoriel Poker Probability and Statistics with Python.

Références

\n
• Random Variables (Yale)
\n
• Poisson distribution
\n
• 6 Common Probability Distributions every data science professional should know (By Radhika Nijhawan)
\n