Démystifier les statistiques essentielles en Python

Si vous avez peu d'expérience avec l'application d'algorithmes de machine learning, vous aurez constaté qu'aucune connaissance préalable en statistiques n'est strictement requise.

Cependant, maîtriser un socle statistique aide autant à comprendre le machine learning d'un point de vue technique que de façon intuitive. Ces notions deviennent incontournables dès que vous souhaitez valider vos résultats et les interpréter. Après tout, là où il y a des données, il y a des statistiques. Comme les mathématiques sont la langue de la science, les statistiques sont un langage à part entière pour la data science et le machine learning.

Les statistiques constituent un domaine des mathématiques riche en théories et en résultats. Divers concepts, outils, techniques et notations en sont issus et ont façonné le machine learning tel que nous le connaissons aujourd'hui. Les méthodes descriptives permettent de transformer des observations en informations exploitables, compréhensibles et partageables. Les techniques inférentielles permettent de raisonner à partir d'échantillons vers des populations entières. Vous verrez plus loin dans cet article les statistiques descriptives et inférentielles. Pas d'inquiétude.

Avant de commencer, voici dix exemples concrets où des méthodes statistiques interviennent dans un projet de machine learning appliqué :

• Définition du problème : nécessite une analyse exploratoire des données et du data mining.
• Compréhension des données : s'appuie sur des statistiques de synthèse et la visualisation de données.
• Nettoyage des données : mobilise la détection de valeurs aberrantes, l'imputation, etc.
• Sélection des données : requiert l'échantillonnage et la sélection de variables.
• Préparation des données : implique des transformations, la mise à l'échelle, l'encodage, et bien plus.
• Évaluation des modèles : repose sur la planification d'expériences et le rééchantillonnage.
• Configuration des modèles : fait appel aux tests d'hypothèse et à l'estimation statistique.
• Sélection des modèles : nécessite des tests d'hypothèse et des statistiques d'estimation.
• Présentation des modèles : utilise des statistiques d'estimation, comme les intervalles de confiance.
• Prédictions des modèles : mobilise des statistiques d'estimation, comme les intervalles de prédiction.

Source : Statistical Methods for Machine Learning

Passionnant, n'est-ce pas ?

Cet article vous donnera des bases solides sur les notions statistiques essentielles pour devenir un praticien du machine learning efficace.

Vous allez voir :

• Introduction aux statistiques et à leurs types
• Statistiques pour la préparation des données
• Statistiques pour l'évaluation des modèles
• Statistiques gaussiennes et descriptives
• Corrélation entre variables
• Statistiques non paramétriques

Le programme est dense et chaque sujet compte. Allons-y !

Introduction aux statistiques et à leurs types

Définissons brièvement les statistiques en termes simples.

Les statistiques sont un sous-domaine des mathématiques. Elles regroupent un ensemble de méthodes pour travailler les données et s'en servir afin de répondre à de nombreux types de questions.

Pour les outils statistiques utilisés en pratique, il est utile de scinder le champ en deux grandes familles : les statistiques descriptives, pour résumer les données, et les statistiques inférentielles, pour tirer des conclusions à partir d'échantillons (Statistics for Machine Learning (7-Day Mini-Course)).

• Statistiques descriptives : elles décrivent les caractéristiques essentielles des données d'une étude. Elles fournissent des résumés simples de l'échantillon et des mesures. Associées à une analyse graphique basique, elles constituent le socle de quasiment toute analyse quantitative. L'infographie ci-dessous en propose un bon résumé :

Source : IntellSpot

• Statistiques inférentielles : elles servent à quantifier des propriétés d'un domaine ou d'une population à partir d'un plus petit ensemble d'observations appelé échantillon. L'infographie ci-dessous illustre très bien ce principe :

  

Source : Analytics Vidhya

Dans la section suivante, vous verrez l'usage des statistiques pour la préparation des données.

Statistiques pour la préparation des données

Des méthodes statistiques sont nécessaires pour constituer vos jeux d'entraînement et de test.

Cela inclut notamment :

• Détection des valeurs aberrantes
• Imputation des valeurs manquantes
• Échantillonnage des données
• Mise à l'échelle des données
• Encodage des variables

