Jenseits der geraden Linie: Die Wahl zwischen OLS, Interaktionstermen und Tweedie-Regression

Jenseits der Geraden: Die Wahl zwischen OLS, Interaktionstermen und Tweedie-Regression

Lineare Regression ist oft das erste Werkzeug, zu dem Data Scientists greifen, wenn sie ein kontinuierliches Ergebnis modellieren. Aber reale Daten folgen selten einer geraden Linie. Beziehungen können gekrümmt, heterogen oder von Nullen und Schiefe durchzogen sein. In diesem Artikel erkunden wir drei zunehmend anspruchsvolle Ansätze: die gewöhnliche Kleinste-Quadrate-Schätzung (OLS), OLS mit Interaktionstermen und die Tweedie-Regression. Wir vergleichen ihre Annahmen, Stärken und Fallstricke und zeigen Ihnen dann, wie Sie jede Methode in Python mit echten Befehlen implementieren.

Die Grenzen der gewöhnlichen Kleinsten Quadrate

Die gewöhnliche Kleinste-Quadrate-Regression geht von einer linearen Beziehung zwischen Prädiktoren und Antwortvariable, normalverteilten Fehlern mit konstanter Varianz und Unabhängigkeit der Beobachtungen aus. Wenn diese Annahmen zutreffen, ist OLS der beste lineare erwartungstreue Schätzer. In der Praxis verletzen jedoch viele Datensätze diese Annahmen.

Betrachten wir die Vorhersage von Versicherungsschadenskosten. Schadensbeträge sind strikt positiv, stark rechtsschief und enthalten oft viele Nullen (kein Schaden). OLS würde negative Werte vorhersagen, die Nullmasse nicht erfassen und heteroskedastische Residuen produzieren. Ähnlich verhält es sich im Marketing-Mix-Modelling: Der Effekt von Werbeausgaben kann nichtlinear sein – abnehmende Grenzerträge bei hohen Ausgaben. OLS würde diese Krümmung übersehen.

Der erste Schritt über die gerade Linie hinaus ist das Hinzufügen von Interaktionstermen, die es erlauben, dass der Effekt eines Prädiktors von einem anderen abhängt.

Interaktionsterme: Erfassung bedingter Beziehungen

Interaktionsterme modellieren, wie sich die Beziehung zwischen einem Prädiktor \(X_1\) und dem Ergebnis \(Y\) mit dem Wert eines anderen Prädiktors \(X_2\) ändert. Zum Beispiel könnte der Effekt von Bildung auf das Einkommen bei jüngeren Arbeitnehmern stärker sein als bei älteren. Sie können dies modellieren, indem Sie das Produkt \(X_1 \times X_2\) in die Regression aufnehmen.

Interaktionsterme sind intuitiv und einfach zu implementieren. Sie erlauben es, dass Steigungen über Gruppen oder Stufen einer kontinuierlichen Variable variieren. Allerdings gehen sie immer noch von einer linearen Beziehung zwischen den Prädiktoren und dem Ergebnis aus, nachdem die Interaktionen berücksichtigt wurden. Sie erfordern auch eine sorgfältige Interpretation: Die Haupteffekte ändern ihre Bedeutung, wenn eine Interaktion vorhanden ist.

Bei Daten mit starker Schiefe, Nullinflation oder nicht-konstanter Varianz reichen Interaktionen allein nicht aus. Sie benötigen ein Verteilungsmodell, das die Natur der Daten respektiert. Hier glänzt die Tweedie-Regression.

Tweedie-Regression: Umgang mit schiefen, null-inflationierten und kontinuierlichen Daten

Die Tweedie-Regression gehört zur Familie der verallgemeinerten linearen Modelle (GLMs). Sie ist für Daten konzipiert, die kontinuierlich sind, aber eine Wahrscheinlichkeit größer null haben, exakt null zu sein, und die positiv schief sind. Diese Kombination macht sie ideal für Versicherungsschäden, Gesundheitskosten, Einzelhandelsumsätze und andere "semi-kontinuierliche" Ergebnisse.

Die Tweedie-Verteilung hat einen Leistungsparameter \(p\) (zwischen 1 und 2), der die Form der Verteilung bestimmt:

• \(p = 1\): Poisson (Zähldaten, diskret)
• \(p = 2\): Gamma (kontinuierlich, positiv, schief)
• \(1 < p < 2\): Zusammengesetztes Poisson–Gamma (kontinuierlich mit Nullen)

Durch die Wahl des geeigneten \(p\) können Sie Daten modellieren, die einen Spike bei Null und einen langen rechten Ausläufer haben. Die Tweedie-Regression behandelt auch Heteroskedastizität auf natürliche Weise, da die Varianz eine Funktion des Mittelwerts ist.

