Die lineare Regression gehört zu den grundlegenden Algorithmen des maschinellen Lernens und wird hauptsächlich für Vorhersageprobleme und die Modellierung von Beziehungen zwischen Variablen verwendet. In diesem Beitrag werde ich die theoretischen Grundlagen der linearen Regression beleuchten, ihre mathematische Herleitung nachvollziehen, die Kostenfunktion und den Optimierungsprozess mittels Gradient Descent erläutern und schließlich eine kleine Implementierung in Python demonstrieren. Ein praktisches Anwendungsbeispiel verdeutlicht abschließend den Nutzen der linearen Regression.
Grundlagen
Die lineare Regression ist ein Modell, das eine lineare Beziehung zwischen einer abhängigen Zielvariablen y und einer oder mehreren unabhängigen Variablen x, auch Prädiktorvariable oder Merkmal genannt, beschreibt. Das Ziel ist es, eine Gerade (bei einer unabhängigen Variable) oder eine Hyperebene (bei mehreren Variablen) zu finden, die die Datenpunkte bestmöglich beschreibt.
Die einfache lineare Regression mit nur einer Prädiktorvariablen kann als Gleichung geschrieben werden:
Dabei sind:
- y: die Zielvariable,
- x: die Prädiktorvariable,
- \(\theta_0\): der Achsenabschnitt (Intercept),
- \(\theta_1\): die Steigung der Geraden (Koeffizient).
Das Modell kann auf beliebig viele Variablen erweitert werden, was zur multiplen linearen Regression führt:
Hierbei gibt es n Prädiktorvariablen \(x_1, x_2, \dots, x_n\) und die zugehörigen Koeffizienten \(\theta_1, \theta_2, \dots, \theta_n \).
Mathematische Herleitung
Um die Parameter \(\theta_0\) und \(\theta_1\) zu bestimmen, verwenden wir die Methode der kleinsten Quadrate (engl. Least-Squares). Dieser Ansatz abzielt darauf, die Differenz zwischen den vorhergesagten Werten \(\hat{y} = \theta_0 + \theta_1 x\) und den tatsächlichen Werten y zu minimieren. Diese Differenz wird durch den Fehler (auch Residual genannt) \(e_i = y_i – \hat{y}_i\) dargestellt.
Der zu minimierende Fehler wird durch die Summe der quadrierten Residuen definiert:
\)
wobei:
- \(h_{\theta}(x_i) = \theta_0 + \theta_1 x_i\) das Modell ist,
- m die Anzahl der Datenpunkte und
- \(J(\theta_0, \theta_1)\) die sogenannte Kostenfunktion ist.
Kostenfunktion und Gradient Descent
Die Kostenfunktion (auch Loss-Funktion genannt) gibt an, wie gut die aktuellen Modellparameter die Daten repräsentieren. Um diese Kosten zu minimieren und die optimalen Parameter \( \theta_0 \) und \( \theta_1 \) zu finden, wird häufig der Gradient Descent-Algorithmus verwendet. Dabei wird die Kostenfunktion iterativ minimiert, indem man die Parameter in Richtung des steilsten Abstiegs anpasst. Der Parameter \( \theta_j \) wird dabei wie folgt aktualisiert:
\[
\theta_j := \theta_j – \alpha \frac{\partial}{\partial \theta_j} J(\theta_0 , \theta_1)
\]
Hierbei ist α die Lernrate, die bestimmt, wie groß die Schritte auf dem Weg zur Minimierung der Kostenfunktion sind. Ein zu großes α führt zu Instabilität, ein zu kleines α zu langsamer Konvergenz.
Implementierung der linearen Regression in Python
In Python kann die lineare Regression relativ einfach implementiert werden kann. Ich verwende dafür die Bibliotheken numpy, zur Berechnung, matplotlib, zur Visualisierung und scikit-learn für die Implementierung der linearen Regression.
# Bibliotheken importieren
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
# Daten erstellen (Alter in Jahren, Größe in cm) -> Ausgedachte Testdaten!
X = np.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]).reshape(-1, 1) # Alter
y = np.array([105, 110, 120, 125, 129, 136, 142, 145, 150, 155, 160, 165, 168, 170, 172]) # Größe
# Lineares Regressionsmodell erstellen und trainieren
model = LinearRegression()
model.fit(X, y)
# Vorhersagen berechnen
y_pred = model.predict(X)
# Residuen berechnen (tatsächliche Werte – vorhergesagte Werte)
residuals = y – y_pred
# Plot erstellen
plt.figure(figsize=(10, 6))
# Streudiagramm der Datenpunkte
plt.scatter(X, y, color=’blue‘, label=’Datenpunkte‘)
# Regressionsgerade plotten
plt.plot(X, y_pred, color=’red‘, label=’Regressionslinie‘)
# Residuen als vertikale Linien plotten
for i in range(len(X)):
plt.vlines(X[i], y_pred[i], y[i], color=’green‘, linestyle=’dotted‘, label=’Residuen‘ if i == 0 else „“) # Nur einmal den Label „Residuen“
# Plot-Dekoration
plt.xlabel(‚Alter (Jahre)‘)
plt.ylabel(‚Größe (cm)‘)
plt.title(‚Lineare Regression: Daten, Regressionsgerade und Residuen‘)
plt.legend() # Legende hinzufügen
plt.grid(True)
# Plot anzeigen
plt.show()
Dieser Python-Code erzeugt den oben gezeigten Plot des Beispiels zur Veranschaulichung von Datenpunkten, der Regressionsgeraden und Residuen.
Zusammenfassung
Die lineare Regression ist ein leistungsstarkes, aber leicht verständliches Werkzeug im maschinellen Lernen. Durch ihre einfache Struktur und Interpretierbarkeit wird sie häufig als erster Ansatz in Datenanalyse und -modellierung verwendet. Von der mathematischen Herleitung bis zur Implementierung in Python zeigt sich, wie flexibel und vielseitig dieses Modell ist. Mit der richtigen Anwendung und dem Verständnis der zugrunde liegenden Prinzipien ist die lineare Regression eine solide Basis für den Einstieg in die Welt des maschinellen Lernens.
Referenzen
[R1]: scikit-learn: Linear Regression (scikit-learn Official Documentation)
[R2]: https://en.wikipedia.org/wiki/Linear_regression
[R3]: Kaggle – Python Linear Regression Tutorial
[R4]: Linear Regression in Machine Learning (GeeksforGeeks)