Une compréhension de base des distributions, des statistiques descriptives et de la visualisation est requise pour choisir les bonnes méthodes lors de ces étapes.

Passons brièvement en revue chaque point.

Détection des valeurs aberrantes :

Commençons par définir une valeur aberrante.

Une valeur aberrante est une observation qui semble s'écarter du reste des observations de l'échantillon. La figure suivante rend cette définition plus parlante.

Source : MathWorks

Vous pouvez repérer les valeurs aberrantes sur les données comme sur la figure ci-dessus.

De nombreux algorithmes de machine learning sont sensibles à l'étendue et à la distribution des attributs en entrée. Des valeurs aberrantes peuvent biaiser et tromper l'entraînement, rallonger les temps de calcul, dégrader la précision des modèles, et in fine produire des résultats médiocres.

Identifier des valeurs aberrantes potentielles est essentiel pour plusieurs raisons :

• Elles peuvent indiquer une donnée de mauvaise qualité. Par exemple, un codage erroné, ou une expérimentation qui s'est mal déroulée. Si l'on détermine qu'un point aberrant est effectivement erroné, il faut le retirer de l'analyse, ou le corriger si possible.

• Il n'est pas toujours possible de trancher. Certaines valeurs aberrantes peuvent relever d'une variation aléatoire, ou signaler un phénomène intéressant. Dans tous les cas, on évite en général de supprimer aveuglément ces observations. Si les données en contiennent beaucoup, envisagez des techniques statistiques robustes.

En bref, les valeurs aberrantes nuisent souvent aux modèles prédictifs (même si, parfois, elles peuvent être exploitées à votre avantage — ce qui sort du cadre de cet article). Il vous faut donc le bagage statistique pour les traiter correctement.

Imputation des valeurs manquantes :

La plupart des jeux de données souffrent aujourd'hui de valeurs manquantes. Si les données injectées dans votre modèle en contiennent, l'entraînement risque d'être inefficace. Les outils et techniques statistiques vous viennent ici en aide.

Beaucoup suppriment purement et simplement les lignes avec des valeurs manquantes. Mauvaise pratique : vous risquez d'éliminer des informations clés. Au-delà des méthodes avancées, deux techniques rapides sont souvent utilisées : l'imputation par la moyenne et l'imputation par la médiane.

Il est donc indispensable de bien comprendre moyenne et médiane.

Supposons une variable X1 avec les valeurs suivantes - 13, 18, 13, 14, 13, 16, 14, 21, 13

La moyenne est la moyenne arithmétique, on additionne puis on divise :

(13 + 18 + 13 + 14 + 13 + 16 + 14 + 21 + 13) / 9 = 15

Notez que la moyenne, ici, ne correspond à aucune valeur de la liste. C'est fréquent. N'anticipez pas que votre moyenne soit l'un des nombres d'origine.

La médiane est la valeur centrale. Il faut d'abord trier la liste :

13, 13, 13, 13, 14, 14, 16, 18, 21

La liste comporte neuf nombres, la valeur du milieu est donc la (9 + 1) / 2 = 10 / 2 = 5e :

13, 13, 13, 13, 14, 14, 16, 18, 21

La médiane est donc 14.

Échantillonnage des données :

Les données sont la monnaie du machine learning appliqué. Leur collecte et leur usage sont tout aussi essentiels.

L'échantillonnage regroupe des méthodes statistiques pour sélectionner des observations dans un domaine afin d'estimer un paramètre de population. Autrement dit, c'est un processus actif de collecte d'observations dans le but d'estimer une variable de population.

Chaque ligne d'un jeu de données représente une observation indicatrice d'une population. En pratique, vous n'avez pas toujours accès à toutes les observations possibles, par exemple :

• Il peut être difficile ou coûteux d'en collecter davantage.
• Il peut être compliqué de rassembler toutes les observations.
• D'autres observations sont attendues à l'avenir.

Souvent, les proportions de classes sont déséquilibrées. Vous devrez alors sous-échantillonner ou sur-échantillonner selon le problème.

