Data Analy)cs (Master Wirtscha3swissenscha3en LUH -> Chapter 5 – „Vorhersage am Beispiel der

linearen Regression“)
Quelle für das gesamte Dokument sind Vorlesung und Übung der Veranstaltung „Data Analy:cs“ im SoSe 26
Ins:tut für Arbeitsökonomik
(Python-Codes wurden durch den Verfasser via Erklärungen von ChatGPT erläutert)

Step 6 „Auswahl der Techniken (z.B. Regression, Logit)“ und Step 7 „Itera)ve Implemen)erung und
„Tuning““ im Data Mining Prozess

Lineare Regression (Erweiterung)

- Zielt darauf ab, eine lineare Beziehung zwischen einer abhängigen und einer (oder mehrerer)
unabhängigen Variablen zu beschreiben
- Annahme: In einer PopulaJon besteht eine lineare Beziehung zwischen den Variablen y und x

Beziehung zw. Autopreisen und Motorleistung (klassische stat. Analyse wie in Teil II)

mod = [Link](toyota_df["PRICE"], mod1_X)

→ definiert ein lineares Regressionsmodell (OLS = Ordinary Least Squares)
[Link](...)
→ erstellt ein lineares Modell zur Erklärung einer Zielvariable durch Prädiktoren
toyota_df["PRICE"]
→ abhängige Variable (Zielvariable) = Fahrzeugpreis
mod1_X
→ unabhängige Variablen (Prädiktoren / Designmatrix)
→ Ziel: Preis durch Einflussfaktoren erklären
res = mod.fit()
→ schätzt das Regressionsmodell
→ berechnet die op:malen Koeffizienten (Least Squares Lösung)
print([Link]())
→ gibt detaillierte Modellzusammenfassung aus
→ enthält u. a.:
Regressionskoeffizienten
Signifikanz (p-Werte)
Gütemaße (R², adj. R²)
Standardfehler

1
Kernidee:
→ OLS modelliert lineare Beziehung zwischen Preis und Einflussvariablen
→ fit() schätzt das Modell
→ summary() liefert vollständige sta:s:sche Auswertung

StaJsJsche Signifikanz
(Klassiche stat. Analyse wie in Teil II)

- Ist es möglich, dass in Wirklichkeit gar kein Zshg. Zwischen den Variablen Price und HP be-
steht (-> also b = 0), allerdings zufällig eine SJchprobe gezogen wurde, in der Price und HP po-
siJv miteinander korreliert sind?
- Pr(>ItI), genannt p-Wert, bezeichnet die W`keit, dass b >= 76,26 oder b <= -76,26 unter der
Hypothese beobachtet wird, dass der wahre Wert von b Null ist
- Im Falle von b (und auch a) ist diese W`keit extrem klein -> man kann sicher sein, dass der
wahre (aber unbeobachtete) Wert b von Null abweicht

Gleicher Code wie auf Seite 1

2
InterpretaJon der Koeffizienten-Schätzer b

Mul)ples Regressionsmodell

Variablen

Datenübersicht

mod2_X
→ enthält die unabhängigen Variablen (Prädiktoren) für ein mul:ples Regressionsmodell
→ entspricht der sogenannten Designmatrix (jede Spalte ist ein separater Regressor im Modell)

3
Klassische sta:s:sche Analyse (wie in Teil II)

