Polynomiale und Spline-Interpolation

Einführung

In diesem Lab werden wir lernen, wie wir eine Funktion mit Polynomen bis zu einem bestimmten Grad mit Hilfe von Ridge-Regression approximieren. Wir werden zwei verschiedene Wege zeigen, dies bei n_samples eindimensionalen Punkten x_i zu tun:

1. PolynomialFeatures: Generiert alle Monome bis zu einem angegebenen Grad. Dies gibt uns die Vandermonde-Matrix mit n_samples Zeilen und degree + 1 Spalten.
2. SplineTransformer: Generiert B-Spline-Basisfunktionen. Eine Basisfunktion einer B-Spline ist eine stückweise Polynomfunktion vom Grad degree, die nur zwischen degree+1 aufeinanderfolgenden Knoten ungleich Null ist.

Wir werden die make_pipeline-Funktion verwenden, um nicht-lineare Merkmale hinzuzufügen, und zeigen, wie diese Transformatoren gut geeignet sind, um nicht-lineare Effekte mit einem linearen Modell zu modellieren. Wir werden die Funktion, die Trainingspunkte und die Interpolation mit Polynommerkmalen und B-Splines plotten. Wir werden auch alle Spalten beider Transformatoren separat plotten und die Knoten der Spline anzeigen. Schließlich werden wir die Verwendung periodischer Splines demonstrieren.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Daten vorbereiten

Wir beginnen, indem wir eine Funktion definieren, die wir approximieren möchten, und bereiten die Darstellung vor.

def f(x):
    """Function to be approximated by polynomial interpolation."""
    return x * np.sin(x)

## whole range we want to plot
x_plot = np.linspace(-1, 11, 100)

## To make it interesting, we only give a small subset of points to train on.
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)

## create 2D-array versions of these arrays to feed to transformers
X_train = x_train[:, np.newaxis]
X_plot = x_plot[:, np.newaxis]

Polynomiale Merkmalsinterpolation

Wir werden PolynomialFeatures verwenden, um polynomiale Merkmale zu generieren und ein Ridge-Regressionsmodell an die Trainingsdaten anzupassen. Anschließend plotten wir die Funktion, die Trainingspunkte und die Interpolation mit polynomiellen Merkmalen.

## plot function
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="ground truth")

## plot training points
ax.scatter(x_train, y_train, label="training points")

## polynomial features
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"degree {degree}")

ax.legend(loc="lower center")
ax.set_ylim(-20, 10)
plt.show()

B-Spline-Interpolation

Wir werden SplineTransformer verwenden, um B-Spline-Basisfunktionen zu generieren und ein Ridge-Regressionsmodell an die Trainingsdaten anzupassen. Anschließend plotten wir die Funktion, die Trainingspunkte und die Interpolation mit B-Splines.

## B-spline with 4 + 3 - 1 = 6 basis functions
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="lower center")
ax.set_ylim(-20, 10)
plt.show()

Darstellung der Transformatoren

Wir plotten alle Spalten beider Transformatoren separat, um mehr Einblicke in die generierten Merkmalsbasen zu erhalten.

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"degree {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")

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

Periodische Splines

Wir demonstrieren die Verwendung von periodischen Splines, indem wir den SplineTransformer verwenden und die Knoten manuell angeben. Wir passen ein Ridge-Regressionsmodell an die Trainingsdaten an und plotten die Funktion, die Trainingspunkte und die Interpolation mit periodischen Splines.

def g(x):
    """Function to be approximated by periodic spline interpolation."""
    return np.sin(x) - 0.7 * np.cos(x * 3)


y_train = g(x_train)

## Extend the test data into the future:
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="ground truth")
ax.scatter(x_train, y_train, label="training points")

for transformer, label in [
    (SplineTransformer(degree=3, n_knots=10), "spline"),
    (
        SplineTransformer(
            degree=3,
            knots=np.linspace(0, 2 * np.pi, 10)[:, None],
            extrapolation="periodic",
        ),
        "periodic spline",
    ),
]:
    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()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man eine Funktion mit Polynomen bis zu einem bestimmten Grad mit Hilfe von Ridge-Regression approximieren kann. Wir haben zwei verschiedene Methoden gezeigt, um dies bei n_samples eindimensionaler Punkte x_i zu tun. Wir haben die Funktion make_pipeline verwendet, um nicht-lineare Merkmale hinzuzufügen, und gezeigt, wie gut diese Transformatoren geeignet sind, um nicht-lineare Effekte mit einem linearen Modell zu modellieren. Wir haben die Funktion, die Trainingspunkte und die Interpolation mit polynomiellen Merkmalen und B-Splines geplottet. Wir haben auch alle Spalten beider Transformatoren separat geplottet und die Knoten des Splines gezeigt. Schließlich haben wir die Verwendung von periodischen Splines demonstriert.