30 · Neuronale Netze und Deep Learning

SEED = 42
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.neural_network import MLPClassifier

labs   = pd.read_csv("https://schradern.github.io/data-science-coach/data/labor.csv")

NUMERIC = ["alter", "sofa_score", "crp_mg_l", "bmi",
           "leukozyten_g_l", "kreatinin_mg_dl", "laktat_mmol_l"]
CATEGORICAL = ["aufnahmegrund", "raucherstatus"]
BINARY = ["diabetes", "hypertonie"]
TARGET = "verstorben_30d"

df = pd.read_csv("https://schradern.github.io/data-science-coach/data/kohorte.csv").merge(labs, on="patient_id", how="left")
X = df[NUMERIC + CATEGORICAL + BINARY]
y = df[TARGET]

pre = ColumnTransformer([
    ("num", Pipeline([("imp", SimpleImputer(strategy="median")),
                      ("scl", StandardScaler())]), NUMERIC),
    ("cat", OneHotEncoder(handle_unknown="ignore"), CATEGORICAL),
    ("bin", "passthrough", BINARY),
])

mlp_pipe = Pipeline([
    ("pre", pre),
    ("mlp", MLPClassifier(
        hidden_layer_sizes=(64, 32),
        activation="relu",
        alpha=0.01,
        early_stopping=True,
        validation_fraction=0.15,
        max_iter=300,
        random_state=SEED,
    )),
])

library(tidyverse); library(tidymodels)
suppressPackageStartupMessages(library(nnet))

labs   <- read_csv("https://schradern.github.io/data-science-coach/data/labor.csv", show_col_types = FALSE)
df <- read_csv("https://schradern.github.io/data-science-coach/data/kohorte.csv", show_col_types = FALSE) |> left_join(labs, by = "patient_id") |>
  mutate(verstorben_30d = factor(verstorben_30d, levels = c(1, 0)))

split <- initial_split(df, prop = 0.75, strata = verstorben_30d)
train <- training(split)

rec <- recipe(verstorben_30d ~ alter + sofa_score + crp_mg_l + bmi +
                leukozyten_g_l + kreatinin_mg_dl + laktat_mmol_l +
                aufnahmegrund + raucherstatus + diabetes + hypertonie,
              data = train) |>
  step_impute_median(all_numeric_predictors()) |>
  step_dummy(all_nominal_predictors()) |>
  step_normalize(all_numeric_predictors())

spec_nnet <- mlp(hidden_units = 64, penalty = 0.01, epochs = 200) |>
  set_engine("nnet") |> set_mode("classification")

wf <- workflow() |> add_recipe(rec) |> add_model(spec_nnet)
fit <- fit(wf, data = train)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, stratify=y, random_state=SEED)

mlp_pipe.fit(X_train, y_train)
mlp = mlp_pipe.named_steps["mlp"]

print(f"Best validation score (accuracy): {mlp.best_validation_score_:.3f} "
      f"after {mlp.n_iter_} epochs")
loss_curve = mlp.loss_curve_
val_curve   = mlp.validation_scores_

# nnet gibt keine Epochenhistorie; brulee (torch-Backend) würde:
# history <- fit$fit$fit$training_history

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import StratifiedKFold, cross_val_score
from scipy import stats
import numpy as np

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)

def make_lr():
    return Pipeline([("pre", pre),
                     ("clf", LogisticRegression(max_iter=1000,
                                                class_weight="balanced",
                                                random_state=SEED))])

def make_gb():
    return Pipeline([("pre", pre),
                     ("clf", GradientBoostingClassifier(n_estimators=200,
                                                        max_depth=3,
                                                        random_state=SEED))])

def summarise_folds(scores):
    k, mean, sd = len(scores), scores.mean(), scores.std(ddof=1)
    half_width = stats.t.ppf(0.975, df=k - 1) * sd / np.sqrt(k)
    return mean, sd, mean - half_width, mean + half_width

fold_scores = {
    "Logistische Regression": cross_val_score(make_lr(), X, y, cv=cv, scoring="roc_auc"),
    "Gradient Boosting":      cross_val_score(make_gb(), X, y, cv=cv, scoring="roc_auc"),
    "MLP":                    cross_val_score(mlp_pipe,  X, y, cv=cv, scoring="roc_auc"),
}
for name, scores in fold_scores.items():
    mean, sd, lo, hi = summarise_folds(scores)
    print(f"  {name:<28} Mean={mean:.3f} SD={sd:.3f} 95%-CI=[{lo:.3f}, {hi:.3f}]")

# Paired per-fold difference — the right comparison, since every model was
# evaluated on the exact same 5 folds.
diff_lr_gb = fold_scores["Logistische Regression"] - fold_scores["Gradient Boosting"]
mean, sd, lo, hi = summarise_folds(diff_lr_gb)
print(f"  LR - GB  Mean diff={mean:+.3f}  95%-CI=[{lo:+.3f}, {hi:+.3f}]")

library(yardstick)
folds <- vfold_cv(df, v = 5, strata = verstorben_30d)

spec_lr <- logistic_reg(penalty = 0.01, mixture = 0) |>
  set_engine("glmnet") |> set_mode("classification")
auc_lr <- workflow() |> add_recipe(rec) |> add_model(spec_lr) |>
  fit_resamples(folds, metrics = metric_set(roc_auc)) |>
  collect_metrics() |> filter(.metric == "roc_auc") |> pull(mean)
cat("Logistische Regression AUC:", round(auc_lr, 3), "\n")

for alpha in [0.0001, 0.001, 0.01, 0.1, 1.0]:
    pipe = Pipeline([("pre", pre),
                     ("mlp", MLPClassifier(hidden_layer_sizes=(64, 32),
                                           alpha=alpha,
                                           max_iter=300,
                                           random_state=SEED))])
    auc = cross_val_score(pipe, X, y, cv=cv, scoring="roc_auc").mean()
    print(f"  alpha={alpha:.4f}  AUC={auc:.3f}")

# ILLUSTRATIV — NICHT AUSFÜHREN (torch ist auf diesem System nicht installiert)

# import torch
# import torch.nn as nn
#
# class SimpleCNN(nn.Module):
#     def __init__(self):
#         super().__init__()
#         self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
#         self.pool = nn.MaxPool2d(2, 2)
#         self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
#         self.fc = nn.Linear(64 * 56 * 56, 2)  # 224x224 input image
#
#     def forward(self, x):
#         x = self.pool(torch.relu(self.conv1(x)))
#         x = self.pool(torch.relu(self.conv2(x)))
#         x = x.flatten(1)
#         return self.fc(x)
#
# # Transfer Learning: fine-tune pretrained weights on medical images
# # torchvision.models.resnet50(weights="IMAGENET1K_V1")