toyota_df[[ "Age_08_04", "Fuel_Type", "Met_Color", "AutomaNc", "CC", "Doors", "Quarterly Tax", "Weight" ]]
→ Auswahl der unabhängigen Variablen (Prädiktoren) aus dem DataFrame
→ diese Variablen erklären später den Preis
→ bildet die Basis für das Regressionsmodell (X-Matrix)
pd.get_dummies(mod2_x, drop_first = True)
→ wandelt kategoriale Variablen in Dummy-Variablen um
get_dummies(...)
→ z. B. Fuel_Type wird in mehrere 0/1-Spalten zerlegt
drop_first = True
→ enkernt eine Kategorie als Referenzklasse
→ verhindert Mul:kollinearität (Dummy-Falle)
sm.add_constant(mod2_x)
→ fügt eine Konstante (Intercept) zum Modell hinzu
→ notwendig, damit das Modell einen Achsenabschnil schätzen kann
[Link](toyota_df["Price"], mod2_X) (korrekt ergänzt)
→ definiert ein mul:ples lineares Regressionsmodell
toyota_df["Price"]
→ abhängige Variable (Zielgröße)
mod2_X
→ alle erklärenden Variablen inkl. Dummies + Konstante
res2 = mod2.fit()
→ schätzt das mul:ple lineare Regressionsmodell
→ berechnet die op:malen Koeffizienten (OLS-Schätzung)
→ Modell wird an die Daten angepasst (Training/Finng)
[Link]()
→ gibt die vollständige sta:s:sche Modellzusammenfassung aus
→ enthält u. a.:
Regressionskoeffizienten (Einfluss jeder Variable)
p-Werte (Signifikanz der Variablen)
R² / adj. R² (Erklärungsgehalt des Modells)
Standardfehler und Konfidenzintervalle

4
Zurück zum Data Mining: Daten ParJJonieren und Schätzung

KompleUer Machine Learning Workflow für lineare Regression

x = toyota_df[[ "Age_08_04", "Fuel_Type", "Met_Color", "AutomaNc", "CC", "Doors", "Quarterly Tax", "Weight" ]]
→ Auswahl der unabhängigen Variablen (Features)
→ diese erklären den Preis
y = toyota_df[[ "Price" ]]
→ Zielvariable (abhängige Variable)
→ wird vorhergesagt
pd.get_dummies(x, drop_first = True)
→ Umwandlung kategorialer Variablen in numerische Dummy-Variablen
→ z. B. Fuel_Type wird in 0/1-Spalten zerlegt
→ drop_first = True verhindert redundante Variable (Dummy-Falle)
train_test_split(x, y, test_size = 0.4, random_state = 1)
→ Aupeilung der Daten in Trainings- und Validierungsdaten
test_size = 0.4
→ 40% der Daten sind Test/Validierung
train_x, valid_x, train_y, valid_y
→ getrennte Feature- und Zielvariablen für Training und Test
random_state = 1
→ sorgt für reproduzierbare Zufallsaupeilung
toyota_slm = LinearRegression()
→ erstellt ein lineares Regressionsmodell (scikit-learn)
toyota_slm.fit(train_x, train_y)
→ trainiert das Modell auf den Trainingsdaten
→ schätzt Zusammenhang zwischen Features und Preis
Kernidee (Data Mining Kontext):
→ vollständiger ML-Workflow:
Features + Target definieren
kategoriale Variablen vorbereiten (Dummies)
Daten in Train/Test splilen (Generalisierung!)
Modell instanziieren
Modell auf Trainingsdaten filen

5
print("Performance Measures (Training data)")
→ gibt eine Überschrip für die Modellbewertung auf Trainingsdaten aus
regressionSummary(train_y, toyota_slm.predict(train_x))
→ berechnet zentrale Gütemaße des Regressionsmodells auf Trainingsdaten
train_y
→ tatsächliche Zielwerte (Training)
toyota_slm.predict(train_x)
→ vom Modell vorhergesagte Werte auf Trainingsdaten
→ vergleicht Ist- vs. Prognosewerte
→ liefert z. B. MAE, RMSE, MAPE (je nach dmba-Funk:on)

print("Performance Measures (ValidaNon data)")

→ Überschrip für Bewertung auf Validierungsdaten
regressionSummary(valid_y, toyota_slm.predict(valid_x))
→ gleiche Kennzahlen, aber auf unbekannten Daten
valid_y
→ tatsächliche Werte im Test/Validierungsset
toyota_slm.predict(valid_x)
→ Modellvorhersagen auf Validierungsdaten

