« Découvrir Scilab/Statistiques » : différence entre les versions

Contenu supprimé Contenu ajouté
m →‎Notes : typo
import de Calcul numérique
Ligne 5 :
<span style="font-size:25px;">4. Statistiques</span>
----
 
Pour l'analyse statistique de données, on peut se reporter au document
: {{lien web | url = http://www.openeering.com/sites/default/files/Data_mining_0.pdf | langue = en | titre = Data Analysis and Statistics: a Scilab data mining tutorial | auteur = Anna Bassi et Giovanni Borzi | format = pdf | site = Openeering}}.
 
== Tendance centrale ==
 
Considérons une matrice X. On peut calculer les moyennes suivantes :
* <code>mean(X)</code> : calcule la moyenne de tous les éléments de X ;
* <code>mean(X, "r")</code> : donne un vecteur ligne ''(row)'' contenant les moyennes colonne par colonne ;
* <code>mean(X, "c")</code> : donne un vecteur colonne contenant les moyennes ligne par ligne.
On peut calculer la moyenne géométrique avec <code>geomean()</code>, et la moyenne harmonique avec <code>harmean()</code>, avec la même syntaxe.
 
De la même manière, on peut calculer les médianes avec <code>median(X)</code>, <code>median(X, "r")</code> et <code>median(X, "c")</code>.
 
La commande <code>trimmean(X, p)</code> permet de calculer la moyenne en éliminant les ''p'' pourcents extrêmes (les ''p''/2 % valeurs les plus élevées, et les ''p''/2 % valeurs les plus faibles). On peut également faire le calcul par ligne ou par colonne — <code>trimmean(X, p, "r")</code> ou <code>trimmean(X, p, "c")</code>. notons que l'on a :
* <code>mean(X) = trimmean(X, 0)</code> ;
* <code>median(X) = trimmean(X, 100)</code>.
 
== Dispersion ==
 
La commande
<source lang="scilab">
strange(X)
</source>
calcule l'écart ''(range)'' entre la valeur maximale et la valeur minimale de la matrice. On peut calculer les valeurs pour chaque colonne ou chaque ligne avec <code>strange(X, "r")</code> et <code>strange(X, "c")</code>.
La commande
<source lang="scilab">
mad(X)
</source>
calcule la déviation absolue moyenne ''(mean absolute deviation)''
: <math>\dfrac{1}{n}\sum| x_i - \bar{x} |</math>
on peut de même la calculer pour chaque colonne ou ligne.
 
La commande
<source lang="scilab">
iqr(X)
</source>
calcule l'écart interquartile ''(interquartile range)''.
 
La commande <code>stdev</code> calcule l'écart type ''(standard deviation)'' et la commande <code>variance</code> la variance des éléments de la matrice (entière, par ligne ou par colonne). Par défaut, la variance est sans biais : normalisée par ''m''×''n'' - 1 pour une matrice de ''m''×''n'' éléments, par ''m'' - 1 par colonne et par ''n'' - 1 par ligne. Si l'on calcule la variance par ligne ou par colonne, on peut ajouter l'option <code>1</code> pour calculer le moment d'ordre 2 (normalisation par ''m'' ou ''n''), par exemple
<source lang="scilab">
mom2 = variance(X, "r", 1) // pour une matrice non-vecteur
mom2 = variance(X, "*", 1) // pour un vecteur
</source>
L'écart type est toujours sans biais. Si l'on veut l'estimateur normalisé par ''m'' ou ''n'', il faut utiliser
<source lang="scilab">
estim_ecart_type = sqrt(variance(X, "*", 1)) // pour une matrice non-vecteur
</source>
 
== Normalisation ==
 
La commande <code>center(X)</code> permet de centrer la matrice (équivalent de <code>X - mean(X)</code>). La commande <code>wcenter(X)</code> donne la matrice centrée réduite (équivalent de <code>1/stdev(X)*(X - mean(X))</code>).
 
== Fréquences et quartiles ==
 
La commande <code>tabul(X)</code> calcule les fréquences d'apparition des valeurs dans la matrice X. Le résultat est classé par défaut par ordre décroissant des valeurs ; pour avoir un classement croissant, on ajoute le paramètre <code>"i"</code> ''({{lang|en|increasing order}})'' :
<source lang="scilab">
tabul(X, "i")
</source>
 
La commande <code>quart(X)</code> calcule les quartiles et les renvoie dans un vecteur de dimension 3. On peut calculer les quartiles pour chaque colonne ou chaque ligne, avec <code>quart(X, "r")</code> et <code>quart(X, "c")</code>.
 
On peut aussi travailler avec des valeurs et leur fréquence. Si la matrice X contient les valeurs et la matrice F leur fréquence — F(''i'', ''j'') est la fréquence de X(''i'', ''j'') —, alors
* <code>meanf(X, F)</code> donne la moyenne ;
* <code>stdevf(X, F)</code> donne l'écart type ;
* <code>variancef(X, F)</code> donne la variance.
Notons que F n'est pas nécessairement normalisé à 1 ou à 100 ; il peut par exemple s'agir d'un nombre d'occurrences.
 
'''Exemple'''
 
<source lang="scilab">
X = int(10*rand(100,1, "normal")); // génère 100 valeurs entières avec une loi normale centrée d'écart type 10
F = tabul(X); // calcule les fréquences d'apparition
x = F(:, 1); // extraction de la liste des valeurs
f = F(:, 2); // extraction de la liste des fréquences
 
quartiles = quart(X); // calcule les quartiles de la population
 
moyenne = meanf(x, f); // calcul de la moyenne pondérée par les fréquences
</source>
 
Considérons maintenant deux vecteurs X et Y de même dimension, et la matrice F des fréquences de X et Y : F(''i'', ''j'') est la fréquence de X(''i'') & Y(''j''). Alors :
* <code>covar(X, Y, F)</code> donne la covariance ;
* <code>correl(X, Y, F)</code> donne le coefficient de corrélation.
 
'''Exemple'''
 
<source lang="scilab">
n = 10; // nombre de valeurs
X = 1:n; // abscisses
Y = 2*X + 5 + 3*rand(X); // ordonnées : droite "bruitée"
plot(X, Y); // tracé des données
F = eye(n, n); // couplage (x, y) : chaque couple est présent une fois, (X(i) & Y(i)) = 1, (X(i) & Y(j)) = 0
 
covariance1 = covar(X, Y, F);
covariance2 = 1/n*sum(X.*Y) - 1/n^2*sum(X)*sum(Y); // calcul "à la main" pour comparer
 
correlation1 = correl(X, Y, F);
correlation2 = covariance2/sqrt(variance(X, "*", 1))/sqrt(variance(Y, "*", 1)); // calcul "à la main"
</source>
 
== Fonctions de distribution et de répartition de lois statistiques ==
 
Par défaut, Scilab propose une loi de distribution, pour la loi binomiale, et onze lois de répartition (probabilités cumulatives).
 
Pour la loi binomiale, la fonction de répartition pour ''n'' épreuves (nombre entier) avec une probabilité ''p'' (nombre réel entre 0 et 1) est donnée par
<source lang="scilab">
f = binomial(p, n)
</source>
La variable <code>f</code> est un vecteur de ''n'' + 1 composantes, avec
: <math>\mathtt{f}(k + 1) = \begin{pmatrix} n \\ k \end{pmatrix} \cdot p^k \cdot (1 - p)^{n - k}
= \mathrm{C}^k_n \cdot p^k \cdot (1 - p)^{n - k}</math>
La fonction de répartition s'obtient avec <code>cdfbin()</code> :
<source lang="scilab">
P = = cdfbin("PQ", k, n, p, 1-p)
</source>
donne la probabilité P d'avoir entre 0 et ''k'' succès pour ''n'' tirages avec une probabilité de réussite ''p''. On peut d'ailleurs le comparer avec
<source lang="scilab">
f = binomial(p, n)
c = sum(f(1:k+1))
</source>
 
De manière générale, les fonctions de répartition commencent par <code>cdf…</code> ''(cumulative distribution function)'', par exemple :
* <code>P = cdfchi("PQ", x, k)</code> : loi du <span style="font-family: serif">χ</span><sup>2</sup> à ''k'' degrés de liberté ;
* <code>P = cdfnor("PQ", x, mu, sigma)</code> : loi normale d'espérance ''mu'' et d'écart type ''sigma'' ;
* <code>P = cdfpoi("PQ", k, lambda)</code> : loi de Poisson de paramètre ''lambda'' ;
* <code>P = cdft("PQ", t, k)</code> : loi t de Student à ''k'' degrés de liberté ;
* … voir ''[http://help.scilab.org/docs/5.4.1/en_US/section_e9886297dc5f06a7c11cf8b143ab8686.html Scilab help >> Statistics > Cumulated Distribution Functions]''
Notons que pour chaque cas, on peut aussi avoir la valeur complémentaire Q = 1 - P avec la syntaxe
[P, Q] = cdf…("PQ", …)
 
'''Exemple'''
 
Ci-dessous, nous traçons la fonction de répartition de la loi normale centrée réduite (μ = 0, σ = 1). Notons que pour des calculs vectoriels, l'espérance et l'écart type sont des vecteurs de même dimension que X.
<source lang="scilab">
X = -3:0.1:3;
mu = zeros(X);
sigma = ones(X);
[P, Q] = cdfnor("PQ", X, mu, sigma);
plot(X', [P', Q'])
</source>
 
Les mêmes fonctions permettent de rechercher les quantiles ou fractiles :
* <code>k = cdfbin("S", n, P, 1-P, p, 1-p)</code> : nombre de succès ''k'' sur ''n'' épreuves ayant pour paramètre ''p'', donnant une probabilité cumulée P ;
* <code>x = cdfchi("X", k, P, 1-P)</code> : valeur de ''x'' pour laquelle on a une probabilité cumulée P avec une loi du <font style="font-family: serif">χ</font><sup>2</sup> à ''k'' degrés de liberté ;
* <code>x = cdfnor("X", mu, sigma, P, 1-P)</code> : valeur de ''x'' pour laquelle on a une probabilité cumulée P avec une loi normale d'espérance ''mu'' et d'écart type ''sigma'' ;
* <code>k = cdfpoi("S", lambda, P, 1-P)</code> : valeur de ''k'' pour laquelle on a une probabilité cumulée P avec une loi de Poisson de paramètre ''lambda'' ;
* <code>t = cdft("T", k, P, 1-P)</code> : valeur de ''t'' pour laquelle on a une probabilité cumulée P avec une loi t de Student à ''k'' degrés de liberté ;
* …
 
'''Exemple'''
 
Ci dessous, nous déterminons le quantile pour un risque α bilatéral de 5 %, c'est-à-dire que l'on rejette 0,25 % des cas les plus hauts et les plus bas, pour une loi normale centrée réduite puis pour une loi t de Student à 30 degrés de liberté
<source lang="scilab">
-->x = cdfnor("X", 0, 1, 0.975, 0.025)
x =
1.959964
-->t = cdft("T", 30, 0.975, 0.025)
t =
2.0422725
</source>
 
Enfin, ces fonctions permettent de déterminer les paramètres des loi pour atteindre un quantile visé :
* loi binomiale :
** <code>n = cdfbin("Xn", p, 1-p, P, 1-P, k)</code> : nombre d'épreuves ayant pour paramètre ''p'' afin d'avoir un quantile P valant ''k'',
** <code>[p, q] = cdfbin("PrOmpr", P, 1-P, k, n)</code> : paramètre ''p'' de chaque épreuve afin d'avoir un quantile P pour ''k'' succès parmi ''n'' ;
* loi du <font style="font-family: serif">χ</font><sup>2</sup> :<br /> <code>k = cdfchi("Df", P, 1-P, x)</code> : valeur du nombre de degrés de liberté ''(degrees of freedom)'' ''k'' pour avoir un quantile P valant ''x'' ;
* loi normale :
** <code>mu = cdfnor("Mean", sigma, P, 1-P, x)</code> : valeur de l'espérance (moyenne) pour avoir un quantile P valant ''x'' si l'on a un écart type ''sigma'',
** <code>sigma = cdfnor("Std", P, 1-P, X, mu)</code> : valeur de l'écart type ''(standard deviation)'' pour avoir un quantile P valant ''x'' si l'on a une espérance de ''mu'' ;
* loi de Poisson : <br /> <code>lambda = cdfpoi("Xlam", P, 1-P, k)</code> : valeur du paramètre λ pour avoir un quantile P valant ''k'' ;
* loi t de Student : <br /> <code>k = cdft("Df", P, 1-P, t)</code> : nombre de degrés de liberté ''k'' pour avoir un quantile P valant ''t''.
 
== Générateurs pseudo-aléatoires ==
 
Les générateurs de nombres aléatoires permettent de tester des programmes ou bien de faire des simulations par la méthode de Monte Carlo.
 
Scilab possède une fonction <code>rand()</code> qui par défaut génère un nombre entre 0 et 1 avec une loi de distribution uniforme. Par exemple, pour simuler un jet de dé à six faces, on peut utiliser :
<source lang="scilab">
de = 1 + int(6*rand())
</source>
La fonction peut générer une matrice ''m''×''n'' avec les syntaxes
<source lang="scilab">
rand(m, n)
rand(X)
</source>
où X est une matrice ''m''×''n''. Notons que si l'on veut générer ''n'' valeurs, il faut bien taper <code>rand(n, 1)</code> ou <code>rand(1, n)</code>.
 
On peut lui faire générer une valeur selon une loi normale centrée réduite avec la clef <code>"normal"</code> :
<source lang="scilab">
rand(m, n, "normal")
</source>
 
'''Exemple'''
 
Supposons par exemple que l'on a une poutre faite dans un acier dont la résistance intrinsèque, la limite d'élasticité R<sub>e</sub>, est garantie au minimum à {{unité|235|MPa}}. En réalité, R<sub>e</sub> suit une loi normale d'espérance μ<sub>Re</sub> = {{unité|269|MPa}} et d'écart type σ<sub>Re</sub> = {{unité|17|MPa}}. Dans les conditions d'utilisation, l'acier de cette poutre doit résister à une contrainte S ''(stress)'' de {{unité|214|MPa}} ; en fait, les conditions de chargement sont variables et suivent une loi normale de paramètres μ<sub>S</sub> = {{unité|214|MPa}} et σ<sub>S</sub> = {{unité|15|MPa}}.
 
On veut déterminer statistiquement dans combien de cas la contrainte S est supérieure à la résistance R<sub>e</sub>.
 
<source lang="scilab">
n = 1e6; // nombre d'événements
R = 269 + 17*rand(n, 1, "normal"); // résistance
S = 214 + 14*rand(n, 1, "normal"); // contrainte
Mbool = S>R; // comparaison des valeurs (matrice de booléens)
moyenne = sum(Mbool)/n; // les "vrai" comptent pour 1 et les "faux" pour 0
disp(string(100*moyenne)+" %") // affichage du résultat
</source>
 
La commande <code>grand()</code> ''(get random number)'' permet d'avoir des nombres aléatoires selon de nombreuses lois, par exemple :
* <code>Y = grand(m, n, "bin", N, p)</code> : matrice ''m''×''n'' de nombres aléatoires tirés selon une loi binomiale de N essais avec une probabilité ''p'' chacun ;
* <code>Y = grand(m, n, "nor", mu, sigma)</code> : pour une loi normale d'espérance ''mu'' et d'écart type ''sigma'' ;
* <code>Y = grand(m, n, "unf", a, b)</code> : pour une loi uniforme sur [''a'' ; ''b''[ (''b'' exclus) ;
* <code>Y = grand(m, n, "uin", a, b)</code> : pour une loi uniforme sur [''a'' ; ''b''] (''b'' inclus) ;
* …
Dans l'exemple précédent, on aurait donc :
<source lang="scilab">
R = grand(n, 1, "nor", 369, 17); // résistance
S = grand(n, 1, "nor", 314, 14); // contrainte
</source>
 
== Autres lois statistiques ==
 
Des modules complémentaires [[../Atoms|Atoms]] permettent d'avoir accès à d'autres loi.
 
Par exemple le module [http://atoms.scilab.org/toolboxes/casci CASCI] donne accès à de nombreuses fonctions de distribution et de répartition, notamment des lois log-normale (<code>pdflognormal()</code>, <code>cdflognormal()</code>), exponentielle (<code>pdfexponential()</code>, <code>cdfexponential()</code>) ou de Weibull (<code>pdfweibull()</code>, <code>cdfweibull()</code>). Ainsi :
 
<source lang="scilab">
p = pdfnormal(x, mu, sigma); // densité d'une loi normale en x
y = cdflognormal(x, lambda); // répartition d'une loi log-normale d'espérance mu et d'écart type sigma
y = cdfexponential(x, mu, sigma); // répartition d'une loi exponentielle de paramètre lambda
y = cdfweibull(x, k, lambda, theta); // répartition d'une loi de Weibull
// de paramètre de forme k, de paramètre d'échelle lambda et de paramètre de position thêta
</source>
 
Le module fournit également le calcul des quantiles avec les fonctions <code>idf…</code> ''({{lang|en|inverse cumulative distribution functions}})'', et des générateurs de nombres aléatoires avec les fonctions <code>rnd…</code>. Par exemple :
<source lang="scilab">
x = idfweibull(y, k, lambda, theta); // quantile y d'une loi de Weibull
// de paramètre de forme k, de paramètre d'échelle lambda et de paramètre de position thêta
X = rndweibull(n, k, lambda, theta); // génère n nombres aléatoires selon la loi de Weibull
</source>
 
== Module Stixbox ==
 
Le module [http://atoms.scilab.org/toolboxes/stixbox Stixbox] définit également un certan nombre de fonctions statistiques utiles.
 
== Notes ==