Wie erstellt man eine Regressionsanalyse in Python?

Lineare Regression in Python – das Wichtigste vorab

Eine Regressionsanalyse in Python lässt sich mit wenigen Zeilen Code durchführen – der eigentliche Aufwand steckt in der korrekten Vorbereitung der Daten, der Auswahl des richtigen Pakets und der sorgfältigen Interpretation der Ergebnisse. Dieser Artikel führt Sie durch den vollständigen Workflow: von der Datenstruktur bis zur Modelldiagnostik.

Die lineare Regression modelliert den Zusammenhang zwischen einer abhängigen Variable y und einer oder mehreren unabhängigen Variablen X. Das Ziel ist es, eine Gerade (oder Hyperebene) zu schätzen, die die beobachteten Datenpunkte möglichst gut beschreibt – gemessen an der Residualsumme der Quadrate (OLS: Ordinary Least Squares).

Dabei steht für den Achsenabschnitt (Intercept), für die Regressionskoeffizienten der Prädiktoren und für den Fehlerterm.

Für die Durchführung in Python brauchen Sie keine kommerzielle Lizenz und keine komplizierte Installation – die relevanten Pakete sind frei verfügbar und lassen sich über pip oder conda installieren. Wenn Sie noch am Anfang Ihrer statistischen Auswertung mit Python stehen, lohnt sich zunächst ein Überblick über die grundlegenden Workflows.

statsmodels oder scikit-learn – welches Paket ist das richtige?

Python bietet zwei etablierte Pakete für lineare Regression – mit unterschiedlichen Schwerpunkten. Die Wahl hängt davon ab, was Sie mit Ihrer Analyse erreichen wollen.

Für wissenschaftliche Abschlussarbeiten in Psychologie, Medizin oder den Sozialwissenschaften ist statsmodels fast immer die richtige Wahl. Es liefert die vollständige Koeffiziententabelle mit p-Werten, Standardfehlern und Konfidenzintervallen – genau das, was Gutachtende erwarten. scikit-learn dagegen minimiert zwar die Residualsumme der Quadrate und stellt Koeffizienten bereit, liefert aber keine inferenzstatistischen Kennzahlen wie p-Werte direkt mit – das ist für prädiktive Fragestellungen kein Problem, für hypothesentestende Arbeiten jedoch ein Nachteil.

Schritt-für-Schritt: Regressionsanalyse mit statsmodels

Schritt 1: Pakete importieren und Daten laden

Stellen Sie sicher, dass die benötigten Pakete installiert sind (pip install statsmodels pandas numpy). Für das folgende Beispiel verwenden wir einen einfachen Datensatz mit einer abhängigen Variable (Prüfungsnote) und zwei Prädiktoren (Lernstunden und Vorkenntnisse).

import pandas as pd
import numpy as np
import statsmodels.api as sm

# Beispieldatensatz erstellen
np.random.seed(42)
n = 100

df = pd.DataFrame({
    'lernstunden': np.random.uniform(1, 20, n),
    'vorkenntnisse': np.random.uniform(0, 10, n),
    'pruefungsnote': np.nan
})

# Abhängige Variable simulieren (mit zufälligem Fehler)
df['pruefungsnote'] = (
    2.0
    - 0.08 * df['lernstunden']
    + 0.15 * df['vorkenntnisse']
    + np.random.normal(0, 0.3, n)
)

Natürlich verwenden Sie in Ihrer eigenen Arbeit keine simulierten Daten, sondern importieren Ihren echten Datensatz – z. B. aus einer CSV-Datei. Wie das funktioniert, erläutert der Beitrag zum Importieren von CSV- und Excel-Daten in Python.

Schritt 2: Designmatrix erstellen und Konstante hinzufügen

Ein häufig übersehener Schritt: statsmodels fügt den Achsenabschnitt (Intercept) nicht automatisch hinzu. Sie müssen ihn manuell mit sm.add_constant() ergänzen. Ohne diesen Schritt erzwingen Sie ein Modell durch den Ursprung – was in den meisten Fällen inhaltlich falsch ist.

# Prädiktoren auswählen
X = df[['lernstunden', 'vorkenntnisse']]

# Konstante (Intercept) hinzufügen
X = sm.add_constant(X)

# Abhängige Variable
y = df['pruefungsnote']

Schritt 3: Modell schätzen

Das Modell wird mit sm.OLS(y, X).fit() geschätzt. Der dokumentierte Ablauf in statsmodels zeigt, wie aus Designmatrix und Zielvektor ein OLS-Modell angepasst und anschließend mit results.summary() vollständig ausgegeben wird – inklusive R², F-Statistik, Koeffizienten, Standardfehlern, t-Werten, p-Werten und Konfidenzintervallen.

