Woche 11-12: Modelldiagnose
Ziel
Diagnose und Verbesserung von Regressionsmodellen zur Sicherstellung ihrer Validität und Robustheit.
Inhalte
Residualanalyse und Identifikation von Ausreißern
Residuen und ihre Bedeutung
Die Residuen sind die Differenzen zwischen den beobachteten Werten und den durch das Modell vorhergesagten Werten:
Die Analyse der Residuen hilft dabei, die Eignung des Modells zu überprüfen und Probleme wie Ausreißer, Heteroskedastizität und Nichtlinearität zu identifizieren.
Identifikation von Ausreißern
Ausreißer sind Beobachtungen, die signifikant von den anderen Datenpunkten abweichen und das Modell stark beeinflussen können. Sie können durch Residualplots, Boxplots oder spezielle statistische Tests identifiziert werden.
Beispiel in R:
# Residuen berechnen
residuals <- resid(model)
# Residualplot erstellen
plot(fitted(model), residuals)
abline(h = 0, col = "red")
# Boxplot der Residuen
boxplot(residuals)Beispiel in Python:
import matplotlib.pyplot as plt
# Residuen berechnen
residuals = model.resid
# Residualplot erstellen
plt.scatter(model.fittedvalues, residuals)
plt.axhline(0, color='red')
plt.xlabel('Fitted values')
plt.ylabel('Residuals')
plt.show()
# Boxplot der Residuen
plt.boxplot(residuals)
plt.show()Prüfung der Modellannahmen
Homoskedastizität
Homoskedastizität bedeutet, dass die Varianz der Residuen konstant ist. Dies ist eine wichtige Annahme für die Validität der Standardfehler und der Hypothesentests in der Regression.
Test auf Homoskedastizität:
- Visuelle Inspektion der Residualplots
- Breusch-Pagan-Test
- White-Test
Beispiel in R:
# Breusch-Pagan-Test durchführen
library(lmtest)
bptest(model)Beispiel in Python:
from statsmodels.stats.diagnostic import het_breuschpagan
# Breusch-Pagan-Test durchführen
bp_test = het_breuschpagan(residuals, model.model.exog)
print('Breusch-Pagan-Test: ', bp_test)Normalität der Residuen
Die Residuen sollten normalverteilt sein, um die Validität der Konfidenzintervalle und Hypothesentests zu gewährleisten.
Test auf Normalität:
- Visuelle Inspektion durch QQ-Plots
- Shapiro-Wilk-Test
- Kolmogorov-Smirnov-Test
Beispiel in R:
# QQ-Plot der Residuen
qqnorm(residuals)
qqline(residuals, col = "red")
# Shapiro-Wilk-Test
shapiro.test(residuals)Beispiel in Python:
import scipy.stats as stats
# QQ-Plot der Residuen
stats.probplot(residuals, dist="norm", plot=plt)
plt.show()
# Shapiro-Wilk-Test
shapiro_test = stats.shapiro(residuals)
print('Shapiro-Wilk-Test: ', shapiro_test)Einflussdiagnostik
Leverage
Leverage misst den Einfluss eines Datenpunkts auf die Anpassung des Modells. Datenpunkte mit hohem Leverage haben eine große Auswirkung auf die Regressionsgerade.
Berechnung von Leverage:
- Leverage-Werte werden in der Regel durch die Diagonale der Hat-Matrix () gegeben:
Beispiel in R:
# Leverage-Werte berechnen
leverage <- hatvalues(model)
# Plot der Leverage-Werte
plot(leverage)
abline(h = 2*mean(leverage), col = "red")Beispiel in Python:
import statsmodels.api as sm
# Leverage-Werte berechnen
leverage = model.get_influence().hat_matrix_diag
# Plot der Leverage-Werte
plt.stem(leverage)
plt.axhline(2*np.mean(leverage), color='red')
plt.show()Cook’s Distance
Cook’s Distance misst den Gesamteinfluss eines Datenpunkts auf die Schätzwerte der Regressionskoeffizienten. Ein hoher Wert von Cook’s Distance deutet auf einen einflussreichen Datenpunkt hin.
Berechnung von Cook’s Distance:
Beispiel in R:
# Cook's Distance berechnen
cooksd <- cooks.distance(model)
# Plot von Cook's Distance
plot(cooksd)
abline(h = 4/length(cooksd), col = "red")Beispiel in Python:
# Cook's Distance berechnen
cooks_d = model.get_influence().cooks_distance[0]
# Plot von Cook's Distance
plt.stem(cooks_d)
plt.axhline(4/len(cooks_d), color='red')
plt.show()Maßnahmen bei Verletzung der Annahmen
Wenn die Annahmen der Regression verletzt sind, gibt es verschiedene Techniken, um das Modell zu verbessern und die Validität sicherzustellen.
Transformation der Variablen
- Log-Transformation: Verwendet bei heteroskedastischen Daten oder nichtlinearen Beziehungen.
- Quadratische Transformation: Verwendet, um nichtlineare Beziehungen zu modellieren.
Beispiel in R:
# Log-Transformation der abhängigen Variablen
data$log_Y <- log(data$Y)
# Modell mit transformierter abhängiger Variable
model_log <- lm(log_Y ~ X1 + X2, data = data)
summary(model_log)Beispiel in Python:
# Log-Transformation der abhängigen Variablen
data['log_Y'] = np.log(data['Y'])
# Modell mit transformierter abhängiger Variable
X_log = data[['X1', 'X2']]
X_log = sm.add_constant(X_log)
model_log = sm.OLS(data['log_Y'], X_log).fit()
print(model_log.summary())Robustheitsmethoden
- Robuste Standardfehler: Korrigieren die Standardfehler bei Verletzung der Homoskedastizitätsannahme.
Beispiel in R:
library(sandwich)
library(lmtest)
# Modell mit robusten Standardfehlern
robust_se <- coeftest(model, vcov = vcovHC(model, type = "HC1"))
print(robust_se)Beispiel in Python:
# Modell mit robusten Standardfehlern
robust_se = model.get_robustcov_results(cov_type='HC1')
print(robust_se.summary())Übungen
Durchführung umfassender Modelldiagnosen
Beispiel in R
# Daten laden
data <- read.csv("data.csv")
# Lineares Regressionsmodell erstellen
model <- lm(Y ~ X1 + X2, data = data)
# Residualanalyse
residuals <- resid(model)
plot(fitted(model), residuals)
abline(h = 0, col = "red")
boxplot(residuals)
qqnorm(residuals)
qqline(residuals, col = "red")
shapiro.test(residuals)
# Leverage-Werte
leverage <- hatvalues(model)
plot(leverage)
abline(h = 2*mean(leverage), col = "red")
# Cook's Distance
cooksd <- cooks.distance(model)
plot(cooksd)
abline(h = 4/length(cooksd), col = "red")
# Breusch-Pagan-Test
library(lmtest)
bptest(model)
# Robuste Standardfehler
library(sandwich)
library(lmtest)
robust_se <- coeftest(model, vcov = vcovHC(model, type = "HC1"))
print(robust_se)Beispiel in Python
import pandas as pd
import statsmodels.api as sm
import matplotlib.pyplot as plt
import numpy as np
import scipy.stats as stats
from statsmodels.stats.diagnostic import het_breuschpagan
# Daten laden
data = pd.read_csv("data.csv")
# Lineares Regressionsmodell erstellen
X = data[['X1', 'X2']]
X = sm.add_constant(X)
model = sm.OLS(data['Y'], X).fit()
# Residualanalyse
residuals = model.resid
plt.scatter(model.fittedvalues, residuals)
plt.axhline(0, color='red')
plt.xlabel('Fitted values')
plt.ylabel('Residuals')
plt.show()
plt.boxplot(residuals)
plt.show()
stats.probplot(residuals, dist="norm", plot=plt)
plt.show()
shapiro_test = stats.shapiro(residuals)
print('Shapiro-Wilk-Test: ', sh
apiro_test)
# Leverage-Werte
leverage = model.get_influence().hat_matrix_diag
plt.stem(leverage)
plt.axhline(2*np.mean(leverage), color='red')
plt.show()
# Cook's Distance
cooks_d = model.get_influence().cooks_distance[0]
plt.stem(cooks_d)
plt.axhline(4/len(cooks_d), color='red')
plt.show()
# Breusch-Pagan-Test
bp_test = het_breuschpagan(residuals, model.model.exog)
print('Breusch-Pagan-Test: ', bp_test)
# Robuste Standardfehler
robust_se = model.get_robustcov_results(cov_type='HC1')
print(robust_se.summary())Anwendung von Transformationsmethoden zur Verbesserung des Modells
Beispiel in R
# Log-Transformation der abhängigen Variablen
data$log_Y <- log(data$Y)
# Modell mit transformierter abhängiger Variable
model_log <- lm(log_Y ~ X1 + X2, data = data)
summary(model_log)
# Residualanalyse des transformierten Modells
residuals_log <- resid(model_log)
plot(fitted(model_log), residuals_log)
abline(h = 0, col = "red")
boxplot(residuals_log)
qqnorm(residuals_log)
qqline(residuals_log, col = "red")
shapiro.test(residuals_log)Beispiel in Python
# Log-Transformation der abhängigen Variablen
data['log_Y'] = np.log(data['Y'])
# Modell mit transformierter abhängiger Variable
X_log = data[['X1', 'X2']]
X_log = sm.add_constant(X_log)
model_log = sm.OLS(data['log_Y'], X_log).fit()
print(model_log.summary())
# Residualanalyse des transformierten Modells
residuals_log = model_log.resid
plt.scatter(model_log.fittedvalues, residuals_log)
plt.axhline(0, color='red')
plt.xlabel('Fitted values')
plt.ylabel('Residuals')
plt.show()
plt.boxplot(residuals_log)
plt.show()
stats.probplot(residuals_log, dist="norm", plot=plt)
plt.show()
shapiro_test_log = stats.shapiro(residuals_log)
print('Shapiro-Wilk-Test: ', shapiro_test_log)Zusammenfassung
Wichtige Konzepte
- Residualanalyse: Überprüfung der Residuen, um die Eignung des Modells zu bewerten und Probleme wie Ausreißer und Heteroskedastizität zu identifizieren.
- Prüfung der Modellannahmen: Sicherstellung, dass die Annahmen der Homoskedastizität und Normalität der Residuen erfüllt sind.
- Einflussdiagnostik: Identifikation einflussreicher Datenpunkte durch Leverage und Cook’s Distance.
- Maßnahmen bei Verletzung der Annahmen: Anwendung von Transformationsmethoden und robusten Standardfehlern, um die Validität des Modells sicherzustellen.
Praktische Anwendungen
- Durchführung umfassender Modelldiagnosen in R und Python.
- Anwendung von Transformationsmethoden zur Verbesserung der Modellanpassung.
- Untersuchung und Interpretation der Ergebnisse, um die Modellvalidität sicherzustellen.
Weiterführende Übungen
- Verwendung von realen Datensätzen zur Anwendung der gelernten Techniken.
- Vergleich der Modellgüte vor und nach der Anwendung von Transformationsmethoden.
- Untersuchung der Auswirkungen verschiedener Einflussdiagnostikmethoden auf das Modell.