Lineare Regression

Lineare Regression ist einer der grundlegendsten Algorithmen im maschinellen Lernen. Sie modelliert die Beziehung zwischen einer abhängigen Variable (dem Vorhersageziel) und einer oder mehreren unabhängigen Variablen (den Eingaben), indem sie eine Gerade – oder eine Hyperebene – durch die Daten legt.

Diese Seite behandelt:

• Wie einfache und multiple lineare Regression mathematisch funktionieren
• Die Methode der kleinsten Quadrate (OLS) zum Anpassen einer Geraden
• Wichtige Annahmen, die vor dem Vertrauen in das Modell geprüft werden müssen
• Eine vollständige scikit-learn-Anleitung: Daten laden, trainieren, auswerten und Ergebnisse interpretieren
• Wie Modellkoeffizienten gelesen werden und häufige Fallstricke erkannt werden

Wie lineare Regression funktioniert

Die Gleichung

Einfache lineare Regression (ein Eingabemerkmal) passt diese Gerade an:

y = β₀ + β₁x + ε

• y — die abhängige Variable (Zielgröße)
• x — die unabhängige Variable (Merkmal)
• β₀ — der Achsenabschnitt (Wert von y bei x = 0)
• β₁ — die Steigung (Änderung von y bei einer Einheitszunahme von x)
• ε — der Fehlerterm (Rauschen, das das Modell nicht erklären kann)

Multiple lineare Regression erweitert dies auf n Merkmale:

y = β₀ + β₁x₁ + β₂x₂ + ... + βₙxₙ + ε

Jeder Koeffizient βᵢ gibt an, wie stark sich y ändert, wenn xᵢ um eine Einheit zunimmt, während alle anderen Merkmale konstant gehalten werden.

Methode der kleinsten Quadrate (OLS)

Das Modell erlernt die Koeffizienten durch Minimierung der Summe der quadrierten Residuen – der Differenz zwischen jedem tatsächlichen Wert yᵢ und der Modellvorhersage ŷᵢ:

SSR = Σ(yᵢ - ŷᵢ)²

Das Quadrieren der Residuen bestraft große Fehler stärker als kleine und stellt sicher, dass sich positive und negative Fehler nicht aufheben. Dieses Kriterium hat eine exakte geschlossene Lösung, weshalb die lineare Regression selbst bei großen Datensätzen nahezu sofort trainiert.

Wichtige Annahmen

Lineare Regression liefert zuverlässige Vorhersagen nur, wenn diese Bedingungen erfüllt sind:

Wenn diese Annahmen verletzt werden, können die Koeffizientenschätzungen verzerrt sein oder das Modell kann bei ungesehenen Daten schlecht abschneiden.

Beispiel: Einfache lineare Regression

Bevor wir zu mehreren Merkmalen übergehen, schauen wir uns an, wie der Algorithmus eine Gerade an ein einzelnes Merkmal anpasst. Dies macht die Geometrie leicht visualisierbar.

import numpy as np
import matplotlib
matplotlib.use('Agg')  # non-interactive backend for scripts
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# Simulate: house size (sq ft) vs price ($1000s)
rng = np.random.default_rng(42)
X_simple = rng.uniform(500, 3000, 50).reshape(-1, 1)
y_simple = 50 + 0.1 * X_simple.ravel() + rng.normal(0, 15, 50)

model = LinearRegression()
model.fit(X_simple, y_simple)

print(f"Intercept (β₀): {model.intercept_:.2f}")
print(f"Slope    (β₁): {model.coef_[0]:.4f}")
print(f"Interpretation: each extra sq ft adds ${model.coef_[0]*1000:.0f} to the predicted price")

Erwartete Ausgabe:

Intercept (β₀): 46.17
Slope    (β₁): 0.1007
Interpretation: each extra sq ft adds $101 to the predicted price

Achsenabschnitt und Steigung werden automatisch durch OLS berechnet – Sie müssen selbst keine Algebra durchführen.

Multiple lineare Regression mit scikit-learn

Reale Datensätze haben viele Merkmale. Dieser Abschnitt führt durch eine vollständige Pipeline mit dem California Housing-Datensatz, der Wohnungsstatistiken auf Volkszählungsblock-Ebene für Kalifornien im Jahr 1990 enthält.

Schritt 1: Bibliotheken importieren

import pandas as pd
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

Schritt 2: Datensatz laden und erkunden

california = fetch_california_housing()
df = pd.DataFrame(california.data, columns=california.feature_names)
df['MedHouseVal'] = california.target  # median house value in $100,000s

