Lab.8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 8- Deep Learning Model\n",
    "\n",
    "This lab is meant to get you started in using Keras to design Deep Neural Networks. The goal here is to simply repeat your previous lab, but with DNNs.\n",
    "\n",
    "Let's start with reading the data, like before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "#filename=\"../Lab.5/SUSY.csv\"\n",
    "#filename=\"../Downloads/data3402/SUSY.csv.gv\"\n",
    "filename=\"C:/Users/aemsh/Downloads/data3402/SUSY.csv.gz\"\n",
    "VarNames=[\"signal\", \"l_1_pT\", \"l_1_eta\",\"l_1_phi\", \"l_2_pT\", \"l_2_eta\", \"l_2_phi\", \"MET\", \"MET_phi\", \"MET_rel\", \"axial_MET\", \"M_R\", \"M_TR_2\", \"R\", \"MT2\", \"S_R\", \"M_Delta_R\", \"dPhi_r_b\", \"cos_theta_r1\"]\n",
    "RawNames=[\"l_1_pT\", \"l_1_eta\",\"l_1_phi\", \"l_2_pT\", \"l_2_eta\", \"l_2_phi\",\"MET\", \"MET_phi\", \"MET_rel\", \"axial_MET\"]\n",
    "FeatureNames=[\"M_R\", \"M_TR_2\", \"R\", \"MT2\", \"S_R\", \"M_Delta_R\", \"dPhi_r_b\", \"cos_theta_r1\"]\n",
    "\n",
    "df = pd.read_csv(filename, dtype='float64', names=VarNames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets define training and test samples. Note that DNNs take very long to train, so for testing purposes we will use only about 10% of the 5 million events in the training/validation sample. Once you get everything working, make the final version of your plots with the full sample. \n",
    "\n",
    "Also note that Keras had trouble with the Pandas tensors, so after doing all of the nice manipulation that Pandas enables, we convert the Tensor to a regular numpy tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_Max=550000\n",
    "N_Train=500000\n",
    "\n",
    "Train_Sample=df[:N_Train]\n",
    "Test_Sample=df[N_Train:N_Max]\n",
    "\n",
    "X_Train=np.array(Train_Sample[VarNames[1:]])\n",
    "y_Train=np.array(Train_Sample[\"signal\"])\n",
    "\n",
    "X_Test=np.array(Test_Sample[VarNames[1:]])\n",
    "y_Test=np.array(Test_Sample[\"signal\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500000, 18)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_Train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\aemsh\\anaconda3\\lib\\site-packages\\scipy\\__init__.py:155: UserWarning: A NumPy version >=1.18.5 and <1.25.0 is required for this version of SciPy (detected version 1.26.2\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\aemsh\\anaconda3\\lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\aemsh\\anaconda3\\lib\\site-packages\\keras\\src\\backend.py:873: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Dense(12, input_dim=X_Train.shape[1], activation='relu'))\n",
    "model.add(Dense(8, activation='relu'))\n",
    "model.add(Dense(8, activation='relu'))\n",
    "model.add(Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 12)                228       \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 8)                 104       \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 8)                 72        \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 1)                 9         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 413 (1.61 KB)\n",
      "Trainable params: 413 (1.61 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "\n",
    "You will need to create several models and make sure they are properly trained. Write a function that takes this history and plots the values versus epoch. For every model that you train in the remainder of this lab, assess:\n",
    "\n",
    "* Has you model's performance plateaued? If not train for more epochs. \n",
    "* Compare the performance on training versus test sample. Are you over training?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "WARNING:tensorflow:From C:\\Users\\aemsh\\anaconda3\\lib\\site-packages\\keras\\src\\utils\\tf_utils.py:492: The name tf.ragged.RaggedTensorValue is deprecated. Please use tf.compat.v1.ragged.RaggedTensorValue instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\aemsh\\anaconda3\\lib\\site-packages\\keras\\src\\engine\\base_layer_utils.py:384: The name tf.executing_eagerly_outside_functions is deprecated. Please use tf.compat.v1.executing_eagerly_outside_functions instead.\n",
      "\n",
      "25000/25000 [==============================] - 62s 2ms/step - loss: 0.4707 - accuracy: 0.7794 - val_loss: 0.4592 - val_accuracy: 0.7862\n",
      "Epoch 2/20\n",
      "25000/25000 [==============================] - 55s 2ms/step - loss: 0.4581 - accuracy: 0.7867 - val_loss: 0.4561 - val_accuracy: 0.7875\n",
      "Epoch 3/20\n",
      "25000/25000 [==============================] - 57s 2ms/step - loss: 0.4567 - accuracy: 0.7875 - val_loss: 0.4560 - val_accuracy: 0.7879\n",
      "Epoch 4/20\n",
      "25000/25000 [==============================] - 56s 2ms/step - loss: 0.4560 - accuracy: 0.7879 - val_loss: 0.4549 - val_accuracy: 0.7882\n",
      "Epoch 5/20\n",
      "25000/25000 [==============================] - 56s 2ms/step - loss: 0.4555 - accuracy: 0.7881 - val_loss: 0.4554 - val_accuracy: 0.7883\n",
      "Epoch 6/20\n",
      "25000/25000 [==============================] - 56s 2ms/step - loss: 0.4552 - accuracy: 0.7883 - val_loss: 0.4558 - val_accuracy: 0.7879\n",
      "Epoch 7/20\n",
      "25000/25000 [==============================] - 57s 2ms/step - loss: 0.4549 - accuracy: 0.7884 - val_loss: 0.4549 - val_accuracy: 0.7886\n",
      "Epoch 8/20\n",
      "25000/25000 [==============================] - 56s 2ms/step - loss: 0.4546 - accuracy: 0.7886 - val_loss: 0.4544 - val_accuracy: 0.7888\n",
      "Epoch 9/20\n",
      "25000/25000 [==============================] - 57s 2ms/step - loss: 0.4544 - accuracy: 0.7888 - val_loss: 0.4548 - val_accuracy: 0.7891\n",
      "Epoch 10/20\n",
      "25000/25000 [==============================] - 59s 2ms/step - loss: 0.4542 - accuracy: 0.7889 - val_loss: 0.4542 - val_accuracy: 0.7891\n",
      "Epoch 11/20\n",
      "25000/25000 [==============================] - 57s 2ms/step - loss: 0.4540 - accuracy: 0.7890 - val_loss: 0.4545 - val_accuracy: 0.7888\n",
      "Epoch 12/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4539 - accuracy: 0.7890 - val_loss: 0.4535 - val_accuracy: 0.7892\n",
      "Epoch 13/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4537 - accuracy: 0.7890 - val_loss: 0.4530 - val_accuracy: 0.7894\n",
      "Epoch 14/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4536 - accuracy: 0.7890 - val_loss: 0.4532 - val_accuracy: 0.7894\n",
      "Epoch 15/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4535 - accuracy: 0.7891 - val_loss: 0.4529 - val_accuracy: 0.7894\n",
      "Epoch 16/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4534 - accuracy: 0.7892 - val_loss: 0.4551 - val_accuracy: 0.7883\n",
      "Epoch 17/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4533 - accuracy: 0.7892 - val_loss: 0.4535 - val_accuracy: 0.7892\n",
      "Epoch 18/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4532 - accuracy: 0.7892 - val_loss: 0.4527 - val_accuracy: 0.7896\n",
      "Epoch 19/20\n",
      "25000/25000 [==============================] - 58s 2ms/step - loss: 0.4531 - accuracy: 0.7892 - val_loss: 0.4531 - val_accuracy: 0.7894\n",
      "Epoch 20/20\n",
      "25000/25000 [==============================] - 59s 2ms/step - loss: 0.4530 - accuracy: 0.7892 - val_loss: 0.4530 - val_accuracy: 0.7894\n",
      "31250/31250 [==============================] - 50s 2ms/step - loss: 0.4531 - accuracy: 0.7895\n",
      "Test Loss: 0.4531117081642151\n",
      "Test Accuracy: 0.7894589900970459\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'plot_metrics_vs_epoch' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_23460\\563895166.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     39\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Test Accuracy: {test_accuracy}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     40\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 41\u001b[1;33m plot_metrics_vs_epoch(\n\u001b[0m\u001b[0;32m     42\u001b[0m     \u001b[1;33m{\u001b[0m\u001b[1;34m\"accuracy\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mhistory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhistory\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"accuracy\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"loss\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mhistory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhistory\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"loss\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     43\u001b[0m     \u001b[1;33m{\u001b[0m\u001b[1;34m\"accuracy\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mhistory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhistory\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"val_accuracy\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"loss\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mhistory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhistory\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"val_loss\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'plot_metrics_vs_epoch' is not defined"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)\n",
    "\n",
    "X = df[FeatureNames]\n",
    "y = df[\"signal\"]\n",
    "\n",
    "# split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train)\n",
    "X_test_scaled = scaler.transform(X_test)\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Dense(12, input_dim=X_train_scaled.shape[1], activation='relu'))\n",
    "model.add(Dense(8, activation='relu'))\n",
    "model.add(Dense(8, activation='relu'))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "\n",
    "model.compile(optimizer=Adam(), loss='binary_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "# train\n",
    "history = model.fit(\n",
    "    X_train_scaled, y_train,\n",
    "    epochs=20,  \n",
    "    batch_size=128,  \n",
    "    validation_split=0.2 \n",
    ")\n",
    "\n",
    "test_loss, test_accuracy = model.evaluate(X_test_scaled, y_test)\n",
    "print(f\"Test Loss: {test_loss}\")\n",
    "print(f\"Test Accuracy: {test_accuracy}\")\n",
    "\n",
    "plot_metrics_vs_epoch(\n",
    "    {\"accuracy\": history.history[\"accuracy\"], \"loss\": history.history[\"loss\"]},\n",
    "    {\"accuracy\": history.history[\"val_accuracy\"], \"loss\": history.history[\"val_loss\"]},\n",
    "    \"Neural Network\",\n",
    "    metrics=(\"accuracy\", \"loss\")\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_metrics_vs_epoch(train_history, val_history, model_name, metrics=('loss', 'accuracy')):\n",
    "\n",
    "    epochs = range(1, len(train_history[metrics[0]]) + 1)\n",
    "\n",
    "    plt.figure(figsize=(12, 6))\n",
    "\n",
    "    for metric in metrics:\n",
    "        plt.plot(epochs, train_history[metric], 'bo-', label=f'Training {metric}')\n",
    "        plt.plot(epochs, val_history[metric], 'ro-', label=f'Validation {metric}')\n",
    "\n",
    "    plt.title(f'Model Performance Over Epochs - {model_name}')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Metrics')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "plot_metrics_vs_epoch(\n",
    "    {\"accuracy\": history.history[\"accuracy\"], \"loss\": history.history[\"loss\"]},\n",
    "    {\"accuracy\": history.history[\"val_accuracy\"], \"loss\": history.history[\"val_loss\"]},\n",
    "    \"Neural Network\",\n",
    "    metrics=(\"accuracy\", \"loss\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "\n",
    "Following the original paper (see lab 6), make a comparison of the performance (using ROC curves and AUC) between models trained with raw, features, and raw+features data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "#from sklearn.preprocessing import StandardScaler\n",
    "#from sklearn.model_selection import train_test_split\n",
    "#import matplotlib.pyplot as plt\n",
    "\n",
    "X_raw = np.array(df[RawNames])\n",
    "y_raw = np.array(df[\"signal\"])\n",
    "\n",
    "X_features = np.array(df[FeatureNames])\n",
    "y_features = np.array(df[\"signal\"])\n",
    "\n",
    "X_combined = np.array(df[VarNames[1:]])\n",
    "y_combined = np.array(df[\"signal\"])\n",
    "\n",
    "# split\n",
    "X_raw_train, X_raw_test, y_raw_train, y_raw_test = train_test_split(X_raw, y_raw, test_size=0.2, random_state=42)\n",
    "X_features_train, X_features_test, y_features_train, y_features_test = train_test_split(\n",
    "    X_features, y_features, test_size=0.2, random_state=42\n",
    ")\n",
    "X_combined_train, X_combined_test, y_combined_train, y_combined_test = train_test_split(\n",
    "    X_combined, y_combined, test_size=0.2, random_state=42\n",
    ")\n",
    "\n",
    "# build and train\n",
    "def train_model(X_train, y_train):\n",
    "    model = RandomForestClassifier(random_state=42)\n",
    "    model.fit(X_train, y_train)\n",
    "    return model\n",
    "\n",
    "model_raw = train_model(X_raw_train, y_raw_train)\n",
    "model_features = train_model(X_features_train, y_features_train)\n",
    "model_combined = train_model(X_combined_train, y_combined_train)\n",
    "\n",
    "def evaluate_model(model, X_test, y_test):\n",
    "    y_prob = model.predict_proba(X_test)[:, 1]\n",
    "    fpr, tpr, _ = roc_curve(y_test, y_prob)\n",
    "    auc_score = auc(fpr, tpr)\n",
    "    return fpr, tpr, auc_score\n",
    "\n",
    "fpr_raw, tpr_raw, auc_raw = evaluate_model(model_raw, X_raw_test, y_raw_test)\n",
    "fpr_features, tpr_features, auc_features = evaluate_model(model_features, X_features_test, y_features_test)\n",
    "fpr_combined, tpr_combined, auc_combined = evaluate_model(model_combined, X_combined_test, y_combined_test)\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(fpr_raw, tpr_raw, label=f'Raw Data (AUC = {auc_raw:.2f})')\n",
    "plt.plot(fpr_features, tpr_features, label=f'Features Data (AUC = {auc_features:.2f})')\n",
    "plt.plot(fpr_combined, tpr_combined, label=f'Combined Data (AUC = {auc_combined:.2f})')\n",
    "\n",
    "plt.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Random')\n",
    "\n",
    "plt.title('ROC Curves for Different Models')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = RandomForestClassifier(random_state=42, n_estimators=100, max_depth=10, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def train_and_evaluate_model(X_train, y_train, X_test, y_test):\n",
    "    model = RandomForestClassifier(random_state=42, n_estimators=100, max_depth=10)  # Adjust hyperparameters as needed\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    y_prob = model.predict_proba(X_test)[:, 1]\n",
    "    fpr, tpr, _ = roc_curve(y_test, y_prob)\n",
    "    auc_score = auc(fpr, tpr)\n",
    "\n",
    "    return fpr, tpr, auc_score\n",
    "\n",
    "# spli\n",
    "X_raw_train, X_raw_test, y_raw_train, y_raw_test = train_test_split(X_raw, y_raw, test_size=0.2, random_state=42)\n",
    "X_features_train, X_features_test, y_features_train, y_features_test = train_test_split(X_features, y_features, test_size=0.2, random_state=42)\n",
    "X_combined_train, X_combined_test, y_combined_train, y_combined_test = train_test_split(X_combined, y_combined, test_size=0.2, random_state=42)\n",
    "\n",
    "# train\n",
    "fpr_raw, tpr_raw, auc_raw = train_and_evaluate_model(X_raw_train, y_raw_train, X_raw_test, y_raw_test)\n",
    "fpr_features, tpr_features, auc_features = train_and_evaluate_model(X_features_train, y_features_train, X_features_test, y_features_test)\n",
    "fpr_combined, tpr_combined, auc_combined = train_and_evaluate_model(X_combined_train, y_combined_train, X_combined_test, y_combined_test)\n",
    "\n",
    "print(\"AUC Raw:\", auc_raw)\n",
    "print(\"AUC Features:\", auc_features)\n",
    "print(\"AUC Combined:\", auc_combined)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'evaluate_model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_23460\\3235495976.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     23\u001b[0m )\n\u001b[0;32m     24\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 25\u001b[1;33m \u001b[0mfpr_raw\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtpr_raw\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mauc_raw\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mevaluate_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel_raw\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_raw_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_raw_test\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     26\u001b[0m \u001b[0mfpr_features\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtpr_features\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mauc_features\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mevaluate_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel_features\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_features_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_features_test\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     27\u001b[0m \u001b[0mfpr_combined\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtpr_combined\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mauc_combined\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mevaluate_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel_combined\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_combined_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_combined_test\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'evaluate_model' is not defined"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "X_raw = np.array(df[RawNames])\n",
    "y_raw = np.array(df[\"signal\"])\n",
    "\n",
    "X_features = np.array(df[FeatureNames])\n",
    "y_features = np.array(df[\"signal\"])\n",
    "\n",
    "X_combined = np.array(df[VarNames[1:]])\n",
    "y_combined = np.array(df[\"signal\"])\n",
    "\n",
    "# split\n",
    "X_raw_train, X_raw_test, y_raw_train, y_raw_test = train_test_split(X_raw, y_raw, test_size=0.2, random_state=42)\n",
    "X_features_train, X_features_test, y_features_train, y_features_test = train_test_split(\n",
    "    X_features, y_features, test_size=0.2, random_state=42\n",
    ")\n",
    "X_combined_train, X_combined_test, y_combined_train, y_combined_test = train_test_split(\n",
    "    X_combined, y_combined, test_size=0.2, random_state=42\n",
    ")\n",
    "\n",
    "fpr_raw, tpr_raw, auc_raw = evaluate_model(model_raw, X_raw_test, y_raw_test)\n",
    "fpr_features, tpr_features, auc_features = evaluate_model(model_features, X_features_test, y_features_test)\n",
    "fpr_combined, tpr_combined, auc_combined = evaluate_model(model_combined, X_combined_test, y_combined_test)\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(fpr_raw, tpr_raw, label=f'Raw Data (AUC = {auc_raw:.2f})')\n",
    "plt.plot(fpr_features, tpr_features, label=f'Features Data (AUC = {auc_features:.2f})')\n",
    "plt.plot(fpr_combined, tpr_combined, label=f'Combined Data (AUC = {auc_combined:.2f})')\n",
    "\n",
    "plt.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Random')\n",
    "\n",
    "plt.title('ROC Curves for Different Models')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "\n",
    "Design and implement at least 3 different DNN models. Train them and compare performance. You may try different architectures, loss functions, and optimizers to see if there is an effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 18)]              0         \n",
      "                                                                 \n",
      " dense_8 (Dense)             (None, 12)                228       \n",
      "                                                                 \n",
      " dense_9 (Dense)             (None, 8)                 104       \n",
      "                                                                 \n",
      " dense_10 (Dense)            (None, 8)                 72        \n",
      "                                                                 \n",
      " dense_11 (Dense)            (None, 1)                 9         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 413 (1.61 KB)\n",
      "Trainable params: 413 (1.61 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Model\n",
    "from keras.layers import Dense, Input\n",
    "\n",
    "in_x = Input(shape = X_Train.shape[1:])\n",
    "x = Dense(12, input_dim=X_Train.shape[1], activation='relu')(in_x)\n",
    "x = Dense(8, activation='relu')(x)\n",
    "x = Dense(8, activation='relu')(x)\n",
    "out_x = Dense(1, activation='sigmoid')(x)\n",
    "\n",
    "model = Model(in_x,out_x)\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_2 (InputLayer)        [(None, 18)]              0         \n",
      "                                                                 \n",
      " dense_12 (Dense)            (None, 12)                228       \n",
      "                                                                 \n",
      " dense_13 (Dense)            (None, 8)                 104       \n",
      "                                                                 \n",
      " tf.nn.relu (TFOpLambda)     (None, 8)                 0         \n",
      "                                                                 \n",
      " dense_14 (Dense)            (None, 1)                 9         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 341 (1.33 KB)\n",
      "Trainable params: 341 (1.33 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from keras.activations import relu\n",
    "\n",
    "in_x = Input(shape = X_Train.shape[1:])\n",
    "x = Dense(12, input_dim=X_Train.shape[1], activation='relu')(in_x)\n",
    "x = Dense(8)(x)\n",
    "x = relu(x)\n",
    "out_x = Dense(1, activation='sigmoid')(x)\n",
    "\n",
    "model = Model(in_x,out_x)\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4\n",
    "\n",
    "Repeat exercise 4 from Lab 7, adding your best performing DNN as one of the models.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "def compare_classifiers(classifier, X_train, y_train, X_test, y_test, label):\n",
    "    classifier.fit(X_train, y_train)\n",
    "    \n",
    "    train_scores = classifier.decision_function(X_train)\n",
    "    test_scores = classifier.decision_function(X_test)\n",
    "    \n",
    "    fpr_train, tpr_train, _ = roc_curve(y_train, train_scores)\n",
    "    fpr_test, tpr_test, _ = roc_curve(y_test, test_scores)\n",
    "    \n",
    "    roc_auc_train = auc(fpr_train, tpr_train)\n",
    "    roc_auc_test = auc(fpr_test, tpr_test)\n",
    "    \n",
    "    plt.figure()\n",
    "    plt.plot(fpr_train, tpr_train, color='blue', label=f'ROC curve (Train), AUC = {roc_auc_train:.2f}')\n",
    "    plt.plot(fpr_test, tpr_test, color='red', label=f'ROC curve (Test), AUC = {roc_auc_test:.2f}')\n",
    "    plt.plot([0, 1], [0, 1], color='gray', linestyle='--')  # Random classifier line\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title(f'Receiver Operating Characteristic (ROC) Curve - {label}')\n",
    "    plt.legend(loc='lower right')\n",
    "    plt.show()\n",
    "    \n",
    "    return roc_auc_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}