C2_W1_Regularization.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1uN3-S6aTmmAbNT879DFTXBMhhlt7nY_U",
      "authorship_tag": "ABX9TyMk15YGCz5380HXeJPoOMNZ"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vXBdFH1dKHsG",
        "outputId": "16c1c756-f4cb-4ecb-fa82-914d4d285453"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The autoreload extension is already loaded. To reload it, use:\n",
            "  %reload_ext autoreload\n"
          ]
        }
      ],
      "source": [
        "# import packages\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import h5py\n",
        "import sklearn\n",
        "import sklearn.datasets\n",
        "import sklearn.linear_model\n",
        "import scipy.io\n",
        "\n",
        "%matplotlib inline\n",
        "plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots\n",
        "plt.rcParams['image.interpolation'] = 'nearest'\n",
        "plt.rcParams['image.cmap'] = 'gray'\n",
        "\n",
        "%load_ext autoreload\n",
        "%autoreload 2"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sigmoid(x):\n",
        "    \"\"\"\n",
        "    Compute the sigmoid of x\n",
        "\n",
        "    Arguments:\n",
        "    x -- A scalar or numpy array of any size.\n",
        "\n",
        "    Return:\n",
        "    s -- sigmoid(x)\n",
        "    \"\"\"\n",
        "    s = 1/(1+np.exp(-x))\n",
        "    return s\n",
        "\n",
        "def relu(x):\n",
        "    \"\"\"\n",
        "    Compute the relu of x\n",
        "\n",
        "    Arguments:\n",
        "    x -- A scalar or numpy array of any size.\n",
        "\n",
        "    Return:\n",
        "    s -- relu(x)\n",
        "    \"\"\"\n",
        "    s = np.maximum(0,x)\n",
        "    \n",
        "    return s\n",
        "\n",
        "def load_planar_dataset(seed):\n",
        "    \n",
        "    np.random.seed(seed)\n",
        "    \n",
        "    m = 400 # number of examples\n",
        "    N = int(m/2) # number of points per class\n",
        "    D = 2 # dimensionality\n",
        "    X = np.zeros((m,D)) # data matrix where each row is a single example\n",
        "    Y = np.zeros((m,1), dtype='uint8') # labels vector (0 for red, 1 for blue)\n",
        "    a = 4 # maximum ray of the flower\n",
        "\n",
        "    for j in range(2):\n",
        "        ix = range(N*j,N*(j+1))\n",
        "        t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta\n",
        "        r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius\n",
        "        X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]\n",
        "        Y[ix] = j\n",
        "        \n",
        "    X = X.T\n",
        "    Y = Y.T\n",
        "\n",
        "    return X, Y\n",
        "\n",
        "def initialize_parameters(layer_dims):\n",
        "    \"\"\"\n",
        "    Arguments:\n",
        "    layer_dims -- python array (list) containing the dimensions of each layer in our network\n",
        "    \n",
        "    Returns:\n",
        "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", ..., \"WL\", \"bL\":\n",
        "                    W1 -- weight matrix of shape (layer_dims[l], layer_dims[l-1])\n",
        "                    b1 -- bias vector of shape (layer_dims[l], 1)\n",
        "                    Wl -- weight matrix of shape (layer_dims[l-1], layer_dims[l])\n",
        "                    bl -- bias vector of shape (1, layer_dims[l])\n",
        "                    \n",
        "    Tips:\n",
        "    - For example: the layer_dims for the \"Planar Data classification model\" would have been [2,2,1]. \n",
        "    This means W1's shape was (2,2), b1 was (1,2), W2 was (2,1) and b2 was (1,1). Now you have to generalize it!\n",
        "    - In the for loop, use parameters['W' + str(l)] to access Wl, where l is the iterative integer.\n",
        "    \"\"\"\n",
        "    \n",
        "    np.random.seed(3)\n",
        "    parameters = {}\n",
        "    L = len(layer_dims) # number of layers in the network\n",
        "\n",
        "    for l in range(1, L):\n",
        "        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) / np.sqrt(layer_dims[l-1])\n",
        "        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))\n",
        "        \n",
        "        assert(parameters['W' + str(l)].shape == layer_dims[l], layer_dims[l-1])\n",
        "        assert(parameters['W' + str(l)].shape == layer_dims[l], 1)\n",
        "\n",
        "        \n",
        "    return parameters\n",
        "\n",
        "def forward_propagation(X, parameters):\n",
        "    \"\"\"\n",
        "    Implements the forward propagation (and computes the loss) presented in Figure 2.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- input dataset, of shape (input size, number of examples)\n",
        "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\":\n",
        "                    W1 -- weight matrix of shape ()\n",
        "                    b1 -- bias vector of shape ()\n",
        "                    W2 -- weight matrix of shape ()\n",
        "                    b2 -- bias vector of shape ()\n",
        "                    W3 -- weight matrix of shape ()\n",
        "                    b3 -- bias vector of shape ()\n",
        "    \n",
        "    Returns:\n",
        "    loss -- the loss function (vanilla logistic loss)\n",
        "    \"\"\"\n",
        "        \n",
        "    # retrieve parameters\n",
        "    W1 = parameters[\"W1\"]\n",
        "    b1 = parameters[\"b1\"]\n",
        "    W2 = parameters[\"W2\"]\n",
        "    b2 = parameters[\"b2\"]\n",
        "    W3 = parameters[\"W3\"]\n",
        "    b3 = parameters[\"b3\"]\n",
        "    \n",
        "    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID\n",
        "    Z1 = np.dot(W1, X) + b1\n",
        "    A1 = relu(Z1)\n",
        "    Z2 = np.dot(W2, A1) + b2\n",
        "    A2 = relu(Z2)\n",
        "    Z3 = np.dot(W3, A2) + b3\n",
        "    A3 = sigmoid(Z3)\n",
        "    \n",
        "    cache = (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3)\n",
        "    \n",
        "    return A3, cache\n",
        "\n",
        "def backward_propagation(X, Y, cache):\n",
        "    \"\"\"\n",
        "    Implement the backward propagation presented in figure 2.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- input dataset, of shape (input size, number of examples)\n",
        "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat)\n",
        "    cache -- cache output from forward_propagation()\n",
        "    \n",
        "    Returns:\n",
        "    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables\n",
        "    \"\"\"\n",
        "    m = X.shape[1]\n",
        "    (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache\n",
        "    \n",
        "    dZ3 = A3 - Y\n",
        "    dW3 = 1./m * np.dot(dZ3, A2.T)\n",
        "    db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)\n",
        "    \n",
        "    dA2 = np.dot(W3.T, dZ3)\n",
        "    dZ2 = np.multiply(dA2, np.int64(A2 > 0))\n",
        "    dW2 = 1./m * np.dot(dZ2, A1.T)\n",
        "    db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)\n",
        "    \n",
        "    dA1 = np.dot(W2.T, dZ2)\n",
        "    dZ1 = np.multiply(dA1, np.int64(A1 > 0))\n",
        "    dW1 = 1./m * np.dot(dZ1, X.T)\n",
        "    db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True)\n",
        "    \n",
        "    gradients = {\"dZ3\": dZ3, \"dW3\": dW3, \"db3\": db3,\n",
        "                 \"dA2\": dA2, \"dZ2\": dZ2, \"dW2\": dW2, \"db2\": db2,\n",
        "                 \"dA1\": dA1, \"dZ1\": dZ1, \"dW1\": dW1, \"db1\": db1}\n",
        "    \n",
        "    return gradients\n",
        "\n",
        "def update_parameters(parameters, grads, learning_rate):\n",
        "    \"\"\"\n",
        "    Update parameters using gradient descent\n",
        "    \n",
        "    Arguments:\n",
        "    parameters -- python dictionary containing your parameters:\n",
        "                    parameters['W' + str(i)] = Wi\n",
        "                    parameters['b' + str(i)] = bi\n",
        "    grads -- python dictionary containing your gradients for each parameters:\n",
        "                    grads['dW' + str(i)] = dWi\n",
        "                    grads['db' + str(i)] = dbi\n",
        "    learning_rate -- the learning rate, scalar.\n",
        "    \n",
        "    Returns:\n",
        "    parameters -- python dictionary containing your updated parameters \n",
        "    \"\"\"\n",
        "    \n",
        "    n = len(parameters) // 2 # number of layers in the neural networks\n",
        "\n",
        "    # Update rule for each parameter\n",
        "    for k in range(n):\n",
        "        parameters[\"W\" + str(k+1)] = parameters[\"W\" + str(k+1)] - learning_rate * grads[\"dW\" + str(k+1)]\n",
        "        parameters[\"b\" + str(k+1)] = parameters[\"b\" + str(k+1)] - learning_rate * grads[\"db\" + str(k+1)]\n",
        "        \n",
        "    return parameters\n",
        "\n",
        "def predict(X, y, parameters):\n",
        "    \"\"\"\n",
        "    This function is used to predict the results of a  n-layer neural network.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- data set of examples you would like to label\n",
        "    parameters -- parameters of the trained model\n",
        "    \n",
        "    Returns:\n",
        "    p -- predictions for the given dataset X\n",
        "    \"\"\"\n",
        "    \n",
        "    m = X.shape[1]\n",
        "    p = np.zeros((1,m), dtype = np.int32)\n",
        "    \n",
        "    # Forward propagation\n",
        "    a3, caches = forward_propagation(X, parameters)\n",
        "    \n",
        "    # convert probas to 0/1 predictions\n",
        "    for i in range(0, a3.shape[1]):\n",
        "        if a3[0,i] > 0.5:\n",
        "            p[0,i] = 1\n",
        "        else:\n",
        "            p[0,i] = 0\n",
        "\n",
        "    # print results\n",
        "\n",
        "    #print (\"predictions: \" + str(p[0,:]))\n",
        "    #print (\"true labels: \" + str(y[0,:]))\n",
        "    print(\"Accuracy: \"  + str(np.mean((p[0,:] == y[0,:]))))\n",
        "    \n",
        "    return p\n",
        "\n",
        "def compute_cost(a3, Y):\n",
        "    \"\"\"\n",
        "    Implement the cost function\n",
        "    \n",
        "    Arguments:\n",
        "    a3 -- post-activation, output of forward propagation\n",
        "    Y -- \"true\" labels vector, same shape as a3\n",
        "    \n",
        "    Returns:\n",
        "    cost - value of the cost function\n",
        "    \"\"\"\n",
        "    m = Y.shape[1]\n",
        "    \n",
        "    logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)\n",
        "    cost = 1./m * np.nansum(logprobs)\n",
        "    \n",
        "    return cost\n",
        "\n",
        "def load_dataset():\n",
        "    train_dataset = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n",
        "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
        "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
        "\n",
        "    test_dataset = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n",
        "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
        "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
        "\n",
        "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
        "    \n",
        "    train_set_y = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
        "    test_set_y = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
        "    \n",
        "    train_set_x_orig = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T\n",
        "    test_set_x_orig = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
        "    \n",
        "    train_set_x = train_set_x_orig/255\n",
        "    test_set_x = test_set_x_orig/255\n",
        "\n",
        "    return train_set_x, train_set_y, test_set_x, test_set_y, classes\n",
        "\n",
        "\n",
        "def predict_dec(parameters, X):\n",
        "    \"\"\"\n",
        "    Used for plotting decision boundary.\n",
        "    \n",
        "    Arguments:\n",
        "    parameters -- python dictionary containing your parameters \n",
        "    X -- input data of size (m, K)\n",
        "    \n",
        "    Returns\n",
        "    predictions -- vector of predictions of our model (red: 0 / blue: 1)\n",
        "    \"\"\"\n",
        "    \n",
        "    # Predict using forward propagation and a classification threshold of 0.5\n",
        "    a3, cache = forward_propagation(X, parameters)\n",
        "    predictions = (a3>0.5)\n",
        "    return predictions\n",
        "\n",
        "def load_planar_dataset(randomness, seed):\n",
        "    \n",
        "    np.random.seed(seed)\n",
        "    \n",
        "    m = 50\n",
        "    N = int(m/2) # number of points per class\n",
        "    D = 2 # dimensionality\n",
        "    X = np.zeros((m,D)) # data matrix where each row is a single example\n",
        "    Y = np.zeros((m,1), dtype='uint8') # labels vector (0 for red, 1 for blue)\n",
        "    a = 2 # maximum ray of the flower\n",
        "\n",
        "    for j in range(2):\n",
        "        \n",
        "        ix = range(N*j,N*(j+1))\n",
        "        if j == 0:\n",
        "            t = np.linspace(j, 4*3.1415*(j+1),N) #+ np.random.randn(N)*randomness # theta\n",
        "            r = 0.3*np.square(t) + np.random.randn(N)*randomness # radius\n",
        "        if j == 1:\n",
        "            t = np.linspace(j, 2*3.1415*(j+1),N) #+ np.random.randn(N)*randomness # theta\n",
        "            r = 0.2*np.square(t) + np.random.randn(N)*randomness # radius\n",
        "            \n",
        "        X[ix] = np.c_[r*np.cos(t), r*np.sin(t)]\n",
        "        Y[ix] = j\n",
        "        \n",
        "    X = X.T\n",
        "    Y = Y.T\n",
        "\n",
        "    return X, Y\n",
        "\n",
        "def plot_decision_boundary(model, X, y):\n",
        "    # Set min and max values and give it some padding\n",
        "    x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1\n",
        "    y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1\n",
        "    h = 0.01\n",
        "    # Generate a grid of points with distance h between them\n",
        "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n",
        "    # Predict the function value for the whole grid\n",
        "    Z = model(np.c_[xx.ravel(), yy.ravel()])\n",
        "    Z = Z.reshape(xx.shape)\n",
        "    # Plot the contour and training examples\n",
        "    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)\n",
        "    plt.ylabel('x2')\n",
        "    plt.xlabel('x1')\n",
        "    plt.scatter(X[0, :], X[1, :], c=y, cmap=plt.cm.Spectral)\n",
        "    plt.show()\n",
        "    \n",
        "def load_2D_dataset():\n",
        "    data = scipy.io.loadmat('/Datasets_Path/Football_Dataset_AI/data.mat')\n",
        "    train_X = data['X'].T\n",
        "    train_Y = data['y'].T\n",
        "    test_X = data['Xval'].T\n",
        "    test_Y = data['yval'].T\n",
        "    plt.scatter(train_X[0, :], train_X[1, :], c=train_Y, s=40, cmap=plt.cm.Spectral);\n",
        "    return train_X, train_Y, test_X, test_Y"
      ],
      "metadata": {
        "id": "cugLCXPhKUx3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_X, train_Y, test_X, test_Y = load_2D_dataset()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "o8depH8vLG-9",
        "outputId": "bf6f56b9-d032-48f1-e2be-65b77255b9ed"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(train_X.shape)\n",
        "print(train_Y.shape)\n",
        "print(test_X.shape)\n",
        "print(test_Y.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aP6_PvJyMXhB",
        "outputId": "c14d2fc8-fcc0-4fe9-e0e2-d7338c9aad46"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 211)\n",
            "(1, 211)\n",
            "(2, 200)\n",
            "(1, 200)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def model(X, Y, learning_rate = 0.3, num_iterations = 30000, print_cost = True, lambd = 0, keep_prob = 1):\n",
        "    \"\"\"\n",
        "    Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- input data, of shape (input size, number of examples)\n",
        "    Y -- true \"label\" vector (1 for blue dot / 0 for red dot), of shape (output size, number of examples)\n",
        "    learning_rate -- learning rate of the optimization\n",
        "    num_iterations -- number of iterations of the optimization loop\n",
        "    print_cost -- If True, print the cost every 10000 iterations\n",
        "    lambd -- regularization hyperparameter, scalar\n",
        "    keep_prob - probability of keeping a neuron active during drop-out, scalar.\n",
        "    \n",
        "    Returns:\n",
        "    parameters -- parameters learned by the model. They can then be used to predict.\n",
        "    \"\"\"\n",
        "        \n",
        "    grads = {}\n",
        "    costs = []                            # to keep track of the cost\n",
        "    m = X.shape[1]                        # number of examples\n",
        "    layers_dims = [X.shape[0], 20, 3, 1]\n",
        "    \n",
        "    # Initialize parameters dictionary.\n",
        "    parameters = initialize_parameters(layers_dims)\n",
        "\n",
        "    # Loop (gradient descent)\n",
        "\n",
        "    for i in range(0, num_iterations):\n",
        "\n",
        "        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.\n",
        "        if keep_prob == 1:\n",
        "            a3, cache = forward_propagation(X, parameters)\n",
        "        elif keep_prob < 1:\n",
        "            a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob)\n",
        "        \n",
        "        # Cost function\n",
        "        if lambd == 0:\n",
        "            cost = compute_cost(a3, Y)\n",
        "        else:\n",
        "            cost = compute_cost_with_regularization(a3, Y, parameters, lambd)\n",
        "            \n",
        "        # Backward propagation.\n",
        "        assert (lambd == 0 or keep_prob == 1)   # it is possible to use both L2 regularization and dropout, \n",
        "                                                # but this assignment will only explore one at a time\n",
        "        if lambd == 0 and keep_prob == 1:\n",
        "            grads = backward_propagation(X, Y, cache)\n",
        "        elif lambd != 0:\n",
        "            grads = backward_propagation_with_regularization(X, Y, cache, lambd)\n",
        "        elif keep_prob < 1:\n",
        "            grads = backward_propagation_with_dropout(X, Y, cache, keep_prob)\n",
        "        \n",
        "        # Update parameters.\n",
        "        parameters = update_parameters(parameters, grads, learning_rate)\n",
        "        \n",
        "        # Print the loss every 10000 iterations\n",
        "        if print_cost and i % 10000 == 0:\n",
        "            print(\"Cost after iteration {}: {}\".format(i, cost))\n",
        "        if print_cost and i % 1000 == 0:\n",
        "            costs.append(cost)\n",
        "    \n",
        "    # plot the cost\n",
        "    plt.plot(costs)\n",
        "    plt.ylabel('cost')\n",
        "    plt.xlabel('iterations (x1,000)')\n",
        "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
        "    plt.show()\n",
        "    \n",
        "    return parameters"
      ],
      "metadata": {
        "id": "YRmEAiXQMiU9"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parameters = model(train_X, train_Y)\n",
        "print (\"On the training set:\")\n",
        "predictions_train = predict(train_X, train_Y, parameters)\n",
        "print (\"On the test set:\")\n",
        "predictions_test = predict(test_X, test_Y, parameters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 417
        },
        "id": "dRn7RzSYRfU6",
        "outputId": "a9242ce5-984a-40c5-d08e-edb871ad6966"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost after iteration 0: 0.6557412523481002\n",
            "Cost after iteration 10000: 0.1632998752572417\n",
            "Cost after iteration 20000: 0.13851642423284755\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "On the training set:\n",
            "Accuracy: 0.9478672985781991\n",
            "On the test set:\n",
            "Accuracy: 0.915\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.title(\"Model without regularization\")\n",
        "axes = plt.gca()\n",
        "axes.set_xlim([-0.75,0.40])\n",
        "axes.set_ylim([-0.75,0.65])\n",
        "plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "DvdNAJO5RhB7",
        "outputId": "0b221334-d124-448f-c954-67d8d43c2bb1"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# reshape the output for generating the confusion matrix\n",
        "predicted = predictions_test.reshape(200)\n",
        "actual = test_Y.reshape(200)\n",
        "\n",
        "#confusion matrix\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import matplotlib.pyplot as plt\n",
        "cm = tf.math.confusion_matrix(labels=actual,predictions=predicted)\n",
        "import seaborn as sn\n",
        "plt.figure(figsize = (10,7))\n",
        "print(\"Confusion Matrix\")\n",
        "sn.heatmap(cm, annot=True, fmt='d')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Truth')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 477
        },
        "id": "4mlHSIG4Rphi",
        "outputId": "c92de9d1-db0f-4f6f-a34c-a2ca2de73fe4"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Confusion Matrix\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(69.0, 0.5, 'Truth')"
            ]
          },
          "metadata": {},
          "execution_count": 17
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: compute_cost_with_regularization\n",
        "\n",
        "def compute_cost_with_regularization(A3, Y, parameters, lambd):\n",
        "    \"\"\"\n",
        "    Implement the cost function with L2 regularization. See formula (2) above.\n",
        "    \n",
        "    Arguments:\n",
        "    A3 -- post-activation, output of forward propagation, of shape (output size, number of examples)\n",
        "    Y -- \"true\" labels vector, of shape (output size, number of examples)\n",
        "    parameters -- python dictionary containing parameters of the model\n",
        "    \n",
        "    Returns:\n",
        "    cost - value of the regularized loss function (formula (2))\n",
        "    \"\"\"\n",
        "    m = Y.shape[1]\n",
        "    W1 = parameters[\"W1\"]\n",
        "    W2 = parameters[\"W2\"]\n",
        "    W3 = parameters[\"W3\"]\n",
        "    \n",
        "    cross_entropy_cost = compute_cost(A3, Y) # This gives you the cross-entropy part of the cost\n",
        "    \n",
        "    #(≈ 1 lines of code)\n",
        "    # L2_regularization_cost = \n",
        "    # YOUR CODE STARTS HERE\n",
        "    L2_regularization_cost = lambd/(2*m)*(np.sum(np.square(W1))+np.sum(np.square(W2))+np.sum(np.square(W3)))\n",
        "    \n",
        "    # YOUR CODE ENDS HERE\n",
        "    \n",
        "    cost = cross_entropy_cost + L2_regularization_cost\n",
        "    \n",
        "    return cost"
      ],
      "metadata": {
        "id": "CemoMR6PRZA0"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: backward_propagation_with_regularization\n",
        "\n",
        "def backward_propagation_with_regularization(X, Y, cache, lambd):\n",
        "    \"\"\"\n",
        "    Implements the backward propagation of our baseline model to which we added an L2 regularization.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- input dataset, of shape (input size, number of examples)\n",
        "    Y -- \"true\" labels vector, of shape (output size, number of examples)\n",
        "    cache -- cache output from forward_propagation()\n",
        "    lambd -- regularization hyperparameter, scalar\n",
        "    \n",
        "    Returns:\n",
        "    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables\n",
        "    \"\"\"\n",
        "    \n",
        "    m = X.shape[1]\n",
        "    (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache\n",
        "    \n",
        "    dZ3 = A3 - Y\n",
        "    #(≈ 1 lines of code)\n",
        "    # dW3 = 1./m * np.dot(dZ3, A2.T) + None\n",
        "    # YOUR CODE STARTS HERE\n",
        "    dW3 = 1./m * np.dot(dZ3, A2.T) + (lambd/m)*W3\n",
        "    \n",
        "    # YOUR CODE ENDS HERE\n",
        "    db3 = 1. / m * np.sum(dZ3, axis=1, keepdims=True)\n",
        "    \n",
        "    dA2 = np.dot(W3.T, dZ3)\n",
        "    dZ2 = np.multiply(dA2, np.int64(A2 > 0))\n",
        "    #(≈ 1 lines of code)\n",
        "    # dW2 = 1./m * np.dot(dZ2, A1.T) + None\n",
        "    # YOUR CODE STARTS HERE\n",
        "    dW2 = 1./m * np.dot(dZ2, A1.T) + (lambd/m)*W2\n",
        "    \n",
        "    # YOUR CODE ENDS HERE\n",
        "    db2 = 1. / m * np.sum(dZ2, axis=1, keepdims=True)\n",
        "    \n",
        "    dA1 = np.dot(W2.T, dZ2)\n",
        "    dZ1 = np.multiply(dA1, np.int64(A1 > 0))\n",
        "    #(≈ 1 lines of code)\n",
        "    # dW1 = 1./m * np.dot(dZ1, X.T) + None\n",
        "    # YOUR CODE STARTS HERE\n",
        "    dW1 = 1./m * np.dot(dZ1, X.T) + (lambd/m)*W1\n",
        "    \n",
        "    # YOUR CODE ENDS HERE\n",
        "    db1 = 1. / m * np.sum(dZ1, axis=1, keepdims=True)\n",
        "    \n",
        "    gradients = {\"dZ3\": dZ3, \"dW3\": dW3, \"db3\": db3,\"dA2\": dA2,\n",
        "                 \"dZ2\": dZ2, \"dW2\": dW2, \"db2\": db2, \"dA1\": dA1, \n",
        "                 \"dZ1\": dZ1, \"dW1\": dW1, \"db1\": db1}\n",
        "    \n",
        "    return gradients"
      ],
      "metadata": {
        "id": "CzrQ_lxGSi05"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parameters = model(train_X, train_Y, lambd = 0.7)\n",
        "print (\"On the train set:\")\n",
        "predictions_train = predict(train_X, train_Y, parameters)\n",
        "print (\"On the test set:\")\n",
        "predictions_test = predict(test_X, test_Y, parameters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 417
        },
        "id": "HNkbhsRuSy8v",
        "outputId": "f62f656d-79c1-477c-b115-bb9f1bf48a62"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost after iteration 0: 0.6974484493131264\n",
            "Cost after iteration 10000: 0.2684918873282239\n",
            "Cost after iteration 20000: 0.2680916337127301\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "On the train set:\n",
            "Accuracy: 0.9383886255924171\n",
            "On the test set:\n",
            "Accuracy: 0.93\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.title(\"Model with L2-regularization\")\n",
        "axes = plt.gca()\n",
        "axes.set_xlim([-0.75,0.40])\n",
        "axes.set_ylim([-0.75,0.65])\n",
        "plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "f4jCZIy7S1O_",
        "outputId": "98c91e50-2c84-4a8b-9321-01aa66b6d28d"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# reshape the output for generating the confusion matrix\n",
        "predicted = predictions_test.reshape(200)\n",
        "actual = test_Y.reshape(200)\n",
        "\n",
        "#confusion matrix\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import matplotlib.pyplot as plt\n",
        "cm = tf.math.confusion_matrix(labels=actual,predictions=predicted)\n",
        "import seaborn as sn\n",
        "plt.figure(figsize = (10,7))\n",
        "print(\"Confusion Matrix\")\n",
        "sn.heatmap(cm, annot=True, fmt='d')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Truth')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 477
        },
        "id": "qt_iT2IpXBAn",
        "outputId": "80368825-2e31-49aa-f026-74e159bae2f3"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Confusion Matrix\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(69.0, 0.5, 'Truth')"
            ]
          },
          "metadata": {},
          "execution_count": 22
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: forward_propagation_with_dropout\n",
        "\n",
        "def forward_propagation_with_dropout(X, parameters, keep_prob = 0.5):\n",
        "    \"\"\"\n",
        "    Implements the forward propagation: LINEAR -> RELU + DROPOUT -> LINEAR -> RELU + DROPOUT -> LINEAR -> SIGMOID.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- input dataset, of shape (2, number of examples)\n",
        "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\":\n",
        "                    W1 -- weight matrix of shape (20, 2)\n",
        "                    b1 -- bias vector of shape (20, 1)\n",
        "                    W2 -- weight matrix of shape (3, 20)\n",
        "                    b2 -- bias vector of shape (3, 1)\n",
        "                    W3 -- weight matrix of shape (1, 3)\n",
        "                    b3 -- bias vector of shape (1, 1)\n",
        "    keep_prob - probability of keeping a neuron active during drop-out, scalar\n",
        "    \n",
        "    Returns:\n",
        "    A3 -- last activation value, output of the forward propagation, of shape (1,1)\n",
        "    cache -- tuple, information stored for computing the backward propagation\n",
        "    \"\"\"\n",
        "    \n",
        "    np.random.seed(1)\n",
        "    \n",
        "    # retrieve parameters\n",
        "    W1 = parameters[\"W1\"]\n",
        "    b1 = parameters[\"b1\"]\n",
        "    W2 = parameters[\"W2\"]\n",
        "    b2 = parameters[\"b2\"]\n",
        "    W3 = parameters[\"W3\"]\n",
        "    b3 = parameters[\"b3\"]\n",
        "    \n",
        "    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID\n",
        "    Z1 = np.dot(W1, X) + b1\n",
        "    A1 = relu(Z1)\n",
        "    #(≈ 4 lines of code)         # Steps 1-4 below correspond to the Steps 1-4 described above. \n",
        "    # D1 =                                           # Step 1: initialize matrix D1 = np.random.rand(..., ...)\n",
        "    # D1 =                                           # Step 2: convert entries of D1 to 0 or 1 (using keep_prob as the threshold)\n",
        "    # A1 =                                           # Step 3: shut down some neurons of A1\n",
        "    # A1 =                                           # Step 4: scale the value of neurons that haven't been shut down\n",
        "    # YOUR CODE STARTS HERE\n",
        "    D1 = np.random.rand(A1.shape[0],A1.shape[1])\n",
        "    D1 = (D1 < keep_prob).astype(int)\n",
        "    A1 = A1*D1\n",
        "    A1 =  A1/keep_prob\n",
        "    # YOUR CODE ENDS HERE\n",
        "    Z2 = np.dot(W2, A1) + b2\n",
        "    A2 = relu(Z2)\n",
        "    #(≈ 4 lines of code)\n",
        "    # D2 =                                           # Step 1: initialize matrix D2 = np.random.rand(..., ...)\n",
        "    # D2 =                                           # Step 2: convert entries of D2 to 0 or 1 (using keep_prob as the threshold)\n",
        "    # A2 =                                           # Step 3: shut down some neurons of A2\n",
        "    # A2 =                                           # Step 4: scale the value of neurons that haven't been shut down\n",
        "    # YOUR CODE STARTS HERE\n",
        "    D2 = np.random.rand(A2.shape[0],A2.shape[1])\n",
        "    D2 = (D2 < keep_prob).astype(int)\n",
        "    A2 = A2*D2\n",
        "    A2 =  A2/keep_prob\n",
        "    \n",
        "    # YOUR CODE ENDS HERE\n",
        "    Z3 = np.dot(W3, A2) + b3\n",
        "    A3 = sigmoid(Z3)\n",
        "    \n",
        "    cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3)\n",
        "    \n",
        "    return A3, cache"
      ],
      "metadata": {
        "id": "zhBwEEO8RbSr"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: backward_propagation_with_dropout\n",
        "\n",
        "def backward_propagation_with_dropout(X, Y, cache, keep_prob):\n",
        "    \"\"\"\n",
        "    Implements the backward propagation of our baseline model to which we added dropout.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- input dataset, of shape (2, number of examples)\n",
        "    Y -- \"true\" labels vector, of shape (output size, number of examples)\n",
        "    cache -- cache output from forward_propagation_with_dropout()\n",
        "    keep_prob - probability of keeping a neuron active during drop-out, scalar\n",
        "    \n",
        "    Returns:\n",
        "    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables\n",
        "    \"\"\"\n",
        "    \n",
        "    m = X.shape[1]\n",
        "    (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) = cache\n",
        "    \n",
        "    dZ3 = A3 - Y\n",
        "    dW3 = 1./m * np.dot(dZ3, A2.T)\n",
        "    db3 = 1./m * np.sum(dZ3, axis=1, keepdims=True)\n",
        "    dA2 = np.dot(W3.T, dZ3)\n",
        "    #(≈ 2 lines of code)\n",
        "    # dA2 =                # Step 1: Apply mask D2 to shut down the same neurons as during the forward propagation\n",
        "    # dA2 =                # Step 2: Scale the value of neurons that haven't been shut down\n",
        "    # YOUR CODE STARTS HERE\n",
        "    dA2 = dA2*D2\n",
        "    dA2 = dA2/keep_prob\n",
        "    # YOUR CODE ENDS HERE\n",
        "    dZ2 = np.multiply(dA2, np.int64(A2 > 0))\n",
        "    dW2 = 1./m * np.dot(dZ2, A1.T)\n",
        "    db2 = 1./m * np.sum(dZ2, axis=1, keepdims=True)\n",
        "    \n",
        "    dA1 = np.dot(W2.T, dZ2)\n",
        "    #(≈ 2 lines of code)\n",
        "    # dA1 =                # Step 1: Apply mask D1 to shut down the same neurons as during the forward propagation\n",
        "    # dA1 =                # Step 2: Scale the value of neurons that haven't been shut down\n",
        "    # YOUR CODE STARTS HERE\n",
        "    dA1 = dA1*D1\n",
        "    dA1 = dA1/keep_prob\n",
        "    # YOUR CODE ENDS HERE\n",
        "    dZ1 = np.multiply(dA1, np.int64(A1 > 0))\n",
        "    dW1 = 1./m * np.dot(dZ1, X.T)\n",
        "    db1 = 1./m * np.sum(dZ1, axis=1, keepdims=True)\n",
        "    \n",
        "    gradients = {\"dZ3\": dZ3, \"dW3\": dW3, \"db3\": db3,\"dA2\": dA2,\n",
        "                 \"dZ2\": dZ2, \"dW2\": dW2, \"db2\": db2, \"dA1\": dA1, \n",
        "                 \"dZ1\": dZ1, \"dW1\": dW1, \"db1\": db1}\n",
        "    \n",
        "    return gradients"
      ],
      "metadata": {
        "id": "zkxpclUaV0qo"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parameters = model(train_X, train_Y, keep_prob = 0.86, learning_rate = 0.3)\n",
        "print (\"On the train set:\")\n",
        "predictions_train = predict(train_X, train_Y, parameters)\n",
        "print (\"On the test set:\")\n",
        "predictions_test = predict(test_X, test_Y, parameters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        },
        "id": "Un-T1BniV5oS",
        "outputId": "7a27f4f7-d92e-4c29-d567-d7f56566ab4b"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost after iteration 0: 0.6543912405149825\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-14-9dda814968f2>:228: RuntimeWarning: divide by zero encountered in log\n",
            "  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)\n",
            "<ipython-input-14-9dda814968f2>:228: RuntimeWarning: invalid value encountered in multiply\n",
            "  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost after iteration 10000: 0.0610169865749056\n",
            "Cost after iteration 20000: 0.060582435798513114\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "On the train set:\n",
            "Accuracy: 0.9289099526066351\n",
            "On the test set:\n",
            "Accuracy: 0.95\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.title(\"Model with dropout\")\n",
        "axes = plt.gca()\n",
        "axes.set_xlim([-0.75,0.40])\n",
        "axes.set_ylim([-0.75,0.65])\n",
        "plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "1OdBVNObV69Q",
        "outputId": "859cbfe0-9dea-47cb-c1cb-0bc687d194b4"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# reshape the output for generating the confusion matrix\n",
        "predicted = predictions_test.reshape(200)\n",
        "actual = test_Y.reshape(200)\n",
        "\n",
        "#confusion matrix\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import matplotlib.pyplot as plt\n",
        "cm = tf.math.confusion_matrix(labels=actual,predictions=predicted)\n",
        "import seaborn as sn\n",
        "plt.figure(figsize = (10,7))\n",
        "print(\"Confusion Matrix\")\n",
        "sn.heatmap(cm, annot=True, fmt='d')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Truth')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 477
        },
        "id": "wfdZGLubXXna",
        "outputId": "e4289977-580d-4c91-b260-8fa2b3d47ae1"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Confusion Matrix\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(69.0, 0.5, 'Truth')"
            ]
          },
          "metadata": {},
          "execution_count": 27
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}