On sous-échantillonne quand une classe est très surreprésentée, en supprimant une partie de ses exemples. On sur-échantillonne quand une classe est sous-représentée, en générant de nouveaux exemples.

Cela vaut aussi en multiclasses.

L'échantillonnage statistique est un vaste domaine, mais trois types sont très utilisés en machine learning : aléatoire simple, systématique et stratifié.

• Aléatoire simple : tirages avec probabilité uniforme.
• Systématique : tirages selon un motif prédéfini, par exemple à intervalles réguliers.
• Stratifié : tirages au sein de catégories prédéfinies (strates).

Bien que ce soient les plus courants, il existe d'autres techniques (A Gentle Introduction to Statistical Sampling and Resampling).

Mise à l'échelle des données :

Les variables d'un jeu de données peuvent avoir des ordres de grandeur très différents. Certaines sont sur une échelle 0 à 100 quand d'autres varient entre 0,01 et 0,001, 10 000 à 20 000, etc.

C'est problématique pour modéliser efficacement. Une petite variation sur une variable de faible amplitude peut n'avoir quasiment aucun impact face à une variable de grande amplitude. Cela nuit à l'apprentissage. Le traitement de ce problème s'appelle la mise à l'échelle.

Parmi les techniques courantes : Min-Max, mise à l'échelle absolue, standardisation, etc.

Encodage des variables :

Vos jeux de données mélangent parfois données numériques et non numériques. Beaucoup de frameworks comme scikit-learn exigent des entrées entièrement numériques, ce qui accélère aussi les calculs.

Là encore, les statistiques vous sauvent la mise.

Des techniques comme le label encoding ou le one-hot encoding convertissent les variables catégorielles en numériques.

Place à la pratique !

Vous avez couvert pas mal de théorie. Passons à l'application pour se faire la main.

Commencez par appliquer quelques méthodes statistiques pour détecter des valeurs aberrantes.

Vous utiliserez l'indice Z-Score pour les détecter sur le jeu de données Boston House Price. Importez d'abord le dataset via les utilitaires de sklearn ; les notions nécessaires seront introduites au fil de l'eau.

import pandas as pd
import numpy as np
from sklearn.datasets import load_boston

# Load the Boston dataset into a variable called boston
boston = load_boston()
Propulsé par

# Separate the features from the target
x = boston.data
y = boston.target
Propulsé par

Pour visualiser le dataset sous forme de tableau avec les noms de variables, convertissez-le en DataFrame pandas.

# Take the columns separately in a variable
columns = boston.feature_names

# Create the dataframe
boston_df = pd.DataFrame(boston.data)
boston_df.columns = columns
boston_df.head()
Propulsé par

On commence souvent par une analyse univariée des valeurs aberrantes, variable par variable. Un simple box-plot d'une caractéristique fournit un bon point de départ. Réalisez un box-plot avec seaborn sur la variable DIS.

import seaborn as sns
sns.boxplot(x=boston_df['DIS'])

import matplotlib.pyplot as plt
plt.show()
Propulsé par

<matplotlib.axes._subplots.AxesSubplot at 0x8abded0>
Propulsé par

Pour afficher le graphique, vous avez importé matplotlib car les graphiques seaborn se comportent comme des tracés matplotlib classiques.

Le tracé ci-dessus montre trois points entre 10 et 12 : ce sont des valeurs aberrantes car ils se situent en dehors de la boîte des autres observations. Ici, vous avez analysé une valeur aberrante de façon univariée en n'utilisant que la variable DIS.

Passons maintenant au Z-Score.

"Le Z-score est le nombre signé d'écarts types par lesquels la valeur d'une observation se situe au-dessus (ou au-dessous) de la moyenne de ce qui est observé ou mesuré." - Wikipedia

L'idée du Z-score est de décrire un point de données par sa relation à l'écart type et à la moyenne du groupe. Le Z-score revient à recentrer et réduire les données (moyenne 0, écart type 1), c'est-à-dire les amener vers une distribution normale.

Mais en quoi cela aide-t-il à identifier des valeurs aberrantes ?

