{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6a3fc02e",
   "metadata": {},
   "source": [
    "# Lesson 26: multilayer perceptron activity\n",
    "\n",
    "## Notebook set up\n",
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a4186739",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Third party imports\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import f1_score, roc_auc_score, log_loss, ConfusionMatrixDisplay\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.preprocessing import StandardScaler, OrdinalEncoder, OneHotEncoder, MinMaxScaler\n",
    "from sklearn.utils.class_weight import compute_sample_weight"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced7ed87",
   "metadata": {},
   "source": [
    "## 1. Data preparation\n",
    "\n",
    "### 1.1. Load diabetes dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c04a2b33",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('https://media.githubusercontent.com/media/gperdrizet/fullstack-2605/refs/heads/main/data/diabetes_train.csv')\n",
    "training_df, testing_df = train_test_split(df, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "579af308",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.DataFrame'>\n",
      "RangeIndex: 700000 entries, 0 to 699999\n",
      "Data columns (total 26 columns):\n",
      " #   Column                              Non-Null Count   Dtype  \n",
      "---  ------                              --------------   -----  \n",
      " 0   id                                  700000 non-null  int64  \n",
      " 1   age                                 700000 non-null  int64  \n",
      " 2   alcohol_consumption_per_week        700000 non-null  int64  \n",
      " 3   physical_activity_minutes_per_week  700000 non-null  int64  \n",
      " 4   diet_score                          700000 non-null  float64\n",
      " 5   sleep_hours_per_day                 700000 non-null  float64\n",
      " 6   screen_time_hours_per_day           700000 non-null  float64\n",
      " 7   bmi                                 700000 non-null  float64\n",
      " 8   waist_to_hip_ratio                  700000 non-null  float64\n",
      " 9   systolic_bp                         700000 non-null  int64  \n",
      " 10  diastolic_bp                        700000 non-null  int64  \n",
      " 11  heart_rate                          700000 non-null  int64  \n",
      " 12  cholesterol_total                   700000 non-null  int64  \n",
      " 13  hdl_cholesterol                     700000 non-null  int64  \n",
      " 14  ldl_cholesterol                     700000 non-null  int64  \n",
      " 15  triglycerides                       700000 non-null  int64  \n",
      " 16  gender                              700000 non-null  str    \n",
      " 17  ethnicity                           700000 non-null  str    \n",
      " 18  education_level                     700000 non-null  str    \n",
      " 19  income_level                        700000 non-null  str    \n",
      " 20  smoking_status                      700000 non-null  str    \n",
      " 21  employment_status                   700000 non-null  str    \n",
      " 22  family_history_diabetes             700000 non-null  int64  \n",
      " 23  hypertension_history                700000 non-null  int64  \n",
      " 24  cardiovascular_history              700000 non-null  int64  \n",
      " 25  diagnosed_diabetes                  700000 non-null  float64\n",
      "dtypes: float64(6), int64(14), str(6)\n",
      "memory usage: 138.9 MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "735e8b6c",
   "metadata": {},
   "source": [
    "Define the label and feature columns below. The label is `diabetes` (binary: 0 or 1). Using separate lists for numerical, nominal and ordinal features makes preprocessing easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b0e50bde",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the label\n",
    "label = 'diagnosed_diabetes'\n",
    "\n",
    "# Define numerical features to apply IQR clipping\n",
    "numerical_features = [\n",
    "    'age', 'alcohol_consumption_per_week', 'physical_activity_minutes_per_week',\n",
    "    'diet_score', 'sleep_hours_per_day', 'screen_time_hours_per_day', 'bmi',\n",
    "    'waist_to_hip_ratio', 'systolic_bp', 'diastolic_bp', 'heart_rate', 'cholesterol_total',\n",
    "    'hdl_cholesterol', 'ldl_cholesterol', 'triglycerides', 'family_history_diabetes',\n",
    "    'hypertension_history', 'cardiovascular_history'\n",
    "]\n",
    "\n",
    "# Define ordinal features to encode\n",
    "ordinal_features = ['education_level', 'income_level']\n",
    "\n",
    "# Define ordinal categories in order\n",
    "education_categories = [['No formal', 'Highschool', 'Graduate', 'Postgraduate']]\n",
    "income_categories = [['Low', 'Lower-Middle', 'Middle', 'Upper-Middle', 'High']]\n",
    "\n",
    "# Define features for one-hot encoding\n",
    "nominal_features = ['gender', 'ethnicity', 'smoking_status', 'employment_status']\n",
    "\n",
    "# Complete feature list\n",
    "features = numerical_features + ordinal_features + nominal_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "75c7e12e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select the features of interest and the label\n",
    "training_df = training_df[features + [label]]\n",
    "testing_df = testing_df[features + [label]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1981de6",
   "metadata": {},
   "source": [
    "### 1.2. Preprocess numerical features\n",
    "\n",
    "#### 1.2.1. Standard scale\n",
    "\n",
    "Neural networks perform better when features are scaled. Use `StandardScaler` to fit on the training features and transform both training and testing features.\n",
    "\n",
    "**Hint:** Fit the scaler on `training_df[features]`, then transform both `training_df[features]` and `testing_df[features]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "232a25d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_scaler = StandardScaler()\n",
    "feature_scaler.fit(training_df[numerical_features])\n",
    "\n",
    "training_df[numerical_features] = feature_scaler.transform(training_df[numerical_features])\n",
    "testing_df[numerical_features] = feature_scaler.transform(testing_df[numerical_features])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72692245",
   "metadata": {},
   "source": [
    "#### 1.2.2. Clip outliers with IQR method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b2069ad0",
   "metadata": {},
   "outputs": [],
   "source": [
    "for feature in numerical_features:\n",
    "\n",
    "    q1 = training_df[feature].quantile(0.25)\n",
    "    q3 = training_df[feature].quantile(0.75)\n",
    "    iqr = q3 - q1\n",
    "\n",
    "    lower_bound = q1 - 1.5 * iqr\n",
    "    upper_bound = q3 + 1.5 * iqr\n",
    "    training_df[feature] = training_df[feature].clip(lower_bound, upper_bound)\n",
    "    testing_df[feature] = testing_df[feature].clip(lower_bound, upper_bound)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6aa7cbd",
   "metadata": {},
   "source": [
    "### 1.3. Preprocess categorical features\n",
    "\n",
    "#### 1.3.1. Ordinal feature encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b1be554d",
   "metadata": {},
   "outputs": [],
   "source": [
    "ordinal_encoder = OrdinalEncoder(\n",
    "    categories=education_categories + income_categories,\n",
    "    handle_unknown='use_encoded_value',\n",
    "    unknown_value=-1\n",
    ")\n",
    "\n",
    "ordinal_encoder.fit(training_df[ordinal_features])\n",
    "\n",
    "training_df[ordinal_features] = ordinal_encoder.transform(training_df[ordinal_features])\n",
    "testing_df[ordinal_features] = ordinal_encoder.transform(testing_df[ordinal_features])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5532511f",
   "metadata": {},
   "source": [
    "#### 1.3.2. Nominal feature encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebf1a990",
   "metadata": {},
   "outputs": [],
   "source": [
    "onehot_encoder = OneHotEncoder(\n",
    "    drop='first',\n",
    "    sparse_output=False,\n",
    "    handle_unknown='ignore'\n",
    ")\n",
    "\n",
    "onehot_encoder.fit(training_df[nominal_features])\n",
    "\n",
    "# Capture encoded features as DataFrame\n",
    "encoded_features_df = pd.DataFrame(\n",
    "    onehot_encoder.transform(training_df[nominal_features]),\n",
    "    columns=onehot_encoder.get_feature_names_out(nominal_features)\n",
    ")\n",
    "\n",
    "# Remove original nominal features and add encoded versions\n",
    "training_df = pd.concat([\n",
    "    training_df.drop(columns=nominal_features).reset_index(drop=True),\n",
    "    encoded_features_df.reset_index(drop=True)\n",
    "], axis=1)\n",
    "\n",
    "training_df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "# Repeat for testing data\n",
    "encoded_features_df = pd.DataFrame(\n",
    "    onehot_encoder.transform(testing_df[nominal_features]),\n",
    "    columns=onehot_encoder.get_feature_names_out(nominal_features)\n",
    ")\n",
    "\n",
    "testing_df = pd.concat([\n",
    "    testing_df.drop(columns=nominal_features).reset_index(drop=True),\n",
    "    encoded_features_df.reset_index(drop=True)\n",
    "    ], axis=1)\n",
    "\n",
    "testing_df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33af5798",
   "metadata": {},
   "source": [
    "#### 1.3.3. Update the feature list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3feb472e",
   "metadata": {},
   "outputs": [],
   "source": [
    "features = training_df.columns.tolist()\n",
    "features.remove(label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f181db49",
   "metadata": {},
   "source": [
    "#### 1.3.4. Min/max scale categorical features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0f2e8fd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical_features = [feature for feature in features if feature not in numerical_features]\n",
    "\n",
    "categorical_scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "categorical_scaler.fit(training_df[categorical_features])\n",
    "\n",
    "training_df[categorical_features] = categorical_scaler.transform(training_df[categorical_features])\n",
    "testing_df[categorical_features] = categorical_scaler.transform(testing_df[categorical_features])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80005c89",
   "metadata": {},
   "source": [
    "## 2. Logistic regression model\n",
    "\n",
    "Logistic regression is a linear model for classification. It serves as a good baseline before trying more complex models like neural networks.\n",
    "\n",
    "### 2.1. Fit\n",
    "\n",
    "Create a `LogisticRegression` model and fit it on the training data. Use `max_iter=1000` to ensure convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ca564d0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "logistic_model = LogisticRegression(class_weight='balanced', max_iter=1000, random_state=315)\n",
    "fit_result = logistic_model.fit(training_df[features], training_df[label])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "689f8ca7",
   "metadata": {},
   "source": [
    "### 2.2. Test set evaluation\n",
    "\n",
    "For classification, we can use accuracy, F1 score and/or AUC-ROC (and others) instead of R². Use sklearn's [`metrics`](https://scikit-learn.org/stable/api/sklearn.metrics.html) module ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "22fa11d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic regression accuracy on test set: 0.6119\n",
      "Logistic regression F1 score on test set: 0.6675\n",
      "Logistic regression AUC-ROC score on test set: 0.6510\n"
     ]
    }
   ],
   "source": [
    "logistic_predictions = logistic_model.predict(testing_df[features])\n",
    "\n",
    "logistic_accuracy = logistic_model.score(testing_df[features], testing_df[label])\n",
    "logistic_f1 = f1_score(testing_df[label], logistic_predictions)\n",
    "logistic_auc = roc_auc_score(testing_df[label], logistic_model.predict_proba(testing_df[features])[:, 1])\n",
    "\n",
    "print(f'Logistic regression accuracy on test set: {logistic_accuracy:.4f}')\n",
    "print(f'Logistic regression F1 score on test set: {logistic_f1:.4f}')\n",
    "print(f'Logistic regression AUC-ROC score on test set: {logistic_auc:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "919e06cf",
   "metadata": {},
   "source": [
    "### 2.3. Performance analysis\n",
    "\n",
    "For classification, visualize performance using a confusion matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8c92bc5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4, 4))\n",
    "\n",
    "ax.set_title(f'Logistic regression test set performance\\n(accuracy: {logistic_accuracy:.2%})')\n",
    "\n",
    "disp_constant = ConfusionMatrixDisplay.from_predictions(\n",
    "    testing_df[label],\n",
    "    logistic_predictions,\n",
    "    normalize='true',\n",
    "    ax=ax,\n",
    "    colorbar=False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "879ce5e3",
   "metadata": {},
   "source": [
    "## 3. Multilayer perceptron (MLP) classifier\n",
    "\n",
    "Now let's build a neural network classifier using sklearn's [`MLPClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html).\n",
    "\n",
    "### 3.1. Single epoch training function\n",
    "\n",
    "Complete the training function below. It should:\n",
    "1. Split the data into training and validation sets\n",
    "2. Call `partial_fit` on the model\n",
    "3. Record training and validation [`log_loss`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html) (aka binary cross-entropy) in the history dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "605c3197",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model: MLPClassifier, df: pd.DataFrame, features: list, label: str, history: dict, classes: list = None) -> tuple[MLPClassifier, dict]:\n",
    "    '''Trains sklearn MLP classifier model on given dataframe using validation split.\n",
    "    Returns the updated model and training history dictionary containing training and\n",
    "    validation log loss. If classes are not provided, assumes 0 and 1.'''\n",
    "\n",
    "    df, val_df = train_test_split(df, stratify=df[label], random_state=315)\n",
    "\n",
    "    # Calculate sample weights\n",
    "    sample_weights = compute_sample_weight(class_weight='balanced', y=df[label])\n",
    "\n",
    "    model.partial_fit(\n",
    "        df[features], df[label],\n",
    "        classes=classes if classes is not None else [0, 1],\n",
    "        sample_weight=sample_weights\n",
    "    )\n",
    "\n",
    "    history['training_loss'].append(log_loss(df[label], model.predict_proba(df[features])))\n",
    "    history['validation_loss'].append(log_loss(val_df[label], model.predict_proba(val_df[features])))\n",
    "\n",
    "    return model, history"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17bf5072",
   "metadata": {},
   "source": [
    "### 3.2. Model training\n",
    "\n",
    "Create an `MLPClassifier` with:\n",
    "- `hidden_layer_sizes=(64, 32)` - two hidden layers\n",
    "- `activation='relu'` - ReLU activation function\n",
    "- `learning_rate_init=0.001` - initial learning rate\n",
    "- `warm_start=True` - keep weights between calls to fit\n",
    "- `random_state=315` - for reproducibility\n",
    "\n",
    "Train for 10 epochs using the training function above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "734cccf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/175 - training loss: 0.6617 - validation loss: 0.6618\n",
      "Epoch 10/175 - training loss: 0.6601 - validation loss: 0.6605\n",
      "Epoch 20/175 - training loss: 0.6582 - validation loss: 0.6585\n",
      "Epoch 30/175 - training loss: 0.6576 - validation loss: 0.6578\n",
      "Epoch 40/175 - training loss: 0.6570 - validation loss: 0.6572\n",
      "Epoch 50/175 - training loss: 0.6566 - validation loss: 0.6568\n",
      "Epoch 60/175 - training loss: 0.6562 - validation loss: 0.6565\n",
      "Epoch 70/175 - training loss: 0.6559 - validation loss: 0.6562\n",
      "Epoch 80/175 - training loss: 0.6557 - validation loss: 0.6561\n",
      "Epoch 90/175 - training loss: 0.6555 - validation loss: 0.6559\n",
      "Epoch 100/175 - training loss: 0.6553 - validation loss: 0.6558\n",
      "Epoch 110/175 - training loss: 0.6552 - validation loss: 0.6557\n",
      "Epoch 120/175 - training loss: 0.6551 - validation loss: 0.6557\n",
      "Epoch 130/175 - training loss: 0.6549 - validation loss: 0.6556\n",
      "Epoch 140/175 - training loss: 0.6548 - validation loss: 0.6555\n",
      "Epoch 150/175 - training loss: 0.6547 - validation loss: 0.6555\n",
      "Epoch 160/175 - training loss: 0.6546 - validation loss: 0.6554\n",
      "Epoch 170/175 - training loss: 0.6545 - validation loss: 0.6554\n",
      "Epoch 175/175 - training loss: 0.6545 - validation loss: 0.6554\n",
      "\n",
      "CPU times: user 44min 29s, sys: 2min 42s, total: 47min 12s\n",
      "Wall time: 13min 24s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "epochs = 175\n",
    "print_interval = 10\n",
    "\n",
    "training_history = {\n",
    "    'training_loss': [],\n",
    "    'validation_loss': []\n",
    "}\n",
    "\n",
    "mlp_model = MLPClassifier(\n",
    "    hidden_layer_sizes=(64, 32, 16),\n",
    "    activation='relu',\n",
    "    learning_rate_init=5e-6,\n",
    "    alpha=2e-4,\n",
    "    warm_start=True,\n",
    "    random_state=315\n",
    ")\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    mlp_model, training_history = train(mlp_model, training_df, features, label, training_history, classes=[0, 1])\n",
    "\n",
    "    if (epoch + 1) % print_interval == 0 or epoch == 0 or epoch == epochs - 1:\n",
    "\n",
    "        print(\n",
    "            f'Epoch {epoch+1}/{epochs} - ' +\n",
    "            f'training loss: {training_history[\"training_loss\"][-1]:.4f} - ' +\n",
    "            f'validation loss: {training_history[\"validation_loss\"][-1]:.4f}'\n",
    "        )\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76005d01",
   "metadata": {},
   "source": [
    "### 3.3. Learning curves\n",
    "\n",
    "Plot the training and validation loss over epochs to visualize the learning process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f7c94bd0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Learning curves')\n",
    "\n",
    "plt.plot(\n",
    "    range(1, epochs + 1), training_history['training_loss'],\n",
    "    label='Training loss'\n",
    ")\n",
    "\n",
    "plt.plot(\n",
    "    range(1, epochs + 1), training_history['validation_loss'],\n",
    "    label='Validation loss'\n",
    ")\n",
    "\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Binary cross-entropy loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2e947e3",
   "metadata": {},
   "source": [
    "### 3.4. Test set evaluation\n",
    "\n",
    "Evaluate the MLP model on the test set, similar to how you evaluated the logistic regression model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "36bc02a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MLP accuracy on test set: 0.6091\n",
      "MLP F1 score on test set: 0.6625\n",
      "MLP AUC-ROC score on test set: 0.6502\n"
     ]
    }
   ],
   "source": [
    "mlp_predictions = mlp_model.predict(testing_df[features])\n",
    "mlp_accuracy = mlp_model.score(testing_df[features], testing_df[label])\n",
    "mlp_f1 = f1_score(testing_df[label], mlp_predictions)\n",
    "mlp_auc = roc_auc_score(testing_df[label], mlp_model.predict_proba(testing_df[features])[:, 1])\n",
    "\n",
    "print(f'MLP accuracy on test set: {mlp_accuracy:.4f}')\n",
    "print(f'MLP F1 score on test set: {mlp_f1:.4f}')\n",
    "print(f'MLP AUC-ROC score on test set: {mlp_auc:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cff8e0",
   "metadata": {},
   "source": [
    "### 3.5. Performance analysis\n",
    "\n",
    "Create a confusion matrix for the MLP model predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "77851967",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4, 4))\n",
    "\n",
    "ax.set_title(f'MLPtest set performance\\n(accuracy: {mlp_accuracy:.2%})')\n",
    "\n",
    "disp_constant = ConfusionMatrixDisplay.from_predictions(\n",
    "    testing_df[label],\n",
    "    mlp_predictions,\n",
    "    normalize='true',\n",
    "    ax=ax,\n",
    "    colorbar=False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f1a0e4",
   "metadata": {},
   "source": [
    "## 4. Model comparison\n",
    "\n",
    "Compare the performance of both models side by side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "809e2c9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression accuracy on test set: 0.6119\n",
      "MLP accuracy on test set: 0.6091\n"
     ]
    }
   ],
   "source": [
    "print(f'Logistic Regression accuracy on test set: {logistic_accuracy:.4f}')\n",
    "print(f'MLP accuracy on test set: {mlp_accuracy:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bada64a",
   "metadata": {},
   "source": [
    "Create a side-by-side comparison of the confusion matrices for both models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "d06ec0a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare confusion matrices for baseline and trained model\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 4.5))\n",
    "\n",
    "fig.suptitle('Test set performance comparison')\n",
    "fig.supxlabel('Predicted label')\n",
    "fig.supylabel('True label')\n",
    "\n",
    "# Confusion matrix for constant 0 baseline\n",
    "axes[0].set_title(f'Logistic regression\\n(accuracy: {logistic_accuracy:.2%})')\n",
    "\n",
    "disp_constant = ConfusionMatrixDisplay.from_predictions(\n",
    "    testing_df[label],\n",
    "    logistic_predictions,\n",
    "    normalize='true',\n",
    "    ax=axes[0],\n",
    "    colorbar=False\n",
    ")\n",
    "\n",
    "axes[0].set_xlabel('')\n",
    "axes[0].set_ylabel('')\n",
    "\n",
    "# Confusion matrix for trained model\n",
    "axes[1].set_title(f'MLP\\n(accuracy: {mlp_accuracy:.2%})')\n",
    "\n",
    "disp_model = ConfusionMatrixDisplay.from_predictions(\n",
    "    testing_df[label],\n",
    "    mlp_predictions,\n",
    "    normalize='true',\n",
    "    ax=axes[1],\n",
    "    colorbar=False\n",
    ")\n",
    "\n",
    "axes[1].set_xlabel('')\n",
    "axes[1].set_ylabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv (3.12.3)",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}