Regression in Python: Lineare, nichtlineare und logistische Modelle

Regression hilft, Beziehungen in Daten zu finden und Vorhersagen zu machen. In diesem Artikel lernen Sie einfache lineare Regression, multiple Regression, polynomiale (nichtlineare) Regression und logistische Regression in Python mit praktischen Beispielen in Seaborn, Pingouin, NumPy und Pandas. Enthalten: Code-Snippets, Checklisten, Akzeptanzkriterien, Entscheiderbaum und ein kurzes Methodenset für produktive Modelle.

Quick Links

• Simple Linear Regression: Finding Trends

• Multiple Linear Regression: Taking Regression into the Third Dimension, And Beyond

• Nonlinear Regression: Fitting Curves

• Logistic Regression: Fitting Binary Categories

Ein Datensatz allein nützt wenig, wenn Sie daraus keine Entscheidungen ableiten können. Regression ist eines der stärksten statistischen Werkzeuge, um Zusammenhänge und Trends zu erkennen. Python macht Regressionen reproduzierbar, flexibel und weit mächtiger als Tabellenkalkulationen. Legen Sie Stift und Lineal zur Seite und nutzen Sie Python. Im Folgenden sehen Sie schrittweise Beispiele, Hinweise zur Interpretation und praxistaugliche Arbeitsabläufe.

Ein kurzes Glossar

• Regressionsmodell: Eine Gleichung, die eine Zielgröße als Funktion von Prädiktoren beschreibt.
• Prädiktor / unabhängige Variable: x-Werte, die die Zielgröße beeinflussen sollen.
• Zielvariable / abhängige Variable: y-Werte, die das Modell vorhersagt.
• r² (Bestimmtheitsmaß): Anteil der Varianz der Zielvariablen, den das Modell erklärt.
• p-Wert: Hinweis darauf, ob ein Effekt statistisch signifikant ist.

1. Einfache lineare Regression: Trends erkennen

Das grundlegendste Regressionsmodell ist die einfache lineare Regression. Hier untersuchen wir, ob zwei Variablen linear zusammenhängen. Die unabhängige Variable liegt typischerweise auf der x-Achse, die abhängige auf der y-Achse. Das Ergebnis ist ein Streudiagramm mit einer möglichst gut passenden Geraden.

Beispiel: Trinkgeld und Rechnungsbetrag (Seaborn “tips”-Datensatz).

Zuerst importieren wir Seaborn:

import seaborn as sns

Dann laden wir den Datensatz:

tips = sns.load_dataset('tips')

Wenn Sie in einem Jupyter-Notebook arbeiten, sorgt folgende Zeile dafür, dass Plots inline erscheinen:

%matplotlib inline

Nun das Streudiagramm mit relplot:

sns.relplot(x='total_bill', y='tip', data=tips)

Das Streudiagramm wirkt überwiegend linear. Wir können eine Regressionsgerade über die Punkte legen:

sns.regplot(x='total_bill', y='tip', data=tips)

Die Gerade wirkt passend. Für eine formale Auswertung verwenden wir die Bibliothek Pingouin.

import pingouin as pg
pg.linear_regression(tips['total_bill'], tips['tip']).round(2)

Wichtig ist das Bestimmtheitsmaß r². In diesem Beispiel ist r² ungefähr 0.46. Die Quadratwurzel (ungefähr 0.68) zeigt die Korrelation und damit eine moderat starke positive lineare Beziehung.

Das Modell liefert Koeffizienten für die Gleichung y = m*x + b. Hier ist m ≈ 0.11 und b ≈ 0.92. Die Vorhersagegleichung lautet also:

tip = 0.92 + 0.11 * total_bill

Als Python-Funktion:

def tip(total_bill):
    return 0.92 + 0.11 * total_bill

Hinweis: Achten Sie auf Einrückungen in Python – typischerweise vier Leerzeichen.

Vorhersage für eine Rechnung über 100 €:

tip(100)