En calculant le Z-score, vous recentrez et mettez à l'échelle les données (moyenne 0, écart type 1) et recherchez les observations très éloignées de zéro. Ces points très éloignés sont considérés comme aberrants. Le seuil de 3 ou -3 est le plus courant. Par exemple, si la valeur du Z-score dépasse 3 (ou est inférieure à -3), le point est identifié comme aberrant.

Vous allez utiliser la fonction Z-score de la bibliothèque scipy pour détecter ces valeurs.

from scipy import stats

z = np.abs(stats.zscore(boston_df))
print(z)
Propulsé par

[[0.41771335 0.28482986 1.2879095  ... 1.45900038 0.44105193 1.0755623 ]
 [0.41526932 0.48772236 0.59338101 ... 0.30309415 0.44105193 0.49243937]
 [0.41527165 0.48772236 0.59338101 ... 0.30309415 0.39642699 1.2087274 ]
 ...
 [0.41137448 0.48772236 0.11573841 ... 1.17646583 0.44105193 0.98304761]
 [0.40568883 0.48772236 0.11573841 ... 1.17646583 0.4032249  0.86530163]
 [0.41292893 0.48772236 0.11573841 ... 1.17646583 0.44105193 0.66905833]]
Propulsé par

Impossible de repérer les aberrants à l'œil nu ici. Soyons plus malins : définissez un seuil, puis une condition simple pour détecter les points qui le dépassent.

threshold = 3
print(np.where(z > 3))
Propulsé par

(array([ 55,  56,  57, 102, 141, 142, 152, 154, 155, 160, 162, 163, 199,
       200, 201, 202, 203, 204, 208, 209, 210, 211, 212, 216, 218, 219,
       220, 221, 222, 225, 234, 236, 256, 257, 262, 269, 273, 274, 276,
       277, 282, 283, 283, 284, 347, 351, 352, 353, 353, 354, 355, 356,
       357, 358, 363, 364, 364, 365, 367, 369, 370, 372, 373, 374, 374,
       380, 398, 404, 405, 406, 410, 410, 411, 412, 412, 414, 414, 415,
       416, 418, 418, 419, 423, 424, 425, 426, 427, 427, 429, 431, 436,
       437, 438, 445, 450, 454, 455, 456, 457, 466], dtype=int32), array([ 1,  1,  1, 11, 12,  3,  3,  3,  3,  3,  3,  3,  1,  1,  1,  1,  1,
        1,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  5,  3,  3,  1,  5,
        5,  3,  3,  3,  3,  3,  3,  1,  3,  1,  1,  7,  7,  1,  7,  7,  7,
        3,  3,  3,  3,  3,  5,  5,  5,  3,  3,  3, 12,  5, 12,  0,  0,  0,
        0,  5,  0, 11, 11, 11, 12,  0, 12, 11, 11,  0, 11, 11, 11, 11, 11,
       11,  0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11],
      dtype=int32))
Propulsé par

Sortie encore peu lisible ! Le premier tableau liste les numéros de lignes, le second les colonnes correspondantes. Par exemple, z[55][1] a un Z-score supérieur à 3.

print(z[55][1])
Propulsé par

3.375038763517309
Propulsé par

Donc, l'enregistrement 55 sur la colonne ZN est aberrant. À vous d'étendre l'analyse.

Vous avez vu comment utiliser le Z-Score avec un seuil pour détecter des valeurs aberrantes potentielles. Passons maintenant à l'imputation des valeurs manquantes.

Utilisons le célèbre jeu de données Pima Indian Diabetes, connu pour contenir des valeurs manquantes. Chargeons-le d'abord dans votre espace de travail.

Chargez-le dans un DataFrame nommé data.

data = pd.read_csv("https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv",header=None)
print(data.describe())
Propulsé par

                0           1           2           3           4           5  \
count  768.000000  768.000000  768.000000  768.000000  768.000000  768.000000   
mean     3.845052  120.894531   69.105469   20.536458   79.799479   31.992578   
std      3.369578   31.972618   19.355807   15.952218  115.244002    7.884160   
min      0.000000    0.000000    0.000000    0.000000    0.000000    0.000000   
25%      1.000000   99.000000   62.000000    0.000000    0.000000   27.300000   
50%      3.000000  117.000000   72.000000   23.000000   30.500000   32.000000   
75%      6.000000  140.250000   80.000000   32.000000  127.250000   36.600000   
max     17.000000  199.000000  122.000000   99.000000  846.000000   67.100000   

                6           7           8  
