DL_P1_BinaryClassification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "DL_P1_BinaryClassification.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "metadata": {
        "id": "B5m5hFfpSbV5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **STEP 1: Loading dataset**"
      ]
    },
    {
      "metadata": {
        "id": "SLaGsDcQSJB2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "2813152f-bd70-4b34-e6db-d3f82a8816ac"
      },
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload() "
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8545e51e-4788-4a23-b4a5-474251ceaa29\" name=\"files[]\" multiple disabled />\n",
              "     <output id=\"result-8545e51e-4788-4a23-b4a5-474251ceaa29\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving sonar.csv to sonar.csv\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "GKCOo1h7TGj_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Step 2. Baseline Neural Network Model Performance"
      ]
    },
    {
      "metadata": {
        "id": "O_aMFUL6TLNd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import numpy\n",
        "import pandas\n",
        "import keras\n",
        "from keras import layers\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense\n",
        "from keras.wrappers.scikit_learn import KerasClassifier\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.model_selection import StratifiedKFold\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.pipeline import Pipeline\n",
        "\n",
        "# fix random seed for reproducibility\n",
        "seed = 7\n",
        "numpy.random.seed(seed)\n",
        "\n",
        "# load dataset\n",
        "dataframe = pandas.read_csv(\"sonar.csv\", header=None)\n",
        "dataset = dataframe.values\n",
        "# split into input (X) and output (Y) variables\n",
        "X = dataset[:,0:60].astype(float)\n",
        "Y = dataset[:,60]\n",
        "\n",
        "# Encoding\n",
        "le = LabelEncoder()\n",
        "encoded_Y = le.fit(Y)\n",
        "encoded_Y = le.transform(Y)\n",
        "train_data = X\n",
        "train_targets = encoded_Y"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "qIDCP1D7Td_6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def create_baseline():\n",
        "  model = Sequential()\n",
        "  model.add(Dense(60, activation = 'relu', input_shape=(60,)))\n",
        "  model.add(Dense(1, activation = 'sigmoid'))\n",
        "  \n",
        "  model.compile(loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])\n",
        "  return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "h3grL7LTT71t",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4b10fa69-a70e-44ef-f9a1-7d57cf648fea"
      },
      "cell_type": "code",
      "source": [
        "# evaluate model with standardized dataset\n",
        "estimator = KerasClassifier(build_fn=create_baseline, epochs=100, batch_size=5, verbose=0)\n",
        "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
        "results = cross_val_score(estimator, X, encoded_Y, cv=kfold)\n",
        "print(\"Results: %.2f%% (%.2f%%)\" % (results.mean()*100, results.std()*100))\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Results: 83.71% (6.13%)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "hAyXzPygVP5Q",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Step 3 : Re-Run The Baseline Model With Data Preparation**"
      ]
    },
    {
      "metadata": {
        "id": "OIGKqTPrVWaU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "03104ec8-2131-495f-a6a5-35cf8c6e5f44"
      },
      "cell_type": "code",
      "source": [
        "# evaluate baseline model with standardized dataset\n",
        "numpy.random.seed(seed)\n",
        "estimators = []\n",
        "estimators.append(('standardize', StandardScaler()))\n",
        "estimators.append(('mlp', KerasClassifier(build_fn=create_baseline, epochs=100, batch_size=5, verbose=0)))\n",
        "pipeline = Pipeline(estimators)\n",
        "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
        "results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)\n",
        "print(\"Standardized: %.2f%% (%.2f%%)\" % (results.mean()*100, results.std()*100))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Standardized: 85.59% (7.46%)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "jG03rmo7WpmI",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Step 4.1: Evaluate a Smaller Network**"
      ]
    },
    {
      "metadata": {
        "id": "c-LaJnjLWsRk",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def create_smaller():\n",
        "  model = Sequential()\n",
        "  model.add(Dense(30, activation = 'relu', input_shape=(60,)))\n",
        "  model.add(Dense(1, activation = 'sigmoid'))\n",
        "  \n",
        "  model.compile(loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])\n",
        "  return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ZCb6PXztWz7O",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a3ce0115-0b43-46b4-c4a6-cdb43fe9cf98"
      },
      "cell_type": "code",
      "source": [
        "# evaluate baseline model with standardized dataset\n",
        "numpy.random.seed(seed)\n",
        "estimators = []\n",
        "estimators.append(('standardize', StandardScaler()))\n",
        "estimators.append(('mlp', KerasClassifier(build_fn=create_smaller, epochs=100, batch_size=5, verbose=0)))\n",
        "pipeline = Pipeline(estimators)\n",
        "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
        "results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)\n",
        "print(\"Smaller: %.2f%% (%.2f%%)\" % (results.mean()*100, results.std()*100))"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Smaller: 85.06% (7.61%)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "ELyJ_wGZX3dl",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Step 4.2. Evaluate a Larger Network**"
      ]
    },
    {
      "metadata": {
        "id": "Qgey4YhSX9i2",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def create_larger():\n",
        "  model = Sequential()\n",
        "  model.add(Dense(60, activation = 'relu', input_shape=(60,)))\n",
        "  model.add(Dense(30, activation = 'relu', input_shape=(60,)))\n",
        "  model.add(Dense(1, activation = 'sigmoid'))\n",
        "  \n",
        "  model.compile(loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])\n",
        "  return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "GnHqHJW_ZJ4k",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ff48c32b-e01a-4ba7-ae17-5041fb701611"
      },
      "cell_type": "code",
      "source": [
        "# evaluate baseline model with standardized dataset\n",
        "numpy.random.seed(seed)\n",
        "estimators = []\n",
        "estimators.append(('standardize', StandardScaler()))\n",
        "estimators.append(('mlp', KerasClassifier(build_fn=create_larger, epochs=100, batch_size=5, verbose=0)))\n",
        "pipeline = Pipeline(estimators)\n",
        "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
        "results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)\n",
        "print(\"Larger: %.2f%% (%.2f%%)\" % (results.mean()*100, results.std()*100))\n",
        "\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Larger: 84.61% (6.36%)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "1gEv8JLrbCvv",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Step 5: Really Scaling up: developing a model that overfits & Step 6: Tuning the Model**"
      ]
    },
    {
      "metadata": {
        "id": "x2NpegkPbX3X",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def create_larger():\n",
        "  model = Sequential()\n",
        "  model.add(Dense(64, activation = 'relu', input_shape=(60,)))\n",
        "  model.add(Dense(50, activation = 'relu'))\n",
        "  model.add(Dense(32, activation = 'relu'))\n",
        "  model.add(Dense(15, activation = 'relu'))\n",
        "  model.add(Dense(5, activation = 'relu'))\n",
        "  model.add(Dense(1, activation = 'sigmoid'))\n",
        "  \n",
        "  model.compile(loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])\n",
        "  return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "gwn7902cbbaV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6e1b567e-8fab-4c74-9a87-0f1a34955a0f"
      },
      "cell_type": "code",
      "source": [
        "# evaluate baseline model with standardized dataset\n",
        "numpy.random.seed(seed)\n",
        "estimators = []\n",
        "estimators.append(('standardize', StandardScaler()))\n",
        "estimators.append(('mlp', KerasClassifier(build_fn=create_larger, epochs=100, batch_size=5, verbose=0)))\n",
        "pipeline = Pipeline(estimators)\n",
        "kfold = StratifiedKFold(n_splits=20, shuffle=True, random_state=seed)\n",
        "results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)\n",
        "print(\"Model results: %.2f%% (%.2f%%)\" % (results.mean()*100, results.std()*100))\n",
        "\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model results: 86.98% (9.28%)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Q-4xK0NfiUaT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Step 7: Rewriting the code using the Keras Functional API**"
      ]
    },
    {
      "metadata": {
        "id": "KorI5UdNiVrz",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def create_func_api_model():\n",
        "  inputs = keras.Input(shape=(60,))\n",
        "  x = layers.Dense(50, activation = 'relu')(inputs)\n",
        "  x = layers.Dense(32, activation = 'relu')(x)\n",
        "  x = layers.Dense(15, activation = 'relu')(x)\n",
        "  x = layers.Dense(5, activation = 'relu')(x)\n",
        "  outputs = layers.Dense(1, activation = 'sigmoid')(x)\n",
        "  \n",
        "  model = keras.Model(inputs, outputs)\n",
        "  model.compile(loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])\n",
        "  return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "aLlBK41Vi2Hn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4a1fd050-e0dc-41d8-bf35-1c4665653e76"
      },
      "cell_type": "code",
      "source": [
        "# evaluate baseline model with standardized dataset\n",
        "numpy.random.seed(seed)\n",
        "estimators = []\n",
        "estimators.append(('standardize', StandardScaler()))\n",
        "estimators.append(('mlp', KerasClassifier(build_fn=create_func_api_model, epochs=300, batch_size=5, verbose=0)))\n",
        "pipeline = Pipeline(estimators)\n",
        "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
        "results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)\n",
        "print(\"Function API model results: %.2f%% (%.2f%%)\" % (results.mean()*100, results.std()*100))\n",
        "\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Function API model results: 83.13% (5.94%)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "j3EoBOtxnV7W",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Step 8: Rewriting the code by doing Model Subclassing**"
      ]
    },
    {
      "metadata": {
        "id": "ytpobgSYnagn",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# TODO"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "wRKtnzsTncHt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## **Step 9: Rewriting the code without using scikit-learn**"
      ]
    },
    {
      "metadata": {
        "id": "mhuk-ZLPneuv",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def baseline_model():\n",
        "  model = Sequential()\n",
        "  model.add(Dense(64, activation = 'relu', input_shape=(60,)))\n",
        "  model.add(Dense(50, activation = 'relu'))\n",
        "  model.add(Dense(32, activation = 'relu'))\n",
        "  model.add(Dense(15, activation = 'relu'))\n",
        "  model.add(Dense(5, activation = 'relu'))\n",
        "  model.add(Dense(1, activation = 'sigmoid'))\n",
        "  \n",
        "  model.compile(loss = 'binary_crossentropy',\n",
        "                optimizer = 'adam',\n",
        "                metrics = ['accuracy'])\n",
        "  return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Sd_1rmeimgWD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 272
        },
        "outputId": "db02d0e4-b981-483c-dd6a-343d9d42992c"
      },
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "k=5\n",
        "num_val_samples = len(train_data) // k\n",
        "num_epochs = 100\n",
        "all_scores = []\n",
        "\n",
        "num_epochs = 500\n",
        "batch_size_val = num_val_samples // k\n",
        "all_mae_histories = []\n",
        "for i in range(k):\n",
        "    print('processing fold #', i)\n",
        "    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]\n",
        "    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]\n",
        "    \n",
        "    partial_train_data = np.concatenate(\n",
        "        [train_data[:i * num_val_samples],\n",
        "         train_data[(i + 1) * num_val_samples:]],\n",
        "        axis=0)\n",
        "    \n",
        "    partial_train_targets = np.concatenate(\n",
        "        [train_targets[:i * num_val_samples],\n",
        "         train_targets[(i + 1) * num_val_samples:]],\n",
        "        axis=0)\n",
        "    \n",
        "    model = baseline_model()\n",
        "    history = model.fit(partial_train_data, partial_train_targets,\n",
        "                    validation_data=(val_data, val_targets),\n",
        "                    epochs=num_epochs, batch_size=batch_size_val, verbose=0)\n",
        "    print(\"Training Accuracy:\", history.history['acc'][num_epochs-1])\n",
        "    print(\"Validation Accuracy:\", history.history['val_acc'][num_epochs-1])\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "processing fold # 0\n",
            "Training Accuracy: 1.0\n",
            "Validation Accuracy: 0.43902439024390244\n",
            "processing fold # 1\n",
            "Training Accuracy: 1.0\n",
            "Validation Accuracy: 0.6585365853658537\n",
            "processing fold # 2\n",
            "Training Accuracy: 1.0\n",
            "Validation Accuracy: 0.4634146341463415\n",
            "processing fold # 3\n",
            "Training Accuracy: 1.0\n",
            "Validation Accuracy: 0.5609756097560976\n",
            "processing fold # 4\n",
            "Training Accuracy: 1.0\n",
            "Validation Accuracy: 0.6341463414634146\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}