Erwartetes Trinkgeld: etwa 12 €.

Wichtig: In realen Datensätzen gilt es, Ausreißer, Heteroskedastizität und Nichtlinearitäten zu prüfen, bevor Sie das Modell produktiv verwenden.

2. Multiple lineare Regression: Mehrere Prädiktoren

Lineare Regression lässt sich auf mehrere unabhängige Variablen erweitern. Statt einer Geraden passt das Modell eine Ebene oder ein Hyperplane an die Daten an. Die Visualisierung wird schwieriger, die Interpretation bleibt aber möglich.

Beispiel: Trinkgeld vorhergesagt durch Rechnungsbetrag und Partygröße:

pg.linear_regression(tips[['total_bill', 'size']], tips['tip']).round(2)

Beachten Sie die doppelte eckige Klammer beim Übergabe-Argument für mehrere Prädiktoren. Wenn r² gleich bleibt oder leicht steigt, erklären die zusätzlichen Variablen zusätzliche Varianz.

Eine mögliche Vorhersagefunktion wäre:

def tip(total_bill, size):
    return 0.67 + 0.09 * total_bill + 0.19 * size

Interpretation: Jeder zusätzliche Gast (size) erhöht den erwarteten Tipp um ca. 0.19 Geldeinheiten, wobei alle anderen Variablen konstant gehalten werden.

Wichtig: Multikollinearität (starke Korrelationen zwischen Prädiktoren) kann Koeffizienten verzerren. Prüfen Sie Variance Inflation Factor (VIF) bei multiplen Modellen.

3. Nichtlineare Regression: Kurven anpassen

Modelle müssen nicht linear sein. Polynomiale Regression passt höhere Grade an (Quadrate, Kubikterme etc.). Das funktioniert in Python, indem Sie Potenzen der Variablen hinzufügen.

Beispiel: Quadratische Funktion erzeugen und anpassen.

import numpy as np
x = np.linspace(-100, 100, 1000)
y = 4 * x**2 + 2 * x + 3

DataFrame bauen:

import pandas as pd
df = pd.DataFrame({'x': x, 'y': y})

df.head()

Streudiagramm:

sns.relplot(x='x', y='y', data=df)

Seaborn kann polynomiale Anpassungen via regplot(order=2) durchführen:

sns.regplot(x='x', y='y', order=2, data=df)

Mit Pingouin erzeugen wir einen x²-Term und führen dann eine lineare Regression auf die transformierten Prädiktoren aus:

df['x2'] = df['x']**2
pg.linear_regression(df[['x', 'x2']], df['y']).round(2)

Da die Daten künstlich erzeugt sind, ist r² = 1. Bei echten Daten ist das selten der Fall.

Beispiel-Funktion für eine quadratische Vorhersage:

def quad(x):
    return 3 + 2 * x + 4 * x**2

Sie können dieselbe Methode auf Polynome höherer Ordnung erweitern, prüfen Sie dabei Overfitting und numerische Stabilität. Alternativ sind splines oder reguläre Verfahren (Ridge, Lasso) geeignet.

4. Logistische Regression: Binäre Kategorien modellieren

Für binäre Zielvariablen (z. B. Überleben vs. Tod, Kauf vs. kein Kauf) eignet sich die logistische Regression. Das Modell schätzt die Wahrscheinlichkeit eines Ereignisses und gibt eine S-Kurve (logistische Kurve) zurück.

Beispiel: Titanic-Datensatz – Vorhersage des Überlebens anhand des Fahrpreises (fare).

titanic = sns.load_dataset('titanic')

titanic.head()

Seaborn kann mit lmplot eine logistische Anpassung visualisieren:

sns.lmplot(x='fare', y='survived', logistic=True, data=titanic)

Formal testen wir mit Pingouin:

pg.logistic_regression(titanic['fare'], titanic['survived']).round(2)