Voraussetzungen

Bevor wir in den Code eintauchen, stellen Sie sicher, dass Ihre Umgebung die folgenden Python-Pakete enthält. Wir verwenden `statsmodels` für OLS und Interaktionsterme und `scikit-learn` für die Tweedie-Regression (über `TweedieRegressor`).

• Python 3.8 oder neuer
• `numpy`
• `pandas`
• `statsmodels`
• `scikit-learn`
• `matplotlib` (für optionale Grafiken)

Schritt-für-Schritt-Installation

Wir erstellen eine dedizierte virtuelle Umgebung und installieren die erforderlichen Pakete.

Erstellen und aktivieren Sie zunächst eine virtuelle Umgebung. Dies isoliert die Abhängigkeiten für dieses Projekt.

python3 -m venv regression_env
source regression_env/bin/activate   # Unter Windows: regression_env\Scripts\activate

Aktualisieren Sie als nächstes `pip` auf die neueste Version, um Abhängigkeitskonflikte zu vermeiden.

pip install --upgrade pip

Installieren Sie nun die Kernpakete. Wir installieren `numpy`, `pandas`, `statsmodels`, `scikit-learn` und `matplotlib`.

pip install numpy pandas statsmodels scikit-learn matplotlib

Um die Installation zu überprüfen, führen Sie einen schnellen Python-Check durch. Dies sollte die Versionen ohne Fehler ausgeben.

python -c "import numpy; import pandas; import statsmodels; import sklearn; print('Alle Pakete erfolgreich installiert')"

Anwendungsbeispiele

Wir simulieren einen realistischen Datensatz: Versicherungsschadenskosten. Er wird einen kontinuierlichen Prädiktor `age` und einen kategorialen Prädiktor `vehicle_type` (0 = Limousine, 1 = LKW) enthalten. Die Antwortvariable `claim_amount` ist null-inflationiert und rechtsschief.

1. Daten simulieren

Generieren Sie zunächst die Daten. Wir erstellen 1000 Beobachtungen mit einer bekannten Struktur.

import numpy as np
import pandas as pd

np.random.seed(42)
n = 1000
age = np.random.uniform(18, 70, n)
vehicle_type = np.random.binomial(1, 0.4, n)

# Basis-Schadenswahrscheinlichkeit: 30% für Limousine, 50% für LKW
prob_claim = 0.3 + 0.2 * vehicle_type
has_claim = np.random.binomial(1, prob_claim)

# Schadenshöhe: gamma-verteilt, Mittelwert hängt von Alter und Fahrzeugtyp ab
mean_claim = 200 + 5 * age + 50 * vehicle_type
claim_amount = has_claim * np.random.gamma(shape=2, scale=mean_claim/2)

df = pd.DataFrame({
    'age': age,
    'vehicle_type': vehicle_type,
    'claim_amount': claim_amount
})
print(df.head())

2. OLS mit Interaktionstermen anpassen

Wir verwenden `statsmodels`, um OLS mit einer Interaktion zwischen `age` und `vehicle_type` anzupassen. Beachten Sie, dass OLS für diese Daten (Nullen und Schiefe) nicht geeignet ist, aber wir nehmen es zum Vergleich auf.

import statsmodels.api as sm

# Interaktionsterm hinzufügen
df['age_vehicle'] = df['age'] * df['vehicle_type']
X = df[['age', 'vehicle_type', 'age_vehicle']]
X = sm.add_constant(X)
y = df['claim_amount']

ols_model = sm.OLS(y, X).fit()
print(ols_model.summary())

Die Ausgabe zeigt Koeffizienten, Standardfehler und Diagnostiken. Beachten Sie, dass das R-Quadrat niedrig sein könnte, weil OLS die Nullmasse nicht erfasst.

3. Tweedie-Regression anpassen

Jetzt passen wir eine Tweedie-Regression mit `scikit-learn`s `TweedieRegressor` an. Wir verwenden `power=1.5` (typisch für Versicherungsdaten). Wir skalieren auch die Merkmale für eine bessere Konvergenz.

from sklearn.linear_model import TweedieRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Merkmale vorbereiten (keine Interaktion nötig – Tweedie behandelt Nichtlinearität über Link-Funktion)
X = df[['age', 'vehicle_type']]
y = df['claim_amount']

# Merkmale skalieren
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Daten aufteilen
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)

