Sklearn Lineare Regression: Der komplette Guide mit Beispielen

Die lineare Regression ist eine grundlegende Technik in Statistik und Machine Learning, mit der sich Zusammenhänge zwischen Variablen modellieren lassen. Einfach gesagt: Sie ermöglicht Vorhersagen eines Ergebnisses auf Basis eines oder mehrerer Einflussfaktoren. Sie wird breit eingesetzt, z. B. bei Immobilienpreisen, Absatzprognosen, Risikobewertungen und vielen weiteren Anwendungsfällen.

In diesem Tutorial schauen wir uns die lineare Regression in scikit-learn an: wie sie funktioniert, warum sie nützlich ist und wie du sie mit scikit-learn implementierst. Am Ende kannst du ein lineares Regressionsmodell erstellen und bewerten, um datenbasierte Vorhersagen zu treffen.

Streudiagramm: Hauspreis vs. Anzahl der Zimmer

Lineare Regression und Machine Learning

Über die unmittelbare Anwendung bei Immobilienpreisen hinaus spielt die lineare Regression eine wichtige Rolle im Machine Learning.

• Sie ist das Fundament, um fortgeschrittenere Verfahren wie logistische Regression, neuronale Netze und Support Vector Machines zu verstehen.
• Sie ist schnell zu trainieren und damit ideal für schnelles Prototyping.
• Sie dient als Baseline zum Vergleich. Wenn komplexere Modelle sie nicht deutlich übertreffen, ist der Mehraufwand oft nicht gerechtfertigt.
• Im Gegensatz zu manchen Verfahren (etwa Deep Learning) ist sie leicht interpretierbar.
• Sie unterstützt die Feature-Auswahl und hilft, die wichtigsten Prädiktoren zu identifizieren.

Trotz ihrer Einfachheit bleibt die lineare Regression wegen Effizienz, Interpretierbarkeit und Vielseitigkeit ein unverzichtbares Werkzeug im Machine Learning.

Lineare Regression und die scikit-learn-Bibliothek

Mit scikit-learn lässt sich lineare Regression sehr einfach umsetzen. Die Bibliothek bietet viele Vorteile.

• Sie hat eine konsistente Schnittstelle. Der Code für unterschiedliche ML-Algorithmen ist ähnlich.
• Der Code bleibt übersichtlich, komplexe Mathematik und Implementierungsdetails sind gekapselt. Um z. B. ein Modell zu trainieren, reicht model.fit(X_train, y_train).
• Du erhältst leicht Zugriff auf Modellkoeffizienten.
• Es gibt eingebaute Metriken zur Bewertung der Modellgüte.
• Vorverarbeitungsschritte wie Skalierung und Feature-Auswahl lassen sich mit Pipelines einfach mit linearer Regression (oder jedem anderen ML-Algorithmus) kombinieren.

Wenn du neu bei scikit-learn bist, schau dir unseren Kurs Machine Learning mit scikit-learn an, um einen praxisnahen Einstieg in die Python-Bibliothek zu bekommen. 

Lineare Regression verstehen

Wie gesehen wird bei der einfachen linearen Regression der Zusammenhang durch eine „Best-Fit-Linie“ modelliert. Die Formel dieser Linie lautet: 

Dabei ist m die Steigung der Geraden und b der Achsenabschnitt.

Die „multiple lineare Regression“ verallgemeinert den Fall mit einem Prädiktor auf mehrere Prädiktoren (Anzahl Zimmer, Nähe zum Meer, mittleres Einkommen der Nachbarschaft). Die Formel verallgemeinert sich zu: 

Dabei ist jedes x_i eine unabhängige Variable und das zugehörige b_i ihr Koeffizient. In drei Dimensionen wird die Gerade zu einer Ebene, in höheren Dimensionen zur „Hyperbene“.

Wie interpretieren wir Koeffizienten und Achsenabschnitt? Der Achsenabschnitt ist der vorhergesagte Wert von y, wenn alle unabhängigen Variablen 0 sind – also der Basiswert der abhängigen Variable ohne Beitrag der Prädiktoren. Jeder Koeffizient b_i steht für die Änderung von y bei einer Einheitsänderung von x_i, wenn alle anderen Variablen konstant bleiben.

Die Umgebung einrichten

Die Installation von scikit-learn ist einfach. Verwende den Befehl pip install scikit-learn. Wenn du eine bestimmte Version, z. B. 1.2.2, installieren möchtest, erweitere den Befehl: pip install scikit-learn==1.2.2. Wenn du Anaconda nutzt, ist scikit-learn in der Regel bereits enthalten. Falls du es in der Anaconda-Distribution dennoch installieren musst, verwende conda install scikit-learn.