Kernidee:
→ Vergleich von Trainings- vs. Validierungsleistung
Training gut, Valida:on schlecht → Overfinng
beide ähnlich → gutes Generalisierungsverhalten
→ genau dieser Vergleich ist zentral im Data-Mining-Kontext

6
Gegenüberstellung von einfachem und mulJplen Regressionsmodell

- Der RSME in den Trainingsdaten sinkt von 3533 auf 1315, wenn von einem Prädiktor (einfa-
ches Modell) zu 10 Prädiktoren (vollständiges Modell) übergegangen wird

Zusammenfassung

- Lineare Regressionsmodelle liefern Schätzungen der Parameter bdurch Minimierung der

Summe der quadrierten Residuen.
- Vorhersagemodelle werden erst an die Trainingsdaten angepasst und ihre
Vorhersagegenauigkeit wird dann anhand eines separaten Validierungsdatensatzes
bewertet.
- Die Enfernung redundanter Prädiktoren ist der Schlüssel zum Erreichen von
Vorhersagegenauigkeit und Robustheit.

7
Übung Chapter 5

import pandas as pd
→ Datenanalyse mit DataFrames (Tabellenstruktur)
import numpy as np
→ numerische Berechnungen mit Arrays und mathema:schen Funk:onen
from sklearn.model_selecNon import train_test_split
→ Funk:on zur Aupeilung in Trainings- und Testdaten
from sklearn.linear_model import LinearRegression
→ lineares Regressionsmodell (Machine Learning Ansatz)
import [Link] as sm
→ sta:s:sche Modellierung (z. B. OLS Regression mit Inferenz)
import matplotlib as mpl / import [Link] as plt
→ Basisbibliothek für Visualisierungen (Plots, Grafiken)
from dmba import regressionSummary
→ Funk:on zur kompakten Auswertung von Regressionsmodellen (MAE, RMSE etc.)
import seaborn as sns
→ sta:s:sche Visualisierung (auf matplotlib autauend, einfacher für Data Analysis Plots)

è Datenimport (wie in den vorherigen Übungen)

8
Toyota_df.Fuel_Type.value_counts()
→ erstellt eine Häufigkeitstabelle für die Variable Fuel_Type
Fuel_Type
→ kategoriale Variable (z. B. Benzin, Diesel, Hybrid)
value_counts()
→ zählt, wie op jede Kategorie vorkommt
→ zeigt die Verteilung der Krapstoffarten im Datensatz

Toyota_df.groupby("Fuel_Type").[Link]()
→ berechnet den durchschnillichen Preis pro Krapstoffart
groupby("Fuel_Type")
→ gruppiert die Daten nach Kategorien der Variable Fuel_Type
[Link]()
→ berechnet den Milelwert der Variable Price innerhalb jeder Gruppe
Kernidee:
→ zeigt, wie sich der durchschnilliche Fahrzeugpreis je Krapstoffart unterscheidet
→ einfache Form der gruppierten Aggrega:on (Gruppenvergleich)

9
[Link](x = "Fuel_Type", y = "Price", data = Toyota_df, whis = 100)
→ erstellt Boxplots des Preises für jede Krapstoffart
x = "Fuel_Type"
→ Gruppierung nach Krapstoffart
y = "Price"
→ numerische Variable (Fahrzeugpreis)
data = Toyota_df
→ Datensatz
whis = 100
→ Whisker reichen bis zu den Minimal- und Maximalwerten
→ prak:sch: keine separaten Ausreißerpunkte, gesamte Spannweite wird gezeigt
Kernidee:
→ Vergleich der Preisverteilungen zwischen Krapstoffarten
→ zeigt Median, Streuung und Extremwerte je Gruppe