print(df.shape)          # (20640, 9)
print(df.head())
print(df.describe())

Der Datensatz hat 20.640 Zeilen und 8 Eingabemerkmale:

Die Zielgröße MedHouseVal ist der mittlere Hauswert in Einheiten von 100.000 $.

Schritt 3: Merkmale auswählen und Daten aufteilen

Für eine einfache Demonstration verwenden wir alle 8 Merkmale. Siehe Train/Test Split für eine detaillierte Erklärung, warum wir Daten aufteilen.

X = df[california.feature_names]   # all 8 features
y = df['MedHouseVal']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"Training samples: {len(X_train)}")   # 16512
print(f"Test samples:     {len(X_test)}")    # 4128

random_state=42 stellt sicher, dass die Aufteilung bei jedem Ausführen des Skripts reproduzierbar ist.

Schritt 4: Modell trainieren

model = LinearRegression()
model.fit(X_train, y_train)

Das ist alles. Die fit()-Methode löst das OLS-Problem analytisch mittels Matrixalgebra – es ist standardmäßig kein iterativer Gradientenabstieg beteiligt.

Schritt 5: Gelernte Koeffizienten untersuchen

Zu verstehen, was das Modell gelernt hat, ist genauso wichtig wie seine Genauigkeit:

coef_df = pd.DataFrame({
    'Feature': california.feature_names,
    'Coefficient': model.coef_
}).sort_values('Coefficient', key=abs, ascending=False)

print(coef_df.to_string(index=False))
print(f"\nIntercept: {model.intercept_:.4f}")

Typische Ausgabe:

   Feature  Coefficient
 AveBedrms     0.7831
    MedInc     0.4487
 Longitude    -0.4337
  Latitude    -0.4198
  AveRooms    -0.1233
  HouseAge     0.0097
  AveOccup    -0.0035
Population    -0.0000

Intercept: -37.0233

Koeffizienten lesen:

• AveBedrms = 0.783: Eine Einheitszunahme bei den durchschnittlichen Schlafzimmern sagt einen Anstieg des Hauswerts um 78.300 $ vorher – aber dies ist mit AveRooms verflochten (die beiden sind korreliert). Wenn korrelierte Merkmale beide vorhanden sind, können einzelne Koeffizienten groß, instabil oder sogar kontraintuitiv werden. Das nennt man Multikollinearität.
• MedInc = 0.449: Eine Einheitszunahme beim Medianeinkommen (etwa 10.000 $) sagt einen Anstieg des Hauswerts um 44.900 $ vorher, wenn alles andere konstant gehalten wird.
• Longitude = -0.434 und Latitude = -0.420: rein geografische Kontrollvariablen; das Modell verwendet sie, um Standorteffekte zu erfassen, obwohl es nichtlineare Geografie nicht gut modellieren kann.

Schritt 6: Modell auswerten

y_pred = model.predict(X_test)

mse  = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2   = r2_score(y_test, y_pred)

print(f"RMSE: {rmse:.4f}  (in $100,000s, so ±${rmse*100_000:,.0f})")
print(f"R²:   {r2:.4f}")

Erwartete Ausgabe:

RMSE: 0.7456  (in $100,000s, so ±$74,560)
R²:   0.5758

Metriken interpretieren:

• RMSE (Wurzel des mittleren quadratischen Fehlers) — der durchschnittliche Vorhersagefehler in denselben Einheiten wie die Zielgröße. Niedriger ist besser.
• R² (Bestimmtheitsmaß) — der Anteil der Varianz in y, den das Modell erklärt. Ein R² von 0,58 bedeutet, dass das Modell etwa 58 % der Varianz der Hauspreise erklärt. Werte näher an 1,0 sind besser; Werte nahe 0 bedeuten, dass das Modell kaum besser ist als die Vorhersage des Mittelwerts.

Ein R² von ~0,58 ist typisch für diesen Datensatz mit linearer Regression. Die Beziehung zwischen Hauspreisen und diesen Merkmalen ist teilweise nichtlinear, weshalb Methoden wie polynomielle Regression oder Gradient Boosting oft höhere Werte erzielen.

Schritt 7: Vorhergesagte vs. tatsächliche Werte visualisieren

Das klarste Diagnosediagramm für ein Regressionsmodell ist vorhergesagt vs. tatsächlich – es funktioniert unabhängig davon, wie viele Merkmale vorhanden sind:

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

