98 lines
3.4 KiB
Python
98 lines
3.4 KiB
Python
"""Workshop 4: kNN Hyperparametersuche auf bank_data_prep.csv.
|
|
|
|
Standardisiert die Features, sucht die besten Werte für n_neighbors und p
|
|
(Minkowski-Distanz), und vergleicht die Accuracy mit vs. ohne Standardisieren.
|
|
"""
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
from sklearn.metrics import confusion_matrix, classification_report
|
|
from sklearn.model_selection import GridSearchCV
|
|
from sklearn.model_selection import train_test_split
|
|
from sklearn.neighbors import KNeighborsClassifier
|
|
from sklearn.preprocessing import StandardScaler
|
|
|
|
RAW = "data/bank_data_prep.csv"
|
|
SEED = 1234
|
|
|
|
|
|
def load_split(path: str = RAW):
|
|
"""Schritt 1-3 der Folien: laden, X/y-Split, train/test-Split."""
|
|
df = pd.read_csv(path)
|
|
|
|
X = df.drop("y", axis=1)
|
|
y = df["y"]
|
|
|
|
X_train, X_test, y_train, y_test = train_test_split(
|
|
X, y, train_size=2 / 3, random_state=SEED
|
|
)
|
|
|
|
return X_train, X_test, y_train, y_test
|
|
|
|
|
|
def scale(X_train, X_test):
|
|
"""Standardisieren: Scaler nur auf Train fitten, auf beide anwenden."""
|
|
scaler = StandardScaler().set_output(transform="pandas")
|
|
scaler.fit(X_train)
|
|
return scaler.transform(X_train), scaler.transform(X_test)
|
|
|
|
|
|
def search_manual(X_train, X_test, y_train, y_test):
|
|
"""Folien-Methode: Grid ueber n_neighbors x p, Score auf Test."""
|
|
results = []
|
|
for k in range(1, 11):
|
|
for p in (1, 2, 3):
|
|
model = KNeighborsClassifier(n_neighbors=k, p=p)
|
|
model.fit(X_train, y_train)
|
|
acc = model.score(X_test, y_test)
|
|
results.append((k, p, acc))
|
|
best = max(results, key=lambda r: r[2])
|
|
print(f"Bestes Ergebnis: k={best[0]}, p={best[1]}, acc={best[2]:.4f}")
|
|
return results, best
|
|
|
|
|
|
def search_grid(X_train, y_train):
|
|
"""Hyperparametersuche per GridSearchCV (CV auf Train, kein Test-Leakage)."""
|
|
param_grid = {
|
|
"n_neighbors": range(1, 11),
|
|
"p": (1, 2, 3),
|
|
}
|
|
grid = GridSearchCV(
|
|
KNeighborsClassifier(),
|
|
param_grid,
|
|
cv=5, # 5-fache Cross-Validation
|
|
scoring="accuracy",
|
|
)
|
|
grid.fit(X_train, y_train) # NUR Train — Test wird nicht angefasst
|
|
print(f"Beste Params: {grid.best_params_}, CV-Score: {grid.best_score_:.4f}")
|
|
return grid
|
|
|
|
|
|
if __name__ == "__main__":
|
|
X_train, X_test, y_train, y_test = load_split()
|
|
|
|
# --- Variante A: OHNE Standardisieren ---
|
|
print("=== Ohne Standardisieren ===")
|
|
results_raw, best_raw = search_manual(X_train, X_test, y_train, y_test)
|
|
|
|
# --- Variante B: MIT Standardisieren ---
|
|
print("=== Mit Standardisieren ===")
|
|
X_train_sc, X_test_sc = scale(X_train, X_test) # Features skalieren
|
|
results_sc, best_sc = search_manual(X_train_sc, X_test_sc, y_train, y_test)
|
|
|
|
# --- Variante C: GridScearch
|
|
grid = search_grid(X_train_sc, y_train) # skalierte Train-Daten rein
|
|
final_acc = grid.score(X_test_sc, y_test) # skalierte Test-Daten messen
|
|
k_grid = grid.best_params_['n_neighbors']
|
|
p_grid = grid.best_params_['p']
|
|
cv_grid = grid.best_score_
|
|
|
|
# --- Vergleich ---
|
|
print(f"\nOhne Skalierung: k={best_raw[0]}, p={best_raw[1]}, acc={best_raw[2]:.4f}")
|
|
print(f"Mit Skalierung: k={best_sc[0]}, p={best_sc[1]}, acc={best_sc[2]:.4f}")
|
|
print(f"Mit GridSearch: k={k_grid}, p={p_grid}, CV-acc={cv_grid:.4f}, test-acc={final_acc:.4f}")
|
|
|
|
y_pred = grid.predict(X_test_sc) # weiterhin skaliert
|
|
print(confusion_matrix(y_test, y_pred))
|
|
print(classification_report(y_test, y_pred))
|