10
erstellt einen Swarmplot (Punktdiagramm ohne Überlappung) für Preise nach Krapstoffart
with pd.opNon_context('mode.use_inf_as_na', True):
→ behandelt unendliche Werte (inf) temporär wie fehlende Werte (NaN)
→ verhindert Darstellungsprobleme oder Fehler im Plot
[Link](rc={'figure.figsize':(13,5), "fi[Link]":300})
→ definiert globale Plot-Einstellungen
figure.figsize = (13,5)
→ Breite und Höhe der Grafik in Zoll
fi[Link] = 300
→ hohe Auflösung (geeignet für Präsenta:onen/Export)
sns.set_theme(style="whitegrid")
→ setzt das visuelle Theme
→ „whitegrid“: heller Hintergrund mit Gilernetzlinien zur besseren Ablesbarkeit
[Link](x = "Fuel_Type", y = "Price", data = Toyota_df, size = 4)
→ erstellt den eigentlichen Swarmplot
x = "Fuel_Type"
→ kategoriale Variable (Krapstoffart) auf der x-Achse
y = "Price"
→ numerische Variable (Fahrzeugpreis) auf der y-Achse
data = Toyota_df
→ verwendeter Datensatz
size = 4
→ Größe der einzelnen Punkte (Beobachtungen)
→ Swarmplot-Logik: Punkte werden so angeordnet, dass sie sich nicht überlappen
→ zeigt die vollständige Verteilung der Datenpunkte innerhalb jeder Kategorie
Kernidee:
→ detaillierte Visualisierung aller einzelnen Beobachtungen je Krapstoffart
→ im Gegensatz zum Boxplot: keine Aggrega:on, sondern vollständige Datenpunkte sichtbar
→ besonders geeignet zur Erkennung von Clustern, Dichtebereichen und Ausreißern
→ kombiniert Verteilungsübersicht mit maximaler Informa:onsdichte je Datenpunkt

11
erstellt einen Stripplot zur Darstellung einzelner Beobachtungen nach Krapstoffart
with pd.opNon_context('mode.use_inf_as_na', True):
→ behandelt unendliche Werte (inf) temporär als fehlende Werte (NaN)
[Link](rc={'figure.figsize':(10,8), "fi[Link]":300})
→ globale Plot-Parameter
figure.figsize = (10,8)
→ Plotgröße (Breite × Höhe)
fi[Link] = 300
→ hohe Auflösung für bessere Darstellung/Export
sns.set_theme(style="whitegrid")
→ visueller S:l mit hellem Hintergrund und Gilernetz
[Link](x = "Fuel_Type", y = "Price", data = Toyota_df)
→ erstellt Punktdiagramm ohne Aggrega:on
x = "Fuel_Type"
→ kategoriale Gruppierungsvariable (z. B. Benzin, Diesel etc.)
y = "Price"
→ numerische Variable (Fahrzeugpreis)
data = Toyota_df
→ verwendeter Datensatz
→ Funk:onsweise Stripplot:
→ alle einzelnen Beobachtungen werden als Punkte dargestellt
→ Standardmäßig leichtes „Jilering“ (zufällige horizontale Verschiebung)
→ reduziert Überlappungen, aber nicht vollständig eliminiert
Kernidee:
→ Visualisierung der vollständigen Datenverteilung je Kategorie
→ zeigt Streuung, Dichte und mögliche Ausreißer auf Einzelwert-Ebene
→ weniger „geordnet“ als Swarmplot, dafür schneller und bei großen Datenmengen robuster
→ gute Alterna:ve zum Boxplot, wenn Detailverteilung wich:g ist

