Sous-ajustement et surajustement

Introduction

Ce laboratoire montre les problèmes d'underfitting et d'overfitting en apprentissage automatique, et comment nous pouvons utiliser la régression linéaire avec des fonctionnalités polynômiales pour approcher des fonctions non linéaires. Nous utiliserons scikit-learn pour générer des données, ajuster des modèles et évaluer les performances des modèles.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Tout d'abord, nous allons importer les bibliothèques nécessaires pour ce laboratoire.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score

Générer des données

Nous allons générer 30 échantillons à partir d'une fonction cosinus, avec un peu de bruit aléatoire ajouté aux échantillons.

def true_fun(X):
    return np.cos(1.5 * np.pi * X)

np.random.seed(0)

n_samples = 30

X = np.sort(np.random.rand(n_samples))
y = true_fun(X) + np.random.randn(n_samples) * 0.1

Visualiser les données

Nous allons tracer la fonction réelle et les échantillons générés.

plt.figure(figsize=(6, 4))
plt.plot(np.linspace(0, 1, 100), true_fun(np.linspace(0, 1, 100)), label="True function")
plt.scatter(X, y, edgecolor="b", s=20, label="Samples")
plt.xlabel("x")
plt.ylabel("y")
plt.legend(loc="best")
plt.show()

Ajuster des modèles avec des fonctionnalités polynômiales

Nous allons ajuster des modèles avec des fonctionnalités polynômiales de degré 1, 4 et 15, et tracer les résultats.

degrees = [1, 4, 15]

plt.figure(figsize=(14, 5))

for i in range(len(degrees)):
    ax = plt.subplot(1, len(degrees), i + 1)
    plt.setp(ax, xticks=(), yticks=())

    polynomial_features = PolynomialFeatures(degree=degrees[i], include_bias=False)
    linear_regression = LinearRegression()
    pipeline = Pipeline(
        [
            ("polynomial_features", polynomial_features),
            ("linear_regression", linear_regression),
        ]
    )
    pipeline.fit(X[:, np.newaxis], y)

    X_test = np.linspace(0, 1, 100)
    plt.plot(X_test, pipeline.predict(X_test[:, np.newaxis]), label="Model")
    plt.plot(X_test, true_fun(X_test), label="True function")
    plt.scatter(X, y, edgecolor="b", s=20, label="Samples")
    plt.xlabel("x")
    plt.ylabel("y")
    plt.xlim((0, 1))
    plt.ylim((-2, 2))
    plt.legend(loc="best")
    plt.title("Degree {}".format(degrees[i]))

plt.show()

Évaluer les performances du modèle

Nous allons évaluer les modèles en utilisant la validation croisée et calculer l'erreur quadratique moyenne (MSE) sur l'ensemble de validation.

degrees = [1, 4, 15]

plt.figure(figsize=(14, 5))

for i in range(len(degrees)):
    ax = plt.subplot(1, len(degrees), i + 1)
    plt.setp(ax, xticks=(), yticks=())

    polynomial_features = PolynomialFeatures(degree=degrees[i], include_bias=False)
    linear_regression = LinearRegression()
    pipeline = Pipeline(
        [
            ("polynomial_features", polynomial_features),
            ("linear_regression", linear_regression),
        ]
    )
    pipeline.fit(X[:, np.newaxis], y)

    ## Évaluer les modèles en utilisant la validation croisée
    scores = cross_val_score(
        pipeline, X[:, np.newaxis], y, scoring="neg_mean_squared_error", cv=10
    )

    X_test = np.linspace(0, 1, 100)
    plt.plot(X_test, pipeline.predict(X_test[:, np.newaxis]), label="Model")
    plt.plot(X_test, true_fun(X_test), label="True function")
    plt.scatter(X, y, edgecolor="b", s=20, label="Samples")
    plt.xlabel("x")
    plt.ylabel("y")
    plt.xlim((0, 1))
    plt.ylim((-2, 2))
    plt.legend(loc="best")
    plt.title(
        "Degree {}\nMSE = {:.2e}(+/- {:.2e})".format(
            degrees[i], -scores.mean(), scores.std()
        )
    )

plt.show()

Sommaire

Ce laboratoire a démontré comment utiliser la régression linéaire avec des fonctionnalités polynômiales pour approximer des fonctions non linéaires, et comment évaluer les performances d'un modèle en utilisant la validation croisée. Nous avons vu qu'une fonction linéaire n'est pas suffisante pour ajuster les échantillons d'entraînement, et qu'un polynôme de degré 4 approche presque parfaitement la fonction réelle. Cependant, pour des degrés plus élevés, le modèle surajustera les données d'entraînement et apprendra le bruit des données d'entraînement. Nous pouvons utiliser la validation croisée et l'erreur quadratique moyenne (MSE) pour évaluer les performances d'un modèle et éviter le surajustement.