count  768.000000  768.000000  768.000000  
mean     0.471876   33.240885    0.348958  
std      0.331329   11.760232    0.476951  
min      0.078000   21.000000    0.000000  
25%      0.243750   24.000000    0.000000  
50%      0.372500   29.000000    0.000000  
75%      0.626250   41.000000    1.000000  
max      2.420000   81.000000    1.000000  
Propulsé par

Vous aurez remarqué que les noms de colonnes sont numériques : vous utilisez un dataset déjà prétraité. Pas d'inquiétude, nous identifierons les variables bientôt.

Ce dataset est connu pour avoir des valeurs manquantes, mais à première vue, les statistiques ci-dessus peuvent laisser croire le contraire. En y regardant de plus près, certaines colonnes ne devraient jamais contenir de zéros : ces zéros matérialisent en fait des valeurs manquantes.

En particulier, les colonnes suivantes ont un minimum invalide à zéro :

• Concentration plasmatique de glucose
• Tension artérielle diastolique
• Épaisseur du pli cutané tricipital
• Insuline sérique à 2 heures
• Indice de masse corporelle

Vérifions-le sur les données brutes en affichant les 20 premières lignes.

data.head(20)
Propulsé par

On observe clairement des zéros dans les colonnes 2, 3, 4 et 5.

Puisque ce dataset note les valeurs manquantes comme 0, il est délicat de les traiter par des moyens classiques. Résumons l'approche :

• Compter le nombre de zéros par colonne identifiée plus haut.
• Repérer celles qui en contiennent le plus.
• Remplacer ces zéros par des NaN.
• Vérifier que les NaN sont bien pris en compte.
• Appeler fillna() avec la stratégie d'imputation.

# Step 1: Get the count of zeros in each of the columns
print((data[[1,2,3,4,5]] == 0).sum())
Propulsé par

1      5
2     35
3    227
4    374
5     11
dtype: int64
Propulsé par

Les colonnes 1, 2 et 5 n'ont que quelques zéros, tandis que 3 et 4 en comptent beaucoup, près de la moitié des lignes.

# Step -2: Mark zero values as missing or NaN
data[[1,2,3,4,5]] = data[[1,2,3,4,5]].replace(0, np.NaN)

# Count the number of NaN values in each column
print(data.isnull().sum())
Propulsé par

0      0
1      5
2     35
3    227
4    374
5     11
6      0
7      0
8      0
dtype: int64
Propulsé par

Assurons-nous maintenant visuellement que le remplacement par NaN a bien fonctionné :

# Step 4
data.head(20)
Propulsé par

On voit que le marquage des valeurs manquantes a eu l'effet attendu.

Jusqu'ici, vous avez identifié des cas typiques de données manquantes et vu comment utiliser des mesures simples pour y faire face. Procédons à l'imputation par la moyenne : on remplace chaque valeur manquante d'une colonne par la moyenne de cette colonne.

# Step 5: Call the fillna() function with the imputation strategy
data.fillna(data.mean(), inplace=True)

# Count the number of NaN values in each column to verify
print(data.isnull().sum())
Propulsé par

0    0
1    0
2    0
3    0
4    0
5    0
6    0
7    0
8    0
dtype: int64
Propulsé par

Parfait !

Cet article DataCamp vous guide efficacement pour implémenter la mise à l'échelle comme étape de prétraitement. À consulter.

Ensuite, passons à l'encodage des variables.

Il nous faut un dataset contenant des données non numériques. Utilisons le célèbre jeu de données Iris.

# Load the dataset to a DataFrame object iris
iris = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data",header=None)
Propulsé par

# See first 20 rows of the dataset
iris.head(20)
Propulsé par

Vous pouvez convertir facilement ces chaînes en entiers avec le LabelEncoder. Les trois classes (Iris-setosa, Iris-versicolor, Iris-virginica) seront mappées vers (0, 1, 2).

Ici, la cinquième colonne/caractéristique contient des valeurs non numériques. Il faut donc l'isoler.