12
Vorbereitung der Regressions-Designmatrix (Feature Engineering für kategoriale Variable)
modg_x = Toyota_df[['Fuel_Type']]
→ Auswahl der unabhängigen Variable (nur Fuel_Type) als DataFrame
pd.get_dummies(modg_x, drop_first = True)
→ One-Hot-Encoding der kategorialen Variable
→ wandelt Kategorien in binäre Dummy-Variablen um (0/1)
drop_first = True
→ enkernt eine Dummy-Variable zur Vermeidung der Dummy-Falle (Mul:kollinearität)
→ eine Kategorie dient als Referenzgruppe
sm.add_constant(modg_x)
→ fügt Intercept (Achsenabschnil) zur Regressionsmatrix hinzu
→ notwendig für OLS-Schätzung mit konstantem Term
astype(float)
→ stellt sicher, dass alle Werte numerisch sind
→ erforderlich für sta:s:sche Modellierung (keine Objekt-/Stringtypen erlaubt)
Kernidee:
→ Umwandlung einer kategorialen Variable in ein regressionsfähiges numerisches Format
→ Defini:on eines linearen Modells mit Referenzkategorie

Schätzung eines linearen Regressionsmodells und Ausgabe der Ergebnisse

[Link](Toyota_df['Price'], modg_x)
→ Defini:on eines Ordinary Least Squares (OLS) Modells
→ abhängige Variable: Price
→ unabhängige Variablen: Dummy-kodierte Fuel_Type + Konstante
modg.fit()
→ Modellschätzung (Parameter werden milels kleinster Quadrate bes:mmt)
[Link]()
→ ausführliche Modellzusammenfassung
→ enthält typischerweise:
→ Regressionskoeffizienten (Effekte der Fuel-Typen rela:v zur Referenz)
→ Standardfehler
→ t-Tests und p-Werte (Signifikanz der Variablen)
→ R² und adj. R² (Modellgüte)
→ F-Test (Gesamtmodellsignifikanz)
Kernidee:
→ Untersuchung des Einflusses der Krapstoffart auf den Preis milels linearer Regression
→ Interpreta:on der Dummy-Koeffizienten als Preisunterschiede zur Referenzkategorie
→ sta:s:sche Bewertung, ob Fuel_Type signifikant zur Preisvaria:on beiträgt

13
Defini:on von Features (X) und Zielvariable (y) für ein Regressionsmodell
x = Toyota_df[['Fuel_Type', 'HP']]
→ unabhängige Variablen (Features)
→ Fuel_Type = kategoriale Variable (später zu Dummies)
→ HP = numerische Variable (z. B. Motorleistung)
y = Toyota_df[['Price']]
→ Zielvariable (abhängige Variable)
→ Fahrzeugpreis

Umwandlung kategorialer Variablen in numerische Dummy-Variablen

pd.get_dummies(x)
→ One-Hot-Encoding für Fuel_Type
→ erzeugt binäre Spalten (0/1) für jede Kategorie
drop_first = True
→ enkernt eine Referenzkategorie
→ verhindert Mul:kollinearität (Dummy-Falle)
Kernidee:
→ Fuel_Type wird regressionsfähig gemacht

Aupeilung des Datensatzes in Trainings- und Validierungsdaten

train_test_split(...)
→ zufällige Trennung der Daten
test_size = 0.4
→ 40% Validierungs-/Testdaten
→ 60% Trainingsdaten
train_x / train_y
→ Daten zum Trainieren des Modells
valid_x / valid_y
→ Daten zur Modellbewertung (Generalisa:on)
Kernidee:
→ Vermeidung von Overfinng durch getrennte Datenbasis

Training eines linearen Regressionsmodells

LinearRegression()
→ Instanziierung eines linearen Modells (scikit-learn)
fit(train_x, train_y)
→ Schätzung der Regressionsparameter auf Trainingsdaten
→ lernt Zusammenhang zwischen Features (HP, Fuel_Type-Dummies) und Preis
Kernidee:
→ Autau eines prädik:ven Modells zur Preisvorhersage
→ Kombina:on aus numerischen und kategorischen Einflussgrößen
→ Grundlage für spätere Vorhersagen und Modellbewertung