Wichtig ist hier der p-Wert (pval). Ein sehr kleiner p-Wert deutet darauf hin, dass die Fahrpreis-Variable statistisch signifikant mit der Überlebenswahrscheinlichkeit zusammenhängt.

Wann Regression versagt oder trügerisch ist

• Kausale Schlussfolgerungen: Regression findet Korrelation, keine Kausalität. Verwenden Sie experimentelle oder quasi-experimentelle Designs für Kausalfragen.
• Ausreißer und Einflussbeobachtungen: Einzelne extremes Werte können Koeffizienten stark verzerren.
• Nichtlineare Beziehungen: Lineare Modelle können nicht jede Kurvenform abbilden.
• Multikollinearität: Starke Korrelation zwischen Prädiktoren erschwert die Interpretation der Koeffizienten.
• Fehlende Werte und Selektionsverzerrung: Unvollständige Daten können zu verzerrten Schätzungen führen.

Alternative Ansätze

• Generalized Additive Models (GAM) für flexible nichtlineare Effekte.
• Entscheidungsbäume und Random Forests für nichtparametrische Beziehungen.
• Gradient Boosting Machines (z. B. XGBoost, LightGBM) für hohe Vorhersageleistung.
• Regularisierte lineare Modelle (Ridge, Lasso) zur Reduktion von Overfitting.

Mini-Methodologie: Schneller Workflow für Regressionsexperimente

1. Fragestellung definieren: Zielvariable, Entscheidungskontext, Metrik.
2. Datenexploration: Verteilungen, Ausreißer, fehlende Werte, Korrelationen.
3. Feature Engineering: Skalierung, Polynome, Dummy-Variablen.
4. Baseline-Modell: Einfache lineare Regression.
5. Validierung: Kreuzvalidierung, Holdout-Set, Metriken (RMSE, AUC, Accuracy).
6. Diagnose: Residuenanalyse, Heteroskedastizität, Multikollinearität.
7. Iteration: Feature-Auswahl, Regularisierung, alternative Modelle.
8. Produktion: Monitoring, Retraining-Plan, Versionierung.

Akzeptanzkriterien

• Modell erklärt mindestens den vorher definierten Anteil der Zielvarianz (z. B. r²- oder AUC-Ziel).
• Residuen zeigen keine offensichtliche Struktur (kein Muster in Residuen vs. Prädiktoren).
• Keine unadressierten Datenlecks (keine Verwendung zukünftiger Informationen).
• Modellperformance auf Holdout entspricht der Validierungsperformance ± akzeptable Drift.

Rolle-basierte Checklisten

Data Scientist

• Definiert Ziel- und Erfolgskriterien.
• Prüft Annahmen (Linearität, Normalität der Residuen, Multikollinearität).
• Führt Feature-Engineering und Modellselektion durch.
• Dokumentiert Modellannahmen, Validierung und Grenzen.

Data Analyst

• Visualisiert Daten und erzeugt erste Hypothesen.
• Bereitet Datensätze für Modellierung vor (Missing, Dummies, Skalierung).
• Erstellt Exploratory-Reports und interpretiert Koeffizienten.

Machine Learning Engineer

• Baut Produktionspipelines (Feature Store, Preprocessing).
• Sorgt für Tests, Monitoring und Re-Training-Strategien.
• Validiert Latenz, Stabilität und Sicherheitsbeschränkungen.

Kurze Cheatsheet-Befehle

• Seaborn Streuplot: sns.relplot(x=’x’, y=’y’, data=df)
• Seaborn Regression: sns.regplot(x=’x’, y=’y’, data=df)
• Pingouin lineare Regression: pg.linear_regression(X, y)
• Pingouin logistische Regression: pg.logistic_regression(X, y)
• Pandas DataFrame: pd.DataFrame({‘a’: a, ‘b’: b})
• NumPy linspace: np.linspace(start, stop, n)

Testfälle und Akzeptanztests (Beispiele)

