Bank_Customer_Churn_Prediction.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Bank_Customer_Churn_Prediction.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "lAsvHMNAc-Nw",
        "TmPPtyLn8PNf"
      ],
      "mount_file_id": "10fuhEoVgv0DTF9lUkF-kzQAEK88wJgXc",
      "authorship_tag": "ABX9TyNfs+r2ikJqQQEVX7X9NvJe"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "8OivXrWEHkla"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "from IPython.display import clear_output"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xjccd2BCR1ZC"
      },
      "source": [
        "# fix random seed for reproducibility\n",
        "seed = 7\n",
        "np.random.seed(seed)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lAsvHMNAc-Nw"
      },
      "source": [
        "# **Configure GPU Acceleration**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M4ztGLl_nh2c",
        "outputId": "27283c8d-65f9-4176-db95-1249a359d051"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dBBPDMKXdDIW",
        "outputId": "67826598-8d63-48fd-bfb3-d69cbdac944a"
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Thu Mar 25 22:15:25 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.56       Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   47C    P8    10W /  70W |      0MiB / 15109MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HkCZKJQOgoPi",
        "outputId": "49d5b11b-b1ef-4d9e-b570-6dbf980f887f"
      },
      "source": [
        "%tensorflow_version 2.x\n",
        "import tensorflow as tf\n",
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found GPU at: /device:GPU:0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_83LF9zNdUuS",
        "outputId": "b1e00127-b26d-4635-98d3-1f3f90d52041"
      },
      "source": [
        "from tensorflow.python.client import device_lib\n",
        "device_lib.list_local_devices()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[name: \"/device:CPU:0\"\n",
              " device_type: \"CPU\"\n",
              " memory_limit: 268435456\n",
              " locality {\n",
              " }\n",
              " incarnation: 10035136589687616099, name: \"/device:GPU:0\"\n",
              " device_type: \"GPU\"\n",
              " memory_limit: 14674281152\n",
              " locality {\n",
              "   bus_id: 1\n",
              "   links {\n",
              "   }\n",
              " }\n",
              " incarnation: 10660773902960875991\n",
              " physical_device_desc: \"device: 0, name: Tesla T4, pci bus id: 0000:00:04.0, compute capability: 7.5\"]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hn8wxghMflkg",
        "outputId": "c6c1183c-9580-49a8-8c29-2906cfe50f2e"
      },
      "source": [
        "import tensorflow as tf\n",
        "sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(log_device_placement=True))"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Device mapping:\n",
            "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: Tesla T4, pci bus id: 0000:00:04.0, compute capability: 7.5\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gzDMz4ucm6Ab"
      },
      "source": [
        "# **Data Preprocessing**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 156
        },
        "id": "DcJjTqb_ozud",
        "outputId": "94fc4d05-fee2-425d-80ca-09840702d435"
      },
      "source": [
        "file_path = '/content/drive/My Drive/Churn_Modelling.csv'\n",
        "\n",
        "df = pd.read_csv(file_path, index_col='RowNumber').reset_index(drop=True)\n",
        "print('Dataframe shape :', df.shape)\n",
        "df.head(3)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dataframe shape : (10000, 13)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "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>CustomerId</th>\n",
              "      <th>Surname</th>\n",
              "      <th>CreditScore</th>\n",
              "      <th>Geography</th>\n",
              "      <th>Gender</th>\n",
              "      <th>Age</th>\n",
              "      <th>Tenure</th>\n",
              "      <th>Balance</th>\n",
              "      <th>NumOfProducts</th>\n",
              "      <th>HasCrCard</th>\n",
              "      <th>IsActiveMember</th>\n",
              "      <th>EstimatedSalary</th>\n",
              "      <th>Exited</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>15634602</td>\n",
              "      <td>Hargrave</td>\n",
              "      <td>619</td>\n",
              "      <td>France</td>\n",
              "      <td>Female</td>\n",
              "      <td>42</td>\n",
              "      <td>2</td>\n",
              "      <td>0.00</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>101348.88</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>15647311</td>\n",
              "      <td>Hill</td>\n",
              "      <td>608</td>\n",
              "      <td>Spain</td>\n",
              "      <td>Female</td>\n",
              "      <td>41</td>\n",
              "      <td>1</td>\n",
              "      <td>83807.86</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>112542.58</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>15619304</td>\n",
              "      <td>Onio</td>\n",
              "      <td>502</td>\n",
              "      <td>France</td>\n",
              "      <td>Female</td>\n",
              "      <td>42</td>\n",
              "      <td>8</td>\n",
              "      <td>159660.80</td>\n",
              "      <td>3</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>113931.57</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   CustomerId   Surname  CreditScore  ... IsActiveMember EstimatedSalary  Exited\n",
              "0    15634602  Hargrave          619  ...              1       101348.88       1\n",
              "1    15647311      Hill          608  ...              1       112542.58       0\n",
              "2    15619304      Onio          502  ...              0       113931.57       1\n",
              "\n",
              "[3 rows x 13 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ip2iPmodo5dm"
      },
      "source": [
        "#Retrieve relevant features by excluding : 'CustomerId', 'Surname', 'Exited' \n",
        "columns = df.columns.to_list()[2:-1]\n",
        "X = df[columns]\n",
        "\n",
        "#Retrieve target column\n",
        "y = df['Exited']"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eN3su5WIi1gc"
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder, StandardScaler\n",
        "from sklearn.pipeline import Pipeline, FeatureUnion\n",
        "from sklearn.compose import ColumnTransformer"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jdKIlMsmkpT0"
      },
      "source": [
        "categorical_encoder = ColumnTransformer(transformers = [('geo_encoder', OneHotEncoder(drop='first'), ['Geography']),\n",
        "                                                        ('gen_encoder', OrdinalEncoder(), ['Gender'])], \n",
        "                                        remainder = 'passthrough')\n",
        "\n",
        "\n",
        "pipe = Pipeline(steps = [('encoder', categorical_encoder), \n",
        "                         ('scaler', StandardScaler())])"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TrA4QXn_mohT"
      },
      "source": [
        "#Split to train/test datasets\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MqYQocs4m9Cp"
      },
      "source": [
        "X_train = pipe.fit_transform(X_train)\n",
        "X_test = pipe.transform(X_test)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hgb4g3QLlf7V"
      },
      "source": [
        "# **Hyperparameter Tuning**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TmPPtyLn8PNf"
      },
      "source": [
        "### **Baseline model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vynBOYZH8VC8",
        "outputId": "d1bd1ecd-9dfc-4cf6-8be9-672b93842b41"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "baseline = LogisticRegression()\n",
        "baseline.fit(X_train, y_train)\n",
        "baseline.score(X_test, y_test)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.8113333333333334"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ibtTuVqN9Qkj"
      },
      "source": [
        "### **Regular Neural Network**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5FclPWbFu6yw"
      },
      "source": [
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Dropout, PReLU\n",
        "from tensorflow.keras.regularizers import l1, l1_l2\n",
        "from keras.wrappers.scikit_learn import KerasClassifier\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "\n",
        "def create_model(neurons=10, activation='relu', regularizer=l1(l=0.1), optimizer='adam', dropout_rate=0.0):\n",
        "  with tf.device('/device:GPU:0'):\n",
        "    #creation\n",
        "    model = Sequential()\n",
        "    model.add(Dense(units=neurons, kernel_initializer='uniform', activation=activation))\n",
        "    model.add(Dense(units=neurons, kernel_initializer='uniform', kernel_regularizer=regularizer, activation=activation))\n",
        "    model.add(Dropout(dropout_rate))\n",
        "    model.add(Dense(units=1, kernel_initializer='uniform', activation='sigmoid'))\n",
        "    #compilation\n",
        "    model.compile(optimizer = optimizer , loss='binary_crossentropy', metrics=['accuracy'])\n",
        "\n",
        "  return model\n",
        "\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=5) \n",
        "\n",
        "model = KerasClassifier(build_fn=create_model, epochs=20, batch_size=10, verbose=0)"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xsaJCVa8GSss"
      },
      "source": [
        "#### **Tuning** : epochs, batch_size, optimizers "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3gd3KVbDgbgX",
        "outputId": "d9acf202-81f2-4239-9fb4-78aeb946f927"
      },
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "\n",
        "batch_size = [10, 20]\n",
        "epochs = [100, 150]\n",
        "optimizer = ['adam', 'RMSprop']\n",
        "\n",
        "param_grid = dict(batch_size=batch_size, epochs=epochs, optimizer=optimizer)\n",
        "\n",
        "grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=2, cv=5, verbose=1)\n",
        "\n",
        "with tf.device('/device:GPU:0'):\n",
        "  grid_result = grid.fit(X_train, y_train)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting 5 folds for each of 8 candidates, totalling 40 fits\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "[Parallel(n_jobs=2)]: Using backend LokyBackend with 2 concurrent workers.\n",
            "[Parallel(n_jobs=2)]: Done  40 out of  40 | elapsed: 33.5min finished\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fkdwv1XUTKZL",
        "outputId": "ece275e7-1f0e-4180-f228-5326a54ee1d3"
      },
      "source": [
        "# summarize results\n",
        "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
        "means = grid_result.cv_results_['mean_test_score']\n",
        "stds = grid_result.cv_results_['std_test_score']\n",
        "params = grid_result.cv_results_['params']\n",
        "for mean, stdev, param in zip(means, stds, params):\n",
        "    print(\"%f (%f) with: %r\" % (mean, stdev, param))"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Best: 0.856286 using {'batch_size': 10, 'epochs': 150, 'optimizer': 'adam'}\n",
            "0.852714 (0.009902) with: {'batch_size': 10, 'epochs': 100, 'optimizer': 'adam'}\n",
            "0.844571 (0.017691) with: {'batch_size': 10, 'epochs': 100, 'optimizer': 'RMSprop'}\n",
            "0.856286 (0.009405) with: {'batch_size': 10, 'epochs': 150, 'optimizer': 'adam'}\n",
            "0.853571 (0.009069) with: {'batch_size': 10, 'epochs': 150, 'optimizer': 'RMSprop'}\n",
            "0.849429 (0.009470) with: {'batch_size': 20, 'epochs': 100, 'optimizer': 'adam'}\n",
            "0.843429 (0.014007) with: {'batch_size': 20, 'epochs': 100, 'optimizer': 'RMSprop'}\n",
            "0.852429 (0.005761) with: {'batch_size': 20, 'epochs': 150, 'optimizer': 'adam'}\n",
            "0.852143 (0.011176) with: {'batch_size': 20, 'epochs': 150, 'optimizer': 'RMSprop'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QFLOt-Rwe634"
      },
      "source": [
        "# **Training model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "em5g-2xYhfZL"
      },
      "source": [
        "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\n",
        "from tensorflow.keras.models import load_model\n",
        "\n",
        "#Early Stopping\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=10)  \n",
        "\n",
        "#Model Checkpoint\n",
        "model_chechpoint = ModelCheckpoint(filepath='best_clf.h5', monitor='val_loss', save_best_only=True)\n",
        "\n",
        "#Create model\n",
        "clf = create_model()\n",
        "\n",
        "#Training\n",
        "fitting = clf.fit(X_train, y_train, \n",
        "                  validation_split=0.2, \n",
        "                  batch_size=10, \n",
        "                  epochs=150, \n",
        "                  callbacks= [early_stopping, model_chechpoint],\n",
        "                  verbose=0)\n",
        "\n",
        "#Get best classifier\n",
        "saved_clf = load_model('best_clf.h5')"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "IJSYnpc24x7N",
        "outputId": "fea2429b-352d-47bb-98b5-41ae330ef28b"
      },
      "source": [
        "#TRAINING ACCURACY HISTORY\n",
        "\n",
        "plt.plot(fitting.history['accuracy'])\n",
        "plt.plot(fitting.history['val_accuracy'])\n",
        "plt.legend(['accuracy', 'val_accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.xlabel('epochs')\n",
        "plt.ylabel('accuraxy')\n",
        "plt.show()\n",
        "\n",
        "validation_accuracy = max(fitting.history['val_accuracy'])\n",
        "validation_loss = min(fitting.history['val_loss'])\n",
        "print(f\"Best Validation Metrics - loss : {validation_loss} - accuracy {validation_accuracy}\")"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Best Validation Metrics - loss : 0.3719637989997864 - accuracy 0.8557142615318298\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hyaC7E6hDbc7",
        "outputId": "da785d7a-a4d8-4561-c0fe-4b011b382723"
      },
      "source": [
        "#TESTING ACCURACY\n",
        "\n",
        "def accuracy(model, X_test, y_test):\n",
        "  '''Compute the accuracy of of a given model'''\n",
        "  y_prob_pred = model.predict(X_test)\n",
        "  y_pred = [int(value) for value in (y_prob_pred > 0.5)]\n",
        "  return sum([int(value) for value in (y_pred == y_test)])/len(y_test)\n",
        "\n",
        "clf_accuracy = accuracy(saved_clf, X_test, y_test)\n",
        "print(f\"Model testing accuracy : {clf_accuracy*100:.2f}%\")"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model testing accuracy : 86.90%\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}