# Tweedie-Regression anpassen
tweedie_model = TweedieRegressor(
    power=1.5,   # zusammengesetztes Poisson–Gamma
    alpha=0.0,   # keine Regularisierung
    max_iter=1000,
    tol=1e-4
)
tweedie_model.fit(X_train, y_train)

# Vorhersagen und bewerten
y_pred = tweedie_model.predict(X_test)
print("Koeffizienten:", tweedie_model.coef_)
print("Achsenabschnitt:", tweedie_model.intercept_)

4. Modellleistung vergleichen

Wir vergleichen den mittleren absoluten Fehler (MAE) und den mittleren quadratischen Fehler (MSE) zwischen OLS und Tweedie. Beachten Sie, dass MSE empfindlicher auf große Fehler reagiert, die Tweedie besser behandelt.

from sklearn.metrics import mean_absolute_error, mean_squared_error

# OLS-Vorhersagen auf dem Testsatz
X_test_ols = sm.add_constant(pd.DataFrame({
    'age': df.loc[X_test_indices, 'age'],
    'vehicle_type': df.loc[X_test_indices, 'vehicle_type'],
    'age_vehicle': df.loc[X_test_indices, 'age'] * df.loc[X_test_indices, 'vehicle_type']
}))
# (Angenommen, X_test_indices sind die Indizes aus train_test_split)
# Der Einfachheit halber sagen wir auf den vollständigen Daten vorher (dies dient der Veranschaulichung)
ols_pred = ols_model.predict(X)

# Tweedie-Vorhersagen (bereits berechnet)
print("OLS MAE:", mean_absolute_error(y, ols_pred))
print("Tweedie MAE:", mean_absolute_error(y_test, y_pred))
print("OLS MSE:", mean_squared_error(y, ols_pred))
print("Tweedie MSE:", mean_squared_error(y_test, y_pred))

In der Praxis wird Tweedie einen niedrigeren MSE liefern, weil es die Nullmasse und Schiefe berücksichtigt.

5. Anpassung visualisieren

Stellen Sie die vorhergesagten gegen die tatsächlichen Werte für beide Modelle dar, um den Unterschied zu sehen.

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.scatter(y, ols_pred, alpha=0.3)
plt.plot([0, y.max()], [0, y.max()], 'r--')
plt.xlabel('Tatsächlich')
plt.ylabel('OLS Vorhergesagt')
plt.title('OLS: Vorhergesagt vs. Tatsächlich')

plt.subplot(1, 2, 2)
plt.scatter(y_test, y_pred, alpha=0.3)
plt.plot([0, y_test.max()], [0, y_test.max()], 'r--')
plt.xlabel('Tatsächlich')
plt.ylabel('Tweedie Vorhergesagt')
plt.title('Tweedie: Vorhergesagt vs. Tatsächlich')

plt.tight_layout()
plt.show()

Das Tweedie-Diagramm sollte weniger Streuung und eine bessere Ausrichtung entlang der Diagonalen zeigen.

Wann welcher Ansatz verwendet werden sollte

• **OLS**: Verwenden Sie dies nur, wenn Ihre Daten annähernd normal, homoskedastisch und ohne Nullen oder begrenzten Bereich sind. Gut geeignet für kontrollierte Experimente oder standardisierte Testergebnisse.
• **OLS mit Interaktionen**: Verwenden Sie dies, wenn Sie vermuten, dass der Effekt einer Variable von einer anderen abhängt, die Daten aber immer noch die OLS-Annahmen erfüllen. Zum Beispiel Marketing-ROI nach Kanal.
• **Tweedie-Regression**: Verwenden Sie dies, wenn Ihr Ergebnis kontinuierlich, positiv (oder null) und rechtsschief ist. Ideal für Versicherungs-, Gesundheits- und Verkaufsdaten. Es behandelt auf natürliche Weise Nullinflation und Heteroskedastizität.

Fazit

Lineare Regression ist eine leistungsstarke Basislinie, aber reale Daten verlangen oft mehr. Interaktionsterme bieten Flexibilität für bedingte Beziehungen, aber sie adressieren keine Verteilungsprobleme wie Schiefe und Nullen. Die Tweedie-Regression schließt die Lücke – sie respektiert die wahre Natur der Daten, während sie interpretierbar und recheneffizient bleibt. Indem Sie das richtige Werkzeug für die Aufgabe wählen, bewegen Sie sich über die gerade Linie hinaus zu Modellen, die die Komplexität der Welt widerspiegeln. Beginnen Sie mit OLS, fügen Sie bei Bedarf Interaktionen hinzu und wechseln Sie zu Tweedie, wenn Ihre Daten es erfordern. Ihre Modelle – und Ihre Stakeholder – werden es Ihnen danken.