# Convert the DataFrame to a NumPy array
iris = iris.values

# Separate
Y = iris[:,4]
Propulsé par

# Label Encode string class values as integers
from sklearn.preprocessing import LabelEncoder

label_encoder = LabelEncoder()
label_encoder = label_encoder.fit(Y)
label_encoded_y = label_encoder.transform(Y)
Propulsé par

Voyons maintenant une autre zone où les bases en statistiques sont cruciales.

Statistiques pour l'évaluation des modèles

Vous avez construit votre modèle. Il faut désormais évaluer ses performances sur les données de test. Pour cela, vous vous appuyez sur des métriques statistiques comme la précision, le rappel, la ROC, l'AUC, le RMSE, etc., ainsi que sur des techniques de rééchantillonnage comme la validation croisée k-fold.

Les statistiques permettent notamment de :

• Estimer la justesse d'une hypothèse
• Déterminer l'erreur entre deux hypothèses
• Comparer des algorithmes avec le test de McNemar

Remarque importante : ici, « hypothèse » renvoie aux modèles appris, c'est-à-dire les résultats d'un algorithme d'apprentissage sur un jeu de données. Évaluer et comparer des hypothèses signifie comparer des modèles appris, ce qui diffère de la comparaison d'algorithmes de machine learning, qui pourraient être entraînés sur des échantillons ou des problèmes différents.

Passons aux statistiques gaussiennes et descriptives.

Introduction aux statistiques gaussiennes et descriptives

Un échantillon de données n'est qu'un instantané d'une population plus large d'observations potentielles issues d'un domaine ou d'un processus.

Fait intéressant, beaucoup d'observations suivent un motif typique appelé distribution normale, ou gaussienne. Vous la connaissez sans doute sous la forme de cloche. La figure suivante en donne un exemple :

Source : HyperPhysics

Les processus et distributions gaussiens sont des sous-domaines à part entière. Concentrons-nous ici sur deux ingrédients essentiels qui structurent ces distributions.

Tout échantillon issu d'une gaussienne peut être résumé par deux paramètres :

• Moyenne : la tendance centrale, valeur la plus probable (sommet de la cloche).
• Variance : l'écart moyen des observations à la moyenne (l'étalement).

La notion de variance mène à l'écart type, simplement la racine carrée de la variance.

Moyenne, variance et écart type se calculent directement sur des échantillons avec numpy.

Générez d'abord un échantillon de 10 000 nombres aléatoires tirés d'une gaussienne de moyenne 50 et d'écart type 5. Calculez ensuite les statistiques de synthèse.

Commencez par importer les dépendances.

#  Dependencies
from numpy.random import seed
from numpy.random import randn
from numpy import mean
from numpy import var
from numpy import std
Propulsé par

Fixez ensuite la graine du générateur aléatoire pour rendre les résultats reproductibles.

seed(1)
Propulsé par

# Generate univariate observations
data = 5 * randn(10000) + 50
Propulsé par

# Calculate statistics
print('Mean: %.3f' % mean(data))
print('Variance: %.3f' % var(data))
print('Standard Deviation: %.3f' % std(data))
Propulsé par

Mean: 50.049
Variance: 24.939
Standard Deviation: 4.994
Propulsé par

On est très proche des paramètres, n'est-ce pas ?

Poursuivons.

Corrélation entre variables

Les caractéristiques d'un jeu de données sont souvent liées entre elles, ce qui est courant en pratique. En statistiques, ce lien (simple ou complexe) entre variables est la corrélation.

Mesurer le degré de corrélation est crucial. Cela revient à une sélection de variables : identifier les plus pertinentes. C'est une étape majeure d'un pipeline de machine learning, capable d'améliorer nettement la précision tout en réduisant le temps de calcul.

Pour comprendre pourquoi les variables peuvent être corrélées :

• Une variable peut déterminer une autre.
• Une variable peut être associée à une autre dans une certaine proportion.
• Plusieurs variables peuvent se combiner pour en engendrer une autre.

La corrélation peut être de trois types : positive (elles évoluent dans le même sens), nulle (aucune relation), négative (elles évoluent en sens opposé).