plt.figure(figsize=(7, 5))
plt.scatter(y_test, y_pred, alpha=0.3, s=10, color='steelblue')
plt.plot([y_test.min(), y_test.max()],
         [y_test.min(), y_test.max()],
         'r--', linewidth=1.5, label='Perfect prediction')
plt.xlabel('Actual Median House Value ($100,000s)')
plt.ylabel('Predicted Median House Value ($100,000s)')
plt.title('Linear Regression: Predicted vs Actual')
plt.legend()
plt.tight_layout()
plt.savefig('lr_predicted_vs_actual.png', dpi=120)
print("Plot saved.")

Punkte, die auf der roten gestrichelten Linie liegen, sind perfekte Vorhersagen. Streuung um die Linie zeigt Fehler an. Eine Fächerform (breitere Streuung bei höheren Werten) signalisiert Heteroskedastizität – eine der wichtigsten Annahmen ist verletzt.

Vollständige Pipeline (alle Schritte zusammen)

import pandas as pd
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Load data
california = fetch_california_housing()
df = pd.DataFrame(california.data, columns=california.feature_names)
df['MedHouseVal'] = california.target

# Split
X = df[california.feature_names]
y = df['MedHouseVal']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train
model = LinearRegression()
model.fit(X_train, y_train)

# Evaluate
y_pred = model.predict(X_test)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2   = r2_score(y_test, y_pred)

print(f"RMSE: {rmse:.4f}")
print(f"R²:   {r2:.4f}")

Wann lineare Regression verwenden

Lineare Regression ist eine gute erste Wahl, wenn:

• Die Beziehung zwischen Eingaben und Ausgabe annähernd linear ist
• Interpretierbarkeit wichtig ist – Sie müssen Vorhersagen gegenüber Stakeholdern erklären
• Der Datensatz klein oder mittelgroß ist und Trainingsgeschwindigkeit wichtig ist
• Sie eine schnelle Baseline wünschen, bevor Sie komplexere Modelle ausprobieren

Erwägen Sie Alternativen, wenn:

• Merkmale und Zielgröße starke nichtlineare Beziehungen haben → versuchen Sie polynomielle Regression oder Entscheidungsbäume
• Sie viele Merkmale haben, die möglicherweise irrelevant sind → regularisierte Varianten (Ridge, Lasso) verhindern Overfitting durch Schrumpfen der Koeffizienten
• Die Zielgröße eine Kategorie und keine Zahl ist → verwenden Sie stattdessen logistische Regression

Häufige Fallstricke

Vergessen, Merkmale zu skalieren. Koeffizienten der linearen Regression spiegeln die Einheiten jedes Merkmals wider. Wenn ein Merkmal in Tausenden und ein anderes in Brüchen angegeben ist, sind die rohen Koeffizientengrößen nicht vergleichbar. Verwenden Sie StandardScaler, bevor Sie Merkmalswichtigkeiten vergleichen. Weitere Details finden Sie unter Feature Scaling.

Multikollinearität. Stark korrelierte Merkmale machen einzelne Koeffizienten unzuverlässig – sie können sogar ihr Vorzeichen wechseln. Prüfen Sie die Korrelationsmatrix mit df.corr() und entfernen oder kombinieren Sie korrelierte Merkmale.

Extrapolation. Ein lineares Modell, das auf Daten in einem bestimmten Bereich trainiert wurde, kann außerhalb dieses Bereichs völlig falsche Vorhersagen liefern. Prüfen Sie immer, ob neue Eingaben innerhalb der Trainingsverteilung liegen.

Residuenplots ignorieren. Plotten Sie nach dem Anpassen immer die Residuen. Muster in Residuen (Kurven, Fächer, Ausreißercluster) weisen darauf hin, dass Modellannahmen verletzt sind, und Vorhersagen sollten ohne weitere Untersuchung nicht vertraut werden.

Nächste Schritte

Sobald Sie eine funktionierende lineare Regressionsbaseline haben, erkunden Sie diese verwandten Themen:

• Multiple Regression — tieferer Einblick in die Verwendung mehrerer Merkmale und die Interpretation jedes Koeffizienten
• Polynomial Regression — Kurven statt Geraden anpassen durch Hinzufügen polynomieller Merkmalsterme
• Train/Test Split — verstehen, warum und wie die Modellleistung korrekt bewertet wird
• Feature Scaling — Eingaben standardisieren, damit Koeffizienten und gradientenbasierte Löser korrekt funktionieren
• Logistic Regression — Kategorien vorhersagen (ja/nein, Spam/kein Spam) statt kontinuierlicher Werte