Mehrere Bibliotheken sind mit scikit-learn nötig oder empfohlen. Die numpy-Bibliothek wird zum Speichern von Features und Labels benötigt. pandas empfiehlt sich zum Laden, Vorverarbeiten und Explorieren von Datensätzen. 

Wenn du scikit-learn verwendest, nutzt du für die Datenvorbereitung höchstwahrscheinlich ohnehin pandas. Für Visualisierungen kommen meist matplotlib oder seaborn oder beide zum Einsatz. Alle Bibliotheken lassen sich wie oben gezeigt mit pip installieren. Du kannst sogar mehrere Bibliotheken mit einem Befehl installieren:

pip install scikit-learn numpy pandas matplotlib seaborn.

Lineare Regression in sklearn implementieren

Bevor wir den Datensatz laden, importieren wir die üblichen Verdächtigen.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

Den Datensatz laden

Wir verwenden den bekannten California-Housing-Datensatz.

# Read in California housing dataset.
from sklearn.datasets import fetch_california_housing


housing = fetch_california_housing()

Daten vorbereiten

Wir teilen die Daten in Trainings- und Testmenge. Wir importieren train_test_split() aus sklearn.model_selection, rufen es auf, geben den Testanteil und einen random_state an. Außerdem nutzen wir einfache lineare Regression mit dem Feature für die durchschnittliche Zimmeranzahl.

# Import train_test_split.
from sklearn.model_selection import train_test_split


# Create features X and target y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)[["AveRooms"]]
y = housing.target  # Median house value in $100,000s


# Split the dataset into training (80%) and testing (20%) sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Nachdem wir in Trainings- und Testdaten aufgeteilt haben, standardisieren wir die Features. So liegen alle Variablen auf derselben Skala, was die Modellleistung und numerische Stabilität verbessern kann.

# Import StandardScaler.
from sklearn.preprocessing import StandardScaler

# Instantiate StandardScaler.
scaler = StandardScaler()

# Fit and transform training data.
X_train_scaled = scaler.fit_transform(X_train)

# Also transform test data.
X_test_scaled = scaler.transform(X_test)

In diesem Code ist StandardScaler ein Vorverarbeitungstool, das den Mittelwert entfernt und Features auf Varianz 1 skaliert. So verhindert man, dass bestimmte Merkmale wegen unterschiedlicher Skalen das Modell dominieren.

Der Scaler wird mit fit_transform() auf die Trainingsdaten angepasst. Die Testdaten transformieren wir separat mit transform(), damit exakt dieselben Parameter wie beim Training gelten und kein Data Leakage entsteht.

Das lineare Regressionsmodell trainieren

Zum Erstellen eines linearen Regressionsmodells importiere LinearRegression() aus sklearn.linear_model. Instanziiere es und weise es einer Variablen zu.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

Das Fitting mit den Trainingsdaten ist unkompliziert.

# Fit the model to the training data.
model.fit(X_train_scaled, y_train)

Vorhersagen treffen

Nachdem das Modell trainiert ist, erstellen wir Vorhersagen auf dem Testset.

# Make predictions on the testing data.
y_pred = model.predict(X_test_scaled)

Modellleistung bewerten

Jetzt müssen wir prüfen, wie gut die Vorhersagen zur Realität passen. Es gibt mehrere Metriken zur Bewertung von Regressionsalgorithmen. Zu den gängigsten zählen Bestimmtheitsmaß (R²), mittlerer quadratischer Fehler (MSE) und Wurzel des mittleren quadratischen Fehlers (RMSE).

Das Bestimmtheitsmaß R² misst, wie gut ein Regressionsmodell die Variabilität der Zielvariable erklärt. Es quantifiziert also, wie viel der Varianz der Zielgröße durch die Prädiktoren erklärt wird – auch Goodness of Fit genannt.

Zur Verdeutlichung die Formel:

Dabei ist yactual der echte Zielwert, ypredicted der vom Modell vorhergesagte Wert und ȳ der Mittelwert der echten Werte. Der Nenner ist die gesamte Varianz in den Daten, der Zähler die unerklärte Varianz nach Anwendung des Modells. Das Verhältnis gibt also den erklärten Varianzanteil an.

Wie interpretieren wir R²?

