Interpolation polynomiale et avec des splines

Introduction

Dans ce laboratoire, nous allons apprendre à approximer une fonction avec des polynômes jusqu'à un certain degré en utilisant la régression ridge. Nous allons montrer deux manières différentes de le faire étant donné n_samples de points 1D x_i :

1. PolynomialFeatures : génère tous les monômes jusqu'à un degré spécifié. Cela nous donne la matrice de Vandermonde avec n_samples lignes et degree + 1 colonnes.
2. SplineTransformer : génère des fonctions de base B-spline. Une fonction de base d'une B-spline est une fonction polynomiale par morceaux de degré degree qui n'est non-nulle que entre degree+1 noeuds consécutifs.

Nous utiliserons la fonction make_pipeline pour ajouter des fonctionnalités non linéaires et montrer comment ces transformateurs sont bien adaptés pour modéliser les effets non linéaires avec un modèle linéaire. Nous tracerons la fonction, les points d'entraînement et l'interpolation en utilisant les fonctionnalités polynômiales et les B-splines. Nous tracerons également toutes les colonnes des deux transformateurs séparément et montrerons les noeuds de la spline. Enfin, nous démontrerons l'utilisation de splines périodiques.

Conseils sur la VM

Une fois le démarrage de la VM 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 votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Skills Graph

Préparer les données

Nous commençons par définir une fonction que nous souhaitons approcher et préparons le tracé de cette fonction.

def f(x):
    """Fonction à approcher par interpolation polynomiale."""
    return x * np.sin(x)

## plage totale que nous voulons tracer
x_plot = np.linspace(-1, 11, 100)

## Pour rendre cela intéressant, nous ne donnons qu'un petit sous-ensemble de points pour l'entraînement.
x_train = np.linspace(0, 10, 100)
rng = np.random.RandomState(0)
x_train = np.sort(rng.choice(x_train, size=20, replace=False))
y_train = f(x_train)

## créer des versions de tableaux 2D de ces tableaux pour alimenter les transformateurs
X_train = x_train[:, np.newaxis]
X_plot = x_plot[:, np.newaxis]

Interpolation avec des fonctionnalités polynômiales

Nous utiliserons PolynomialFeatures pour générer des fonctionnalités polynômiales et ajuster un modèle de régression ridge aux données d'entraînement. Ensuite, nous traçons la fonction, les points d'entraînement et l'interpolation en utilisant les fonctionnalités polynômiales.

## tracé de la fonction
lw = 2
fig, ax = plt.subplots()
ax.set_prop_cycle(
    color=["black", "teal", "yellowgreen", "gold", "darkorange", "tomato"]
)
ax.plot(x_plot, f(x_plot), linewidth=lw, label="vérité terrain")

## tracé des points d'entraînement
ax.scatter(x_train, y_train, label="points d'entraînement")

## fonctionnalités polynômiales
for degree in [3, 4, 5]:
    model = make_pipeline(PolynomialFeatures(degree), Ridge(alpha=1e-3))
    model.fit(X_train, y_train)
    y_plot = model.predict(X_plot)
    ax.plot(x_plot, y_plot, label=f"degré {degree}")

ax.legend(loc="bas centre")
ax.set_ylim(-20, 10)
plt.show()

Interpolation avec des B-splines

Nous utiliserons SplineTransformer pour générer des fonctions de base B-spline et ajuster un modèle de régression ridge aux données d'entraînement. Ensuite, nous traçons la fonction, les points d'entraînement et l'interpolation en utilisant les B-splines.

## B-spline avec 4 + 3 - 1 = 6 fonctions de base
model = make_pipeline(SplineTransformer(n_knots=4, degree=3), Ridge(alpha=1e-3))
model.fit(X_train, y_train)

y_plot = model.predict(X_plot)
ax.plot(x_plot, y_plot, label="B-spline")
ax.legend(loc="bas centre")
ax.set_ylim(-20, 10)
plt.show()

Tracer les transformateurs

Nous traçons séparément toutes les colonnes des deux transformateurs pour mieux comprendre les bases de fonctionnalités générées.

fig, axes = plt.subplots(ncols=2, figsize=(16, 5))
pft = PolynomialFeatures(degree=3).fit(X_train)
axes[0].plot(x_plot, pft.transform(X_plot))
axes[0].legend(axes[0].lines, [f"degré {n}" for n in range(4)])
axes[0].set_title("PolynomialFeatures")

splt = SplineTransformer(n_knots=4, degree=3).fit(X_train)
axes[1].plot(x_plot, splt.transform(X_plot))
axes[1].legend(axes[1].lines, [f"spline {n}" for n in range(6)])
axes[1].set_title("SplineTransformer")

## tracer les noeuds de la spline
knots = splt.bsplines_[0].t
axes[1].vlines(knots[3:-3], ymin=0, ymax=0.8, linestyles="dashed")
plt.show()

Splines périodiques

Nous démontrons l'utilisation de splines périodiques en utilisant SplineTransformer et en spécifiant manuellement les noeuds. Nous ajustons un modèle de régression ridge aux données d'entraînement et traçons la fonction, les points d'entraînement et l'interpolation en utilisant des splines périodiques.

def g(x):
    """Fonction à approcher par interpolation de spline périodique."""
    return np.sin(x) - 0.7 * np.cos(x * 3)


y_train = g(x_train)

## Étendre les données de test dans le futur :
x_plot_ext = np.linspace(-1, 21, 200)
X_plot_ext = x_plot_ext[:, np.newaxis]

lw = 2
fig, ax = plt.subplots()
ax.set_prop_cycle(color=["black", "tomato", "teal"])
ax.plot(x_plot_ext, g(x_plot_ext), linewidth=lw, label="vérité terrain")
ax.scatter(x_train, y_train, label="points d'entraînement")

for transformer, label in [
    (SplineTransformer(degree=3, n_knots=10), "spline"),
    (
        SplineTransformer(
            degree=3,
            knots=np.linspace(0, 2 * np.pi, 10)[:, None],
            extrapolation="periodique",
        ),
        "spline périodique",
    ),
]:
    model = make_pipeline(transformer, Ridge(alpha=1e-3))
    model.fit(X_train, y_train)
    y_plot_ext = model.predict(X_plot_ext)
    ax.plot(x_plot_ext, y_plot_ext, label=label)

ax.legend()
fig.show()

Sommaire

Dans ce laboratoire, nous avons appris à approximer une fonction avec des polynômes jusqu'à un certain degré en utilisant la régression ridge. Nous avons montré deux façons différentes de le faire étant donné n_samples de points 1D x_i. Nous avons utilisé la fonction make_pipeline pour ajouter des fonctionnalités non linéaires et démontré comment ces transformateurs sont bien adaptés pour modéliser les effets non linéaires avec un modèle linéaire. Nous avons tracé la fonction, les points d'entraînement et l'interpolation en utilisant des fonctionnalités polynômiales et des B-splines. Nous avons également tracé séparément toutes les colonnes des deux transformateurs et montré les noeuds de la spline. Enfin, nous avons démontré l'utilisation de splines périodiques.