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:

$$e_i=y_i-{\hat{y}}_i$$

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 ($H$) gegeben:

$$h_i=H_{ii}$$

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:

$$D_i=\frac{{\sum }_{j=1}^n({\hat{y}}_j-{\hat{y}}_{j(-i)}{)}^2}{p\cdot MSE}$$

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.

$$Y^{\prime }=\log (Y)$$

• Quadratische Transformation: Verwendet, um nichtlineare Beziehungen zu modellieren.

$$Y^{\prime }=Y^2$$

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

1. Residualanalyse: Überprüfung der Residuen, um die Eignung des Modells zu bewerten und Probleme wie Ausreißer und Heteroskedastizität zu identifizieren.
2. Prüfung der Modellannahmen: Sicherstellung, dass die Annahmen der Homoskedastizität und Normalität der Residuen erfüllt sind.
3. Einflussdiagnostik: Identifikation einflussreicher Datenpunkte durch Leverage und Cook’s Distance.
4. 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.

---

---