• R² = 1: Das Modell erklärt die gesamte Varianz perfekt. 
• R² = 0: Das Modell erklärt keine Varianz; Vorhersagen sind nicht besser als der Mittelwert. 
• R² < 0: Das Modell ist schlechter als der Mittelwert – ein sehr schlechter Fit.

Wichtige Punkte, die du im Blick behalten solltest.

• Ein höheres R² ist nicht automatisch besser. Ein sehr hohes R² kann auf Overfitting hindeuten, vor allem bei komplexen Modellen. 
• Mehr Features können R² künstlich erhöhen – ein höherer Wert ist nicht zwingend besser.
• Bei multipler Regression nutze das adjustierte R², das die Anzahl der Prädiktoren berücksichtigt und Scheinverbesserungen durch unnötige Variablen vermeidet.

Die Bewertung mit dem Bestimmtheitsmaß ist in scikit-learn schnell erledigt.

# Import metrics.
from sklearn.metrics import mean_squared_error, r2_score


# Calculate and print R^2 score.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")

R-squared: 0.0138

Weitere verbreitete Metriken sind MSE und RMSE. Beide messen, wie stark die Vorhersagen von den tatsächlichen Werten abweichen.

MSE berechnet den durchschnittlichen quadrierten Unterschied zwischen echten und vorhergesagten Werten: 

für die Gesamtzahl der Beobachtungen n. Da Fehler vor dem Mitteln quadriert werden, werden große Fehler stärker bestraft als kleine – MSE ist also empfindlich gegenüber Ausreißern. Ein niedrigerer MSE steht für einen besseren Fit.

Um dem zu begegnen, wird die RMSE verwendet – die Quadratwurzel des MSE. Da RMSE in denselben Einheiten wie die Zielvariable vorliegt, ist sie leichter interpretierbar: Sie zeigt die durchschnittliche Abweichung der Vorhersage.

Die Berechnung mit scikit-learn ist unkompliziert.

# Calculate and print MSE.
mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


# Calculate and print RMSE.
rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

Mean squared error: 1.2923
Root mean squared error: 1.1368

Arbeiten mit multipler linearer Regression in scikit-learn

Lass uns das Modell erneut laufen lassen – diesmal mit allen verfügbaren Features, nicht nur der durchschnittlichen Zimmeranzahl. Erwartest du bessere oder schlechtere Ergebnisse?

# Uses all features.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load data set.
housing = fetch_california_housing()


# Split into X, y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target  # Median house value in $100,000s
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data.
scaler = StandardScaler()


X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create model and fit it to the training data.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions.
y_pred = model.predict(X_test_scaled)


# Calculate and print errors.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")


mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5758
Mean squared error: 0.5559
Root mean squared error: 0.7456

Die Ergebnisse sind deutlich besser als mit nur einem Feature. Damit stellt sich die Frage, ob wir wirklich alle Features brauchen. Sind manche Merkmale relevanter als andere? Die Auswahl der relevantesten Merkmale nennt man Feature-Auswahl.

Feature-Auswahl ist aus mehreren Gründen wichtig.

• Weniger Overfitting. Weniger Features bedeuten geringere Komplexität und damit weniger Overfitting.
• Höhere Genauigkeit. Irrelevante oder redundante Merkmale zu entfernen, hilft dem Modell, sich auf die wichtigen Muster zu konzentrieren.
• Bessere Interpretierbarkeit. Das Modell wird verständlicher, weil die wichtigsten Einflussfaktoren klarer werden.
• Schnelleres Training. Weniger Features reduzieren Rechenzeit und Speicherbedarf.

Wenn mehrere Features stark korrelieren, sind sie redundant – sie liefern dem Modell im Kern dieselben Informationen. Dies nennt man Multikollinearität. Sie beeinträchtigt nicht immer die Prognosegenauigkeit, erschwert aber Feature-Auswahl und Interpretation, besonders bei linearer Regression und verwandten Modellen.

Der Variance Inflation Factor (VIF) ist eine Kennzahl zur Erkennung von Multikollinearität unter Prädiktoren. Für jeden Prädiktor wird der VIF wie folgt berechnet: 

Dabei ist R_i² der R²-Wert, wenn der Prädiktor X_i gegen alle übrigen Prädiktoren regressiert wird. Ein höherer VIF bedeutet eine starke Korrelation mit anderen Variablen.

• VIF = 1: keine Multikollinearität (Idealzustand).
• VIF < 5: geringe bis moderate Multikollinearität (meist unkritisch).
• VIF > 5: hohe Multikollinearität (erwäge Entfernen oder Zusammenfassen korrelierter Variablen).
• VIF > 10: sehr starke Multikollinearität (deutlicher Hinweis auf Redundanz).

