Python pour le calcul scientifique/Statistiques

Le module NumPy fournit des fonctions statistiques.
Rappelons que dorénavant les programmes commencent tous par :
import numpy as np
import matplotlib.pyplot as plt
Méthodes de matrices.
Rappel : la classe des matrices "(ndarray)" dispose de méthodes permettant de calculer des statistiques sur les éléments des matrices :
Statistiques descriptives.
NumPy fournit la fonction codice_6 qui détermine les quantiles avec la syntaxe :
np.quantile(M, q)
où codice_7 est une matrice (ou une liste, un n-uplet, bref un itérable de nombres) et codice_8 est un quantile ou un vecteur de quantiles sous la forme d'un nombre entre 0 et 1. Par exemple, pour avoir les quartiles :
np.quantile(M, [0, 0.25, 0.5, 0.75, 1])
Si un des éléments de la matrice est un NaN, le résultat est un NaN. Pour éviter cela, on peut utiliser la fonction codice_9 qui ignore les NaN.
Les fonctions codice_10 et codice_11 donnent les centiles ; on indique alors le centile que l'on veut sous la forme d'un nombre entier entre 0 et 100.
Nous disposons également des fonctions suivantes :
Notons que pour toutes les fonctions, il est possible d'indiquer l'axe selon lequel on effectue le calcul. Par exemple,
M = np.arange(9).reshape(3, 3)
print(np.quantile(M, [0.25, 0.5], 0))
print(np.quantile(M, [0.25, 0.5], 1))
Indicateurs de position et de dispersion.
NumPy fournit les indicateurs de tendance centrale suivants :
En terme de performances, la fonction codice_17 est équivalente à la méthode codice_26 et à la fonction codice_19 sans poids (ce qui équivaut donc à la moyenne). En revanche, la fonction codice_18 est plus lente, de même que la fonction codice_19 lorsque l'on utilise des poids (même s'ils sont tous égaux à 1).
Comme précédemment, on peut indiquer l'axe (si l'on veut évaluer les valeurs par colonne ou par ligne). Pour la moyenne pondérée, on utilise une matrice poids P de même dimension que la matrice de valeurs M, codice_30 étant le poids associé à la valeur codice_31. Par exemple, si l'on veut évaluer la moyenne pondérée pour toutes les valeurs de M (pas d'axe), on peut écrire une des deux solutions suivantes :
np.average(M, None, P) # l'axe est le 2e paramètre
np.average(M, weights = P)
NumPy fournit également les indicateurs de dispersion suivants :
Fréquence, histogramme.
On peut générer une matrice aléatoire avec les fonctions codice_36, qui utilise une loi uniforme sur [0 ; 1], et codice_37 qui utilise une loi normale centrée réduite.
Lorsque l'on dispose d'une série de données aléatoires, qu'elles aient été mesurées ou bien générées par une fonction aléatoire, on peut ensuite les mettre dans des classes "()". Les classes sont définies par un vecteur (ou une liste, un n-uplet) codice_38. La classe 0 désigne les valeurs inférieures à "c"1 ; la classe 1 désigne les valeurs "c"1 ≤ "x" < "c"2 ; la classe "n" (codice_39) désigne les valeurs supérieures à "cn".
La fonction codice_40 indique dans quelle classe se trouve un nombre. Si on lui donne une matrice (ou un vecteur, une liste, un n-uplet), il renvoie une matrice de même dimension, codice_41 étant la classe de l'élément codice_31. Par exemple :
M = np.random.rand(10)
classes = (0, 0.2, 0.4, 0.6, 0.8, 1)
print(M)
print(np.digitize(M, classes))
On peut changer la « largeur » des inégalités avec le paramètre codice_43 : ', « droite », est vrai "()" lorsque l'inégalité large est à droite, la classe "i" désigne les valeurs "ci" < "x" ≤ "c""i" + 1. La syntaxe est alors codice_44 ou bien codice_45. Le sens de l'inégalité ne dépend pas du sens du vecteur de classes ; ainsi, ' désigne la valeur supérieure de l'intervalle même si le vecteur de classes est classé par ordre décroissant.
La fonction codice_46 détermine "n" classes de même taille et renvoie deux vecteurs : le premier contient le nombre d'éléments dans chaque classe et le second décrit les classes (c'est-à-dire les bornes des classes).
Pour tracer l'histogramme, nous disposons de la fonction codice_47 :
M = np.random.randn(50)
plt.plot(M, np.ones_like(M), "|")
plt.hist(M, bins=10, density=1)
La fonction codice_48 travaille sur les listes de nombres entiers. Elle renvoie un n-uplet, codice_49 est le nombre de fois que le nombre "i" revient dans la matrice M — rappel, le premier élément du n-uplet codice_50 a l'indice 0 donc correspond au nombre de fois que le nombre 0 apparaît dans la matrice M.
Lois de probabilités.
Le module codice_51 fournit un grand nombre de lois de probabilités. Ces lois sont des objets ayant toutes les mêmes méthodes. Par exemple, on dispose des lois suivantes :
et des méthodes suivantes :
Par exemple
from scipy import stats
moy, var, asy, kurt = stats.norm.stats(moments="mvsk")
print(moy, var, asy, kurt)
print(stats.norm.pdf(1), ";", stats.norm.cdf(0.5), ";", stats.norm.ppf(0.99))
x = np.linspace(-6, 6, 100)
y1 = stats.norm.pdf(x)
y2 = stats.norm.cdf(x)
plt.plot(x, y1, label="densité")
plt.plot(x, y2, label="répartition")
plt.legend()
Par défaut, les lois continues sont centrées réduites (de moyenne nulle et d'écart type unité). Les objets disposent des paramètres codice_71 ("location", position) et codice_72 (échelle) ; par exemple pour un tirage aléatoire de 100 échantillons avec une loi normale de moyenne 10 et d'écart type 5 :
stats.norm.rvs(100, loc=5, scale=10)
Il est possible de fixer ces paramètres pour une loi, de la « geler », par exemple :
from scipy import stats
varAl = stats.norm(loc=5, scale=10) # loi "gelée"
n = 100
x = varAl.rvs(n)
plt.plot(x, np.ones_like(x), "|")
plt.hist(x)
print(varAl.mean(), varAl.std())
ou encore
from scipy import stats
n = 100
varAl = stats.poisson(mu=50)
x = varAl.rvs(size=n)
plt.plot(x, np.ones_like(x), "|")
plt.hist(x)
print(varAl.mean(), varAl.std())
res = stats.norm.fit(x)
print(res)
L'exemple suivant consiste à vérifier qu'un échantillon suit bien une loi normale centrée réduite en traçant sa droite de Henry :
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
X = stats.norm.rvs(size=100)
p = np.arange(0.1, 1, 0.1)
qexp = np.quantile(X, p)
qth = stats.norm.ppf(p)
extr = stats.norm.ppf([0.1, 0.9])
plt.plot(extr, extr, "--r")
plt.plot(qth, qexp, "*")
plt.title("diagramme quantiles-quantiles")
plt.xlabel("quantiles théoriques")
plt.ylabel("quantiles expérimentaux")
plt.savefig("diagramme_qq_python_matplotlib.svg")
Pour les lois discrète, il est nécessaire d'indiquer leurs paramètres. Par exemple :
Notes et références.
Polynômes < ↑ > Interpolation, extrapolation et lissage

Python pour le calcul scientifique/Interpolation, extrapolation et lissage