{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import statsmodels.api as sm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from itertools import product\n",
    "from sklearn.metrics import f1_score, recall_score, roc_auc_score, accuracy_score\n",
    "from imblearn.over_sampling import SMOTE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "# os.chdir(\"your path\") # uncomment to change the working directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the data files\n",
    "df_public = pd.read_csv('lc_loan.csv')\n",
    "# df_private = pd.read_csv('lc_loan_private.csv') # students do not have access to this file\n",
    "df_test = pd.read_csv('lc_loan_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot histogram of 'return' grouped by 'loan_status'\n",
    "df_public.groupby('loan_status')['return'].plot(kind='hist', alpha=0.5, legend=True, bins=30)\n",
    "plt.title('Histogram of Return Grouped by Loan Status')\n",
    "plt.xlabel('Return')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_r2(y, pred_y, benchmark = 0, is_train = True):\n",
    "\n",
    "    # Determine the benchmark\n",
    "    if is_train:\n",
    "        benchmark = y.mean()\n",
    "\n",
    "    # Calculate the total sum of squares (TSS)\n",
    "    tss = np.sum((y - benchmark) ** 2)\n",
    "\n",
    "    # Calculate the residual sum of squares (RSS)\n",
    "    rss = np.sum((y - pred_y) ** 2)\n",
    "\n",
    "    # Calculate R-squared\n",
    "    r_squared = 1 - (rss / tss)\n",
    "\n",
    "    return r_squared\n",
    "\n",
    "def feature_split(data):\n",
    "    \n",
    "    # split features and predictors\n",
    "    X = data.drop(columns=['id', 'issue_d', 'loan_status', 'year', 'early_default', 'return'])\n",
    "    loan_return = data['return']\n",
    "    loan_default = data['early_default']\n",
    "\n",
    "    return X, loan_return, loan_default\n",
    "\n",
    "def expanding_window(data, model, subsample=1, type='regression', threshold = 0.5):\n",
    "    # split training and validation\n",
    "    train_window = [2008, 2009, 2010, 2011, 2012]\n",
    "    val_window = 2013\n",
    "    train_eval, val_eval, val_n = [], [], []\n",
    "\n",
    "    while val_window < 2017:\n",
    "        # prepare data\n",
    "        train_df = data[data['year'].isin(train_window)].sample(frac=subsample, replace=False, random_state=528)\n",
    "        val_df = data[data['year'].isin([val_window])].sample(frac=subsample, replace=False, random_state=528)\n",
    "\n",
    "        X_train, return_train, default_train = feature_split(train_df)\n",
    "        X_val, return_val, default_val = feature_split(val_df)\n",
    "\n",
    "        # train and validation\n",
    "        if type == 'regression':\n",
    "            # get supervised label\n",
    "            y_train = return_train\n",
    "            y_val = return_val\n",
    "\n",
    "            # model\n",
    "            model.fit(X_train, y_train)  # training\n",
    "            train_pred = model.predict(X_train)  # in-sample prediction\n",
    "            val_pred = model.predict(X_val)  # out-of-sample prediction\n",
    "            in_sample_eval = get_r2(y_train, train_pred, is_train=True)  # in-sample evaluation\n",
    "            out_of_sample_eval = get_r2(y_val, val_pred, benchmark=0, is_train=False)  # out-of-sample evaluation\n",
    "        elif type == 'classification':\n",
    "            # resampling\n",
    "            smote_ratio = 0.3  # Define the ratio for SMOTE: 3:7 ratio for minority to majority\n",
    "            smote = SMOTE(sampling_strategy=smote_ratio, random_state=42) # Initialize SMOTE\n",
    "            X_train, default_train = smote.fit_resample(X_train, default_train) # Apply SMOTE to the training data\n",
    "\n",
    "            # get supervised label\n",
    "            y_train = default_train\n",
    "            y_val = default_val\n",
    "\n",
    "            # model\n",
    "            model.fit(X_train, y_train)  # training\n",
    "            train_prob = model.predict_proba(X_train)[:, 1]  # probability of y=1 for training set\n",
    "            val_prob = model.predict_proba(X_val)[:, 1]  # probability of y=1 for validation set\n",
    "            \n",
    "            # convert probabilities to predictions using threshold of threshold\n",
    "            train_pred = (train_prob >= threshold).astype(int)\n",
    "            val_pred = (val_prob >= threshold).astype(int)\n",
    "            \n",
    "            in_sample_eval = f1_score(y_train, train_pred)  # in-sample evaluation\n",
    "            out_of_sample_eval = f1_score(y_val, val_pred)  # out-of-sample evaluation\n",
    "        else:\n",
    "            print(\"The specified model type is not supported.\")\n",
    "            return 0, 0 \n",
    "\n",
    "        train_eval.append(in_sample_eval)\n",
    "        val_eval.append(out_of_sample_eval)\n",
    "        val_n.append(len(return_val))\n",
    "\n",
    "        # update expanding window\n",
    "        train_window.append(val_window)\n",
    "        val_window += 1\n",
    "    \n",
    "    # calculate the weighted average of validation evaluation\n",
    "    avg_train_eval = np.mean(train_eval)\n",
    "    avg_val_eval = sum(r * n for r, n in zip(val_eval, val_n)) / sum(val_n)\n",
    "\n",
    "    return avg_train_eval, avg_val_eval\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Missing Value Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Missing Values</th>\n",
       "      <th>Percentage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mths_since_last_delinq</th>\n",
       "      <td>464293</td>\n",
       "      <td>49.754919</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>emp_length</th>\n",
       "      <td>58768</td>\n",
       "      <td>6.297741</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Missing Values  Percentage\n",
       "mths_since_last_delinq          464293   49.754919\n",
       "emp_length                       58768    6.297741"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# missing value\n",
    "missing_values = df_public.isnull().sum()\n",
    "missing_percentage = (missing_values / len(df_public)) * 100\n",
    "missing_data = pd.DataFrame({'Missing Values': missing_values, 'Percentage': missing_percentage})\n",
    "missing_tmp = missing_data[missing_data['Missing Values'] > 0]\n",
    "\n",
    "# lookup table\n",
    "missing_tmp.sort_values(by='Missing Values', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Missing Values</th>\n",
       "      <th>Percentage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mths_since_last_delinq</th>\n",
       "      <td>54347</td>\n",
       "      <td>5.823974</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>emp_length</th>\n",
       "      <td>8374</td>\n",
       "      <td>0.897381</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Missing Values  Percentage\n",
       "mths_since_last_delinq           54347    5.823974\n",
       "emp_length                        8374    0.897381"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# missing value\n",
    "missing_values = df_test.isnull().sum()\n",
    "missing_percentage = (missing_values / len(df_public)) * 100\n",
    "missing_data = pd.DataFrame({'Missing Values': missing_values, 'Percentage': missing_percentage})\n",
    "missing_tmp = missing_data[missing_data['Missing Values'] > 0]\n",
    "\n",
    "# lookup table\n",
    "missing_tmp.sort_values(by='Missing Values', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mths_since_last_delinq\n",
    "df_public['dummy_delinq'] = df_public['mths_since_last_delinq'].isnull().astype(int)\n",
    "max_delinq = df_public['mths_since_last_delinq'].max()\n",
    "df_public['mths_since_last_delinq'] = df_public['mths_since_last_delinq'].fillna(max_delinq)\n",
    "df_public['inter_delinq'] = df_public['dummy_delinq'] * df_public['mths_since_last_delinq']\n",
    "\n",
    "# emp_length\n",
    "df_public['emp_length'] = df_public['emp_length'].replace({'10+ years': '10', '< 1 year': '0'}).str.extract('(\\d+)').astype(float)\n",
    "average_emp_length = df_public['emp_length'].mean()\n",
    "df_public['emp_length'] = df_public['emp_length'].fillna(average_emp_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Categorical Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['grade', 'sub_grade', 'home_ownership', 'verification_status',\n",
      "       'issue_d', 'loan_status', 'purpose', 'zip_code', 'addr_state',\n",
      "       'earliest_cr_line'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# print the categorical features\n",
    "non_numeric_columns = df_public.select_dtypes(exclude=['int64', 'float64']).columns\n",
    "print(non_numeric_columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# grade and subgrade\n",
    "df_public.drop(columns=['sub_grade'], inplace=True)\n",
    "grade_dummies = pd.get_dummies(df_public['grade'], prefix='grade', drop_first=True).astype(int)\n",
    "df_public = pd.concat([df_public, grade_dummies], axis=1)\n",
    "df_public.drop(columns=['grade'], inplace=True)\n",
    "\n",
    "# homeownership\n",
    "home_ownership_dummies = pd.get_dummies(df_public['home_ownership'], prefix='home', drop_first=False).astype(int)\n",
    "home_ownership_dummies.drop(columns=[\"home_ANY\", \"home_OTHER\", \"home_NONE\"], inplace=True)\n",
    "df_public = pd.concat([df_public, home_ownership_dummies], axis=1)\n",
    "df_public.drop(columns=['home_ownership'], inplace=True)\n",
    "\n",
    "# verification_status\n",
    "df_public['verification_status'] = df_public['verification_status'].map({'Not Verified': 0, 'Verified': 1, 'Source Verified': 1})\n",
    "\n",
    "# purpose\n",
    "purpose_dummies = pd.get_dummies(df_public['purpose'], prefix='purpose', drop_first=True).astype(int)\n",
    "df_public = pd.concat([df_public, purpose_dummies], axis=1)\n",
    "df_public.drop(columns=['purpose'], inplace=True)\n",
    "\n",
    "# earliest_cr_line\n",
    "df_public['earliest_cr_line'] = pd.to_datetime(df_public['earliest_cr_line'], format='%b-%Y')\n",
    "df_public['issue_d'] = pd.to_datetime(df_public['issue_d'], format='%b-%Y')\n",
    "df_public['length_credit'] = (df_public['issue_d'] - df_public['earliest_cr_line']).dt.days / 365.25\n",
    "df_public.drop(columns=['earliest_cr_line'], inplace=True)\n",
    "\n",
    "# fico_range_low and fico_range_high\n",
    "df_public.drop(columns=['fico_range_high'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# interaction term: Annual income and verification\n",
    "df_public['inter_income'] = df_public['verification_status'] * df_public['annual_inc']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# feature engineering: create a new feature state_income\n",
    "state_income = df_public[df_public['verification_status'] == 1].groupby(['addr_state', 'year'])['annual_inc'].mean().reset_index()\n",
    "state_income.rename(columns={'annual_inc': 'state_income'}, inplace=True)\n",
    "df_public = df_public.merge(state_income, on=['addr_state', 'year'], how='left')\n",
    "df_public['state_income'] = df_public['state_income'].fillna(df_public['state_income'].mean())\n",
    "\n",
    "# drop the location related features\n",
    "df_public.drop(columns=['addr_state','zip_code'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop 'loan_amnt' since 'loan_amnt' and 'funded_amnt' are highly correlated\n",
    "df_public.drop(columns=['loan_amnt'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# standardize features\n",
    "scale_fea_set = ['funded_amnt', 'installment', 'emp_length', 'annual_inc', \n",
    "                'dti', 'delinq_2yrs', 'fico_range_low', 'inq_last_6mths', \n",
    "                'mths_since_last_delinq', 'open_acc', 'pub_rec', 'revol_bal', \n",
    "                'revol_util', 'total_acc', 'collections_12_mths_ex_med',\n",
    "                'acc_now_delinq', 'chargeoff_within_12_mths', 'delinq_amnt',\n",
    "                'pub_rec_bankruptcies', 'tax_liens', 'inter_delinq',\n",
    "                'length_credit', 'inter_income', 'state_income']\n",
    "\n",
    "# Standardize the features in scale_fea_set for data\n",
    "scaled_df = pd.DataFrame(columns=df_public.columns)\n",
    "\n",
    "# Use a list to collect scaled dataframes for concatenation\n",
    "scaled_dataframes = []\n",
    "\n",
    "for year, data in df_public.groupby('year'):\n",
    "    scaler = StandardScaler()\n",
    "    # Standardize the features\n",
    "    data[scale_fea_set] = scaler.fit_transform(data[scale_fea_set])\n",
    "    # Append the scaled data to the list\n",
    "    scaled_dataframes.append(data)\n",
    "\n",
    "# Concatenate all scaled dataframes at once\n",
    "scaled_df = pd.concat(scaled_dataframes, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gradient-Boosted Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/yv/vzpq5vmx6_qg5lfn6g6yvn5c0000gp/T/ipykernel_42940/2269870631.py:19: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training R2: 0.01764143804839799, Validation R2: 0.06405904839143779 for learning_rate=0.01, max_depth=5, subsample=0.7\n",
      "Training R2: 0.01744685042583413, Validation R2: 0.06365754590951506 for learning_rate=0.01, max_depth=5, subsample=0.9\n",
      "Training R2: 0.05777295141909569, Validation R2: 0.065239996468383 for learning_rate=0.01, max_depth=9, subsample=0.7\n",
      "Training R2: 0.06107862677940504, Validation R2: 0.06507770897112648 for learning_rate=0.01, max_depth=9, subsample=0.9\n",
      "Training R2: 0.12694579537848136, Validation R2: 0.06485804514056065 for learning_rate=0.01, max_depth=12, subsample=0.7\n",
      "Training R2: 0.14017844129360682, Validation R2: 0.06503748097323712 for learning_rate=0.01, max_depth=12, subsample=0.9\n",
      "Training R2: 0.010669864406489399, Validation R2: 0.06194180943766506 for learning_rate=0.005, max_depth=5, subsample=0.7\n",
      "Training R2: 0.010483348267882664, Validation R2: 0.06205905144157727 for learning_rate=0.005, max_depth=5, subsample=0.9\n",
      "Training R2: 0.03328539834983332, Validation R2: 0.06349478396808778 for learning_rate=0.005, max_depth=9, subsample=0.7\n",
      "Training R2: 0.03478939540789358, Validation R2: 0.06300917450169848 for learning_rate=0.005, max_depth=9, subsample=0.9\n",
      "Training R2: 0.07130155132131999, Validation R2: 0.06376439892492293 for learning_rate=0.005, max_depth=12, subsample=0.7\n",
      "Training R2: 0.07900965837554433, Validation R2: 0.06397682767602281 for learning_rate=0.005, max_depth=12, subsample=0.9\n"
     ]
    }
   ],
   "source": [
    "# Define the parameter grid\n",
    "param_grid = {\n",
    "    'learning_rate': [0.01, 0.005],\n",
    "    'max_depth': [5, 9, 12],\n",
    "    'subsample': [0.7, 0.9]\n",
    "}\n",
    "\n",
    "# Generate all combinations of parameters\n",
    "param_combinations = list(product(param_grid['learning_rate'], param_grid['max_depth'], param_grid['subsample']))\n",
    "\n",
    "# Create a dataframe to store the validation results\n",
    "exp_wind_results = pd.DataFrame(columns=[\"model\", \"specification\", \"train R2\", \"validation R2\"])\n",
    "\n",
    "for lr, max_depth, subsample in param_combinations:\n",
    "    gb_model = GradientBoostingRegressor(n_estimators = 100, learning_rate = lr, max_depth = max_depth, subsample = subsample)\n",
    "    avg_train_r2, avg_val_r2 = expanding_window(scaled_df, gb_model, subsample = 0.8)\n",
    "    \n",
    "    exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n",
    "        \"model\": \"GradientBoostingRegressor\",\n",
    "        \"specification\": f\"learning_rate={lr}, max_depth={max_depth}, subsample={subsample}\",\n",
    "        \"train R2\": avg_train_r2,\n",
    "        \"validation R2\": avg_val_r2\n",
    "    }])], ignore_index=True)\n",
    "\n",
    "    print(f\"Training R2: {avg_train_r2}, Validation R2: {avg_val_r2} for learning_rate={lr}, max_depth={max_depth}, subsample={subsample}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model</th>\n",
       "      <th>specification</th>\n",
       "      <th>train R2</th>\n",
       "      <th>validation R2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.01, max_depth=9, subsample=0.7</td>\n",
       "      <td>0.057773</td>\n",
       "      <td>0.065240</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.01, max_depth=9, subsample=0.9</td>\n",
       "      <td>0.061079</td>\n",
       "      <td>0.065078</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.01, max_depth=12, subsample=0.9</td>\n",
       "      <td>0.140178</td>\n",
       "      <td>0.065037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.01, max_depth=12, subsample=0.7</td>\n",
       "      <td>0.126946</td>\n",
       "      <td>0.064858</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.01, max_depth=5, subsample=0.7</td>\n",
       "      <td>0.017641</td>\n",
       "      <td>0.064059</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.005, max_depth=12, subsample=0.9</td>\n",
       "      <td>0.079010</td>\n",
       "      <td>0.063977</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.005, max_depth=12, subsample=0.7</td>\n",
       "      <td>0.071302</td>\n",
       "      <td>0.063764</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.01, max_depth=5, subsample=0.9</td>\n",
       "      <td>0.017447</td>\n",
       "      <td>0.063658</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.005, max_depth=9, subsample=0.7</td>\n",
       "      <td>0.033285</td>\n",
       "      <td>0.063495</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.005, max_depth=9, subsample=0.9</td>\n",
       "      <td>0.034789</td>\n",
       "      <td>0.063009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.005, max_depth=5, subsample=0.9</td>\n",
       "      <td>0.010483</td>\n",
       "      <td>0.062059</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>GradientBoostingRegressor</td>\n",
       "      <td>learning_rate=0.005, max_depth=5, subsample=0.7</td>\n",
       "      <td>0.010670</td>\n",
       "      <td>0.061942</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        model  \\\n",
       "2   GradientBoostingRegressor   \n",
       "3   GradientBoostingRegressor   \n",
       "5   GradientBoostingRegressor   \n",
       "4   GradientBoostingRegressor   \n",
       "0   GradientBoostingRegressor   \n",
       "11  GradientBoostingRegressor   \n",
       "10  GradientBoostingRegressor   \n",
       "1   GradientBoostingRegressor   \n",
       "8   GradientBoostingRegressor   \n",
       "9   GradientBoostingRegressor   \n",
       "7   GradientBoostingRegressor   \n",
       "6   GradientBoostingRegressor   \n",
       "\n",
       "                                       specification  train R2  validation R2  \n",
       "2     learning_rate=0.01, max_depth=9, subsample=0.7  0.057773       0.065240  \n",
       "3     learning_rate=0.01, max_depth=9, subsample=0.9  0.061079       0.065078  \n",
       "5    learning_rate=0.01, max_depth=12, subsample=0.9  0.140178       0.065037  \n",
       "4    learning_rate=0.01, max_depth=12, subsample=0.7  0.126946       0.064858  \n",
       "0     learning_rate=0.01, max_depth=5, subsample=0.7  0.017641       0.064059  \n",
       "11  learning_rate=0.005, max_depth=12, subsample=0.9  0.079010       0.063977  \n",
       "10  learning_rate=0.005, max_depth=12, subsample=0.7  0.071302       0.063764  \n",
       "1     learning_rate=0.01, max_depth=5, subsample=0.9  0.017447       0.063658  \n",
       "8    learning_rate=0.005, max_depth=9, subsample=0.7  0.033285       0.063495  \n",
       "9    learning_rate=0.005, max_depth=9, subsample=0.9  0.034789       0.063009  \n",
       "7    learning_rate=0.005, max_depth=5, subsample=0.9  0.010483       0.062059  \n",
       "6    learning_rate=0.005, max_depth=5, subsample=0.7  0.010670       0.061942  "
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_wind_results = exp_wind_results.sort_values(by=\"validation R2\", ascending=False)\n",
    "exp_wind_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimal parameters for GradientBoostingRegressor according the expanding window validation is: *learning_rate*=0.01, *max_depth*=9, *subsample*=0.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/yv/vzpq5vmx6_qg5lfn6g6yvn5c0000gp/T/ipykernel_51480/414490802.py:19: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training R2: 0.01583910187814036, Validation R2: 0.061509808604499686 for learning_rate=0.01, hidden_layers=(32, 16), activation=relu\n",
      "Training R2: 0.018755508091779116, Validation R2: 0.06595107350940375 for learning_rate=0.01, hidden_layers=(32, 16), activation=logistic\n",
      "Training R2: 0.01644950445947485, Validation R2: 0.06205419072849019 for learning_rate=0.01, hidden_layers=(32, 16, 8), activation=relu\n",
      "Training R2: 0.018099271487807572, Validation R2: 0.06550831494030653 for learning_rate=0.01, hidden_layers=(32, 16, 8), activation=logistic\n",
      "Training R2: 0.017658437874900096, Validation R2: 0.062026176721712775 for learning_rate=0.01, hidden_layers=(32, 16, 8, 8), activation=relu\n",
      "Training R2: 0.017086361008203738, Validation R2: 0.06565205626122754 for learning_rate=0.01, hidden_layers=(32, 16, 8, 8), activation=logistic\n",
      "Training R2: 0.022780225317820535, Validation R2: 0.06618840064346006 for learning_rate=0.005, hidden_layers=(32, 16), activation=relu\n",
      "Training R2: 0.021117698189476897, Validation R2: 0.06606361720528572 for learning_rate=0.005, hidden_layers=(32, 16), activation=logistic\n",
      "Training R2: 0.019980992545609644, Validation R2: 0.06727107611466968 for learning_rate=0.005, hidden_layers=(32, 16, 8), activation=relu\n",
      "Training R2: 0.021105566091994404, Validation R2: 0.0680632947683734 for learning_rate=0.005, hidden_layers=(32, 16, 8), activation=logistic\n",
      "Training R2: 0.023563229438384486, Validation R2: 0.06627520727874922 for learning_rate=0.005, hidden_layers=(32, 16, 8, 8), activation=relu\n",
      "Training R2: 0.02056620826526348, Validation R2: 0.06627090470483184 for learning_rate=0.005, hidden_layers=(32, 16, 8, 8), activation=logistic\n",
      "Training R2: 0.028400639661109284, Validation R2: 0.0650651642668522 for learning_rate=0.001, hidden_layers=(32, 16), activation=relu\n",
      "Training R2: 0.020229535905753215, Validation R2: 0.06899344521266759 for learning_rate=0.001, hidden_layers=(32, 16), activation=logistic\n",
      "Training R2: 0.028407381022511086, Validation R2: 0.06651371572490089 for learning_rate=0.001, hidden_layers=(32, 16, 8), activation=relu\n",
      "Training R2: 0.020854726561278042, Validation R2: 0.06898309980904135 for learning_rate=0.001, hidden_layers=(32, 16, 8), activation=logistic\n",
      "Training R2: 0.0273432601913475, Validation R2: 0.06271554841489667 for learning_rate=0.001, hidden_layers=(32, 16, 8, 8), activation=relu\n",
      "Training R2: 0.02174785083798167, Validation R2: 0.06866067932145022 for learning_rate=0.001, hidden_layers=(32, 16, 8, 8), activation=logistic\n"
     ]
    }
   ],
   "source": [
    "# Define the parameter grid\n",
    "param_grid = {\n",
    "    'learning_rate_init': [0.01, 0.005, 0.001],  # Learning rate for the MLP\n",
    "    'hidden_layer_sizes': [(32, 16), (32, 16, 8), (32, 16, 8, 8)],  # Tuning the number of hidden layers\n",
    "    'activation': ['relu', 'logistic']  # Activation functions to try\n",
    "}\n",
    "\n",
    "# Generate all combinations of parameters\n",
    "param_combinations = list(product(param_grid['learning_rate_init'], param_grid['hidden_layer_sizes'], param_grid['activation']))\n",
    "\n",
    "# Create a dataframe to store the validation results\n",
    "exp_wind_results = pd.DataFrame(columns=[\"model\", \"specification\", \"train R2\", \"validation R2\"])\n",
    "\n",
    "for lr, hidden_layers, activation in param_combinations:\n",
    "    nn_model = MLPRegressor(hidden_layer_sizes=hidden_layers, learning_rate_init=lr, activation=activation, max_iter=1000, \n",
    "                            batch_size = 128, early_stopping = True, n_iter_no_change = 10, random_state=42)\n",
    "    avg_train_r2, avg_val_r2 = expanding_window(scaled_df, nn_model, subsample=0.8)\n",
    "    \n",
    "    exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n",
    "        \"model\": \"MLPRegressor\",\n",
    "        \"specification\": f\"lr={lr}, hid_layer={hidden_layers}, act={activation}\",\n",
    "        \"train R2\": avg_train_r2,\n",
    "        \"validation R2\": avg_val_r2\n",
    "    }])], ignore_index=True)\n",
    "\n",
    "    print(f\"Training R2: {avg_train_r2}, Validation R2: {avg_val_r2} for learning_rate={lr}, hidden_layers={hidden_layers}, activation={activation}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model</th>\n",
       "      <th>specification</th>\n",
       "      <th>train R2</th>\n",
       "      <th>validation R2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16), act=logistic</td>\n",
       "      <td>0.020230</td>\n",
       "      <td>0.068993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8), act=logistic</td>\n",
       "      <td>0.020855</td>\n",
       "      <td>0.068983</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8, 8), act=logistic</td>\n",
       "      <td>0.021748</td>\n",
       "      <td>0.068661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8), act=logistic</td>\n",
       "      <td>0.021106</td>\n",
       "      <td>0.068063</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8), act=relu</td>\n",
       "      <td>0.019981</td>\n",
       "      <td>0.067271</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8), act=relu</td>\n",
       "      <td>0.028407</td>\n",
       "      <td>0.066514</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8, 8), act=relu</td>\n",
       "      <td>0.023563</td>\n",
       "      <td>0.066275</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8, 8), act=logistic</td>\n",
       "      <td>0.020566</td>\n",
       "      <td>0.066271</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16), act=relu</td>\n",
       "      <td>0.022780</td>\n",
       "      <td>0.066188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16), act=logistic</td>\n",
       "      <td>0.021118</td>\n",
       "      <td>0.066064</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16), act=logistic</td>\n",
       "      <td>0.018756</td>\n",
       "      <td>0.065951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8, 8), act=logistic</td>\n",
       "      <td>0.017086</td>\n",
       "      <td>0.065652</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8), act=logistic</td>\n",
       "      <td>0.018099</td>\n",
       "      <td>0.065508</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16), act=relu</td>\n",
       "      <td>0.028401</td>\n",
       "      <td>0.065065</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8, 8), act=relu</td>\n",
       "      <td>0.027343</td>\n",
       "      <td>0.062716</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8), act=relu</td>\n",
       "      <td>0.016450</td>\n",
       "      <td>0.062054</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8, 8), act=relu</td>\n",
       "      <td>0.017658</td>\n",
       "      <td>0.062026</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MLPRegressor</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16), act=relu</td>\n",
       "      <td>0.015839</td>\n",
       "      <td>0.061510</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           model                                     specification  train R2  \\\n",
       "13  MLPRegressor        lr=0.001, hid_layer=(32, 16), act=logistic  0.020230   \n",
       "15  MLPRegressor     lr=0.001, hid_layer=(32, 16, 8), act=logistic  0.020855   \n",
       "17  MLPRegressor  lr=0.001, hid_layer=(32, 16, 8, 8), act=logistic  0.021748   \n",
       "9   MLPRegressor     lr=0.005, hid_layer=(32, 16, 8), act=logistic  0.021106   \n",
       "8   MLPRegressor         lr=0.005, hid_layer=(32, 16, 8), act=relu  0.019981   \n",
       "14  MLPRegressor         lr=0.001, hid_layer=(32, 16, 8), act=relu  0.028407   \n",
       "10  MLPRegressor      lr=0.005, hid_layer=(32, 16, 8, 8), act=relu  0.023563   \n",
       "11  MLPRegressor  lr=0.005, hid_layer=(32, 16, 8, 8), act=logistic  0.020566   \n",
       "6   MLPRegressor            lr=0.005, hid_layer=(32, 16), act=relu  0.022780   \n",
       "7   MLPRegressor        lr=0.005, hid_layer=(32, 16), act=logistic  0.021118   \n",
       "1   MLPRegressor         lr=0.01, hid_layer=(32, 16), act=logistic  0.018756   \n",
       "5   MLPRegressor   lr=0.01, hid_layer=(32, 16, 8, 8), act=logistic  0.017086   \n",
       "3   MLPRegressor      lr=0.01, hid_layer=(32, 16, 8), act=logistic  0.018099   \n",
       "12  MLPRegressor            lr=0.001, hid_layer=(32, 16), act=relu  0.028401   \n",
       "16  MLPRegressor      lr=0.001, hid_layer=(32, 16, 8, 8), act=relu  0.027343   \n",
       "2   MLPRegressor          lr=0.01, hid_layer=(32, 16, 8), act=relu  0.016450   \n",
       "4   MLPRegressor       lr=0.01, hid_layer=(32, 16, 8, 8), act=relu  0.017658   \n",
       "0   MLPRegressor             lr=0.01, hid_layer=(32, 16), act=relu  0.015839   \n",
       "\n",
       "    validation R2  \n",
       "13       0.068993  \n",
       "15       0.068983  \n",
       "17       0.068661  \n",
       "9        0.068063  \n",
       "8        0.067271  \n",
       "14       0.066514  \n",
       "10       0.066275  \n",
       "11       0.066271  \n",
       "6        0.066188  \n",
       "7        0.066064  \n",
       "1        0.065951  \n",
       "5        0.065652  \n",
       "3        0.065508  \n",
       "12       0.065065  \n",
       "16       0.062716  \n",
       "2        0.062054  \n",
       "4        0.062026  \n",
       "0        0.061510  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_wind_results = exp_wind_results.sort_values(by=\"validation R2\", ascending=False)\n",
    "exp_wind_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimal parameters for MLPRegressor according the expanding window validation is: *learning_rate*=0.001, *hidden_layer_sizes*=(32,16), *activation*=logistic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gradient Boosted Tree Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Baseline Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the training data into train and validation sets (70:30)\n",
    "train_df, val_df = train_test_split(scaled_df, test_size=0.3, random_state=528)\n",
    "\n",
    "X_train, return_train, default_train = feature_split(train_df)\n",
    "X_val, return_val, default_val = feature_split(val_df)\n",
    "\n",
    "# Define the ratio for SMOTE\n",
    "smote_ratio = 0.3  # 3:7 ratio for minority to majority\n",
    "\n",
    "# Initialize SMOTE\n",
    "smote = SMOTE(sampling_strategy=smote_ratio, random_state=42)\n",
    "\n",
    "# Apply SMOTE to the training data\n",
    "X_train_resampled, y_train_resampled = smote.fit_resample(X_train, default_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create and train the GradientBoostingClassifier\n",
    "gb_model = GradientBoostingClassifier(\n",
    "    learning_rate=0.01,\n",
    "    n_estimators=100,\n",
    "    max_depth=6,\n",
    "    subsample=0.8,\n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "# Fit the model on the training data\n",
    "gb_model.fit(X_train_resampled, y_train_resampled)\n",
    "\n",
    "# Predict the default probability on the validation set\n",
    "default_prob_gb = gb_model.predict_proba(X_val)[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Threshold: 0.10, F1 Score: 0.1037\n",
      "Threshold: 0.11, F1 Score: 0.1122\n",
      "Threshold: 0.12, F1 Score: 0.1216\n",
      "Threshold: 0.13, F1 Score: 0.1264\n",
      "Threshold: 0.14, F1 Score: 0.1321\n",
      "Threshold: 0.15, F1 Score: 0.1377\n",
      "Threshold: 0.16, F1 Score: 0.1481\n",
      "Threshold: 0.17, F1 Score: 0.1627\n",
      "Threshold: 0.18, F1 Score: 0.1687\n",
      "Threshold: 0.19, F1 Score: 0.1739\n",
      "Threshold: 0.20, F1 Score: 0.1738\n",
      "Threshold: 0.21, F1 Score: 0.1737\n",
      "Threshold: 0.22, F1 Score: 0.1738\n",
      "Threshold: 0.23, F1 Score: 0.1734\n",
      "Threshold: 0.24, F1 Score: 0.1698\n",
      "Threshold: 0.25, F1 Score: 0.1692\n",
      "Threshold: 0.26, F1 Score: 0.1403\n",
      "Threshold: 0.27, F1 Score: 0.0884\n",
      "Threshold: 0.28, F1 Score: 0.0825\n",
      "Threshold: 0.29, F1 Score: 0.0823\n",
      "Threshold: 0.30, F1 Score: 0.0796\n",
      "Best Threshold: 0.19, Best F1 Score: 0.1739\n"
     ]
    }
   ],
   "source": [
    "# Define thresholds to evaluate\n",
    "thresholds = np.arange(0.10, 0.31, 0.01)\n",
    "f1_scores = []\n",
    "\n",
    "# Evaluate each threshold\n",
    "for threshold in thresholds:\n",
    "    # Convert probabilities to binary predictions based on the threshold\n",
    "    predictions = (default_prob_gb >= threshold).astype(int)\n",
    "    \n",
    "    # Calculate F1 score\n",
    "    score = f1_score(default_val, predictions)\n",
    "    f1_scores.append(score)\n",
    "    print(f\"Threshold: {threshold:.2f}, F1 Score: {score:.4f}\")\n",
    "\n",
    "# Find the best threshold\n",
    "best_threshold = thresholds[np.argmax(f1_scores)]\n",
    "best_f1_score = max(f1_scores)\n",
    "print(f\"Best Threshold: {best_threshold:.2f}, Best F1 Score: {best_f1_score:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameter Tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/yv/vzpq5vmx6_qg5lfn6g6yvn5c0000gp/T/ipykernel_51480/30923057.py:18: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training F1: 0.6180566653357699, Validation F1: 0.10633729175401421 for learning_rate=0.01, max_depth=5, subsample=0.7\n",
      "Training F1: 0.6166525720556703, Validation F1: 0.11168715327609413 for learning_rate=0.01, max_depth=5, subsample=0.9\n",
      "Training F1: 0.7562571532325437, Validation F1: 0.10920227616449898 for learning_rate=0.01, max_depth=9, subsample=0.7\n",
      "Training F1: 0.7520502927040638, Validation F1: 0.11177799567200548 for learning_rate=0.01, max_depth=9, subsample=0.9\n",
      "Training F1: 0.8447718325675065, Validation F1: 0.10753537066608027 for learning_rate=0.01, max_depth=12, subsample=0.7\n",
      "Training F1: 0.8400613336195972, Validation F1: 0.11639986374944308 for learning_rate=0.01, max_depth=12, subsample=0.9\n",
      "Training F1: 0.5496745474610594, Validation F1: 0.11425607586451238 for learning_rate=0.005, max_depth=5, subsample=0.7\n",
      "Training F1: 0.5559723293262089, Validation F1: 0.11447302603592037 for learning_rate=0.005, max_depth=5, subsample=0.9\n",
      "Training F1: 0.6740628419809974, Validation F1: 0.10809193144425781 for learning_rate=0.005, max_depth=9, subsample=0.7\n",
      "Training F1: 0.6711257364286896, Validation F1: 0.11711099428382936 for learning_rate=0.005, max_depth=9, subsample=0.9\n",
      "Training F1: 0.7687034420777624, Validation F1: 0.10763540846174986 for learning_rate=0.005, max_depth=12, subsample=0.7\n",
      "Training F1: 0.7628341908161064, Validation F1: 0.11561506356037049 for learning_rate=0.005, max_depth=12, subsample=0.9\n"
     ]
    }
   ],
   "source": [
    "# Define the parameter grid\n",
    "param_grid = {\n",
    "    'learning_rate': [0.01, 0.005],\n",
    "    'max_depth': [5, 9, 12], \n",
    "    'subsample': [0.7, 0.9]\n",
    "}\n",
    "\n",
    "# Generate all combinations of parameters\n",
    "param_combinations = list(product(param_grid['learning_rate'], param_grid['max_depth'], param_grid['subsample']))\n",
    "\n",
    "# Create a dataframe to store the validation results\n",
    "exp_wind_results = pd.DataFrame(columns=[\"model\", \"specification\", \"train F1\", \"validation F1\"])\n",
    "\n",
    "for lr, max_depth, subsample in param_combinations:\n",
    "    gb_model = GradientBoostingClassifier(n_estimators = 100, learning_rate = lr, max_depth = max_depth, subsample = subsample)\n",
    "    avg_train_f1, avg_val_f1 = expanding_window(scaled_df, gb_model, subsample = 0.8, type = 'classification', threshold=0.20)\n",
    "    \n",
    "    exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n",
    "        \"model\": \"GradientBoostingClassifier\",\n",
    "        \"specification\": f\"learning_rate={lr}, max_depth={max_depth}, subsample={subsample}\",\n",
    "        \"train F1\": avg_train_f1,\n",
    "        \"validation F1\": avg_val_f1\n",
    "    }])], ignore_index=True)\n",
    "\n",
    "    print(f\"Training F1: {avg_train_f1}, Validation F1: {avg_val_f1} for learning_rate={lr}, max_depth={max_depth}, subsample={subsample}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model</th>\n",
       "      <th>specification</th>\n",
       "      <th>train F1</th>\n",
       "      <th>validation F1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.005, max_depth=9, subsample=0.9</td>\n",
       "      <td>0.671126</td>\n",
       "      <td>0.117111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.01, max_depth=12, subsample=0.9</td>\n",
       "      <td>0.840061</td>\n",
       "      <td>0.116400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.005, max_depth=12, subsample=0.9</td>\n",
       "      <td>0.762834</td>\n",
       "      <td>0.115615</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.005, max_depth=5, subsample=0.9</td>\n",
       "      <td>0.555972</td>\n",
       "      <td>0.114473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.005, max_depth=5, subsample=0.7</td>\n",
       "      <td>0.549675</td>\n",
       "      <td>0.114256</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.01, max_depth=9, subsample=0.9</td>\n",
       "      <td>0.752050</td>\n",
       "      <td>0.111778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.01, max_depth=5, subsample=0.9</td>\n",
       "      <td>0.616653</td>\n",
       "      <td>0.111687</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.01, max_depth=9, subsample=0.7</td>\n",
       "      <td>0.756257</td>\n",
       "      <td>0.109202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.005, max_depth=9, subsample=0.7</td>\n",
       "      <td>0.674063</td>\n",
       "      <td>0.108092</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.005, max_depth=12, subsample=0.7</td>\n",
       "      <td>0.768703</td>\n",
       "      <td>0.107635</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.01, max_depth=12, subsample=0.7</td>\n",
       "      <td>0.844772</td>\n",
       "      <td>0.107535</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GradientBoostingClassifier</td>\n",
       "      <td>learning_rate=0.01, max_depth=5, subsample=0.7</td>\n",
       "      <td>0.618057</td>\n",
       "      <td>0.106337</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         model  \\\n",
       "9   GradientBoostingClassifier   \n",
       "5   GradientBoostingClassifier   \n",
       "11  GradientBoostingClassifier   \n",
       "7   GradientBoostingClassifier   \n",
       "6   GradientBoostingClassifier   \n",
       "3   GradientBoostingClassifier   \n",
       "1   GradientBoostingClassifier   \n",
       "2   GradientBoostingClassifier   \n",
       "8   GradientBoostingClassifier   \n",
       "10  GradientBoostingClassifier   \n",
       "4   GradientBoostingClassifier   \n",
       "0   GradientBoostingClassifier   \n",
       "\n",
       "                                       specification  train F1  validation F1  \n",
       "9    learning_rate=0.005, max_depth=9, subsample=0.9  0.671126       0.117111  \n",
       "5    learning_rate=0.01, max_depth=12, subsample=0.9  0.840061       0.116400  \n",
       "11  learning_rate=0.005, max_depth=12, subsample=0.9  0.762834       0.115615  \n",
       "7    learning_rate=0.005, max_depth=5, subsample=0.9  0.555972       0.114473  \n",
       "6    learning_rate=0.005, max_depth=5, subsample=0.7  0.549675       0.114256  \n",
       "3     learning_rate=0.01, max_depth=9, subsample=0.9  0.752050       0.111778  \n",
       "1     learning_rate=0.01, max_depth=5, subsample=0.9  0.616653       0.111687  \n",
       "2     learning_rate=0.01, max_depth=9, subsample=0.7  0.756257       0.109202  \n",
       "8    learning_rate=0.005, max_depth=9, subsample=0.7  0.674063       0.108092  \n",
       "10  learning_rate=0.005, max_depth=12, subsample=0.7  0.768703       0.107635  \n",
       "4    learning_rate=0.01, max_depth=12, subsample=0.7  0.844772       0.107535  \n",
       "0     learning_rate=0.01, max_depth=5, subsample=0.7  0.618057       0.106337  "
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_wind_results = exp_wind_results.sort_values(by=\"validation F1\", ascending=False)\n",
    "exp_wind_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimal parameters for GradientBoostingRegressor according the expanding window validation is: *learning_rate*=0.005, *max_depth*=9, *subsample*=0.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Baseline Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the training data into train and validation sets (70:30)\n",
    "train_df, val_df = train_test_split(scaled_df, test_size=0.3, random_state=528)\n",
    "\n",
    "X_train, return_train, default_train = feature_split(train_df)\n",
    "X_val, return_val, default_val = feature_split(val_df)\n",
    "\n",
    "# Define the ratio for SMOTE\n",
    "smote_ratio = 0.3  # 3:7 ratio for minority to majority\n",
    "\n",
    "# Initialize SMOTE\n",
    "smote = SMOTE(sampling_strategy=smote_ratio, random_state=42)\n",
    "\n",
    "# Apply SMOTE to the training data\n",
    "X_train_resampled, y_train_resampled = smote.fit_resample(X_train, default_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp_model = MLPClassifier(hidden_layer_sizes=(32, 16), learning_rate_init=0.001, \n",
    "                          activation='relu', max_iter=1000, batch_size=128, \n",
    "                          early_stopping=True, n_iter_no_change=10, random_state=42)\n",
    "\n",
    "# Fit the model on the training data\n",
    "mlp_model.fit(X_train_resampled, y_train_resampled)\n",
    "\n",
    "# Predict the probabilities on the validation set\n",
    "y_val_pred_proba = mlp_model.predict_proba(X_val)[:, 1]  # Get probabilities for the positive class\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Threshold: 0.10, F1 Score: 0.1590\n",
      "Threshold: 0.11, F1 Score: 0.1610\n",
      "Threshold: 0.12, F1 Score: 0.1629\n",
      "Threshold: 0.13, F1 Score: 0.1646\n",
      "Threshold: 0.14, F1 Score: 0.1650\n",
      "Threshold: 0.15, F1 Score: 0.1646\n",
      "Threshold: 0.16, F1 Score: 0.1631\n",
      "Threshold: 0.17, F1 Score: 0.1619\n",
      "Threshold: 0.18, F1 Score: 0.1599\n",
      "Threshold: 0.19, F1 Score: 0.1574\n",
      "Threshold: 0.20, F1 Score: 0.1554\n",
      "Threshold: 0.21, F1 Score: 0.1510\n",
      "Threshold: 0.22, F1 Score: 0.1485\n",
      "Threshold: 0.23, F1 Score: 0.1453\n",
      "Threshold: 0.24, F1 Score: 0.1417\n",
      "Threshold: 0.25, F1 Score: 0.1368\n",
      "Threshold: 0.26, F1 Score: 0.1310\n",
      "Threshold: 0.27, F1 Score: 0.1270\n",
      "Threshold: 0.28, F1 Score: 0.1208\n",
      "Threshold: 0.29, F1 Score: 0.1155\n",
      "Threshold: 0.30, F1 Score: 0.1102\n",
      "Threshold: 0.31, F1 Score: 0.1041\n",
      "Threshold: 0.32, F1 Score: 0.1004\n",
      "Threshold: 0.33, F1 Score: 0.0929\n",
      "Threshold: 0.34, F1 Score: 0.0883\n",
      "Threshold: 0.35, F1 Score: 0.0838\n",
      "Threshold: 0.36, F1 Score: 0.0790\n",
      "Threshold: 0.37, F1 Score: 0.0732\n",
      "Threshold: 0.38, F1 Score: 0.0696\n",
      "Threshold: 0.39, F1 Score: 0.0654\n",
      "Threshold: 0.40, F1 Score: 0.0604\n",
      "Best Threshold: 0.14, Best F1 Score: 0.1650\n"
     ]
    }
   ],
   "source": [
    "# Define thresholds to evaluate\n",
    "thresholds = np.arange(0.10, 0.41, 0.01)\n",
    "f1_scores = []\n",
    "\n",
    "# Evaluate each threshold\n",
    "for threshold in thresholds:\n",
    "    # Convert probabilities to binary predictions based on the threshold\n",
    "    predictions = (y_val_pred_proba >= threshold).astype(int)\n",
    "    \n",
    "    # Calculate F1 score\n",
    "    score = f1_score(default_val, predictions)\n",
    "    f1_scores.append(score)\n",
    "    print(f\"Threshold: {threshold:.2f}, F1 Score: {score:.4f}\")\n",
    "\n",
    "# Find the best threshold\n",
    "best_threshold = thresholds[np.argmax(f1_scores)]\n",
    "best_f1_score = max(f1_scores)\n",
    "print(f\"Best Threshold: {best_threshold:.2f}, Best F1 Score: {best_f1_score:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/yv/vzpq5vmx6_qg5lfn6g6yvn5c0000gp/T/ipykernel_51480/2436552896.py:19: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training F1: 0.6658595428831928, Validation F1: 0.12814956653893766 for learning_rate=0.01, hidden_layers=(32, 16), activation=relu\n",
      "Training F1: 0.6622503981077196, Validation F1: 0.1316089607437619 for learning_rate=0.01, hidden_layers=(32, 16), activation=logistic\n",
      "Training F1: 0.6820186567765261, Validation F1: 0.1252828431312489 for learning_rate=0.01, hidden_layers=(32, 16, 8), activation=relu\n",
      "Training F1: 0.6915137692882738, Validation F1: 0.1306393120189435 for learning_rate=0.01, hidden_layers=(32, 16, 8), activation=logistic\n",
      "Training F1: 0.6648103520427198, Validation F1: 0.12199689648605408 for learning_rate=0.01, hidden_layers=(32, 16, 8, 8), activation=relu\n",
      "Training F1: 0.6617520013600628, Validation F1: 0.13457915706568263 for learning_rate=0.01, hidden_layers=(32, 16, 8, 8), activation=logistic\n",
      "Training F1: 0.6584630473723254, Validation F1: 0.12819494751752433 for learning_rate=0.005, hidden_layers=(32, 16), activation=relu\n",
      "Training F1: 0.6737253946242135, Validation F1: 0.12708952228967677 for learning_rate=0.005, hidden_layers=(32, 16), activation=logistic\n",
      "Training F1: 0.6908867354264461, Validation F1: 0.10865510390871337 for learning_rate=0.005, hidden_layers=(32, 16, 8), activation=relu\n",
      "Training F1: 0.6825239471083195, Validation F1: 0.1269202110194689 for learning_rate=0.005, hidden_layers=(32, 16, 8), activation=logistic\n",
      "Training F1: 0.6895687573625287, Validation F1: 0.11036605435413681 for learning_rate=0.005, hidden_layers=(32, 16, 8, 8), activation=relu\n",
      "Training F1: 0.6805295768831445, Validation F1: 0.12278198000318304 for learning_rate=0.005, hidden_layers=(32, 16, 8, 8), activation=logistic\n",
      "Training F1: 0.6542758258601022, Validation F1: 0.13034327434588613 for learning_rate=0.001, hidden_layers=(32, 16), activation=relu\n",
      "Training F1: 0.6285706090535648, Validation F1: 0.10231696582045897 for learning_rate=0.001, hidden_layers=(32, 16), activation=logistic\n",
      "Training F1: 0.6694973354857036, Validation F1: 0.14683058467634247 for learning_rate=0.001, hidden_layers=(32, 16, 8), activation=relu\n",
      "Training F1: 0.6353264302890503, Validation F1: 0.1297527193512411 for learning_rate=0.001, hidden_layers=(32, 16, 8), activation=logistic\n",
      "Training F1: 0.6605412536307022, Validation F1: 0.12037359837694905 for learning_rate=0.001, hidden_layers=(32, 16, 8, 8), activation=relu\n",
      "Training F1: 0.6505573197444745, Validation F1: 0.1495501790444526 for learning_rate=0.001, hidden_layers=(32, 16, 8, 8), activation=logistic\n"
     ]
    }
   ],
   "source": [
    "# Define the parameter grid\n",
    "param_grid = {\n",
    "    'learning_rate_init': [0.01, 0.005, 0.001],  # Learning rate for the MLP\n",
    "    'hidden_layer_sizes': [(32, 16), (32, 16, 8), (32, 16, 8, 8)],  # Tuning the number of hidden layers\n",
    "    'activation': ['relu', 'logistic']  # Activation functions to try\n",
    "}\n",
    "\n",
    "# Generate all combinations of parameters\n",
    "param_combinations = list(product(param_grid['learning_rate_init'], param_grid['hidden_layer_sizes'], param_grid['activation']))\n",
    "\n",
    "# Create a dataframe to store the validation results\n",
    "exp_wind_results = pd.DataFrame(columns=[\"model\", \"specification\", \"train F1\", \"validation F1\"])\n",
    "\n",
    "for lr, hidden_layers, activation in param_combinations:\n",
    "    nn_model = MLPClassifier(hidden_layer_sizes=hidden_layers, learning_rate_init=lr, activation=activation, max_iter=1000, \n",
    "                            batch_size = 128, early_stopping = True, n_iter_no_change = 10, random_state=42)\n",
    "    avg_train_f1, avg_val_f1 = expanding_window(scaled_df, nn_model, subsample = 0.8, type = 'classification', threshold=0.14)\n",
    "    \n",
    "    exp_wind_results = pd.concat([exp_wind_results, pd.DataFrame([{\n",
    "        \"model\": \"MLPClassifier\",\n",
    "        \"specification\": f\"lr={lr}, hid_layer={hidden_layers}, activation={activation}\",\n",
    "        \"train F1\": avg_train_f1,\n",
    "        \"validation F1\": avg_val_f1\n",
    "    }])], ignore_index=True)\n",
    "\n",
    "    print(f\"Training F1: {avg_train_f1}, Validation F1: {avg_val_f1} for learning_rate={lr}, hidden_layers={hidden_layers}, activation={activation}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model</th>\n",
       "      <th>specification</th>\n",
       "      <th>train F1</th>\n",
       "      <th>validation F1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8, 8), activation...</td>\n",
       "      <td>0.650557</td>\n",
       "      <td>0.149550</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8), activation=relu</td>\n",
       "      <td>0.669497</td>\n",
       "      <td>0.146831</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8, 8), activation=...</td>\n",
       "      <td>0.661752</td>\n",
       "      <td>0.134579</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16), activation=logistic</td>\n",
       "      <td>0.662250</td>\n",
       "      <td>0.131609</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8), activation=log...</td>\n",
       "      <td>0.691514</td>\n",
       "      <td>0.130639</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16), activation=relu</td>\n",
       "      <td>0.654276</td>\n",
       "      <td>0.130343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8), activation=lo...</td>\n",
       "      <td>0.635326</td>\n",
       "      <td>0.129753</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16), activation=relu</td>\n",
       "      <td>0.658463</td>\n",
       "      <td>0.128195</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16), activation=relu</td>\n",
       "      <td>0.665860</td>\n",
       "      <td>0.128150</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16), activation=logistic</td>\n",
       "      <td>0.673725</td>\n",
       "      <td>0.127090</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8), activation=lo...</td>\n",
       "      <td>0.682524</td>\n",
       "      <td>0.126920</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8), activation=relu</td>\n",
       "      <td>0.682019</td>\n",
       "      <td>0.125283</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8, 8), activation...</td>\n",
       "      <td>0.680530</td>\n",
       "      <td>0.122782</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.01, hid_layer=(32, 16, 8, 8), activation=...</td>\n",
       "      <td>0.664810</td>\n",
       "      <td>0.121997</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16, 8, 8), activation...</td>\n",
       "      <td>0.660541</td>\n",
       "      <td>0.120374</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8, 8), activation...</td>\n",
       "      <td>0.689569</td>\n",
       "      <td>0.110366</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.005, hid_layer=(32, 16, 8), activation=relu</td>\n",
       "      <td>0.690887</td>\n",
       "      <td>0.108655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>MLPClassifier</td>\n",
       "      <td>lr=0.001, hid_layer=(32, 16), activation=logistic</td>\n",
       "      <td>0.628571</td>\n",
       "      <td>0.102317</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            model                                      specification  \\\n",
       "17  MLPClassifier  lr=0.001, hid_layer=(32, 16, 8, 8), activation...   \n",
       "14  MLPClassifier   lr=0.001, hid_layer=(32, 16, 8), activation=relu   \n",
       "5   MLPClassifier  lr=0.01, hid_layer=(32, 16, 8, 8), activation=...   \n",
       "1   MLPClassifier   lr=0.01, hid_layer=(32, 16), activation=logistic   \n",
       "3   MLPClassifier  lr=0.01, hid_layer=(32, 16, 8), activation=log...   \n",
       "12  MLPClassifier      lr=0.001, hid_layer=(32, 16), activation=relu   \n",
       "15  MLPClassifier  lr=0.001, hid_layer=(32, 16, 8), activation=lo...   \n",
       "6   MLPClassifier      lr=0.005, hid_layer=(32, 16), activation=relu   \n",
       "0   MLPClassifier       lr=0.01, hid_layer=(32, 16), activation=relu   \n",
       "7   MLPClassifier  lr=0.005, hid_layer=(32, 16), activation=logistic   \n",
       "9   MLPClassifier  lr=0.005, hid_layer=(32, 16, 8), activation=lo...   \n",
       "2   MLPClassifier    lr=0.01, hid_layer=(32, 16, 8), activation=relu   \n",
       "11  MLPClassifier  lr=0.005, hid_layer=(32, 16, 8, 8), activation...   \n",
       "4   MLPClassifier  lr=0.01, hid_layer=(32, 16, 8, 8), activation=...   \n",
       "16  MLPClassifier  lr=0.001, hid_layer=(32, 16, 8, 8), activation...   \n",
       "10  MLPClassifier  lr=0.005, hid_layer=(32, 16, 8, 8), activation...   \n",
       "8   MLPClassifier   lr=0.005, hid_layer=(32, 16, 8), activation=relu   \n",
       "13  MLPClassifier  lr=0.001, hid_layer=(32, 16), activation=logistic   \n",
       "\n",
       "    train F1  validation F1  \n",
       "17  0.650557       0.149550  \n",
       "14  0.669497       0.146831  \n",
       "5   0.661752       0.134579  \n",
       "1   0.662250       0.131609  \n",
       "3   0.691514       0.130639  \n",
       "12  0.654276       0.130343  \n",
       "15  0.635326       0.129753  \n",
       "6   0.658463       0.128195  \n",
       "0   0.665860       0.128150  \n",
       "7   0.673725       0.127090  \n",
       "9   0.682524       0.126920  \n",
       "2   0.682019       0.125283  \n",
       "11  0.680530       0.122782  \n",
       "4   0.664810       0.121997  \n",
       "16  0.660541       0.120374  \n",
       "10  0.689569       0.110366  \n",
       "8   0.690887       0.108655  \n",
       "13  0.628571       0.102317  "
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_wind_results = exp_wind_results.sort_values(by=\"validation F1\", ascending=False)\n",
    "exp_wind_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimal parameters for MLPRegressor according the expanding window validation is: *learning_rate*=0.001, *hidden_layer_sizes*=(32,16,8,8), *activation*=logistic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To conclude, according to the above expanding-window validation:\n",
    "\n",
    "- the optimal regression algorithm is a neural network with *learning_rate*=0.001, *hidden_layer_sizes*=(32,16), *activation*=logistic\n",
    "\n",
    "- the optimal classification algorithm is a neural network with *learning_rate*=0.001, *hidden_layer_sizes*=(32,16,8,8), *activation*=logistic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prediction on Test Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocess Test Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_csv('lc_loan_test.csv')\n",
    "\n",
    "# mths_since_last_delinq\n",
    "df_test['dummy_delinq'] = df_test['mths_since_last_delinq'].isnull().astype(int)\n",
    "max_delinq = df_test['mths_since_last_delinq'].max()\n",
    "df_test['mths_since_last_delinq'] = df_test['mths_since_last_delinq'].fillna(max_delinq)\n",
    "df_test['inter_delinq'] = df_test['dummy_delinq'] * df_test['mths_since_last_delinq']\n",
    "\n",
    "# emp_length\n",
    "df_test['emp_length'] = df_test['emp_length'].replace({'10+ years': '10', '< 1 year': '0'}).str.extract('(\\d+)').astype(float)\n",
    "average_emp_length = df_test['emp_length'].mean()\n",
    "df_test['emp_length'] = df_test['emp_length'].fillna(average_emp_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# grade and subgrade\n",
    "df_test.drop(columns=['sub_grade'], inplace=True)\n",
    "grade_dummies = pd.get_dummies(df_test['grade'], prefix='grade', drop_first=False).astype(int)\n",
    "df_test = pd.concat([df_test, grade_dummies], axis=1)\n",
    "df_test.drop(columns=['grade'], inplace=True)\n",
    "\n",
    "# homeownership\n",
    "home_ownership_dummies = pd.get_dummies(df_test['home_ownership'], prefix='home', drop_first=False).astype(int)\n",
    "df_test = pd.concat([df_test, home_ownership_dummies], axis=1)\n",
    "df_test.drop(columns=['home_ownership'], inplace=True)\n",
    "\n",
    "# verification_status\n",
    "df_test['verification_status'] = df_test['verification_status'].map({'Not Verified': 0, 'Verified': 1, 'Source Verified': 1})\n",
    "\n",
    "# purpose\n",
    "purpose_dummies = pd.get_dummies(df_test['purpose'], prefix='purpose', drop_first=False).astype(int)\n",
    "df_test = pd.concat([df_test, purpose_dummies], axis=1)\n",
    "df_test.drop(columns=['purpose'], inplace=True)\n",
    "\n",
    "# earliest_cr_line\n",
    "df_test['earliest_cr_line'] = pd.to_datetime(df_test['earliest_cr_line'], format='%b-%Y')\n",
    "df_test['issue_d'] = pd.to_datetime(df_test['issue_d'], format='%b-%Y')\n",
    "df_test['length_credit'] = (df_test['issue_d'] - df_test['earliest_cr_line']).dt.days / 365.25\n",
    "df_test.drop(columns=['earliest_cr_line'], inplace=True)\n",
    "\n",
    "# fico_range_low and fico_range_high\n",
    "df_test.drop(columns=['fico_range_high'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# interaction term: Annual income and verification\n",
    "df_test['inter_income'] = df_test['verification_status'] * df_test['annual_inc']\n",
    "\n",
    "# feature engineering: create a new feature state_income\n",
    "state_income = df_test[df_test['verification_status'] == 1].groupby(['addr_state', 'year'])['annual_inc'].mean().reset_index()\n",
    "state_income.rename(columns={'annual_inc': 'state_income'}, inplace=True)\n",
    "df_test = df_test.merge(state_income, on=['addr_state', 'year'], how='left')\n",
    "df_test['state_income'] = df_test['state_income'].fillna(df_test['state_income'].mean())\n",
    "\n",
    "# drop the location related features\n",
    "df_test.drop(columns=['addr_state','zip_code'], inplace=True)\n",
    "\n",
    "# drop 'loan_amnt' since 'loan_amnt' and 'funded_amnt' are highly correlated\n",
    "df_test.drop(columns=['loan_amnt'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Columns in df_public but not in df_test:\n",
      "['early_default', 'loan_status', 'purpose_educational', 'purpose_wedding', 'return']\n",
      "Columns in df_test but not in df_public:\n",
      "['grade_A', 'home_ANY', 'purpose_car']\n"
     ]
    }
   ],
   "source": [
    "missing_in_test = df_public.columns.difference(df_test.columns)\n",
    "missing_in_public = df_test.columns.difference(df_public.columns)\n",
    "\n",
    "print(\"Columns in df_public but not in df_test:\")\n",
    "print(missing_in_test.tolist())\n",
    "\n",
    "print(\"Columns in df_test but not in df_public:\")\n",
    "print(missing_in_public.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# align the features in df_public and df_test\n",
    "for col in missing_in_test:\n",
    "    df_test[col] = 0\n",
    "\n",
    "df_test.drop(columns=missing_in_public.tolist(), inplace=True)\n",
    "\n",
    "df_test = df_test[df_public.columns] # rearrange the columns in df_test according to df_public"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# standardize features\n",
    "scale_fea_set = ['funded_amnt', 'installment', 'emp_length', 'annual_inc', \n",
    "                'dti', 'delinq_2yrs', 'fico_range_low', 'inq_last_6mths', \n",
    "                'mths_since_last_delinq', 'open_acc', 'pub_rec', 'revol_bal', \n",
    "                'revol_util', 'total_acc', 'collections_12_mths_ex_med',\n",
    "                'acc_now_delinq', 'chargeoff_within_12_mths', 'delinq_amnt',\n",
    "                'pub_rec_bankruptcies', 'tax_liens', 'inter_delinq',\n",
    "                'length_credit', 'inter_income', 'state_income']\n",
    "\n",
    "scaled_df_test = df_test.copy()\n",
    "scaler = StandardScaler()\n",
    "scaled_df_test[scale_fea_set] = scaler.fit_transform(scaled_df_test[scale_fea_set]) # Standardize the features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampling_proportions = {2016: 0.8, 2015: 0.8, 2014: 0.7, 2013: 0.6, 2012: 0.5, \n",
    "                        2011: 0.4, 2010: 0.3, 2009: 0.2, 2008: 0.1}\n",
    "\n",
    "train_sample = []\n",
    "\n",
    "for year, proportion in sampling_proportions.items():\n",
    "    year_data = scaled_df[scaled_df['year'] == year]\n",
    "    sampled_year_data = year_data.sample(frac=proportion, replace=False, random_state=42)\n",
    "    train_sample.append(sampled_year_data)\n",
    "\n",
    "    # create validation sample\n",
    "    if year == 2016:\n",
    "        val_df = year_data[~year_data.index.isin(sampled_year_data.index)]\n",
    "\n",
    "train_df = pd.concat(train_sample, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split train and validation\n",
    "X_train, return_train, default_train = feature_split(train_df)\n",
    "X_val, return_val, default_val = feature_split(val_df)\n",
    "X_test, _, __ = feature_split(scaled_df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation R2: 0.04892560008933877\n"
     ]
    }
   ],
   "source": [
    "# regression\n",
    "nn_model_reg = MLPRegressor(hidden_layer_sizes=(32,16), learning_rate_init=0.001, activation='logistic', max_iter=1000, \n",
    "                            batch_size = 128, early_stopping = True, n_iter_no_change = 10, random_state=42)\n",
    "\n",
    "nn_model_reg.fit(X_train, return_train)  # training\n",
    "val_pred_reg = nn_model_reg.predict(X_val) # validation\n",
    "test_pred_reg = nn_model_reg.predict(X_test) # test\n",
    "out_of_sample_eval = get_r2(return_val, val_pred_reg, benchmark=0, is_train=False)  # out-of-sample evaluation\n",
    "print(f\"Validation R2: {out_of_sample_eval}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# classification\n",
    "## resampling\n",
    "smote_ratio = 0.3  # Define the ratio for SMOTE: 3:7 ratio for minority to majority\n",
    "smote = SMOTE(sampling_strategy=smote_ratio, random_state=42) # Initialize SMOTE\n",
    "X_train, default_train = smote.fit_resample(X_train, default_train) # Apply SMOTE to the training data\n",
    "\n",
    "nn_model_clf = MLPClassifier(hidden_layer_sizes=(32,16,8,8), learning_rate_init=0.001, \n",
    "                          activation='logistic', max_iter=1000, batch_size=128, \n",
    "                          early_stopping=True, n_iter_no_change=10, random_state=42)\n",
    "\n",
    "nn_model_clf.fit(X_train, default_train)  # training\n",
    "val_prob_clf = nn_model_clf.predict_proba(X_val)[:, 1] # validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Threshold: 0.10, F1 Score: 0.1626\n",
      "Threshold: 0.11, F1 Score: 0.1663\n",
      "Threshold: 0.12, F1 Score: 0.1687\n",
      "Threshold: 0.13, F1 Score: 0.1712\n",
      "Threshold: 0.14, F1 Score: 0.1735\n",
      "Threshold: 0.15, F1 Score: 0.1761\n",
      "Threshold: 0.16, F1 Score: 0.1772\n",
      "Threshold: 0.17, F1 Score: 0.1781\n",
      "Threshold: 0.18, F1 Score: 0.1781\n",
      "Threshold: 0.19, F1 Score: 0.1789\n",
      "Threshold: 0.20, F1 Score: 0.1792\n",
      "Threshold: 0.21, F1 Score: 0.1808\n",
      "Threshold: 0.22, F1 Score: 0.1819\n",
      "Threshold: 0.23, F1 Score: 0.1810\n",
      "Threshold: 0.24, F1 Score: 0.1806\n",
      "Threshold: 0.25, F1 Score: 0.1801\n",
      "Threshold: 0.26, F1 Score: 0.1788\n",
      "Threshold: 0.27, F1 Score: 0.1758\n",
      "Threshold: 0.28, F1 Score: 0.1743\n",
      "Threshold: 0.29, F1 Score: 0.1709\n",
      "Threshold: 0.30, F1 Score: 0.1667\n",
      "Threshold: 0.31, F1 Score: 0.1627\n",
      "Threshold: 0.32, F1 Score: 0.1593\n",
      "Threshold: 0.33, F1 Score: 0.1563\n",
      "Threshold: 0.34, F1 Score: 0.1520\n",
      "Threshold: 0.35, F1 Score: 0.1479\n",
      "Threshold: 0.36, F1 Score: 0.1437\n",
      "Threshold: 0.37, F1 Score: 0.1406\n",
      "Threshold: 0.38, F1 Score: 0.1355\n",
      "Threshold: 0.39, F1 Score: 0.1311\n",
      "Threshold: 0.40, F1 Score: 0.1265\n",
      "Best Threshold: 0.22, Best F1 Score: 0.1819\n"
     ]
    }
   ],
   "source": [
    "# Define thresholds to evaluate\n",
    "thresholds = np.arange(0.10, 0.41, 0.01)\n",
    "f1_scores = []\n",
    "\n",
    "# Evaluate each threshold\n",
    "for threshold in thresholds:\n",
    "    # Convert probabilities to binary predictions based on the threshold\n",
    "    predictions = (val_prob_clf >= threshold).astype(int)\n",
    "    \n",
    "    # Calculate F1 score\n",
    "    score = f1_score(default_val, predictions)\n",
    "    f1_scores.append(score)\n",
    "    print(f\"Threshold: {threshold:.2f}, F1 Score: {score:.4f}\")\n",
    "\n",
    "# Find the best threshold\n",
    "best_threshold = thresholds[np.argmax(f1_scores)]\n",
    "best_f1_score = max(f1_scores)\n",
    "print(f\"Best Threshold: {best_threshold:.2f}, Best F1 Score: {best_f1_score:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict on test set\n",
    "test_prob_clf = nn_model_clf.predict_proba(X_test)[:, 1] # validation\n",
    "test_pred_clf = (test_prob_clf >= best_threshold).astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R-squared: 0.0543\n",
      "F1 Score: 0.1198\n",
      "Accuracy: 0.4657\n",
      "Recall: 0.6237\n",
      "AUC Score: 0.5359\n"
     ]
    }
   ],
   "source": [
    "# get ground truth\n",
    "return_true = df_private['return'].to_numpy()\n",
    "early_default_true = df_private['early_default'].to_numpy()\n",
    "\n",
    "# evaluation\n",
    "r2_test = get_r2(return_true, test_pred_reg, benchmark=0, is_train=False)\n",
    "f1_score_test = f1_score(early_default_true, test_pred_clf)\n",
    "accuracy_test = accuracy_score(early_default_true, test_pred_clf)\n",
    "recall_test = recall_score(early_default_true, test_pred_clf)\n",
    "auc_test = roc_auc_score(early_default_true, test_prob_clf)\n",
    "\n",
    "print(f\"R-squared: {r2_test:.4f}\")\n",
    "print(f\"F1 Score: {f1_score_test:.4f}\")\n",
    "print(f\"Accuracy: {accuracy_test:.4f}\")\n",
    "print(f\"Recall: {recall_test:.4f}\")\n",
    "print(f\"AUC Score: {auc_test:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Calculate confusion matrix\n",
    "cm = confusion_matrix(early_default_true, test_pred_clf)\n",
    "\n",
    "# Plot confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['No Default', 'Default'], yticklabels=['No Default', 'Default'])\n",
    "plt.ylabel('Actual')\n",
    "plt.xlabel('Predicted')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SHAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/miniconda3/envs/fa590/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import shap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using 1000 background data samples could cause slower run times. Consider using shap.sample(data, K) or shap.kmeans(data, K) to summarize the background as K samples.\n",
      "100%|██████████| 1000/1000 [1:39:17<00:00,  5.96s/it]  \n"
     ]
    }
   ],
   "source": [
    "X_test_small = X_test.sample(n=1000)\n",
    "\n",
    "# Create a Kernel Explainer\n",
    "explainer = shap.KernelExplainer(nn_model_reg.predict, X_test_small)  # Use the model's predict method\n",
    "\n",
    "# Calculate SHAP values\n",
    "shap_values = explainer.shap_values(X_test_small)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x550 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# summary plots\n",
    "shap.plots.beeswarm(shap.Explanation(values=shap_values, base_values=explainer.expected_value, data=X_test_small))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "teaching",
   "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