# Import libraries.
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from statsmodels.stats.outliers_influence import variance_inflation_factor


# Load the dataset.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)


# Compute the correlation matrix.
corr_matrix = X.corr()


# Identify pairs of features with high collinearity (correlation > 0.8 or < -0.8).
high_corr_features = [(col1, col2, corr_matrix.loc[col1, col2])
                     for col1 in corr_matrix.columns
                     for col2 in corr_matrix.columns
                     if col1 != col2 and abs(corr_matrix.loc[col1, col2]) > 0.8]


# Convert to a DataFrame for better visualization.
collinearity_df = pd.DataFrame(high_corr_features, columns=["Feature 1", "Feature 2", "Correlation"])
print("\nHighly Correlated Features:\n", collinearity_df)


# Compute Variance Inflation Factor (VIF) for each feature.
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]


# Print VIF values.
print("\nVariance Inflation Factor (VIF) for each feature:\n", vif_data)

   Highly Correlated Features:
       Feature 1  Feature 2  Correlation
   0   AveRooms  AveBedrms     0.847621
   1  AveBedrms   AveRooms     0.847621
   2   Latitude  Longitude    -0.924664
   3  Longitude   Latitude    -0.924664
  
   Variance Inflation Factor (VIF) for each feature:
          Feature         VIF
   0      MedInc   11.511140
   1    HouseAge    7.195917
   2    AveRooms   45.993601
   3   AveBedrms   43.590314
   4  Population    2.935745
   5    AveOccup    1.095243
   6    Latitude  559.874071
   7   Longitude  633.711654

Lass uns AveBedrms aus dem Modell entfernen.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load California housing dataset.
housing = fetch_california_housing()


# Create DataFrame and remove "AveBedrms" feature.
X = pd.DataFrame(housing.data, columns=housing.feature_names).drop(columns=["AveBedrms"])
y = housing.target  # Median house value in $100,000s


# Split data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data (Standardization).
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create a linear regression model and train it.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions on the test set.
y_pred = model.predict(X_test_scaled)


# Calculate performance metrics.
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# Print evaluation metrics
print(f"R-squared: {r2:.4f}")
print(f"Mean squared error: {mse:.4f}")
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5823
Mean squared error: 0.5473
Root mean squared error: 0.7398

Die Ergebnisse sind (leicht) verbessert.

Modelleinsichten gewinnen

Ein Regressionsmodell zu bauen ist nur der erste Schritt; seine Ergebnisse zu verstehen ist ebenso wichtig. Über die Koeffizienten des Modells lässt sich erkennen, welche Features den größten Einfluss auf die Vorhersagen haben.

Regressionskoeffizienten verstehen

Sobald ein lineares Regressionsmodell trainiert ist, kannst du die Koeffizienten über model.coef_ abrufen. Den Achsenabschnitt erhältst du mit model.intercept_.

Wenn du das Modell mit LinearRegression() trainiert hast, stehen dir die Koeffizienten über model.coef_ und der Achsenabschnitt über model.intercept_ zur Verfügung.

print("Intercept:", model.intercept_)


coeff_df = pd.DataFrame({"Feature": X.columns, "Coefficient": model.coef_})
print("\nFeature Coefficients:\n", coeff_df)

   Intercept: 2.0719469373788777  

   Feature Coefficients:

         Feature  Coefficient

   0     MedInc     0.725747

   1   HouseAge     0.121519

   2   Latitude    -0.943105

   3  Longitude    -0.900735

Modellergebnisse zusammenfassen

Da Scikit-Learn keine eingebaute Methode summary() wie Statsmodels bietet, können wir die Wichtigkeit der Features manuell über die Regressionskoeffizienten extrahieren und visualisieren. Features mit größeren absoluten Koeffizienten haben stärkeren Einfluss auf die Zielvariable. Betrachte den folgenden Code.

# Sort dataframe by coefficients.
coef_df_sorted = coef_df.sort_values(by="Coefficient", ascending=False)


# Create plot.
plt.figure(figsize=(8,6))
plt.barh(coef_df["Feature"], coef_df_sorted["Coefficient"], color="blue")
plt.xlabel("Coefficient Value")
plt.ylabel("Feature")
plt.title("Feature Importance (Linear Regression Coefficients)")
plt.show()

Diagramm der Feature-Wichtigkeit basierend auf Koeffizienten

