Deux sources majeures expliquent les erreurs dans les modèles d’apprentissage automatique :
- Le biais décrit un modèle qui fait des hypothèses simplificatrices afin de rendre la fonction cible plus facile à approximer ; par exemple, un modèle pourrait « apprendre » que tous les hommes mesurant 1,75 m portent une taille M — c’est manifestement biaisé.
- La variance décrit la variabilité de la prédiction du modèle ; c’est l’ampleur des changements de la prédiction lorsque l’on modifie les données utilisées pour l’entraîner.
Pour obtenir une solution plus précise, nous cherchons à réduire la part de biais et de variance présente dans notre modèle. Ce n’est pas trivial. Biais et variance sont en tension — réduire l’un augmente l’autre, un phénomène connu sous le nom de compromis biais-variance.
Dans cet article, vous allez apprendre :
- Comment détecter si un modèle souffre d’un biais élevé ou d’une variance élevée
- Comment diagnostiquer un modèle présentant l’un ou l’autre symptôme
- Comment construire un modèle bien ajusté
Avant d’aborder la détection des symptômes d’erreur, détaillons d’abord le compromis biais-variance.
Tour d’horizon du compromis biais-variance
Tous les algorithmes d’apprentissage supervisé visent le même objectif : estimer la fonction d’appariement (f_hat) d’une variable cible (y) à partir de données d’entrée (X). La fonction qu’un modèle d’apprentissage automatique cherche à approximer est appelée la fonction cible.
Modifier les données d’entrée utilisées pour approximer la variable cible produira vraisemblablement une autre fonction cible, ce qui peut impacter les sorties prédites par le modèle. La mesure dans laquelle notre fonction cible varie quand on change les données d’entraînement s’appelle la variance. Nous ne voulons pas d’une variance élevée, car même si l’algorithme peut sembler parfait à l’entraînement, il échouera à généraliser sur des instances inédites.
Sur l’image ci-dessus, la fonction cible apprise est la ligne verte et la droite de régression est en noir. Observez comme le modèle colle bien aux données d’entraînement avec la ligne verte : il cherche à séparer au mieux les points rouges et bleus. Si nous réentrainions ce modèle sur de nouvelles observations, il apprendrait une toute nouvelle fonction cible et tenterait de reproduire le même comportement.
Imaginons maintenant que nous utilisions une méthode linéaire, comme la régression linéaire, pour approximer la fonction cible. Premier constat : la régression linéaire suppose une relation linéaire entre les entrées et la cible à prédire. Le monde réel est bien plus complexe. En échange d’un peu de flexibilité, cette hypothèse simplificatrice rend la fonction cible plus rapide à apprendre et plus facile à interpréter. Ce cadre se traduit par du biais.
Sur l’image, la ligne rouge représente la fonction cible apprise. De nombreuses observations s’écartent fortement des valeurs prédites par le modèle.
On peut réduire le biais d’un modèle en le rendant plus flexible, mais cela introduit de la variance. À l’inverse, on peut réduire la variance en simplifiant le modèle, mais cela introduit du biais. On n’échappe pas à ce compromis. La meilleure approche consiste à choisir et configurer un modèle de manière à trouver le bon équilibre entre biais et variance.
En raison de facteurs inconnus qui influencent la fonction cible, il restera toujours une part d’erreur dans le modèle, appelée erreur irréductible. On l’aperçoit sur l’image au niveau du point le plus bas de la courbe d’erreur totale. Pour construire le modèle idéal, il faut équilibrer biais et variance de sorte à minimiser l’erreur totale. C’est illustré par la ligne en pointillés « complexité optimale du modèle ».
Explorons maintenant biais et variance à l’aide des courbes d’apprentissage.
Anatomie d’une courbe d’apprentissage
Les courbes d’apprentissage représentent la performance d’un modèle à mesure que la taille du jeu d’entraînement augmente. Elles peuvent aussi montrer la performance du modèle sur une période donnée. On les utilise généralement pour diagnostiquer des algorithmes qui apprennent de façon incrémentale à partir des données. Le principe : évaluer un modèle sur les jeux d’entraînement et de validation, puis tracer les performances mesurées.
Par exemple, imaginons que nous ayons modélisé la relation entre des entrées et des sorties avec un algorithme d’apprentissage. Nous commençons par entraîner le modèle sur une seule instance et le validons sur cent instances. Que va-t-il se passer ? Si vous dites que le modèle mémorisera parfaitement l’instance d’entraînement, vous avez raison — il n’y aura pas d’erreur.
Modéliser la relation d’une seule entrée vers une sortie n’est pas difficile ; il suffit de la retenir. Le défi, c’est de prédire correctement face à de nouvelles instances. Comme notre modèle a trop bien appris les données d’entraînement, il aura beaucoup de mal à généraliser à des données inédites. Il se comportera mal sur les données de validation. Autrement dit, l’écart entre la performance du modèle sur l’entraînement et sur la validation sera important. Cet écart est l’erreur de généralisation.
Pour que notre algorithme ait une chance de mieux prédire sur le jeu de validation, il faut ajouter des données. L’introduction de nouvelles instances dans l’entraînement modifiera inévitablement la fonction cible du modèle. La façon dont le modèle se comporte à mesure que l’on augmente l’échantillon d’entraînement peut être suivie et tracée pour visualiser l’évolution des erreurs d’entraînement et de validation.
Le graphique affiche donc deux résultats distincts :
- Courbe d’entraînement : calculée sur les données d’entraînement ; indique la qualité d’apprentissage du modèle.
- Courbe de validation : calculée sur les données de validation ; indique la capacité du modèle à généraliser sur des instances inédites.
Ces courbes montrent comment le modèle progresse à mesure que les données augmentent ; d’où l’appellation courbes d’apprentissage.
Remarque : on peut appliquer le même processus pour suivre l’apprentissage dans le temps. Au lieu d’observer la montée en performance avec plus de données, on observe la progression semaine après semaine. Par exemple, si vous décidez d’apprendre une nouvelle langue, votre niveau pourrait être évalué et noté pour refléter vos progrès sur 52 semaines.
Vous connaissez désormais l’anatomie d’une courbe d’apprentissage ; passons à la pratique avec un jeu de données réel pour une compréhension visuelle.
Cas d’usage : prédire la valorisation immobilière
Nous allons utiliser le jeu de données : market historical data set of real estate valuation. Ces données, collectées dans le district de Sindian (Nouvelle Taipei, Taïwan), rassemblent des historiques de marché.
Notre mission est de prédire la valorisation immobilière à partir des variables suivantes :
- X1 = date de transaction (par exemple, 2013.250 = mars 2013, 2013.500 = juin 2013, etc.)
- X2 = âge du bien (en années)
- X3 = distance à la station de MRT la plus proche (en mètres)
- X4 = nombre de supérettes accessibles à pied dans le périmètre de vie (entier)
- X5 = coordonnée géographique, latitude (en degrés)
- X6 = coordonnée géographique, longitude (en degrés)
La variable cible est définie comme :
- Y = prix au mètre carré du bien (10 000 nouveaux dollars taïwanais/Ping, Ping étant une unité locale, 1 Ping = 3,3 mètres carrés)
La cible à prédire est continue ; nous allons donc recourir à des techniques de régression.
Commençons par jeter un œil aux données :
import pandas as pd
data = pd.read_excel("/content/gdrive/MyDrive/real_estate_valuation_data.xlsx")
print(data.info())
data.head()
>>>>
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 414 entries, 0 to 413
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 No 414 non-null int64
1 X1 transaction date 414 non-null float64
2 X2 house age 414 non-null float64
3 X3 distance to the nearest MRT station 414 non-null float64
4 X4 number of convenience stores 414 non-null int64
5 X5 latitude 414 non-null float64
6 X6 longitude 414 non-null float64
7 Y house price of unit area 414 non-null float64
dtypes: float64(6), int64(2)
memory usage: 26.0 KB
None
No X1 transaction date X2 house age X3 distance to the nearest MRT station X4 number of convenience stores X5 latitude X6 longitude Y house price of unit area
0 1 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 3 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 4 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 5 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
Une variable supplémentaire appelée No n’est pas référencée dans la documentation. Il s’agit sans doute d’un index ; pour simplifier, nous allons la supprimer. De plus, les noms de variables ne correspondent pas à ceux de la documentation, nous allons donc les nettoyer.
# rename the columns
renamed_columns = [col.split()[0] for col in data.columns]
renamed_columns_map = {data.columns[i]:renamed_columns[i] for i in range(len(data.columns))}
data.rename(renamed_columns_map, axis=1, inplace=True)
# remove No column
data.drop("No", axis=1, inplace=True)
print(data.head())
# separate features and target data
features, target = data.columns[:-1], data.columns[-1]
X = data[features]
y = data[target]
Voici à quoi ressemble le jeu de données final avant de séparer variables explicatives et cible :
X1 X2 X3 X4 X5 X6 Y
0 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
Pour illustrer biais, variance et bon ajustement, nous allons entraîner trois modèles : un arbre de décision pour la régression, une machine à vecteurs de support (régression) et une forêt aléatoire (random forest). Nous tracerons ensuite les courbes d’apprentissage de chacun et proposerons quelques techniques de diagnostic.
Diagnostiquer les courbes d’apprentissage
On interprète les courbes d’apprentissage en analysant leur forme. Une fois la dynamique comprise, elles permettent de diagnostiquer les problèmes de comportement d’un modèle.
La fonction learning_curve() de Scikit-learn facilite le suivi des scores d’entraînement et de validation, indispensables pour tracer une courbe d’apprentissage.
Les paramètres passés à learning_curve() sont les suivants :
- estimator : le modèle utilisé pour approximer la fonction cible
- X : les données d’entrée
- y : la cible
- cv : la stratégie de validation croisée
- scoring : la métrique d’évaluation des performances
- train_sizes : le nombre absolu d’exemples d’entraînement utilisés pour générer la courbe ; ici, les valeurs sont choisies arbitrairement.
Modèle 1 : arbre de décision (régression)
Un modèle à forte variance est dit sur‑appris (overfit). Il apprend extrêmement bien les données d’entraînement ainsi que le bruit aléatoire, ce qui le rend performant sur l’entraînement mais incapable de généraliser. On observe ce comportement lorsque l’algorithme est trop flexible pour le problème, ou lorsqu’on l’entraîne trop longtemps.
Par exemple, l’arbre de décision pour la régression est un algorithme non linéaire. Les algorithmes non linéaires présentent généralement un biais faible et une variance élevée. Cela signifie que des changements dans le jeu de données provoquent de fortes variations de la fonction cible.
Illustrons une forte variance avec notre arbre de décision :
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt
# overfitting
decision_tree = DecisionTreeRegressor()
train_sizes, train_scores, test_scores = learning_curve(
estimator=decision_tree,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 165, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Le modèle commet très peu d’erreurs lorsqu’il doit prédire des instances vues à l’entraînement, mais il se comporte très mal sur des instances inédites. On le voit à l’importance de l’erreur de généralisation entre la courbe d’entraînement et la courbe de validation. Une piste d’amélioration consiste à ajouter des instances au jeu d’entraînement, ce qui introduira du biais. Une autre consiste à régulariser le modèle (par exemple, limiter la profondeur maximale de l’arbre).
Modèle 2 : support vector machine
Un modèle à fort biais est dit sous‑appris (underfit). Il fait des hypothèses trop simplistes sur les données d’entraînement, ce qui l’empêche d’apprendre les motifs sous‑jacents. Résultat : une erreur élevée sur l’entraînement comme sur la validation. On observe cela quand le modèle est trop simple pour le problème, ou lorsqu’il n’est pas entraîné assez longtemps.
Par exemple, la machine à vecteurs de support est un algorithme linéaire. Les algorithmes linéaires ont généralement un biais élevé et une variance faible. Autrement dit, ils imposent davantage d’hypothèses sur la forme de la fonction cible. Pour introduire plus de biais dans notre modèle, nous avons ajouté de la régularisation via le paramètre C.
Illustrons un biais élevé avec notre SVM :
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
# Underfitting
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
svm = SVR(C=0.25)
train_sizes, train_scores, test_scores = learning_curve(
estimator=svm,
X=X_scaled,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
L’écart de généralisation entre les courbes d’entraînement et de validation devient très faible à mesure que la taille du jeu d’entraînement augmente. Cela indique que rajouter des exemples n’améliorera pas les performances. Une solution serait d’ingénier davantage de variables ou de rendre le modèle plus flexible afin de réduire le nombre d’hypothèses.
Modèle 3 : random forest (régression)
Un modèle bien ajusté se situe entre le sous‑apprentissage et le sur‑apprentissage. Il ne sera peut‑être pas aussi performant sur l’entraînement que dans le cas de sur‑apprentissage, mais il commettra bien moins d’erreurs face à des instances inédites. Ce comportement s’observe quand l’erreur d’entraînement augmente jusqu’à se stabiliser, tandis que l’erreur de validation diminue jusqu’à atteindre, elle aussi, un plateau.
Pour le montrer, nous utilisons une random forest, un ensemble d’arbres de décision. Le modèle est donc non linéaire, mais on y introduit du biais en créant plusieurs modèles diversifiés et en combinant leurs prédictions.
Nous avons également ajouté de la régularisation en fixant max_depth, qui limite la profondeur maximale de chaque arbre, à 3.
Voyons cela en code :
from sklearn.ensemble import RandomForestRegressor
# better
random_forest = RandomForestRegressor(max_depth=3)
train_sizes, train_scores, test_scores = learning_curve(
estimator=random_forest,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
On constate ici une réduction de l’erreur sur les données de validation. Cela s’est fait au prix d’une performance moindre à l’entraînement, mais le modèle est globalement meilleur.
L’erreur de généralisation est bien plus faible, avec peu d’erreurs. De plus, les deux courbes sont stables au‑delà d’une taille d’entraînement d’environ 250, ce qui laisse penser qu’ajouter davantage d’instances n’améliorera pas beaucoup ce modèle.
En résumé, le comportement d’un modèle s’observe efficacement via des courbes d’apprentissage. L’objectif, en apprentissage automatique, est de maintenir l’erreur au plus bas. Deux facteurs clés l’augmentent : le biais et la variance. Savoir trouver le bon équilibre entre les deux conduit à un modèle plus performant.