# Modell schätzen
modell = sm.OLS(y, X).fit()

# Ergebnistabelle ausgeben
print(modell.summary())

Der Aufruf von modell.summary() liefert eine strukturierte Tabelle, die alles enthält, was Sie für eine wissenschaftliche Auswertung benötigen. Im nächsten Abschnitt erklären wir die wichtigsten Kennzahlen.

Ergebnisse interpretieren: Was steht in results.summary()?

Die Ausgabe von results.summary() gliedert sich in drei Blöcke. Hier die wichtigsten Kennzahlen im Überblick:

Block 1: Modellgüte

• R²: Anteil der erklärten Varianz an der Gesamtvarianz der abhängigen Variable. Ein R² von 0,45 bedeutet: 45 % der Variation in y werden durch das Modell erklärt.
• Adj. R²: Das adjustierte R² berücksichtigt die Anzahl der Prädiktoren und bestraft unnötig komplexe Modelle. Für Vergleiche zwischen Modellen mit unterschiedlich vielen Prädiktoren ist dieser Wert aussagekräftiger.
• F-Statistik / Prob(F): Prüft, ob das Modell als Ganzes signifikant ist (d. h. ob mindestens ein Prädiktor einen bedeutsamen Beitrag leistet). Ein Prob(F) < 0,05 gilt als statistisch signifikant.
• AIC / BIC: Informationskriterien für den Modellvergleich – niedrigere Werte sprechen für ein sparsameres, besser angepasstes Modell.

Block 2: Koeffiziententabelle

Für jeden Prädiktor werden ausgegeben:

• coef: Der geschätzte Regressionskoeffizient – gibt an, um wie viel sich y verändert, wenn der Prädiktor um eine Einheit steigt (bei konstanten übrigen Prädiktoren).
• std err: Standardfehler des Koeffizienten – ein Maß für die Schätzunsicherheit.
• t / P>|t|: t-Wert und zugehöriger p-Wert für den Einzeltest jedes Koeffizienten.
• [0.025, 0.975]: Das 95%-Konfidenzintervall. Schließt es die Null nicht ein, ist der Koeffizient auf dem 5%-Niveau signifikant.

Block 3: Diagnostische Hinweise

Hier finden Sie Kennzahlen wie den Durbin-Watson-Wert (Autokorrelation der Residuen) und die Condition Number (Hinweis auf Multikollinearität). Eine Condition Number über 30 gilt als Warnsignal für problematische Multikollinearität – ein Thema, das im Abschnitt zu den Modellannahmen weiter behandelt wird.

Modellannahmen prüfen: Residuenanalyse in Python

Ein häufiger Fehler in Abschlussarbeiten: Das Modell wird geschätzt und die Koeffizienten werden direkt interpretiert – ohne zu prüfen, ob die Modellannahmen überhaupt erfüllt sind. Das ist methodisch problematisch, denn ungültige Annahmen können die Koeffizienten und ihre Signifikanztests verzerren.

Die Qualität einer Regressionsanalyse lässt sich nicht allein an R² oder p-Werten ablesen – entscheidend ist auch die Prüfung der Modellannahmen anhand grafischer Residuendiagnostik, bei der Residuen gegen Fitted Values, gegen einzelne Prädiktoren und in einem Normalwahrscheinlichkeitsplot dargestellt werden.

Die vier zentralen Annahmen der OLS-Regression

• Linearität: Der Zusammenhang zwischen Prädiktoren und abhängiger Variable ist linear.
• Homoskedastizität: Die Varianz der Residuen ist über alle Fitted Values konstant.
• Normalverteilung der Residuen: Die Residuen sind (annähernd) normalverteilt – wichtig für die Gültigkeit der t- und F-Tests.
• Unabhängigkeit der Residuen: Die Fehler sind nicht autokorreliert (besonders relevant bei Zeitreihendaten).

Residuenplots in Python erstellen

Für die Visualisierung benötigen Sie matplotlib und scipy:

import matplotlib.pyplot as plt
import scipy.stats as stats

# Residuen und Fitted Values extrahieren
residuen = modell.resid
fitted_values = modell.fittedvalues

# Plot 1: Residuen gegen Fitted Values (Linearität & Homoskedastizität)
plt.figure(figsize=(8, 4))
plt.scatter(fitted_values, residuen, alpha=0.5)
plt.axhline(0, color='red', linestyle='--')
plt.xlabel('Fitted Values')
plt.ylabel('Residuen')
plt.title('Residuen vs. Fitted Values')
plt.tight_layout()
plt.show()

# Plot 2: Q-Q-Plot (Normalverteilung der Residuen)
fig, ax = plt.subplots(figsize=(6, 5))
stats.probplot(residuen, dist="norm", plot=ax)
ax.set_title('Q-Q-Plot der Residuen')
plt.tight_layout()
plt.show()

