Initiez-vous au Machine Learning

Commençons ce chapitre par un petit exercice de mise en pratique, dans lequel on va :

1. Charger un dataset.

2. Entraîner le modèle.

3. Évaluer le modèle.

Pour cela, nous allons partir d’un exemple simple de régression linéaire (nous verrons d’ailleurs cette notion plus en détail dans le chapitre suivant).

À vous de jouer !

Voici un dataset avec 237 échantillons comprenant l'âge, le sexe, la taille et le poids d'enfants de 11,5 à 20 ans. Et voici en quelques lignes comment entraîner un modèle prédictif sur ces données.

Pour débuter, nous allons utiliser tous les échantillons du dataset sans le scinder en 2 (entraînement + test).

Nous allons construire un modèle qui prédit la variable cible (le poids de l'enfant) à partir des autres variables (sexe, âge et taille).

On cherche donc les coefficients  a  ,  b  ,  c  tels que :

poids = a * sexe + b * age + c * taille + du bruit

Rappel : le bruit représente l'information qui n'est pas capturée par le modèle linéaire.

Voici un exemple où on ne considère que les variables de sexe et d'âge. Votre mission consiste à ajouter la variable de taille.

import pandas as pd
df = pd.read_csv(<le fichier csv>;)

# les variables prédictives
X = df[['age', 'taille']]

# la variable cible, le poids
y = df.poids

# on choisit un modèle de régression linéaire
from sklearn.linear_model import LinearRegression
reg = LinearRegression()

# on entraîne ce modèle sur les données avec la méthode fit
reg.fit(X, y)

# et on obtient directement un score
print(reg.score(X, y))

# ainsi que les coefficients a,b,c de la régression linéaire
print(reg.coef_)

Reprenons chaque ligne en commençant par les données.

Étape 1 : charger le dataset dans une dataframe Pandas

On charge le dataset dans une dataframe Pandas :

df = pd.read_csv(<fichier csv des données>;)

Par convention on note la matrice des variables prédictives X  :

X = df[['age', 'height']]

Ici on ne considère que les 2 variables âge et taille.

De même par convention on note le vecteur (array) de la variable cible y  .

y = df.weight

Étape 2 : entraîner le modèle

Maintenant, étape 2, on passe au modèle.
On choisit la régression linéaire de scikit-learn :

from sklearn.linear_model import LinearRegression
reg = LinearRegression()

Entraîner le modèle consiste à appliquer la méthode  fit()  sur le modèle en lui fournissant en entrée les valeurs des variables prédictives  X  et de la variable cible  y  .

reg.fit(X, y)

À ce stade, le modèle est entièrement entraîné sur le jeu de données.

Étape 3 : évaluer le modèle

Enfin, étape 3, on regarde la performance du modèle par l'intermédiaire du score.

print(reg.score(X, y))

Les coefficients  a  et  b  sont donnés par  reg.coef_  :

print(reg.coef_)
> [-2.06, 0.3 ]

Allez plus loin

Retournez sur le notebook Colab et cette fois, entraînez un modèle pour tous les prédicteurs : sexe, age et taille. Il vous suffit d'ajouter la colonne  taille  à la matrice de design :

X = df[['sexe','age', 'taille']]

Vous devriez observer un meilleur score que sans la colonne taille. Qu'observez-vous au niveau des coefficients ?

Vous pouvez enfin faire une prédiction si un nouvel élève arrive en cours d'année. Par exemple, pour un garçon (0) agé de 150 mois, de taille 153 :

poids = reg.predict(np.array([[0, 150, 153]]))

Bravo ! Vous venez de faire votre première régression linéaire ! Ne vous inquiétez pas si c'est allé un peu vite, nous approfondirons cette notion dans le chapitre suivant.

Minimisez une fonction de coût

Dans le chapitre précédent, nous avons abordé l'exemple de l'algorithme de calcul de la racine de 2, mettant en évidence le concept d'erreur d'estimation. Cette erreur nous permet non seulement d'arrêter l'algorithme quand l'erreur atteint un certain seuil, mais aussi de mettre à jour progressivement les coefficients du modèle dans le cas de l'exemple du gradient stochastique.

La fonction de coût est un concept essentiel en Machine Learning. C'est une façon spécifique de mesurer l'écart entre les prédictions du modèle et les valeurs réelles de la variable cible.

Dans scikit-learn, quand on applique la fonction  fit(X,y)  sur un modèle, on démarre l'algorithme qui va minimiser cette fonction de coût jusqu'à atteindre un seuil minimum d'erreur.

Comme il s'agit d'une routine hautement optimisée, la fonction de coût est souvent liée au choix du modèle.

•  $\$\backslash (N\backslash )\$$   : le nombre d'échantillons d'entraînement ;

•  $\$\backslash (y\_k\backslash )\$$   : les valeurs cibles ;

•  $\$\backslash (ŷ\_k\backslash )\$$   :  les valeurs prédites par le modèle.

Évaluez la performance d'un modèle

La fonction de coût permet de faire tourner l'algorithme d'entraînement du modèle. Mais pour évaluer sa performance une fois entraîné, nous avons besoin de calculer son score de performance.

Ce  score permet de quantifier directement la qualité des prédictions du modèle sur un ensemble d'échantillons. Cet ensemble peut être l'ensemble de test, celui d'entraînement ou tout nouveau set d'échantillons sur lesquels nous souhaitons évaluer le modèle.

Le calcul du score d'un modèle dépend de la tâche ML considérée. Un modèle de classification ne sera pas évalué de la même manière qu'un modèle de régression.

De manière nominale, dans le contexte d'une régression, on a les scores suivants :

• Root Mean Square Error (écart quadratique moyen) ou RMSE :

$\$\backslash (\backslash text\{RMSE\}=\backslash sqrt\{\backslash frac\{1\}\{N\}\; \backslash sum\_\{k\; =\; 1\}^N\; (y\_k\; -\; \backslash hat\{y\}\_k)^2\}\backslash )\$$

• Mean Absolute Error (erreur absolue moyenne) ou MAE :

$\$\backslash (\backslash text\{MAE\}=\; \backslash frac\{1\}\{N\}\backslash sum\_\{k\; =\; 1\}^\{N\}\; |y\_k\; -\; \backslash hat\{y\}\_k\; |\backslash )\$$

On obtient des scores en pourcentage en divisant par la valeur cible :

• Mean Absolute Percentage Error (erreur absolue moyenne en pourcentage) ou MAPE :

$\$\backslash (\backslash text\{MAPE\}=\; \backslash frac\{1\}\{N\}\backslash sum\_\{k\; =\; 1\}^\{N\}\; \backslash frac\{\; |y\_k\; -\; \backslash hat\{y\}\_k\; |\}\{|y\_k|\}\backslash )\$$

Pour fixer les idées, calculons ces scores sur notre modèle de régression, en utilisant les fonctions déjà implémentées de scikit-learn :

Obtenons d'abord les prédictions du modèle :

y_pred = reg.predict(X)

Ce qui donne pour le modèle :  poids ~ sexe + age

from sklearn.metrics import mean_squared_error, mean_absolute_error, mean_absolute_percentage_error
mean_squared_error(y, y_pred): 45.17
mean_absolute_error(y, y_pred): 5.22 mean_absolute_percentage_error(y, y_pred): 0.12

Appliquez la méthodologie du processus d’entraînement

Dans les 3 chapitres suivants, nous entrerons plus en détail dans les différences entre :

1. Régression linéaire.

2. Classification.

3. Et clustering.

Mais avant d’en arriver là, il est utile de souligner la similarité du processus d'entraînement qu'ils ont en commun. En effet, dans ces 3 contextes, entraîner un modèle va consister à enchaîner ces étapes :

1. Charger les données.

2. Transformer / améliorer les données. 

3. Scinder les données en train / test ou train / test / validation.

4. Entraîner le modèle avec plusieurs configurations de paramètres (si le modèle s'y prête).

5. Calculer le score de chaque version du modèle.

Par rapport à l'exercice d'introduction du début de ce chapitre, nous avons rajouté les étapes 2 et 3.

Puis recommencer pour essayer d'obtenir un meilleur score !

En résumé

• La fonction de coût mesure l'erreur entre les prédictions d'un modèle et les valeurs réelles. Entraîner un modèle consiste à minimiser cette fonction de coût.

• Il existe de nombreuses fonctions de coût, chacune ayant ses propres avantages et inconvénients. La plus courante pour la régression est l'erreur quadratique moyenne (MSE).

• La performance d'un modèle peut être évaluée en utilisant une variété de mesures, telles que la racine de l'erreur quadratique moyenne (RMSE) ou le coefficient de détermination (R^2). 

• Dans un contexte de régression, pour les métriques de types RMSE, plus le score est petit, meilleur est le modèle. Contrairement au coefficient R^2, où un score proche de 1 indique un meilleur modèle.

Dans le chapitre suivant nous allons approfondir le sujet de la régression linéaire dans le cadre d'un nouveau jeu de données.