C1_W4_Deep_Neural_Network_Application.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "OFSUcGXJwVB_"
      },
      "outputs": [],
      "source": [
        "#import necessary packages\n",
        "import time\n",
        "import numpy as np\n",
        "import h5py\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy\n",
        "from PIL import Image\n",
        "from scipy import ndimage\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "fS8A80tnw0kz"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: initialize_parameters\n",
        "def initialize_parameters(n_x, n_h, n_y):\n",
        "    \"\"\"\n",
        "    Argument:\n",
        "    n_x -- size of the input layer\n",
        "    n_h -- size of the hidden layer\n",
        "    n_y -- size of the output layer\n",
        "    \n",
        "    Returns:\n",
        "    parameters -- python dictionary containing your parameters:\n",
        "                    W1 -- weight matrix of shape (n_h, n_x)\n",
        "                    b1 -- bias vector of shape (n_h, 1)\n",
        "                    W2 -- weight matrix of shape (n_y, n_h)\n",
        "                    b2 -- bias vector of shape (n_y, 1)\n",
        "    \"\"\"\n",
        "    np.random.seed(1)\n",
        "    \n",
        "    W1 = np.random.randn(n_h, n_x)*0.01\n",
        "    b1 = np.zeros((n_h, 1))\n",
        "    W2 = np.random.randn(n_y, n_h)*0.01\n",
        "    b2 = np.zeros((n_y, 1))\n",
        "    \n",
        "    assert(W1.shape == (n_h, n_x))\n",
        "    assert(b1.shape == (n_h, 1))\n",
        "    assert(W2.shape == (n_y, n_h))\n",
        "    assert(b2.shape == (n_y, 1))\n",
        "    \n",
        "    parameters = {\"W1\": W1,\n",
        "                  \"b1\": b1,\n",
        "                  \"W2\": W2,\n",
        "                  \"b2\": b2}\n",
        "    \n",
        "    return parameters     "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "Q1JjM_nVw2_i"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: initialize_parameters_deep\n",
        "def initialize_parameters_deep(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",
        "                    Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])\n",
        "                    bl -- bias vector of shape (layer_dims[l], 1)\n",
        "    \"\"\"\n",
        "    \n",
        "    np.random.seed(1)\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]) #*0.01\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['b' + str(l)].shape == (layer_dims[l], 1))\n",
        "\n",
        "        \n",
        "    return parameters "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "iGhmpZ9sw4_a"
      },
      "outputs": [],
      "source": [
        "#sigmoid function\n",
        "def sigmoid(Z):\n",
        "    A = 1/(1+np.exp(-Z))\n",
        "    cache = Z\n",
        "    return A, cache"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "a0J55r8Mw6my"
      },
      "outputs": [],
      "source": [
        "#relu function\n",
        "def relu(Z):\n",
        "    A = np.maximum(0,Z)\n",
        "    assert(A.shape == Z.shape)\n",
        "    cache = Z \n",
        "    return A, cache"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "UlNr17Haw73i"
      },
      "outputs": [],
      "source": [
        "# sigmoid_backward\n",
        "def sigmoid_backward(dA, cache):\n",
        "    Z = cache\n",
        "    s = 1/(1+np.exp(-Z))\n",
        "    dZ = dA * s * (1-s)\n",
        "    assert (dZ.shape == Z.shape) \n",
        "    return dZ"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "VCgkl31Nw9A8"
      },
      "outputs": [],
      "source": [
        "# relu_backward\n",
        "def relu_backward(dA, cache):\n",
        "    Z = cache\n",
        "    dZ = np.array(dA, copy=True) # just converting dz to a correct object.\n",
        "    # When z <= 0, you should set dz to 0 as well. \n",
        "    dZ[Z <= 0] = 0\n",
        "    assert (dZ.shape == Z.shape)\n",
        "    return dZ"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "XewtHTsOw-Qg"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: linear_forward\n",
        "def linear_forward(A, W, b):\n",
        "    \"\"\"\n",
        "    Implement the linear part of a layer's forward propagation.\n",
        "\n",
        "    Arguments:\n",
        "    A -- activations from previous layer (or input data): (size of previous layer, number of examples)\n",
        "    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)\n",
        "    b -- bias vector, numpy array of shape (size of the current layer, 1)\n",
        "\n",
        "    Returns:\n",
        "    Z -- the input of the activation function, also called pre-activation parameter \n",
        "    cache -- a python dictionary containing \"A\", \"W\" and \"b\" ; stored for computing the backward pass efficiently\n",
        "    \"\"\"\n",
        "    \n",
        "    Z = W.dot(A) + b\n",
        "    \n",
        "    assert(Z.shape == (W.shape[0], A.shape[1]))\n",
        "    cache = (A, W, b)\n",
        "    \n",
        "    return Z, cache"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "6xBHWoJ7w_W_"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: linear_activation_forward\n",
        "def linear_activation_forward(A_prev, W, b, activation):\n",
        "    \"\"\"\n",
        "    Implement the forward propagation for the LINEAR->ACTIVATION layer\n",
        "\n",
        "    Arguments:\n",
        "    A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples)\n",
        "    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)\n",
        "    b -- bias vector, numpy array of shape (size of the current layer, 1)\n",
        "    activation -- the activation to be used in this layer, stored as a text string: \"sigmoid\" or \"relu\"\n",
        "\n",
        "    Returns:\n",
        "    A -- the output of the activation function, also called the post-activation value \n",
        "    cache -- a python dictionary containing \"linear_cache\" and \"activation_cache\";\n",
        "             stored for computing the backward pass efficiently\n",
        "    \"\"\"\n",
        "    \n",
        "    if activation == \"sigmoid\":\n",
        "        # Inputs: \"A_prev, W, b\". Outputs: \"A, activation_cache\".\n",
        "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
        "        A, activation_cache = sigmoid(Z)\n",
        "    \n",
        "    elif activation == \"relu\":\n",
        "        # Inputs: \"A_prev, W, b\". Outputs: \"A, activation_cache\".\n",
        "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
        "        A, activation_cache = relu(Z)\n",
        "    \n",
        "    assert (A.shape == (W.shape[0], A_prev.shape[1]))\n",
        "    cache = (linear_cache, activation_cache)\n",
        "\n",
        "    return A, cache  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "pcC6S46IxAwA"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: L_model_forward\n",
        "def L_model_forward(X, parameters):\n",
        "    \"\"\"\n",
        "    Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation\n",
        "    \n",
        "    Arguments:\n",
        "    X -- data, numpy array of shape (input size, number of examples)\n",
        "    parameters -- output of initialize_parameters_deep()\n",
        "    \n",
        "    Returns:\n",
        "    AL -- activation value from the output (last) layer\n",
        "    caches -- list of caches containing:\n",
        "                every cache of linear_activation_forward() (there are L of them, indexed from 0 to L-1)\n",
        "    \"\"\"\n",
        "\n",
        "    caches = []\n",
        "    A = X\n",
        "    L = len(parameters) // 2                  # number of layers in the neural network\n",
        "    \n",
        "    # Implement [LINEAR -> RELU]*(L-1). Add \"cache\" to the \"caches\" list.\n",
        "    # The for loop starts at 1 because layer 0 is the input\n",
        "    for l in range(1, L):\n",
        "        A_prev = A \n",
        "        #(≈ 2 lines of code)\n",
        "        # A, cache = ...\n",
        "        # caches ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        A, cache =  linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], \"relu\")\n",
        "        caches.append(cache) \n",
        "        # YOUR CODE ENDS HERE\n",
        "    \n",
        "    # Implement LINEAR -> SIGMOID. Add \"cache\" to the \"caches\" list.\n",
        "    #(≈ 2 lines of code)\n",
        "    # AL, cache = ...\n",
        "    # caches ...\n",
        "    # YOUR CODE STARTS HERE\n",
        "    AL, cache =  linear_activation_forward(A, parameters['W'+str(L)], parameters['b'+str(L)], \"sigmoid\")\n",
        "    caches.append(cache) \n",
        "    assert(AL.shape == (1,X.shape[1]))    \n",
        "    return AL, caches\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "r5wGDAOdxCRf"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: compute_cost\n",
        "def compute_cost(AL, Y):\n",
        "    \"\"\"\n",
        "    Implement the cost function defined by equation (7).\n",
        "\n",
        "    Arguments:\n",
        "    AL -- probability vector corresponding to your label predictions, shape (1, number of examples)\n",
        "    Y -- true \"label\" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples)\n",
        "\n",
        "    Returns:\n",
        "    cost -- cross-entropy cost\n",
        "    \"\"\"\n",
        "    \n",
        "    m = Y.shape[1]\n",
        "\n",
        "    # Compute loss from aL and y.\n",
        "    cost = (1./m) * (-np.dot(Y,np.log(AL).T) - np.dot(1-Y, np.log(1-AL).T))\n",
        "    \n",
        "    cost = np.squeeze(cost)      # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n",
        "    assert(cost.shape == ())\n",
        "    \n",
        "    return cost"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "wL62M8LUxDfw"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: linear_backward\n",
        "def linear_backward(dZ, cache):\n",
        "    \"\"\"\n",
        "    Implement the linear portion of backward propagation for a single layer (layer l)\n",
        "\n",
        "    Arguments:\n",
        "    dZ -- Gradient of the cost with respect to the linear output (of current layer l)\n",
        "    cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer\n",
        "\n",
        "    Returns:\n",
        "    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev\n",
        "    dW -- Gradient of the cost with respect to W (current layer l), same shape as W\n",
        "    db -- Gradient of the cost with respect to b (current layer l), same shape as b\n",
        "    \"\"\"\n",
        "    A_prev, W, b = cache\n",
        "    m = A_prev.shape[1]\n",
        "\n",
        "    dW = 1./m * np.dot(dZ,A_prev.T)\n",
        "    db = 1./m * np.sum(dZ)\n",
        "    dA_prev = np.dot(W.T,dZ)\n",
        "    \n",
        "    assert (dA_prev.shape == A_prev.shape)\n",
        "    assert (dW.shape == W.shape)\n",
        "    assert (isinstance(db, float))\n",
        "    \n",
        "    return dA_prev, dW, db"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "0kMmOmzbxE5I"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: linear_activation_backward\n",
        "def linear_activation_backward(dA, cache, activation):\n",
        "    \"\"\"\n",
        "    Implement the backward propagation for the LINEAR->ACTIVATION layer.\n",
        "    \n",
        "    Arguments:\n",
        "    dA -- post-activation gradient for current layer l \n",
        "    cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently\n",
        "    activation -- the activation to be used in this layer, stored as a text string: \"sigmoid\" or \"relu\"\n",
        "    \n",
        "    Returns:\n",
        "    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev\n",
        "    dW -- Gradient of the cost with respect to W (current layer l), same shape as W\n",
        "    db -- Gradient of the cost with respect to b (current layer l), same shape as b\n",
        "    \"\"\"\n",
        "    linear_cache, activation_cache = cache\n",
        "    \n",
        "    if activation == \"relu\":\n",
        "        dZ = relu_backward(dA, activation_cache)\n",
        "        dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
        "        \n",
        "    elif activation == \"sigmoid\":\n",
        "        dZ = sigmoid_backward(dA, activation_cache)\n",
        "        dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
        "    \n",
        "    return dA_prev, dW, db "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "Xx4ekKFWxGDn"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: L_model_backward\n",
        "\n",
        "def L_model_backward(AL, Y, caches):\n",
        "    \"\"\"\n",
        "    Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group\n",
        "    \n",
        "    Arguments:\n",
        "    AL -- probability vector, output of the forward propagation (L_model_forward())\n",
        "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat)\n",
        "    caches -- list of caches containing:\n",
        "                every cache of linear_activation_forward() with \"relu\" (there are (L-1) or them, indexes from 0 to L-2)\n",
        "                the cache of linear_activation_forward() with \"sigmoid\" (there is one, index L-1)\n",
        "    \n",
        "    Returns:\n",
        "    grads -- A dictionary with the gradients\n",
        "             grads[\"dA\" + str(l)] = ... \n",
        "             grads[\"dW\" + str(l)] = ...\n",
        "             grads[\"db\" + str(l)] = ... \n",
        "    \"\"\"\n",
        "    grads = {}\n",
        "    L = len(caches) # the number of layers\n",
        "    m = AL.shape[1]\n",
        "    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\n",
        "    \n",
        "    # Initializing the backpropagation\n",
        "    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\n",
        "    \n",
        "    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: \"AL, Y, caches\". Outputs: \"grads[\"dAL\"], grads[\"dWL\"], grads[\"dbL\"]\n",
        "    current_cache = caches[L-1]\n",
        "    grads[\"dA\" + str(L)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_activation_backward(dAL, current_cache, activation = \"sigmoid\")\n",
        "    \n",
        "    for l in reversed(range(L-1)):\n",
        "        # lth layer: (RELU -> LINEAR) gradients.\n",
        "        current_cache = caches[l]\n",
        "        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads[\"dA\" + str(l + 2)], current_cache, activation = \"relu\")\n",
        "        grads[\"dA\" + str(l + 1)] = dA_prev_temp\n",
        "        grads[\"dW\" + str(l + 1)] = dW_temp\n",
        "        grads[\"db\" + str(l + 1)] = db_temp\n",
        "\n",
        "    return grads"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "3inw8RvfxHLA"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: update_parameters\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",
        "    grads -- python dictionary containing your gradients, output of L_model_backward\n",
        "    \n",
        "    Returns:\n",
        "    parameters -- python dictionary containing your updated parameters \n",
        "                  parameters[\"W\" + str(l)] = ... \n",
        "                  parameters[\"b\" + str(l)] = ...\n",
        "    \"\"\"\n",
        "    \n",
        "    L = len(parameters) // 2 # number of layers in the neural network\n",
        "\n",
        "    # Update rule for each parameter. Use a for loop.\n",
        "    for l in range(L):\n",
        "        parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)] - learning_rate * grads[\"dW\" + str(l+1)]\n",
        "        parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)] - learning_rate * grads[\"db\" + str(l+1)]\n",
        "        \n",
        "    return parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "nlFgi58rxPLV"
      },
      "outputs": [],
      "source": [
        "# load_datasets\n",
        "def load_dataset():\n",
        "    train_dataset = h5py.File('Training_Datasets/catvnoncat/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('Testing_Datasets/catvnoncat/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_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
        "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
        "    print(\"DataSet Loading Complete.\")\n",
        "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JCGWjyYHxcQa",
        "outputId": "3ad2fed8-ef2d-4b19-e295-2593eee178ec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "DataSet Loading Complete.\n"
          ]
        }
      ],
      "source": [
        "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "mD3wW9ZDx1pq",
        "outputId": "a576482b-9037-47c1-f122-0098f94649e6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "y = 0. It's a non-cat picture.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Example of a picture\n",
        "index = 8\n",
        "plt.imshow(train_set_x_orig[index])\n",
        "print (\"y = \" + str(train_set_y[0,index]) + \". It's a \" + classes[train_set_y[0,index]].decode(\"utf-8\") +  \" picture.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B1j7qex_yHvj",
        "outputId": "f9580fff-7c84-40ed-e96a-27108e4c87a6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_set_x's shape: (12288, 209)\n",
            "test_set_x's shape: (12288, 50)\n"
          ]
        }
      ],
      "source": [
        "# Reshape the training and test examples\n",
        "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
        "test_set_x_flatten =  test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T\n",
        "\n",
        "# Standardize data to have feature values between 0 and 1.\n",
        "train_set_x = train_set_x_flatten / 255.\n",
        "test_set_x = test_set_x_flatten / 255.\n",
        "\n",
        "print (\"train_set_x's shape: \" + str(train_set_x.shape))\n",
        "print (\"test_set_x's shape: \" + str(test_set_x.shape))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "OX_Gv2GSymgx"
      },
      "outputs": [],
      "source": [
        "### CONSTANTS DEFINING THE MODEL ####\n",
        "n_x = 12288     # num_px * num_px * 3\n",
        "n_h = 7\n",
        "n_y = 1\n",
        "layers_dims = (n_x, n_h, n_y)\n",
        "learning_rate = 0.0075"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "yiwS22-ZzAAq"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: two_layer_model\n",
        "\n",
        "def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
        "    \"\"\"\n",
        "    Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.\n",
        "    \n",
        "    Arguments:\n",
        "    X -- input data, of shape (n_x, number of examples)\n",
        "    Y -- true \"label\" vector (containing 1 if cat, 0 if non-cat), of shape (1, number of examples)\n",
        "    layers_dims -- dimensions of the layers (n_x, n_h, n_y)\n",
        "    num_iterations -- number of iterations of the optimization loop\n",
        "    learning_rate -- learning rate of the gradient descent update rule\n",
        "    print_cost -- If set to True, this will print the cost every 100 iterations \n",
        "    \n",
        "    Returns:\n",
        "    parameters -- a dictionary containing W1, W2, b1, and b2\n",
        "    \"\"\"\n",
        "    \n",
        "    np.random.seed(1)\n",
        "    grads = {}\n",
        "    costs = []                              # to keep track of the cost\n",
        "    m = X.shape[1]                           # number of examples\n",
        "    (n_x, n_h, n_y) = layers_dims\n",
        "    \n",
        "    # Initialize parameters dictionary, by calling one of the functions you'd previously implemented\n",
        "    #(≈ 1 line of code)\n",
        "    # parameters = ...\n",
        "    # YOUR CODE STARTS HERE\n",
        "    parameters = initialize_parameters(n_x, n_h, n_y)\n",
        "    # YOUR CODE ENDS HERE\n",
        "    \n",
        "    # Get W1, b1, W2 and b2 from the dictionary parameters.\n",
        "    W1 = parameters[\"W1\"]\n",
        "    b1 = parameters[\"b1\"]\n",
        "    W2 = parameters[\"W2\"]\n",
        "    b2 = parameters[\"b2\"]\n",
        "    \n",
        "    # Loop (gradient descent)\n",
        "\n",
        "    for i in range(0, num_iterations):\n",
        "\n",
        "        # Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: \"X, W1, b1, W2, b2\". Output: \"A1, cache1, A2, cache2\".\n",
        "        #(≈ 2 lines of code)\n",
        "        # A1, cache1 = ...\n",
        "        # A2, cache2 = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        A1, cache1 = linear_activation_forward(X, W1, b1, activation=\"relu\")\n",
        "        A2, cache2 = linear_activation_forward(A1, W2, b2, activation=\"sigmoid\")\n",
        "        # YOUR CODE ENDS HERE\n",
        "        \n",
        "        # Compute cost\n",
        "        #(≈ 1 line of code)\n",
        "        # cost = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        cost = compute_cost(A2,Y)\n",
        "        # YOUR CODE ENDS HERE\n",
        "        \n",
        "        # Initializing backward propagation\n",
        "        dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))\n",
        "        \n",
        "        # Backward propagation. Inputs: \"dA2, cache2, cache1\". Outputs: \"dA1, dW2, db2; also dA0 (not used), dW1, db1\".\n",
        "        #(≈ 2 lines of code)\n",
        "        # dA1, dW2, db2 = ...\n",
        "        # dA0, dW1, db1 = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        dA1, dW2, db2 = linear_activation_backward(dA2, cache2, activation=\"sigmoid\")\n",
        "        dA0, dW1, db1 = linear_activation_backward(dA1, cache1, activation=\"relu\")\n",
        "        # YOUR CODE ENDS HERE\n",
        "        \n",
        "        # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2\n",
        "        grads['dW1'] = dW1\n",
        "        grads['db1'] = db1\n",
        "        grads['dW2'] = dW2\n",
        "        grads['db2'] = db2\n",
        "        \n",
        "        # Update parameters.\n",
        "        #(approx. 1 line of code)\n",
        "        # parameters = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        parameters = update_parameters(parameters, grads, learning_rate)\n",
        "        # YOUR CODE ENDS HERE\n",
        "\n",
        "        # Retrieve W1, b1, W2, b2 from parameters\n",
        "        W1 = parameters[\"W1\"]\n",
        "        b1 = parameters[\"b1\"]\n",
        "        W2 = parameters[\"W2\"]\n",
        "        b2 = parameters[\"b2\"]\n",
        "        \n",
        "        # Print the cost every 100 iterations\n",
        "        if print_cost and i % 100 == 0 or i == num_iterations - 1:\n",
        "            print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n",
        "        if i % 100 == 0 or i == num_iterations:\n",
        "            costs.append(cost)\n",
        "\n",
        "    return parameters, costs\n",
        "\n",
        "def plot_costs(costs, learning_rate=0.0075):\n",
        "    plt.plot(np.squeeze(costs))\n",
        "    plt.ylabel('cost')\n",
        "    plt.xlabel('iterations (per hundreds)')\n",
        "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 746
        },
        "id": "k3dBc-kQzG2S",
        "outputId": "35b29a66-2205-405f-8fd4-93d245c6beea"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost after iteration 0: 0.693049735659989\n",
            "Cost after iteration 100: 0.6464283150388815\n",
            "Cost after iteration 200: 0.632508625794858\n",
            "Cost after iteration 300: 0.6014932097069347\n",
            "Cost after iteration 400: 0.5601652326734954\n",
            "Cost after iteration 500: 0.5157934975899228\n",
            "Cost after iteration 600: 0.47590238832247345\n",
            "Cost after iteration 700: 0.4385864099711226\n",
            "Cost after iteration 800: 0.39100728875669444\n",
            "Cost after iteration 900: 0.3584220494573507\n",
            "Cost after iteration 1000: 0.34299735904004836\n",
            "Cost after iteration 1100: 0.31019042350954656\n",
            "Cost after iteration 1200: 0.2739661328726089\n",
            "Cost after iteration 1300: 0.2370347086950204\n",
            "Cost after iteration 1400: 0.18734248651597407\n",
            "Cost after iteration 1500: 0.16864009816415468\n",
            "Cost after iteration 1600: 0.14197411005689567\n",
            "Cost after iteration 1700: 0.11292363594102983\n",
            "Cost after iteration 1800: 0.09758444844752398\n",
            "Cost after iteration 1900: 0.08554699338649559\n",
            "Cost after iteration 2000: 0.07593496617351729\n",
            "Cost after iteration 2100: 0.06794136245969246\n",
            "Cost after iteration 2200: 0.060857593382313814\n",
            "Cost after iteration 2300: 0.05488773565315855\n",
            "Cost after iteration 2400: 0.04950829635846383\n",
            "Cost after iteration 2499: 0.045292420058210645\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "parameters, costs = two_layer_model(train_set_x, train_set_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)\n",
        "plot_costs(costs, learning_rate)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "zyYyMz7y5bV5"
      },
      "outputs": [],
      "source": [
        "def predict(X, y, parameters, train_or_test):\n",
        "    \"\"\"\n",
        "    This function is used to predict the results of a  L-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",
        "    n = len(parameters) // 2 # number of layers in the neural network\n",
        "    p = np.zeros((1,m))\n",
        "    \n",
        "    # Forward propagation\n",
        "    feature, caches = L_model_forward(X, parameters)\n",
        "\n",
        "    \n",
        "    # convert probas to 0/1 predictions\n",
        "    for i in range(0, feature.shape[1]):\n",
        "        if feature[0,i] > 0.5:\n",
        "            p[0,i] = 1\n",
        "        else:\n",
        "            p[0,i] = 0\n",
        "    \n",
        "    #print results\n",
        "    #print (\"predictions: \" + str(p))\n",
        "    #print (\"true labels: \" + str(y))\n",
        "    if train_or_test==\"train\":\n",
        "      print(\"Training Accuracy: \"  + str(np.sum((p == y)/m)))\n",
        "    if train_or_test==\"test\":\n",
        "      print(\"Testing Accuracy: \"  + str(np.sum((p == y)/m)))     \n",
        "    return p"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "TocqizTl3o0R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5240091e-e510-4138-ca00-ed92f446d277"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: 0.9999999999999998\n",
            "Testing Accuracy: 0.72\n"
          ]
        }
      ],
      "source": [
        "predictions_train = predict(train_set_x, train_set_y, parameters,train_or_test=\"train\")\n",
        "predictions_test = predict(test_set_x, test_set_y, parameters,train_or_test=\"test\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "### CONSTANTS ###\n",
        "layers_dims = [12288, 20, 7, 5, 1] #  4-layer model\n",
        "learning_rate = 0.01"
      ],
      "metadata": {
        "id": "-gciuklEWxfe"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: L_layer_model\n",
        "\n",
        "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
        "\n",
        "    np.random.seed(1)\n",
        "    costs = []                         # keep track of cost\n",
        "    \n",
        "    # Parameters initialization.\n",
        "    #(≈ 1 line of code)\n",
        "    # parameters = ...\n",
        "    # YOUR CODE STARTS HERE\n",
        "    parameters = initialize_parameters_deep(layers_dims)\n",
        "    # YOUR CODE ENDS HERE\n",
        "    \n",
        "    # Loop (gradient descent)\n",
        "    for i in range(0, num_iterations):\n",
        "\n",
        "        # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.\n",
        "        #(≈ 1 line of code)\n",
        "        # AL, caches = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        AL, caches = L_model_forward(X, parameters)\n",
        "        # YOUR CODE ENDS HERE\n",
        "        \n",
        "        # Compute cost.\n",
        "        #(≈ 1 line of code)\n",
        "        # cost = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        cost = compute_cost(AL, Y)\n",
        "        # YOUR CODE ENDS HERE\n",
        "    \n",
        "        # Backward propagation.\n",
        "        #(≈ 1 line of code)\n",
        "        # grads = ...    \n",
        "        # YOUR CODE STARTS HERE\n",
        "        grads = L_model_backward(AL, Y, caches)\n",
        "        # YOUR CODE ENDS HERE\n",
        " \n",
        "        # Update parameters.\n",
        "        #(≈ 1 line of code)\n",
        "        # parameters = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "        parameters = update_parameters(parameters, grads, learning_rate)\n",
        "        \n",
        "        # YOUR CODE ENDS HERE\n",
        "                \n",
        "        # Print the cost every 100 iterations\n",
        "        if print_cost and i % 100 == 0 or i == num_iterations - 1:\n",
        "            print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n",
        "        if i % 100 == 0 or i == num_iterations:\n",
        "            costs.append(cost)\n",
        "    \n",
        "    return parameters, costs\n",
        "def plot_costs(costs, learning_rate=0.0075):\n",
        "    plt.plot(np.squeeze(costs))\n",
        "    plt.ylabel('cost')\n",
        "    plt.xlabel('iterations (per hundreds)')\n",
        "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
        "    plt.show()    "
      ],
      "metadata": {
        "id": "ANCm_9sQW0HV"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parameters, costs = L_layer_model(train_set_x, train_set_y, layers_dims, num_iterations = 2500, print_cost = True)\n",
        "plot_costs(costs, learning_rate)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 746
        },
        "id": "_4rp8U3RW6eF",
        "outputId": "c0fc9a7b-091f-4ff6-f0d4-03e6cc57bd99"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost after iteration 0: 0.7717493284237686\n",
            "Cost after iteration 100: 0.6733497445150208\n",
            "Cost after iteration 200: 0.6482474434189346\n",
            "Cost after iteration 300: 0.6203838286619946\n",
            "Cost after iteration 400: 0.5684005832232022\n",
            "Cost after iteration 500: 0.5207539233884928\n",
            "Cost after iteration 600: 0.46920283449786865\n",
            "Cost after iteration 700: 0.48726346207145943\n",
            "Cost after iteration 800: 0.35843638746138656\n",
            "Cost after iteration 900: 0.3476412649527719\n",
            "Cost after iteration 1000: 0.29195450833485825\n",
            "Cost after iteration 1100: 0.2732233721467601\n",
            "Cost after iteration 1200: 0.229250446670083\n",
            "Cost after iteration 1300: 0.19666712417436594\n",
            "Cost after iteration 1400: 0.17658497226677403\n",
            "Cost after iteration 1500: 0.15772717776012246\n",
            "Cost after iteration 1600: 0.1427416869443923\n",
            "Cost after iteration 1700: 0.13901490818978188\n",
            "Cost after iteration 1800: 0.12386257988583614\n",
            "Cost after iteration 1900: 0.1115142786610861\n",
            "Cost after iteration 2000: 0.10595322235177426\n",
            "Cost after iteration 2100: 0.0981985777460593\n",
            "Cost after iteration 2200: 0.09421316656586305\n",
            "Cost after iteration 2300: 0.08716125336992755\n",
            "Cost after iteration 2400: 0.08207705462719336\n",
            "Cost after iteration 2499: 0.0782256007322427\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "predictions_train = predict(train_set_x, train_set_y, parameters,train_or_test=\"train\")\n",
        "predictions_test = predict(test_set_x, test_set_y, parameters,train_or_test=\"test\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g3YYC-1tXaI8",
        "outputId": "8c31b395-5c73-47b9-a5fb-d0c2904d3db5"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: 0.9999999999999998\n",
            "Testing Accuracy: 0.8400000000000001\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "predicted = (predictions_test).reshape(50)\n",
        "actual = test_set_y.reshape(50)"
      ],
      "metadata": {
        "id": "iEC2hio3jZT0"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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",
        "sn.heatmap(cm, annot=True, fmt='d')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Truth')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 463
        },
        "id": "9QfiMswLjbo_",
        "outputId": "235fb3b3-bbaf-440d-c4ba-4aa792d4a395"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(69.0, 0.5, 'Truth')"
            ]
          },
          "metadata": {},
          "execution_count": 30
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1m3TGMatBvxPtbsT1-H5UC7clrr9hMpHS",
      "authorship_tag": "ABX9TyPvCP7SC82vQZM9KOcCcKYU"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}