Als Nächstes visualisieren wir Residuen und den Regressionsfit.

# Compute residuals.
residuals = y_test - y_pred


# Create plots.
plt.figure(figsize=(12,5))


# Plot 1: Residuals Distribution.
plt.subplot(1,2,1)
sns.histplot(residuals, bins=30, kde=True, color="blue")
plt.axvline(x=0, color='red', linestyle='--')
plt.title("Residuals Distribution")
plt.xlabel("Residuals (y_actual - y_predicted)")
plt.ylabel("Frequency")


# Plot 2: Regression Fit (Actual vs Predicted).
plt.subplot(1,2,2)
sns.scatterplot(x=y_test, y=y_pred, alpha=0.5)
plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')  # Perfect fit line
plt.title("Regression Fit: Actual vs Predicted")
plt.xlabel("Actual Prices (in $100,000s)")
plt.ylabel("Predicted Prices (in $100,000s)")


# Show plots.
plt.tight_layout()
plt.show()

Visualisierungen der Residuen und des Regressionsfits

Die Verteilung der Residuen (linker Plot) sollte um Null zentriert sein, damit die Fehler zufällig verteilt sind. Folgen die Residuen näherungsweise einer Normalverteilung, passt das Modell gut; bei Schiefe oder Trends können systematische Fehler vorliegen. Der Regressionsfit (rechter Plot) vergleicht echte vs. vorhergesagte Werte, die rote gestrichelte Linie markiert den perfekten Fit. Liegen die Punkte nahe an der Linie, sind die Vorhersagen präzise; zeigt sich ein Muster (z. B. Kurve), ist der Zusammenhang womöglich nicht linear. 

Diese Visualisierungen helfen, Over- oder Underfitting zu erkennen, Muster in den Residuen aufzudecken und die Wirksamkeit des Modells klar einzuschätzen.

Praxisnahe Einsatzszenarien

Lineare Regression wird branchenübergreifend für Vorhersagen und Entscheidungen genutzt. In der Immobilienbranche schätzt sie Hauspreise anhand von Faktoren wie Größe und Lage. 

Im Vertrieb und Marketing unterstützt sie Nachfrageprognosen und Budgetoptimierung; im Gesundheitswesen dient sie der Risikobewertung von Erkrankungen. In der Finanzwelt hilft sie bei Aktienkursprognosen und Kredit-Scoring, in der Produktion bei Qualitätskontrolle und Ausfallprognosen. 

Wann lineare Regression sinnvoll ist

• Zwischen Features und Zielvariable besteht ein linearer Zusammenhang.
• Interpretierbarkeit und Einfachheit sind wichtiger als komplexes Modeling.
• Es ist nur wenig Feature Engineering erforderlich.

Wann du lineare Regression meiden solltest

• Der Zusammenhang zwischen Ziel und Features ist komplex und nichtlinear.
• Die Daten sind stark korreliert.
• Die Daten enthalten Ausreißer, die nicht entfernt werden können. In diesem Fall solltest du Daten­transformationen anwenden oder Strategien zur Dämpfung ihres Einflusses nutzen.

Fazit

Die lineare Regression gehört zu den grundlegendsten und am weitesten verbreiteten Verfahren im Machine Learning und in der Statistik. Trotz ihrer Einfachheit ist sie ein leistungsfähiges Werkzeug, um Zusammenhänge zwischen Variablen zu verstehen und in vielen realen Anwendungen Vorhersagen zu treffen.

Die wichtigsten Punkte aus dem Tutorial:

• Vielseitige Anwendungen. Lineare Regression liefert wertvolle Einblicke in vielen Branchen und Problemfeldern.
• Gut interpretierbar. Anders als komplexe Black-Box-Modelle bietet sie klare, koeffizientenbasierte Erklärungen und ist leicht vermittelbar.
• Feature-Auswahl. Eine sorgfältige Auswahl der Merkmale und der Umgang mit Multikollinearität sorgen für genaue, stabile und verlässliche Modelle. 

Weitere Informationen zur String-Interpolation in Python findest du in den DataCamp-Ressourcen.

• Einfache lineare Regression: Alles, was du wissen musst - Tutorial
• Lineare Regression in R - Tutorial
• Lineare Regression in Excel: Der umfassende Guide für Einsteiger - Tutorial
• Introduction to Regression in R - Kurs
• Supervised Learning with scikit-learn - Kurs
• Scikit-Learn Cheat Sheet: Python Machine Learning - Cheat Sheet
• Understanding Logistic Regression in Python - Tutorial