Les mesures de corrélation sont à la base des techniques de sélection filtrée de variables. Pour aller plus loin, consultez cet article.

Vous pouvez quantifier la relation entre deux variables avec le coefficient de corrélation de Pearson, du nom de Karl Pearson.

Dans pandas, utilisez corr() avec method = pearson. Examinons la corrélation entre les variables du jeu Pima Indians Diabetes utilisé précédemment. Vos données sont prêtes.

# Data
data.head()
Propulsé par

# Create the matrix of correlation score between the features and the label
scoreTable = data.corr(method='pearson')
Propulsé par

# Visulaize the matrix
data.corr(method='pearson').style.format("{:.2}").background_gradient(cmap=plt.get_cmap('coolwarm'), axis=1)
Propulsé par

Vous visualisez clairement la corrélation de Pearson entre toutes les variables et le label du dataset.

Dans la section suivante, vous verrez les statistiques non paramétriques.

Statistiques non paramétriques

Une large part des méthodes statistiques s'applique lorsque la distribution est connue.

Les statistiques non paramétriques sont utiles quand on dispose de peu ou pas d'informations sur les paramètres de population. Elles ne font aucune hypothèse sur la distribution des données.

Lorsque vous travaillez avec des données non paramétriques, vous pouvez utiliser des méthodes spécialisées qui ignorent toute information de distribution. On parle alors de méthodes sans distribution (distribution-free).

Mais avant d'appliquer une méthode non paramétrique, il faut convertir les données en rangs. Les méthodes qui attendent des données sous forme de rangs sont appelées statistiques de rang (ex. corrélation de rang, tests d'hypothèse sur rangs). Le classement fait exactement ce que son nom suggère.

Un test d'hypothèse non paramétrique très répandu pour comparer deux échantillons indépendants est le test U de Mann-Whitney, dû à Henry Mann et Donald Whitney.

Vous l'implémenterez en Python via mannwhitneyu() fourni par SciPy.

# The dependencies that you need
from scipy.stats import mannwhitneyu
from numpy.random import rand

# seed the random number generator
seed(1)
Propulsé par

# Generate two independent samples
data1 = 50 + (rand(100) * 10)
data2 = 51 + (rand(100) * 10)
# Compare samples
stat, p = mannwhitneyu(data1, data2)
print('Statistics = %.3f, p = %.3f' % (stat, p))
# Interpret
alpha = 0.05
if p > alpha:
    print('Same distribution (fail to reject H0)')
else:
    print('Different distribution (reject H0)')
Propulsé par

Statistics = 4077.000, p = 0.012
Different distribution (reject H0)
Propulsé par

alpha est le seuil que vous fixez. La fonction mannwhitneyu() renvoie :

• statistic : la statistique U de Mann-Whitney, égale à min(U pour x, U pour y) si alternative est None (déprécié ; pour compatibilité), sinon U pour y.

• pvalue : la p-valeur en supposant une distribution normale asymptotique.

Pour explorer d'autres méthodes non paramétriques, rendez-vous ici.

Deux autres tests de significativité non paramétriques populaires :

• Test de Friedman
• Test des rangs signés de Wilcoxon

On conclut !

Vous êtes arrivé au bout. Dans cet article, vous avez passé en revue des concepts statistiques essentiels qui jouent un rôle déterminant dans vos projets de machine learning. Les comprendre est indispensable.

D'une simple introduction aux statistiques jusqu'aux méthodes de classement, vous avez mis en pratique à plusieurs reprises. Vous avez manipulé trois jeux de données, exploité au maximum pandas et numpy, et utilisé SciPy. Pour aller plus loin :

• The Elements of Statistical Learning
• Machine Learning book by Tom Mitchell
• All for Statistics

Voici les ressources qui m'ont aidé à rédiger cet article :

• Machine Learning Mastery mini course on Statistics
• A Gentle Introduction to Statistical Sampling and Resampling
• https://www.khanacademy.org/math/statistics-probability
• Statistical Learning course by Stanford University

Partagez vos questions et retours en commentaires. Et découvrez le cours DataCamp "Statistical Thinking in Python", résolument orienté pratique.