tuning_dnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "print(len(tf.config.list_physical_devices('GPU')) > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from fast_ml.feature_selection import get_constant_features\n",
    "from imblearn.combine import SMOTETomek\n",
    "from collections import Counter\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import OneHotEncoder, StandardScaler, PowerTransformer\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold, RandomizedSearchCV\n",
    "from sklearn.feature_extraction.text import HashingVectorizer\n",
    "import scipy.stats as stats\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, roc_auc_score\n",
    "import xgboost\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Dropout, BatchNormalization\n",
    "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\n",
    "import keras_tuner as kt\n",
    "\n",
    "import pickle\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8895369, 14) (3812301, 14) (8895369, 1) (3812301, 1)\n"
     ]
    }
   ],
   "source": [
    "X_resampled = pd.read_csv('csv_balanced/X_resampled.csv')\n",
    "y_resampled = pd.read_csv('csv_balanced/y_resampled.csv')\n",
    "\n",
    "Xtrain, Xtest, ytrain, ytest = train_test_split(X_resampled, y_resampled, test_size=0.3, random_state=42)\n",
    "\n",
    "print(Xtrain.shape, Xtest.shape, ytrain.shape, ytest.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformer = PowerTransformer(method = 'yeo-johnson', standardize=True)\n",
    "\n",
    "Xtrain_transformed = transformer.fit_transform(Xtrain)\n",
    "\n",
    "Xtest_transformed = transformer.transform(Xtest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xtrain_transformed = pd.DataFrame(Xtrain_transformed, columns=Xtrain.columns)\n",
    "Xtest_transformed = pd.DataFrame(Xtest_transformed, columns=Xtest.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_model(hyperparameter):\n",
    "    model = Sequential()\n",
    "    counter = 0\n",
    "    \n",
    "    for i in range(hyperparameter.Int('num_layers',min_value = 1, max_value = 10)):\n",
    "        if i == 0:\n",
    "            model.add(Dense(\n",
    "                hyperparameter.Int('units' + str(i), min_value = 8, max_value = 256, step = 8),\n",
    "                hyperparameter.Choice('activation' + str(i), values = ['relu', 'selu', 'tanh', 'sigmoid']),\n",
    "                kernel_initializer = 'he_uniform', kernel_regularizer = 'l2',\n",
    "                input_dim = Xtrain_transformed.shape[1]\n",
    "            ))\n",
    "            counter += 1\n",
    "        else:\n",
    "            model.add(Dense(\n",
    "                hyperparameter.Int('units' + str(i), min_value = 8, max_value = 256, step = 8),\n",
    "                hyperparameter.Choice('activation' + str(i), values = ['relu', 'selu', 'tanh', 'sigmoid']),\n",
    "                kernel_initializer = 'he_uniform', kernel_regularizer = 'l2'\n",
    "            ))\n",
    "            model.add(Dropout(hyperparameter.Choice('dropout' + str(i), values=[0.1,0.2,0.3,0.4,0.5,0.6])))\n",
    "            model.add(BatchNormalization())\n",
    "            \n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    model.compile(hyperparameter.Choice(\n",
    "        'optimizer', values = ['adam', 'rmsprop', 'sgd', 'adadelta', 'adagrad']), \n",
    "                  loss='binary_crossentropy', metrics=['accuracy']\n",
    "                  )\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuner = kt.Hyperband(hypermodel = build_model, max_epochs = 1, objective = ['val_accuracy'], \n",
    "                     directory = 'DNN_Hyperband_Tuner', project_name = 'trial_02')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 1 Complete [00h 07m 14s]\n",
      "multi_objective: -0.9938259720802307\n",
      "\n",
      "Best multi_objective So Far: -0.9938259720802307\n",
      "Total elapsed time: 00h 07m 14s\n"
     ]
    }
   ],
   "source": [
    "tuner.search(Xtrain_transformed[:1000000], ytrain[:1000000], epochs = 3, \n",
    "             validation_data = (Xtest_transformed[:1000000], ytest[:1000000]), validation_split=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'num_layers': 4,\n",
       " 'units0': 48,\n",
       " 'activation0': 'relu',\n",
       " 'optimizer': 'rmsprop',\n",
       " 'tuner/epochs': 1,\n",
       " 'tuner/initial_epoch': 0,\n",
       " 'tuner/bracket': 0,\n",
       " 'tuner/round': 0,\n",
       " 'units1': 8,\n",
       " 'activation1': 'relu',\n",
       " 'dropout1': 0.1,\n",
       " 'units2': 8,\n",
       " 'activation2': 'relu',\n",
       " 'dropout2': 0.1,\n",
       " 'units3': 8,\n",
       " 'activation3': 'relu',\n",
       " 'dropout3': 0.1}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuner.get_best_hyperparameters()[0].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 48)                720       \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 8)                 392       \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 8)                 0         \n",
      "                                                                 \n",
      " batch_normalization (BatchN  (None, 8)                32        \n",
      " ormalization)                                                   \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 8)                 72        \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 8)                 0         \n",
      "                                                                 \n",
      " batch_normalization_1 (Batc  (None, 8)                32        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 8)                 72        \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 8)                 0         \n",
      "                                                                 \n",
      " batch_normalization_2 (Batc  (None, 8)                32        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " dense_4 (Dense)             (None, 1)                 9         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1,361\n",
      "Trainable params: 1,313\n",
      "Non-trainable params: 48\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "tuned_model = tuner.get_best_models()[0]\n",
    "tuned_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "early_stopping = EarlyStopping(monitor='val_accuracy',\n",
    "    min_delta=0.003,\n",
    "    patience=5,\n",
    "    verbose=0,\n",
    "    mode='auto',\n",
    "    baseline=None,\n",
    "    restore_best_weights=True,)\n",
    "\n",
    "tuned_dl_model_checkpoint = ModelCheckpoint('tuned_dnn.h5', monitor='val_accuracy', mode='auto', \n",
    "                                            verbose=1, save_best_only=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuned_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n",
      "31250/31250 [==============================] - ETA: 0s - loss: 0.0512 - accuracy: 0.9911\n",
      "Epoch 1: val_accuracy improved from -inf to 0.99334, saving model to tuned_dnn.h5\n",
      "31250/31250 [==============================] - 442s 14ms/step - loss: 0.0512 - accuracy: 0.9911 - val_loss: 0.0346 - val_accuracy: 0.9933\n",
      "Epoch 2/50\n",
      "31248/31250 [============================>.] - ETA: 0s - loss: 0.0487 - accuracy: 0.9916\n",
      "Epoch 2: val_accuracy improved from 0.99334 to 0.99422, saving model to tuned_dnn.h5\n",
      "31250/31250 [==============================] - 451s 14ms/step - loss: 0.0487 - accuracy: 0.9916 - val_loss: 0.0345 - val_accuracy: 0.9942\n",
      "Epoch 3/50\n",
      "31246/31250 [============================>.] - ETA: 0s - loss: 0.0485 - accuracy: 0.9918\n",
      "Epoch 3: val_accuracy did not improve from 0.99422\n",
      "31250/31250 [==============================] - 426s 14ms/step - loss: 0.0485 - accuracy: 0.9918 - val_loss: 0.0374 - val_accuracy: 0.9935\n",
      "Epoch 4/50\n",
      "31249/31250 [============================>.] - ETA: 0s - loss: 0.0487 - accuracy: 0.9918\n",
      "Epoch 4: val_accuracy improved from 0.99422 to 0.99437, saving model to tuned_dnn.h5\n",
      "31250/31250 [==============================] - 414s 13ms/step - loss: 0.0487 - accuracy: 0.9918 - val_loss: 0.0344 - val_accuracy: 0.9944\n",
      "Epoch 5/50\n",
      "31246/31250 [============================>.] - ETA: 0s - loss: 0.0485 - accuracy: 0.9919\n",
      "Epoch 5: val_accuracy did not improve from 0.99437\n",
      "31250/31250 [==============================] - 428s 14ms/step - loss: 0.0485 - accuracy: 0.9919 - val_loss: 0.0367 - val_accuracy: 0.9938\n",
      "Epoch 6/50\n",
      "31250/31250 [==============================] - ETA: 0s - loss: 0.0487 - accuracy: 0.9918\n",
      "Epoch 6: val_accuracy did not improve from 0.99437\n",
      "31250/31250 [==============================] - 418s 13ms/step - loss: 0.0487 - accuracy: 0.9918 - val_loss: 0.0369 - val_accuracy: 0.9939\n"
     ]
    }
   ],
   "source": [
    "tuned_history = tuned_model.fit(Xtrain_transformed[:1000000], ytrain[:1000000], batch_size=32, epochs=50, \n",
    "                    validation_data=(Xtest_transformed[:1000000], ytest[:1000000]),\n",
    "                    validation_split=0.2,\n",
    "                    callbacks=[early_stopping, tuned_dl_model_checkpoint])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(3,3))\n",
    "\n",
    "plt.plot(tuned_history.history['val_accuracy'], color='blue', label='Validation Accuracy')\n",
    "plt.plot(tuned_history.history['accuracy'], color='orange', label='Training Accuracy')\n",
    "\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(3,3))\n",
    "\n",
    "plt.plot(tuned_history.history['val_loss'], color='blue', label='Validation Accuracy')\n",
    "plt.plot(tuned_history.history['loss'], color='orange', label='Training Accuracy')\n",
    "\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Training and Validation Loss')\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15625/15625 [==============================] - 35s 2ms/step\n",
      "Accuracy = 0.993434\n"
     ]
    }
   ],
   "source": [
    "## Checking the metrics for this model\n",
    "\n",
    "y_pred = tuned_model.predict(Xtest_transformed[1000000:1500000])\n",
    "\n",
    "y_pred = (y_pred > 0.5).astype(int) # converting the probabilities to 0 and 1\n",
    "\n",
    "accuracy = accuracy_score(ytest[1000000:1500000], y_pred)\n",
    "\n",
    "print(\"Accuracy = {}\".format(accuracy))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.99      0.99    250228\n",
      "           1       0.99      1.00      0.99    249772\n",
      "\n",
      "    accuracy                           0.99    500000\n",
      "   macro avg       0.99      0.99      0.99    500000\n",
      "weighted avg       0.99      0.99      0.99    500000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(ytest[1000000:1500000], y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[247713,   2515],\n",
       "       [   768, 249004]], dtype=int64)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(ytest[1000000:1500000], y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contrast with Untuned DNN Model - - \n",
    "\n",
    "- The tuned DNN exhibits a False Negative (FN) count of 768, compared to the DNN model's count of 922.\n",
    "- This reduction is notably substantial, providing increased reliability for the current business model."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}