- added earlyFusionTest

- changed to group split

model_training/CNN/CNN_crossVal_EarlyFusion_Test_Eval.ipynb

@@ -0,0 +1,529 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "47f6de7b",
+   "metadata": {},
+   "source": [
+    "Bibliotheken importieren"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99294260",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd \n",
+    "import numpy as np \n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns \n",
+    "import random \n",
+    "import joblib \n",
+    "from pathlib import Path \n",
+    "\n",
+    "from sklearn.model_selection import GroupKFold, GroupShuffleSplit\n",
+    "from sklearn.preprocessing import StandardScaler \n",
+    "from sklearn.metrics import ( \n",
+    "    precision_score, recall_score,\n",
+    "    confusion_matrix, roc_curve, auc, \n",
+    "    precision_recall_curve, f1_score, \n",
+    "    balanced_accuracy_score, accuracy_score\n",
+    ") \n",
+    "\n",
+    "import tensorflow as tf \n",
+    "from tensorflow.keras import Input, layers, models, regularizers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52b4ca8c",
+   "metadata": {},
+   "source": [
+    "Seed festlegen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e49d281",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SEED = 42 \n",
+    "np.random.seed(SEED) \n",
+    "tf.random.set_seed(SEED) \n",
+    "random.seed(SEED)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1a715f",
+   "metadata": {},
+   "source": [
+    "Daten laden"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "870f01c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_path = Path(r\"~/data-paulusjafahrsimulator-gpu/new_datasets/50s_25Hz_dataset.parquet\") \n",
+    "\n",
+    "data = pd.read_parquet(path=data_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bedbc23b",
+   "metadata": {},
+   "source": [
+    "Labels erstellen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "38848515",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "low_all = data[((data[\"PHASE\"] == \"baseline\") | \n",
+    "                ((data[\"STUDY\"] == \"n-back\") & (data[\"PHASE\"] != \"baseline\") & (data[\"LEVEL\"].isin([1,4]))))].copy() \n",
+    "\n",
+    "high_all = pd.concat([ \n",
+    "    data[(data[\"STUDY\"]==\"n-back\") & (data[\"LEVEL\"].isin([2,3,5,6])) & (data[\"PHASE\"].isin([\"train\",\"test\"]))], \n",
+    "    data[(data[\"STUDY\"]==\"k-drive\") & (data[\"PHASE\"]!=\"baseline\")] \n",
+    "]).copy() \n",
+    "\n",
+    "low_all[\"label\"] = 0 \n",
+    "high_all[\"label\"] = 1 \n",
+    "data = pd.concat([low_all, high_all], ignore_index=True).drop_duplicates() "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b282acf",
+   "metadata": {},
+   "source": [
+    "Features und Labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5edb00a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Face AUs\n",
+    "au_columns = [col for col in data.columns if \"face\" in col.lower()] \n",
+    "\n",
+    "#Eye Features\n",
+    "eye_columns = [ \n",
+    "    'Fix_count_short_66_150', \n",
+    "    'Fix_count_medium_300_500', \n",
+    "    'Fix_count_long_gt_1000', \n",
+    "    'Fix_count_100', \n",
+    "    'Fix_mean_duration', \n",
+    "    'Fix_median_duration', \n",
+    "    'Sac_count', \n",
+    "    'Sac_mean_amp', \n",
+    "    'Sac_mean_dur', \n",
+    "    'Sac_median_dur', \n",
+    "    'Blink_count', \n",
+    "    'Blink_mean_dur', \n",
+    "    'Blink_median_dur', \n",
+    "    'Pupil_mean', \n",
+    "    'Pupil_IPA' \n",
+    "]\n",
+    "\n",
+    "#Early Fusion\n",
+    "feature_columns = au_columns + eye_columns\n",
+    "\n",
+    "#NaNs entfernen \n",
+    "data = data.dropna(subset=feature_columns + [\"label\"])\n",
+    "\n",
+    "X = data[feature_columns].values[..., np.newaxis] \n",
+    "y = data[\"label\"].values \n",
+    "\n",
+    "groups = data[\"subjectID\"].values\n",
+    "print(data.columns.tolist())\n",
+    "\n",
+    "print(\"Gefundene FACE_AU-Spalten:\", au_columns)\n",
+    "print(\"Gefundene Eye Features:\" , eye_columns)\n",
+    "\n",
+    "print(\"Anzahl FACE_AUs:\", len(au_columns)) \n",
+    "print(\"Anzahl EYE Features:\", len(eye_columns)) \n",
+    "print(\"Gesamtzahl Features:\", len(feature_columns))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8689679",
+   "metadata": {},
+   "source": [
+    "Train-Test-Split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5cf88c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)\n",
+    "train_idx, test_idx = next(gss.split(X, y, groups))\n",
+    "\n",
+    "feature_columns_train, feature_columns_test = X[train_idx], X[test_idx]\n",
+    "y_train, y_test = y[train_idx], y[test_idx]\n",
+    "groups_train, groups_test = groups[train_idx], groups[test_idx]\n",
+    "\n",
+    "print(\"Train:\", len(y_train), \" | Test:\", len(y_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a539b83b",
+   "metadata": {},
+   "source": [
+    "CNN-Modell"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4a7f496",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_model(input_shape, lr=1e-4): \n",
+    "    model = models.Sequential([ \n",
+    "        Input(shape=input_shape), \n",
+    "        layers.Conv1D(32, kernel_size=3, activation=\"relu\", kernel_regularizer=regularizers.l2(0.001)), \n",
+    "        layers.BatchNormalization(), \n",
+    "        layers.MaxPooling1D(pool_size=2),\n",
+    "\n",
+    "        layers.Conv1D(64, kernel_size=3, activation=\"relu\", kernel_regularizer=regularizers.l2(0.001)), \n",
+    "        layers.BatchNormalization(), \n",
+    "        layers.GlobalAveragePooling1D(), \n",
+    "        \n",
+    "        layers.Dense(32, activation=\"relu\", kernel_regularizer=regularizers.l2(0.001)), \n",
+    "        layers.Dropout(0.5), \n",
+    "        layers.Dense(1, activation=\"sigmoid\") \n",
+    "    ]) \n",
+    "    \n",
+    "    model.compile( \n",
+    "        optimizer=tf.keras.optimizers.Adam(learning_rate=lr), \n",
+    "        loss=\"binary_crossentropy\", \n",
+    "        metrics=[\"accuracy\", tf.keras.metrics.AUC(name=\"auc\")] \n",
+    "    ) \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5905871b",
+   "metadata": {},
+   "source": [
+    "Cross-Validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90658000",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gkf = GroupKFold(n_splits=5) \n",
+    "cv_histories = [] \n",
+    "cv_results = [] \n",
+    "fold_subjects = []\n",
+    "all_conf_matrices = []\n",
+    "\n",
+    "for fold, (train_idx, val_idx) in enumerate(gkf.split(X, y, groups)):\n",
+    "    train_subjects = np.unique(groups[train_idx]) \n",
+    "    val_subjects = np.unique(groups[val_idx]) \n",
+    "    fold_subjects.append({\"Fold\": fold+1, \n",
+    "                          \"Train_Subjects\": train_subjects, \n",
+    "                          \"Val_Subjects\": val_subjects}) \n",
+    "    \n",
+    "    print(f\"\\n--- Fold {fold+1} ---\") \n",
+    "    print(\"Train-Subjects:\", train_subjects) \n",
+    "    print(\"Val-Subjects:\", val_subjects) \n",
+    "\n",
+    "    #Split\n",
+    "    X_train, X_val = X[train_idx], X[val_idx] \n",
+    "    y_train, y_val = y[train_idx], y[val_idx] # Normalisierung pro Fold \n",
+    "\n",
+    "    #Normalisierung pro Fold\n",
+    "    scaler = StandardScaler() \n",
+    "    X_train = scaler.fit_transform(X_train.reshape(len(X_train), -1)).reshape(X_train.shape) \n",
+    "    X_val = scaler.transform(X_val.reshape(len(X_val), -1)).reshape(X_val.shape) \n",
+    "\n",
+    "    # Plausibilitäts-Check \n",
+    "    print(\"Train Mittelwerte (erste 5 Features):\", X_train.mean(axis=0)[:5]) \n",
+    "    print(\"Train Std (erste 5 Features):\", X_train.std(axis=0)[:5]) \n",
+    "    print(\"Val Mittelwerte (erste 5 Features):\", X_val.mean(axis=0)[:5]) \n",
+    "    print(\"Val Std (erste 5 Features):\", X_val.std(axis=0)[:5]) \n",
+    "\n",
+    "    # Modell \n",
+    "    model = build_model(input_shape=(len(feature_columns_train),1), lr=1e-4) \n",
+    "    model.summary()  \n",
+    "\n",
+    "    callbacks = [ \n",
+    "        tf.keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=10, restore_best_weights=True), \n",
+    "        tf.keras.callbacks.ReduceLROnPlateau(monitor=\"val_loss\", factor=0.5, patience=5, min_lr=1e-6) \n",
+    "    ] \n",
+    "\n",
+    "    history = model.fit( \n",
+    "        X_train, y_train, \n",
+    "        validation_data=(X_val, y_val), \n",
+    "        epochs=100, \n",
+    "        batch_size=16, \n",
+    "        callbacks=callbacks, \n",
+    "        verbose=0 \n",
+    "    ) \n",
+    "\n",
+    "    cv_histories.append(history.history) \n",
+    "    scores = model.evaluate(X_val, y_val, verbose=0) \n",
+    "    cv_results.append(scores) \n",
+    "    print(f\"Fold {fold+1} - Val Loss: {scores[0]:.4f}, Val Acc: {scores[1]:.4f}, Val AUC: {scores[2]:.4f}\")\n",
+    "\n",
+    "\n",
+    "    #Konfusionsmatrix \n",
+    "    y_pred = (model.predict(X_val) > 0.5).astype(int) \n",
+    "    cm = confusion_matrix(y_val, y_pred) \n",
+    "    all_conf_matrices.append(cm) \n",
+    "    \n",
+    "    print(f\"Konfusionsmatrix Fold {fold+1}:\\n{cm}\\n\") \n",
+    "    \n",
+    "# Aggregierte Matrix \n",
+    "agg_cm = sum(all_conf_matrices) \n",
+    "print(\"Aggregierte Konfusionsmatrix über alle Folds:\") \n",
+    "print(agg_cm)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d10b7e78",
+   "metadata": {},
+   "source": [
+    "Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9aeba7f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#results\n",
+    "cv_results = np.array(cv_results) \n",
+    "print(\"\\n=== Cross-Validation Ergebnisse ===\") \n",
+    "print(f\"Durchschnittlicher Val-Loss: {cv_results[:,0].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-Accuracy: {cv_results[:,1].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-AUC: {cv_results[:,2].mean():.4f}\")\n",
+    "\n",
+    "#Ergebnis-Tabelle erstellen\n",
+    "results_table = pd.DataFrame({ \n",
+    "    \"Fold\": np.arange(1, len(cv_results)+1), \n",
+    "    \"Val Loss\": cv_results[:,0], \n",
+    "    \"Val Accuracy\": cv_results[:,1], \n",
+    "    \"Val AUC\": cv_results[:,2] }) \n",
+    "\n",
+    "# Durchschnittszeile hinzufügen \n",
+    "avg_row = pd.DataFrame({ \n",
+    "    \"Fold\": [\"Ø\"], \n",
+    "    \"Val Loss\": [cv_results[:,0].mean()], \n",
+    "    \"Val Accuracy\": [cv_results[:,1].mean()], \n",
+    "    \"Val AUC\": [cv_results[:,2].mean()] \n",
+    "}) \n",
+    "\n",
+    "results_table = pd.concat([results_table, avg_row], ignore_index=True) \n",
+    "\n",
+    "print(\"\\n=== Ergebnis-Tabelle ===\") \n",
+    "print(results_table) \n",
+    "\n",
+    "#Tabelle speichern \n",
+    "results_table.to_csv(\"cnn_crossVal_results.csv\", index=False) \n",
+    "print(\"Ergebnisse gespeichert als 'cnn_crossVal_results.csv'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fae5df7a",
+   "metadata": {},
+   "source": [
+    "Finales Modell trainieren"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b3eab61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scaler_final = StandardScaler() \n",
+    "X_scaled = scaler_final.fit_transform(feature_columns_train.reshape(len(feature_columns_train), -1)).reshape(feature_columns_train.shape) \n",
+    "\n",
+    "final_model = build_model(input_shape=(len(feature_columns_train),1), lr=1e-4) \n",
+    "final_model.summary() \n",
+    "\n",
+    "final_model.fit( \n",
+    "    X_scaled, y_train, \n",
+    "    epochs=150, \n",
+    "    batch_size=16, \n",
+    "    verbose=1 \n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c7f9cc4",
+   "metadata": {},
+   "source": [
+    "Speichern des Modells"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d3af5be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# final_model.save(\"cnn_crossVal_EarlyFusion_V2.keras\") \n",
+    "# joblib.dump(scaler_final, \"scaler_crossVal_EarlyFusion_V2.joblib\") \n",
+    "\n",
+    "# print(\"Finales Modell und Scaler gespeichert als 'cnn_crossVal_EarlyFusion_V2.keras' und 'scaler_crossVal_EarlyFusion_V2.joblib'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c11891e0",
+   "metadata": {},
+   "source": [
+    "Plots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f6a8584",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#plots\n",
+    "def plot_cv_histories(cv_histories, metric): \n",
+    "    plt.figure(figsize=(10,6)) \n",
+    "    \n",
+    "    for i, hist in enumerate(cv_histories): \n",
+    "        plt.plot(hist[metric], label=f\"Fold {i+1} Train\", alpha=0.7) \n",
+    "        plt.plot(hist[f\"val_{metric}\"], label=f\"Fold {i+1} Val\", linestyle=\"--\", alpha=0.7) \n",
+    "    plt.xlabel(\"Epochs\") \n",
+    "    plt.ylabel(metric.capitalize()) \n",
+    "    plt.title(f\"Cross-Validation {metric.capitalize()} Verläufe\") \n",
+    "    plt.legend() \n",
+    "    plt.grid(True) \n",
+    "    plt.show()\n",
+    "    \n",
+    "plot_cv_histories(cv_histories, \"loss\") \n",
+    "plot_cv_histories(cv_histories, \"accuracy\") \n",
+    "plot_cv_histories(cv_histories, \"auc\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4aebe6c6",
+   "metadata": {},
+   "source": [
+    "Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d34d6b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Preprocessing Testdaten \n",
+    "X_test_scaled = scaler.transform( \n",
+    "    feature_columns_test.reshape(len(feature_columns_test), -1) \n",
+    ").reshape(feature_columns_test.shape) \n",
+    "\n",
+    "# Vorhersagen \n",
+    "y_prob_test = model.predict(X_test_scaled).flatten() \n",
+    "y_pred_test = (y_prob_test > 0.5).astype(int) \n",
+    "\n",
+    "# Konfusionsmatrix \n",
+    "cm_test = confusion_matrix(y_test, y_pred_test) \n",
+    "\n",
+    "plt.figure(figsize=(6,5)) \n",
+    "sns.heatmap(cm_test, annot=True, fmt=\"d\", cmap=\"Greens\", \n",
+    "            xticklabels=[\"Pred 0\", \"Pred 1\"], \n",
+    "            yticklabels=[\"True 0\", \"True 1\"]) \n",
+    "plt.title(\"Konfusionsmatrix - Testdaten\") \n",
+    "plt.show() \n",
+    "\n",
+    "# ROC \n",
+    "fpr, tpr, _ = roc_curve(y_test, y_prob_test) \n",
+    "roc_auc = auc(fpr, tpr) \n",
+    "\n",
+    "plt.figure(figsize=(7,6)) \n",
+    "plt.plot(fpr, tpr, label=f\"AUC = {roc_auc:.3f}\") \n",
+    "plt.plot([0,1], [0,1], \"k--\") \n",
+    "plt.title(\"ROC - Testdaten\") \n",
+    "plt.legend() \n",
+    "plt.grid(True) \n",
+    "plt.show() \n",
+    "\n",
+    "# Precision-Recall \n",
+    "precision, recall, _ = precision_recall_curve(y_test, y_prob_test) \n",
+    "plt.figure(figsize=(7,6)) \n",
+    "plt.plot(recall, precision) \n",
+    "plt.title(\"Precision-Recall - Testdaten\") \n",
+    "plt.grid(True) \n",
+    "plt.show() \n",
+    "\n",
+    "# Metriken \n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred_test))\n",
+    "print(\"F1-Score:\", f1_score(y_test, y_pred_test)) \n",
+    "print(\"Balanced Accuracy:\", balanced_accuracy_score(y_test, y_pred_test)) \n",
+    "print(\"Precision:\", precision_score(y_test, y_pred_test)) \n",
+    "print(\"Recall:\", recall_score(y_test, y_pred_test)) \n",
+    "print(\"AUC:\", roc_auc)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

model_training/CNN/CNN_crossVal_HybridFusion_Test_Eval.ipynb

@@ -10,23 +10,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "530e70af",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-02-24 16:57:49.034186: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2026-02-24 16:57:49.047136: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2026-02-24 16:57:49.050974: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2026-02-24 16:57:49.062835: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
-      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2026-02-24 16:57:49.832762: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import pandas as pd \n",
     "import numpy as np \n",
@@ -36,13 +23,13 @@
     "import joblib \n",
     "from pathlib import Path \n",
     "\n",
-    "from sklearn.model_selection import GroupKFold, train_test_split \n",
+    "from sklearn.model_selection import GroupKFold, GroupShuffleSplit \n",
     "from sklearn.preprocessing import StandardScaler \n",
     "from sklearn.metrics import ( \n",
     "    precision_score, recall_score,\n",
     "    confusion_matrix, roc_curve, auc, \n",
     "    precision_recall_curve, f1_score, \n",
-    "    balanced_accuracy_score \n",
+    "    balanced_accuracy_score, accuracy_score\n",
     ") \n",
     "\n",
     "import tensorflow as tf \n",
@@ -59,7 +46,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "67aaf56e",
    "metadata": {},
    "outputs": [],
@@ -80,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "73a34b69",
    "metadata": {},
    "outputs": [],
@@ -99,7 +86,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "a5ad3126",
    "metadata": {},
    "outputs": [],
@@ -134,7 +121,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "5f10e6ca",
    "metadata": {},
    "outputs": [],
@@ -169,25 +156,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "52d3b7cf",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train: 6377  | Test: 1595\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "X_au_train, X_au_test, X_eye_train, X_eye_test, y_train, y_test, groups_train, groups_test = train_test_split( \n",
-    "    X_au, X_eye, y, \n",
-    "    groups, test_size=0.2, \n",
-    "    random_state=42, \n",
-    "    stratify=y \n",
-    ") \n",
+    "gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)\n",
+    "train_idx, test_idx = next(gss.split(X_au, y, groups))\n",
+    "\n",
+    "X_au_train, X_au_test = X_au[train_idx], X_au[test_idx]\n",
+    "X_eye_train, X_eye_test = X_eye[train_idx], X_eye[test_idx]\n",
+    "y_train, y_test = y[train_idx], y[test_idx]\n",
+    "groups_train, groups_test = groups[train_idx], groups[test_idx]\n",
     "\n",
     "print(\"Train:\", len(y_train), \" | Test:\", len(y_test))"
    ]
@@ -202,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "41cc1b30",
    "metadata": {},
    "outputs": [],
@@ -246,151 +226,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "9c390b46",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 1 =====\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
-      "I0000 00:00:1771948671.077495  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.117462  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.119081  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.125047  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.126507  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.127885  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.321528  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.323000  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "2026-02-24 16:57:51.324225: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:47] Overriding orig_value setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n",
-      "I0000 00:00:1771948671.324317  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "2026-02-24 16:57:51.325558: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 35614 MB memory:  -> device: 0, name: NVIDIA A100 80GB PCIe MIG 3g.40gb, pci bus id: 0000:1e:00.0, compute capability: 8.0\n",
-      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
-      "I0000 00:00:1771948673.622665  347894 service.cc:146] XLA service 0x7fcbc40111e0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
-      "I0000 00:00:1771948673.622720  347894 service.cc:154]   StreamExecutor device (0): NVIDIA A100 80GB PCIe MIG 3g.40gb, Compute Capability 8.0\n",
-      "2026-02-24 16:57:53.667316: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
-      "2026-02-24 16:57:53.897373: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n",
-      "I0000 00:00:1771948676.141382  347894 device_compiler.h:188] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Val Loss=0.0339 | Val Acc=0.9836 | Val AUC=0.9994\n",
-      "\u001b[1m41/41\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 2 =====\n",
-      "Val Loss=0.1241 | Val Acc=0.9591 | Val AUC=0.9861\n",
-      "\u001b[1m40/40\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 3 =====\n",
-      "Val Loss=0.1050 | Val Acc=0.9772 | Val AUC=0.9900\n",
-      "\u001b[1m40/40\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 4 =====\n",
-      "Val Loss=0.1166 | Val Acc=0.9489 | Val AUC=0.9913\n",
-      "\u001b[1m40/40\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 5 =====\n",
-      "Val Loss=0.1385 | Val Acc=0.9571 | Val AUC=0.9910\n",
-      "\u001b[1m41/41\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 6ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe4AAAHBCAYAAACv7Vi1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPuhJREFUeJzt3XtclHX6//H3cBoBkQSUgTRFRc3QQjRSK1FBKw+ZW1pkaWoHT4VKluuWuBWkW0pl2Wampl9121y1XcvUSjdSC0lL7bAdSJeNCQ+EJxxO9++Pfk6NoM7oIN72eva4H4/43J/5zDU0jy6u6/7MPRbDMAwBAABT8KnrAAAAgPtI3AAAmAiJGwAAEyFxAwBgIiRuAABMhMQNAICJkLgBADAREjcAACZC4gYAwERI3BeRhQsXymKxaNu2bS7j+/fvV6dOnVS/fn2tX7++Vp67rKxMDzzwgKKiouTr66urrrrK688xfPhwNW/e3OvrXqiOHTumjIwMbdy40aPHZWRkyGKx1E5QZ7Bx40ZZLJYaj1tvvfWs1nLn9bv73hg+fHiNsbVt29aj2IC65FfXAaB2FRQUKCUlRT/99JM2bNiga665plaeZ+7cufrrX/+qF154QQkJCapfv77Xn+Oxxx7TQw895PV1L1THjh3T9OnTJUlJSUluP27UqFG64YYbaikq92RmZqpHjx4uY+Hh4XUUjavAwEC9//771cYAsyBxX8S++eYbJScnq7y8XJs2bVL79u1r7bl27dqlwMBAjRs3rtaeo2XLlrW29sXg2LFjCgoKUpMmTdSkSZM6jSU2NrbW/kg8Vz4+PhdsbIA7aJVfpHbs2KFrr71Wfn5+ysnJqZa0c3Jy1KtXL4WEhCgoKEhdu3bVmjVrXOacaL1/8MEHGj16tCIiIhQeHq5Bgwbpxx9/dM6zWCx69dVXVVpa6mw9Lly4UD/88IPz309msViUkZHh/Hnfvn2677771LRpU1mtVjVq1EjdunXThg0bnHNqaoceP35cU6ZMUUxMjAICAnTppZdq7Nix+vnnn13mNW/eXP369dPatWvVsWNHBQYGqm3btnrttddc5h07dkzp6emKiYlRvXr1FBYWpk6dOmnZsmUucdSvX19fffWV+vTpo+DgYEVFRenpp5+WJG3dulXXXnutgoOD1bp1ay1atMjlOfbt26cxY8aoXbt2ql+/vho3bqyePXvqww8/dM754Ycf1KhRI0nS9OnTnb/X4cOHS/q1Hf7pp5/q1ltvVcOGDZ1/2JzcKs/JyZG/v7/S09Nd4jjx33f+/PnV/vvUNnfef6eycOFCtWnTRlarVZdffrlef/31Wo4WuLCQuC9COTk5SkpKUuPGjZWTk6MWLVq4nN+0aZN69uypkpISzZ8/X8uWLVNISIj69++vv/3tb9XWGzVqlPz9/bV06VLNnDlTGzdu1NChQ53nt2zZoptuukmBgYHasmWLtmzZor59+3oU81133aVVq1bp8ccf17p16/Tqq68qOTlZBw4cOOVjDMPQwIED9cwzz+iuu+7SmjVrNHHiRC1atEg9e/aUw+Fwmf/ZZ59p0qRJmjBhglavXq0OHTpo5MiR+ve//+2cM3HiRM2dO1cPPvig1q5dq8WLF+u2226rFkd5ebkGDRqkvn37avXq1brxxhs1ZcoU/fGPf9SwYcM0YsQIrVy5Um3atNHw4cOVl5fnfOzBgwclSdOmTdOaNWu0YMECtWjRQklJSc7ruVFRUVq7dq0kaeTIkc7f62OPPeYSx6BBg9SqVSv9/e9/18svv1zj7+naa6/Vk08+qWeffVZvvfWWJGn37t0aO3ashg4dqpEjR57uP81ZqaqqUkVFhctxgqfvv99auHCh7rnnHl1++eVasWKF/vSnP+mJJ56o1vo+ndLSUtlsNvn6+qpJkyYaN26c878JYAoGLhoLFiwwJBmSjNDQUKOoqKjGeddcc43RuHFj4/Dhw86xiooKIy4uzmjSpIlRVVXlst6YMWNcHj9z5kxDklFYWOgcGzZsmBEcHOwyLz8/35BkLFiwoFoMkoxp06Y5f65fv76RlpZ22tc3bNgwo1mzZs6f165da0gyZs6c6TLvb3/7myHJeOWVV5xjzZo1M+rVq2fs2bPHOVZaWmqEhYUZ999/v3MsLi7OGDhw4BnjkGSsWLHCOVZeXm40atTIkGR8+umnzvEDBw4Yvr6+xsSJE0+5XkVFhVFeXm706tXLuOWWW5zj+/btq/Z7OmHatGmGJOPxxx8/5bnfqqqqMm666SbjkksuMXbt2mW0a9fOaNu2rXHkyJHTvlZPffDBB8734MnHN998YxiG+++/E2t98MEHhmEYRmVlpREdHW107NjROccwDOOHH34w/P39Xd4bpzJr1ixj1qxZxrp164x169YZU6dONYKCgoy2bdu6xANcyKi4L0IDBgxQSUmJ0tLSVFlZ6XLu6NGj+vjjj3Xrrbe6bCDz9fXVXXfdpYKCAn399dfV1vutDh06SJL27NnjtZivvvpqLVy4UE8++aS2bt2q8vLyMz7mRJV1on18wm233abg4GC99957LuNXXXWVLrvsMufP9erVU+vWrV1ex9VXX6133nlHjz76qDZu3KjS0tIan9tiseimm25y/uzn56dWrVopKipK8fHxzvGwsDA1bty42u/q5ZdfVseOHVWvXj35+fnJ399f7733nr788sszvu7f+sMf/uDWPIvFotdff10hISHq1KmT8vPz9cYbbyg4OPi0jzMM45SV8+nMmDFDubm5LkfTpk3P6v13wtdff60ff/xRqampLpcCmjVrpq5du7oV14QJEzRhwgSlpKQoJSVFTz75pF5//XV99dVXmjdvnltrAHWNxH0Reuyxx/T4449r6dKlGjp0qEvyLi4ulmEYioqKqva46OhoSarWFj55N7DVapWkUya1s/G3v/1Nw4YN06uvvqouXbooLCxMd999t+x2+ykfc+DAAfn5+TmvBZ9gsVhks9nO+DqkX17Lb1/H888/r0ceeUSrVq1Sjx49FBYWpoEDB+qbb75xeVxQUJDq1avnMhYQEKCwsLBqzxEQEKDjx487f541a5ZGjx6txMRErVixQlu3blVubq5uuOEGj3+nNf13PJXw8HANGDBAx48f1w033ODWZsVFixbJ39/f5XBHixYt1KlTJ5fDarWe1fvvhBPjNput2rmaxtx1yy23KDg4WFu3bj3rNYDziV3lF6kTG5qmT5+uqqoq/d///Z/8/PzUsGFD+fj4qLCwsNpjTmw4i4iI8EoMJxLbydeaa/ofc0REhLKzs5Wdna29e/fqrbfe0qOPPqqioiLntd6ThYeHq6KiQvv27XNJ3oZhyG63q3Pnzh7HHBwcrOnTp2v69On66aefnNV3//799dVXX3m8Xk2WLFmipKQkzZ0712X88OHDHq/lyee1169fr7lz5+rqq6/WypUrtWLFijNW7P3791dubq7HcZ3Kubz/TvzhVdMfc6f7A88dhmHIx4c6BubAO/UilpGRoenTp+uNN95QamqqKioqFBwcrMTERP3jH/9wqe6qqqq0ZMkSNWnSRK1bt/bK80dGRqpevXr6/PPPXcZXr1592sdddtllGjdunFJSUvTpp5+ecl6vXr0k/ZIIf2vFihU6evSo8/zZioyM1PDhw3XHHXfo66+/1rFjx85pvRMsFouza3HC559/ri1btriMebOzUVhYqKFDh6p79+7avHmzBgwYoJEjRyo/P/+0jwsPD69WOZ+Lc3n/tWnTRlFRUVq2bJkMw3CO79mzR5s3bz7rmN58800dO3aMj4jBNKi4L3KPP/64fHx89Nhjj8kwDC1btkxZWVlKSUlRjx49lJ6eroCAAL300kvatWuXli1b5rW7blksFg0dOlSvvfaaWrZsqSuvvFKffPKJli5d6jKvpKREPXr0UGpqqtq2bauQkBDl5uZq7dq1GjRo0CnXT0lJUZ8+ffTII4/o0KFD6tatmz7//HNNmzZN8fHxuuuuuzyOOTExUf369VOHDh3UsGFDffnll1q8eLG6dOmioKAgj9erSb9+/fTEE09o2rRp6t69u77++mv9+c9/VkxMjMs15JCQEDVr1kyrV69Wr169FBYWpoiICI/vHldZWak77rhDFotFS5cula+vrxYuXKirrrpKQ4YMUU5OjgICArzy2txxtu8/Hx8fPfHEExo1apRuueUW3Xvvvfr555+VkZHhVqt8z549Sk1N1e23365WrVrJYrFo06ZNys7O1hVXXKFRo0Z5+6UCtaMON8bBy07sAs/Nza127qmnnjIkGYMGDTLKysqMDz/80OjZs6cRHBxsBAYGGtdcc43xz3/+0631Tt7taxg17yo3DMMoKSkxRo0aZURGRhrBwcFG//79jR9++MFlt/Tx48eNBx54wOjQoYPRoEEDIzAw0GjTpo0xbdo04+jRoy7PcfLO4dLSUuORRx4xmjVrZvj7+xtRUVHG6NGjjeLiYpd5zZo1M/r27Vstvu7duxvdu3d3/vzoo48anTp1Mho2bGhYrVajRYsWxoQJE4z9+/ef8bV2797duOKKK6qNn/zcDofDSE9PNy699FKjXr16RseOHY1Vq1bV+Po2bNhgxMfHG1ar1ZBkDBs2zDCMX3eO79u3r9rznbyrfOrUqYaPj4/x3nvvuczbvHmz4efnZzz00EPV1jhbJ94bf//73087z533X03vM8MwjFdffdWIjY01AgICjNatWxuvvfZajb+7kx08eNC45ZZbjObNmxuBgYFGQECAERsba0yePNn4+eefz+blAnXCYhi/6TkBAIALGte4AQAwERI3AAAmQuIGAMBESNwAAJgIiRsAABMhcQMAYCIkbgAATOSCuXPa9bM+qusQgFq3ZmyXug4BqHUh1tqrCQPjx3ltrdLtc7y21vlExQ0AgIlcMBU3AABnZKHeJHEDAMzDS1+CZGb86QIAgIlQcQMAzINWOYkbAGAitMpLine truncated
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "gkf = GroupKFold(n_splits=5) \n",
     "cv_histories = [] \n",
@@ -460,6 +299,53 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "97df9df1",
+   "metadata": {},
+   "source": [
+    "Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9eae5c0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#results\n",
+    "cv_results = np.array(cv_results) \n",
+    "print(\"\\n=== Cross-Validation Ergebnisse ===\") \n",
+    "print(f\"Durchschnittlicher Val-Loss: {cv_results[:,0].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-Accuracy: {cv_results[:,1].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-AUC: {cv_results[:,2].mean():.4f}\")\n",
+    "\n",
+    "#Ergebnis-Tabelle erstellen\n",
+    "results_table = pd.DataFrame({ \n",
+    "    \"Fold\": np.arange(1, len(cv_results)+1), \n",
+    "    \"Val Loss\": cv_results[:,0], \n",
+    "    \"Val Accuracy\": cv_results[:,1], \n",
+    "    \"Val AUC\": cv_results[:,2] }) \n",
+    "\n",
+    "# Durchschnittszeile hinzufügen \n",
+    "avg_row = pd.DataFrame({ \n",
+    "    \"Fold\": [\"Ø\"], \n",
+    "    \"Val Loss\": [cv_results[:,0].mean()], \n",
+    "    \"Val Accuracy\": [cv_results[:,1].mean()], \n",
+    "    \"Val AUC\": [cv_results[:,2].mean()] \n",
+    "}) \n",
+    "\n",
+    "results_table = pd.concat([results_table, avg_row], ignore_index=True) \n",
+    "\n",
+    "print(\"\\n=== Ergebnis-Tabelle ===\") \n",
+    "print(results_table) \n",
+    "\n",
+    "#Tabelle speichern \n",
+    "results_table.to_csv(\"cnn_crossVal_results.csv\", index=False) \n",
+    "print(\"Ergebnisse gespeichert als 'cnn_crossVal_results.csv'\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "7e564308",
@@ -470,22 +356,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "9afc926b",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Finales Modell gespeichert.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "model_cv.save(\"hybrid_fusion_model_Test.keras\") \n",
-    "joblib.dump(scaler_au, \"scaler_au_Test.joblib\") \n",
-    "joblib.dump(scaler_eye, \"scaler_eye_Test.joblib\") \n",
+    "model_cv.save(\"hybrid_fusion_model_Test_group_split.keras\") \n",
+    "joblib.dump(scaler_au, \"scaler_au_Test_group_split.joblib\") \n",
+    "joblib.dump(scaler_eye, \"scaler_eye_Test_group_split.joblib\") \n",
     "\n",
     "print(\"Finales Modell gespeichert.\")"
    ]
@@ -500,59 +378,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "0bb8c14c",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1m50/50\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 700x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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 truncated
-      "text/plain": [
-       "<Figure size 700x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "F1-Score: 0.9851222104144527\n",
-      "Balanced Accuracy: 0.9809860091542237\n",
-      "Precision: 0.9809523809523809\n",
-      "Recall: 0.9893276414087513\n",
-      "AUC: 0.997147009306686\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Preprocessing Testdaten \n",
     "X_au_test_scaled = scaler_au.transform( \n",
@@ -596,6 +425,7 @@
     "plt.show() \n",
     "\n",
     "# Metriken \n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred_test))\n",
     "print(\"F1-Score:\", f1_score(y_test, y_pred_test)) \n",
     "print(\"Balanced Accuracy:\", balanced_accuracy_score(y_test, y_pred_test)) \n",
     "print(\"Precision:\", precision_score(y_test, y_pred_test)) \n",