• Unit-Test: tip(0) gibt den Intercept zurück (z. B. 0.92).
• Integrationstest: Pipeline von Raw CSV bis Modellvorhersage gibt plausible Bereiche (Sanity checks).
• Robustheitstest: Modellleistung bleibt stabil bei ±10% Änderungen in den Input-Verteilungen.

Entscheidungshilfe: Wann welches Modell?

flowchart TD
  A[Zielvariable binär?] -->|Ja| B[Logistische Regression oder Klassifikator]
  A -->|Nein| C[Kontinuierliche Zielgröße]
  C --> D[Lineare Beziehung sichtbar?]
  D -->|Ja| E[Lineares Modell 'ggf. multiple']
  D -->|Nein| F[Nichtlineares Modell 'GAM, Polynom, Tree']
  E --> G[Schleife: Diagnose & Regularisierung]
  F --> G

Vergleich von Bibliotheken (Kurzmatrix)

• Seaborn: Visualisierung, schnelle Regressionen für Exploration.
• Pingouin: Statistische Tests, einfache Regressionen mit tabellarischer Ausgabe.
• Statsmodels: Detaillierte statistische Inferenz (Konfidenzintervalle, Tests).
• Scikit-learn: Produktionstaugliche Modelle, Pipelines, Cross-Validation.

Sicherheit, Datenschutz und Lokale Hinweise

• Personenbeziehbare Daten: Pseudonymisieren oder minimieren, bevor Sie Modelle trainieren.
• GDPR: Dokumentieren Sie Zweckbindung und Rechtsgrundlage beim Einsatz personenbezogener Daten.
• Versionskontrolle: Speichern Sie Modellparameter, Trainingsdatenhash und Code für Reproduzierbarkeit.

Beispiel-Playbook: Schnelles Regressionsprojekt (SOP)

1. Scope & Ziel definieren (KPIs, Entscheidungskriterien).
2. Datensichtung: Profiling-Report erzeugen (Verteilungen, Nullwerte).
3. Baseline-Modell bauen (einfache lineare Regression).
4. Validieren auf Holdout, Residuen analysieren.
5. Iterieren mit Feature-Engineering.
6. Testen im Staging, A/B-Test oder Shadow-Deployment.
7. Monitoring definieren (Drift, SLI/SLO, Re-Training-Trigger).

Häufige Fehler und Gegenmaßnahmen

• Problem: Overfitting bei polynomiellen Modellen.
  Gegenmaßnahme: Regularisierung, Kreuzvalidierung, niedrigere Polynomgrade.

• Problem: Hohe VIF-Werte (Multikollinearität).
  Gegenmaßnahme: Entfernen oder kombinieren korrelierter Features, PCA nutzen.

• Problem: Heteroskedastizität (varianzabhängige Residuen).
  Gegenmaßnahme: Transformationen (z. B. Box-Cox) oder robuste Standardfehler.

Zusammenfassung

Regression ist ein mächtiges Werkzeug, um Zusammenhänge zu quantifizieren und Vorhersagen zu treffen. Seaborn bietet schnelle Visualisierungen; Pingouin und Statsmodels liefern statistische Metriken; scikit-learn und Regularisierungsmethoden machen Modelle produktionsreif. Achten Sie auf Datenqualität, Annahmenprüfung und Validierung, bevor Sie ein Modell in Produktion nehmen.

Wichtig

Regression liefert Hinweise auf Beziehungen, keine Kausalität. Prüfen Sie Annahmen und dokumentieren Sie Grenzen Ihres Modells.

Weitere Ressourcen

• Dokumentation: Seaborn, Pingouin, Statsmodels, scikit-learn.
• Empfohlene Praxis: Keep it simple – beginnen Sie mit einem Baseline-Modell.

Schlussbemerkung: Python beschleunigt und reproduzierbar macht, was früher manuell und fehleranfällig war. Regressionen helfen, Muster in Daten zu finden und fundierte Entscheidungen zu treffen. Nutzen Sie die hier gezeigten Workflows als Startpunkt und passen Sie sie an Ihre Domäne an.