Was Sie in diesen Plots suchen:

• Im Residuen-vs.-Fitted-Plot: Kein erkennbares Muster, keine trichterförmige Streuung. Punktwolken um die Nulllinie sind ein gutes Zeichen.
• Im Q-Q-Plot: Die Punkte sollten möglichst nah an der Diagonalen liegen. Starke Abweichungen an den Enden deuten auf Schiefe oder schwere Ränder hin.

Exkurs: Multiple Regression mit mehreren Prädiktoren

Das beschriebene Vorgehen funktioniert unmittelbar auch für die multiple Regression – Sie erweitern lediglich die Designmatrix um weitere Spalten. Wichtig ist dabei, auf Multikollinearität zu achten: Wenn zwei Prädiktoren stark miteinander korrelieren, werden die Koeffizienten instabil und die Standardfehler aufgebläht.

Ein einfacher erster Check ist die Korrelationsmatrix der Prädiktoren:

# Korrelationsmatrix der Prädiktoren
print(df[['lernstunden', 'vorkenntnisse']].corr())

# VIF berechnen (Variance Inflation Factor)
from statsmodels.stats.outliers_influence import variance_inflation_factor

X_ohne_const = df[['lernstunden', 'vorkenntnisse']]
vif_data = pd.DataFrame({
    'Variable': X_ohne_const.columns,
    'VIF': [variance_inflation_factor(X_ohne_const.values, i)
            for i in range(X_ohne_const.shape[1])]
})
print(vif_data)

Als Faustregel gilt: VIF-Werte über 10 sind ein ernsthaftes Warnsignal; Werte über 5 sollten zumindest diskutiert werden. Die Condition Number aus modell.summary() liefert eine ergänzende Einschätzung.

Falls Sie in Ihrer Arbeit auch eine ANOVA in Python benötigen, lohnt sich ein Blick in den entsprechenden Beitrag – viele Konzepte wie Varianzzerlegung und F-Test überschneiden sich mit der Regressionsanalyse.

Prädiktive Modellierung mit scikit-learn

Wenn Ihre Fragestellung nicht auf Hypothesentests, sondern auf Vorhersage ausgerichtet ist, bietet scikit-learn eine elegante Alternative. Der Workflow unterscheidet sich in einigen Details von statsmodels.

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error

# Daten aufteilen in Trainings- und Testset
X_sk = df[['lernstunden', 'vorkenntnisse']]
y_sk = df['pruefungsnote']

X_train, X_test, y_train, y_test = train_test_split(
    X_sk, y_sk, test_size=0.2, random_state=42
)

# Modell trainieren
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train, y_train)

# Ergebnisse ausgeben
print("Intercept:", lr.intercept_)
print("Koeffizienten:", lr.coef_)

# Modellgüte auf Testdaten
y_pred = lr.predict(X_test)
print("R² (Test):", r2_score(y_test, y_pred))
print("RMSE (Test):", mean_squared_error(y_test, y_pred, squared=False))

Der Parameter fit_intercept=True ist der Standard – wenn Sie ihn auf False setzen, setzt scikit-learn voraus, dass die Daten bereits zentriert sind. Außerdem stellt das Modell nach dem Fit nützliche Attribute wie coef_, intercept_ und n_features_in_ bereit. Was scikit-learn nicht liefert: p-Werte und Konfidenzintervalle – für Abschlussarbeiten mit inferenzstatistischem Anspruch bleibt statsmodels die bessere Wahl.

Einen tiefgehenden Vergleich der Stärken und Schwächen von Python gegenüber klassischen Statistikprogrammen finden Sie im Beitrag zu den Vor- und Nachteilen von Python gegenüber SPSS.

Regressionsanalyse für Abschlussarbeiten – worauf Sie achten sollten

Das Durchführen der Regression ist technisch der einfachste Teil. Für eine überzeugende Abschlussarbeit gehört mehr dazu:

Zur Darstellung der Ergebnisse in der Abschlussarbeit: Der Beitrag zum Export von Python-Ergebnissen für Abschlussarbeiten zeigt, wie Sie Tabellen und Plots publikationsreif aufbereiten. Und wer sich fragt, welche Visualisierungen für die Darstellung der Regressionsergebnisse geeignet sind, findet Orientierung im Artikel zu Diagrammen und Visualisierungen in Python.

Falls Ihnen bei der Interpretation oder methodischen Einordnung Ihrer Regressionsergebnisse Unterstützung fehlt, bietet die methodische Begleitung durch erfahrene Statistiker bei QuantExpert eine fundierte Anlaufstelle – von der Modellspezifikation bis zur Ergebnisdarstellung.