Churn_Modelling.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Churn_Modelling.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/roshank1605A04/Churn-Modelling-Dataset/blob/master/Churn_Modelling.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "metadata": {
        "id": "_S34U5S-i69d",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Importing the libraries**"
      ]
    },
    {
      "metadata": {
        "id": "PYU9RIEWif6n",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "9IZetEZ8jQJm",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Importing the Dataset**"
      ]
    },
    {
      "metadata": {
        "id": "rvPXb5V5jPN-",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data = pd.read_csv('drive/My Drive/super/Artificial Neural Networks/Churn_Modelling.csv')\n",
        "\n",
        "data.head(4)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "TinF8sdf9atQ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data.info()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "fX7PPpba973B",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data.describe()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RKwSmzQU97nY",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data.tail()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "DKnxi2l3jzWs",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Checking if our dataset contains any NULL values\n",
        "\n",
        "data.isnull().sum()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Cpzuyj7gxwCg",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Data Analysis**"
      ]
    },
    {
      "metadata": {
        "id": "N_gQ0bLF-PHe",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data['Gender'].value_counts()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "oFY8xmMnk7fa",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Plotting the features of the dataset to see the correlation between them\n",
        "\n",
        "plt.hist(x = data.Gender, bins = 3, color = 'pink')\n",
        "plt.title('comparison of male and female')\n",
        "plt.xlabel('Gender')\n",
        "plt.ylabel('population')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "hJGjglDq-WRG",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data['Age'].value_counts()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Web4HrNqlou0",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# comparison of age in the dataset\n",
        "\n",
        "plt.hist(x = data.Age, bins = 10, color = 'orange')\n",
        "plt.title('comparison of Age')\n",
        "plt.xlabel('Age')\n",
        "plt.ylabel('population')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "0W2IB3hu-vRH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data['Geography'].value_counts()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "CacR8PLhpx6g",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# comparison of geography\n",
        "\n",
        "plt.hist(x = data.Geography, bins = 5, color = 'green')\n",
        "plt.title('comparison of Geography')\n",
        "plt.xlabel('Geography')\n",
        "plt.ylabel('population')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UqBMAWek-05s",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data['HasCrCard'].value_counts()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "NSgBRAikqXCd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# comparision of how many customers hold the credit card\n",
        "\n",
        "plt.hist(x = data.HasCrCard, bins = 3, color = 'red')\n",
        "plt.title('how many people have or not have the credit card')\n",
        "plt.xlabel('customers holding credit card')\n",
        "plt.ylabel('population')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "UCVDCm0N-9Mb",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data['IsActiveMember'].value_counts()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "_v_jHh6zraHS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# How many active member does the bank have ?\n",
        "\n",
        "plt.hist(x = data.IsActiveMember, bins = 3, color = 'brown')\n",
        "plt.title('Active Members')\n",
        "plt.xlabel('Customers')\n",
        "plt.ylabel('population')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "uubQD4NktRaN",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# comparison between Geography and Gender\n",
        "\n",
        "Gender = pd.crosstab(data['Gender'],data['Geography'])\n",
        "Gender.div(Gender.sum(1).astype(float), axis=0).plot(kind=\"bar\", stacked=True, figsize=(6, 6))\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "i68rxAM1wyTt",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# comparison between geography and card holders\n",
        "\n",
        "HasCrCard = pd.crosstab(data['HasCrCard'], data['Geography'])\n",
        "HasCrCard.div(HasCrCard.sum(1).astype(float), axis = 0).plot(kind = 'bar',\n",
        "                                            stacked = True,figsize = (6, 6))\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JcSXelsA0nYU",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# comparison of active member in differnt geographies\n",
        "\n",
        "IsActiveMember = pd.crosstab(data['IsActiveMember'], data['Geography'])\n",
        "IsActiveMember.div(IsActiveMember.sum(1).astype(float), axis = 0).plot(kind = 'bar', \n",
        "                                             stacked = True, figsize= (6, 6))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Y03E7IVV1fOh",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# comparing ages in different geographies\n",
        "\n",
        "Age = pd.crosstab(data['Age'], data['Geography'])\n",
        "Age.div(Age.sum(1).astype(float), axis = 0).plot(kind = 'bar', \n",
        "                                           stacked = True, figsize = (15,15))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "6Vp0UZiK2bTJ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# calculating total balance in france, germany and spain\n",
        "\n",
        "total_france = data.Balance[data.Geography == 'France'].sum()\n",
        "total_germany = data.Balance[data.Geography == 'Germany'].sum()\n",
        "total_spain = data.Balance[data.Geography == 'Spain'].sum()\n",
        "\n",
        "print(\"Total Balance in France :\",total_france)\n",
        "print(\"Total Balance in Germany :\",total_germany)\n",
        "print(\"Total Balance in Spain :\",total_spain)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "w6ZyljXl_YB1",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# plotting a pie chart\n",
        "\n",
        "labels = 'France', 'Germany', 'Spain'\n",
        "colors = ['cyan', 'magenta', 'orange']\n",
        "sizes =  [311, 300, 153]\n",
        "explode = [ 0.01, 0.01, 0.01]\n",
        "\n",
        "plt.pie(sizes, colors = colors, labels = labels, explode = explode, shadow = True)\n",
        "\n",
        "plt.axis('equal')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ss9REZXjU4at",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Data Preprocessing**"
      ]
    },
    {
      "metadata": {
        "id": "wce3Hm9XU3XT",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Removing the unnecassary features from the dataset\n",
        "\n",
        "data = data.drop(['CustomerId', 'Surname', 'RowNumber'], axis = 1)\n",
        "\n",
        "\n",
        "\n",
        "print(data.columns)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "M-UovDqiK5LK",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data.shape"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "-6e_Flxh7cpa",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# splitting the dataset into x(independent variables) and y(dependent variables)\n",
        "\n",
        "x = data.iloc[:,0:10]\n",
        "y = data.iloc[:,10]\n",
        "\n",
        "print(x.shape)\n",
        "print(y.shape)\n",
        "\n",
        "print(x.columns)\n",
        "#print(y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "-tIpZZBWZTMu",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Encoding Categorical variables into numerical variables\n",
        "# One Hot Encoding\n",
        "\n",
        "x = pd.get_dummies(x)\n",
        "\n",
        "x.head()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "QUX4XvrtLWGy",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x.shape"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "9RqmZSGX5TcE",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# splitting the data into training and testing set\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.25, random_state = 0)\n",
        "\n",
        "print(x_train.shape)\n",
        "print(y_train.shape)\n",
        "print(x_test.shape)\n",
        "print(y_test.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "HMz6rg-_bTzq",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Feature Scaling \n",
        "# Only on Independent Variable to convert them into values ranging from -1 to +1\n",
        "\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "sc = StandardScaler()\n",
        "x_train = sc.fit_transform(x_train)\n",
        "x_test = sc.fit_transform(x_test)\n",
        "\n",
        "x_train = pd.DataFrame(x_train)\n",
        "x_train.head()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "0-fUw-Wacj97",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Modelling**"
      ]
    },
    {
      "metadata": {
        "id": "nO64kkKHdRzm",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Decision Tree**"
      ]
    },
    {
      "metadata": {
        "id": "eci1C6NS9N6p",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "model = DecisionTreeClassifier() \n",
        "model.fit(x_train, y_train)\n",
        "\n",
        "y_pred = model.predict(x_test)\n",
        "\n",
        "print(\"Training Accuracy :\", model.score(x_train, y_train))\n",
        "print(\"Testing Accuaracy :\", model.score(x_test, y_test))\n",
        "\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "print(cm)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "BvCzfjYPdW_m",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Random Forest**"
      ]
    },
    {
      "metadata": {
        "id": "Yz8YzOCXcotr",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "\n",
        "model = RandomForestClassifier()\n",
        "model.fit(x_train, y_train)\n",
        "\n",
        "y_pred = model.predict(x_test)\n",
        "\n",
        "print(\"Training Accuracy :\", model.score(x_train, y_train))\n",
        "print(\"Testing Accuracy :\", model.score(x_test, y_test))\n",
        "\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "print(cm)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "eTH2C_0BBMUO",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# k fold cross validatio\n",
        "\n",
        "from sklearn.model_selection import cross_val_score\n",
        "\n",
        "cvs = cross_val_score(estimator = model, X = x_train, y = y_train, cv = 10)\n",
        "print(cvs)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "4EBQnw2CB4Hy",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Mean Accuracy :\", cvs.mean())\n",
        "print(\"Variance :\", cvs.std())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "j60iKI-ieMQ6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Logistic Regression**"
      ]
    },
    {
      "metadata": {
        "id": "P-ce8xt_9x98",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "model = LogisticRegression()\n",
        "model.fit(x_train, y_train)\n",
        "\n",
        "y_pred = model.predict(x_test)\n",
        "\n",
        "print(\"Training Accuracy :\", model.score(x_train, y_train))\n",
        "print(\"Testing Accuracy :\", model.score(x_test, y_test))\n",
        "\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "print(cm)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "wQeWPg-3ehE9",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Support Vector Machine**"
      ]
    },
    {
      "metadata": {
        "id": "-pgdW05FefW0",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from sklearn.svm import SVC\n",
        "\n",
        "model = SVC()\n",
        "model.fit(x_train, y_train)\n",
        "\n",
        "y_pred = model.predict(x_test)\n",
        "\n",
        "print(\"Training Accuracy :\", model.score(x_train, y_train))\n",
        "print(\"Testing Accuracy :\", model.score(x_test, y_test))\n",
        "\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "print(cm)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "eoQoqSJJMK_3",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# k fold cross validatio\n",
        "\n",
        "from sklearn.model_selection import cross_val_score\n",
        "\n",
        "cvs = cross_val_score(estimator = model, X = x_train, y = y_train, cv = 10)\n",
        "print(cvs)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "2RIsnUf3MKom",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Mean Accuracy :\", cvs.mean())\n",
        "print(\"Variance :\", cvs.std())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "5QNYyEWSe5cR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Multi Layer Perceptron**"
      ]
    },
    {
      "metadata": {
        "id": "HyUIYbfne4cL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from sklearn.neural_network import MLPClassifier\n",
        "\n",
        "model = MLPClassifier(hidden_layer_sizes = (100, 100), activation ='relu', \n",
        "                      solver = 'adam', max_iter = 50)\n",
        "model.fit(x_train, y_train)\n",
        "\n",
        "y_pred = model.predict(x_test)\n",
        "\n",
        "print(\"Training Accuracy :\", model.score(x_train, y_train))\n",
        "print(\"Testing Accuracy :\", model.score(x_test, y_test))\n",
        "\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "print(cm)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "veMTFqaZgQOI",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "**Aritificial Neural Networks**"
      ]
    },
    {
      "metadata": {
        "id": "U3DQbZVRfR_j",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import keras\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "xafViQmvgjhV",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# creating the model\n",
        "model = Sequential()\n",
        "\n",
        "# first hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu', input_dim = 14))\n",
        "\n",
        "# second hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "\n",
        "# third hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "\n",
        "# fourth hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "\n",
        "# fifth hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "\n",
        "# output layer\n",
        "model.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'))\n",
        "\n",
        "# Compiling the NN\n",
        "# binary_crossentropy loss function used when a binary output is expected\n",
        "model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) \n",
        "\n",
        "model.fit(x_train, y_train, batch_size = 10, nb_epoch = 50)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "uVd2MAhXE5Hc",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# creating the model\n",
        "model = Sequential()\n",
        "\n",
        "from keras.layers import Dropout\n",
        "\n",
        "# first hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu', input_dim = 14))\n",
        "model.add(Dropout(0.5))\n",
        "\n",
        "# second hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "model.add(Dropout(0.5))\n",
        "\n",
        "# output layer\n",
        "model.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'))\n",
        "\n",
        "# Compiling the NN\n",
        "# binary_crossentropy loss function used when a binary output is expected\n",
        "model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) \n",
        "\n",
        "model.fit(x_train, y_train, batch_size = 10, nb_epoch = 50)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "h5YNM3DLFiTf",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# creating the model\n",
        "model = Sequential()\n",
        "\n",
        "# first hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu', input_dim = 14))\n",
        "model.add(Dropout(0.1))\n",
        "\n",
        "# second hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "model.add(Dropout(0.1))\n",
        "\n",
        "# output layer\n",
        "model.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'))\n",
        "\n",
        "# Compiling the NN\n",
        "# binary_crossentropy loss function used when a binary output is expected\n",
        "model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) \n",
        "\n",
        "model.fit(x_train, y_train, batch_size = 10, nb_epoch = 50)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "tlBmG8fVGEb6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# creating the model\n",
        "model = Sequential()\n",
        "\n",
        "# first hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu', input_dim = 13))\n",
        "\n",
        "# second hidden layer\n",
        "model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "\n",
        "# output layer\n",
        "model.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'))\n",
        "\n",
        "# Compiling the NN\n",
        "# binary_crossentropy loss function used when a binary output is expected\n",
        "model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) \n",
        "\n",
        "model.fit(x_train, y_train, batch_size = 10, nb_epoch = 49)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "DLA-gwNvJFsE",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "data.columns"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "WFOvRqg6GeW3",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "'''\n",
        "predicting if the costumer having following information will leave the bank or not ?\n",
        "\n",
        "Geography : france\n",
        "Age = 50\n",
        "Credit score = 850\n",
        "Tenure = 4\n",
        "Balance = 150000\n",
        "Number of Products = 5\n",
        "Gender = Female\n",
        "Has Credit Card = yes\n",
        "Is Active Member = yes\n",
        "Estimated Salary = 85000\n",
        "'''\n",
        "\n",
        "new_prediction = model.predict(sc.transform(np.array([[850, 50, 4, 150000, 5, 1, 1, 85000, 1, 0, 0, 1, 0]])))\n",
        "\n",
        "new_prediction = (new_prediction > 0.5 )\n",
        "print(new_prediction)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "jjseXpQzGLZP",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from keras.wrappers.scikit_learn import KerasClassifier\n",
        "from sklearn.model_selection import cross_val_score\n",
        "\n",
        "from keras.layers import Dense\n",
        "from keras.models import Sequential\n",
        "\n",
        "def build_classifier():\n",
        "  # creating the model\n",
        "  model = Sequential()\n",
        "\n",
        "  # first hidden layer\n",
        "  model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu', input_dim = 13))\n",
        "\n",
        "  # second hidden layer\n",
        "  model.add(Dense(output_dim = 8, init = 'uniform', activation = 'relu'))\n",
        "\n",
        "  # output layer\n",
        "  model.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'))\n",
        "\n",
        "  # Compiling the NN\n",
        "  # binary_crossentropy loss function used when a binary output is expected\n",
        "  model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])\n",
        "  \n",
        "  return model\n",
        "\n",
        "model = KerasClassifier(build_fn = build_classifier, batch_size = 10, nb_epoch = 50)\n",
        "accuracies = cross_val_score(estimator = model, X = x_train, y = y_train, cv = 10, n_jobs = -1)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "IB8HfZ1yR3dz",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(\"Accuracies :\", accuracies)\n",
        "\n",
        "print(\"Mean Accuracy :\", accuracies.mean())\n",
        "print(\"Variance :\", accuracies.std())"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}