14
Ausgabe der Modellgüte auf den Trainingsdaten
print('Performance Measures (Training data)')
→ Überschrip zur Strukturierung der Ausgabe
regressionSummary(train_y, toyota_ml.predict(train_x))
→ vergleicht tatsächliche Preise mit Modellvorhersagen auf Trainingsdaten
train_y
→ echte Zielwerte (Preise)
toyota_ml.predict(train_x)
→ vorhergesagte Preise des Modells
→ liefert typische Fehlermaße (z. B. MAE, RMSE, MAPE)
Kernidee:
→ schnelle Bewertung, wie gut das Modell die Trainingsdaten erklärt
→ Grundlage für Overfinng-Check im Vergleich zu Validierungsdaten

Ausgabe der Modellgüte auf Validierungsdaten

print('Performance Measures (ValidaNon data)')
→ Überschrip zur Einordnung der Ergebnisse
regressionSummary(valid_y, toyota_ml.predict(valid_x))
→ vergleicht tatsächliche mit vorhergesagten Preisen auf dem Validierungsset
valid_y
→ echte Zielwerte im Validierungsdatensatz
toyota_ml.predict(valid_x)
→ Modellvorhersagen für unbekannte (nicht trainierte) Daten
→ liefert typische Fehlermaße (z. B. MAE, RMSE, MAPE)
Kernidee:
→ Bewertung der Generalisierungsfähigkeit des Modells
→ zeigt, wie gut das Modell auf unbekannten Daten funk:oniert
→ zentral zur Erkennung von Overfinng/Underfinng

15
Defini:on der Modellvariablen
x = Toyota_df[['HP']]
→ unabhängige Variable (Feature)
→ HP = Motorleistung als einzige erklärende Variable
y = Toyota_df[['Price']]
→ abhängige Variable (Zielgröße)
→ Fahrzeugpreis
Kernidee:
→ einfaches lineares Modell nur mit einem Prädiktor

Aupeilung in Trainings- und Validierungsdaten

train_test_split(...)
→ zufällige Trennung des Datensatzes
test_size = 0.4
→ 40% Validierungsdaten, 60% Trainingsdaten
train_x / train_y
→ Daten zum Modelltraining
valid_x / valid_y
→ Daten zur Modellbewertung
Kernidee:
→ saubere Trennung von Training und Test zur Überprüfung der Modellgeneralisa:on

16
Ausgabe der Modellgüte auf Trainingsdaten
print("Performance Measures (Training data)")
→ Überschrip zur Strukturierung der Ergebnisanzeige
regressionSummary(train_y, toyota_sml.predict(train_x))
→ Vergleich von tatsächlichen und vorhergesagten Werten im Trainingsset
train_y
→ echte Zielwerte (Preise)
toyota_sml.predict(train_x)
→ Modellvorhersagen auf Basis der Trainingsdaten
→ liefert typische Fehlermaße (z. B. MAE, RMSE, MAPE)
Kernidee:
→ Bewertung der Anpassungsgüte des Modells auf Trainingsdaten
→ Basis für Vergleich mit Validierungs-/Testperformance (Overfinng-Check)

Ausgabe der Modellgüte auf Validierungsdaten

print('Perfromance Measures (ValidiaNon data)')
→ Überschrip zur Ergebnisstruktur (Hinweis: Tippfehler im String)
regressionSummary(valid_y, toyota_sml.predict(valid_x))
→ Vergleich von echten und prognos:zierten Preisen auf Validierungsdaten
valid_y
→ tatsächliche Zielwerte im Validierungsset
toyota_sml.predict(valid_x)
→ Modellvorhersagen für unbekannte Daten
→ typische Kennzahlen: MAE, RMSE, MAPE
Kernidee:
→ Prüfung der Generalisierungsfähigkeit des Modells
→ zentraler Vergleich zur Trainingsperformance zur Erkennung von Overfinng

17