C1_W4_Building_your_Deep_Neural_Network_Step_by_Step.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMFfjkbAw2pFn+H/XoPxgbb"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "2lqUtIYND6tE"
      },
      "outputs": [],
      "source": [
        "#import necessary packages\n",
        "import numpy as np\n",
        "import h5py\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: initialize_parameters\n",
        "def initialize_parameters(nx, nh, ny):\n",
        "  W1 = np.random.randn(nh,nx)*0.01\n",
        "  b1 = np.zeros((nh,1))\n",
        "  W2 = np.random.randn(ny,nh)*0.01\n",
        "  b2 = np.zeros((ny,1))\n",
        "  parameters = {\n",
        "        \"W1\":W1,\n",
        "        \"b1\":b1,\n",
        "        \"W2\":W2,\n",
        "        \"b2\":b2}\n",
        "  return parameters      "
      ],
      "metadata": {
        "id": "eyd6ir_kEdIG"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parameters = initialize_parameters(3, 2, 1)\n",
        "print(\"W1 = \" + str(parameters[\"W1\"]))\n",
        "print(\"b1 = \" + str(parameters[\"b1\"]))\n",
        "print(\"W2 = \" + str(parameters[\"W2\"]))\n",
        "print(\"b2 = \" + str(parameters[\"b2\"]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JQcgsrhiGStX",
        "outputId": "f6c3e659-0a3a-447f-ab55-f525718d54ef"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "W1 = [[-2.64530812e-03 -1.37971215e-02 -1.36692358e-02]\n",
            " [-3.95741404e-05  2.42648713e-03  8.91458019e-03]]\n",
            "b1 = [[0.]\n",
            " [0.]]\n",
            "W2 = [[0.0099746  0.00589904]]\n",
            "b2 = [[0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: initialize_parameters_deep\n",
        "def initialize_parameters_deep(layer_dims):\n",
        "  np.random.seed(3)\n",
        "  parameters = {}\n",
        "  L = len(layer_dims)\n",
        "  for l in range(1, L):\n",
        "    parameters[\"W\" + str(l)] = np.random.randn(layer_dims[l], 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",
        "  return parameters  "
      ],
      "metadata": {
        "id": "CzPSXZtkG1EP"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "parameters = initialize_parameters_deep([5,4,3])\n",
        "print(\"W1 = \" + str(parameters[\"W1\"]))\n",
        "print(\"b1 = \" + str(parameters[\"b1\"]))\n",
        "print(\"W2 = \" + str(parameters[\"W2\"]))\n",
        "print(\"b2 = \" + str(parameters[\"b2\"]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "20MQ7LsUF65d",
        "outputId": "6cfecb31-8ffe-4ba2-8186-bfd59409ffcf"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "W1 = [[ 0.01788628  0.0043651   0.00096497 -0.01863493 -0.00277388]\n",
            " [-0.00354759 -0.00082741 -0.00627001 -0.00043818 -0.00477218]\n",
            " [-0.01313865  0.00884622  0.00881318  0.01709573  0.00050034]\n",
            " [-0.00404677 -0.0054536  -0.01546477  0.00982367 -0.01101068]]\n",
            "b1 = [[0.]\n",
            " [0.]\n",
            " [0.]\n",
            " [0.]]\n",
            "W2 = [[-0.01185047 -0.0020565   0.01486148  0.00236716]\n",
            " [-0.01023785 -0.00712993  0.00625245 -0.00160513]\n",
            " [-0.00768836 -0.00230031  0.00745056  0.01976111]]\n",
            "b2 = [[0.]\n",
            " [0.]\n",
            " [0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#sigmoid function\n",
        "def sigmoid(Z):\n",
        "    A = 1/(1+np.exp(-Z))\n",
        "    cache = Z\n",
        "    return A, cache"
      ],
      "metadata": {
        "id": "N3HYrWgGKqZM"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "hcmIe7nLmH42"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "G6TcS43AQMFm"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "A0atyuKzQJvc"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: linear_forward\n",
        "def linear_forward(A,W,b):\n",
        "  Z = (np.dot(W,A)+b)\n",
        "  cache = (A,W,b)\n",
        "  return Z,cache"
      ],
      "metadata": {
        "id": "BK49sDSJo2rr"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: linear_activation_forward\n",
        "def linear_activation_forward(A_prev, W, b, activation):\n",
        "  if activation==\"sigmoid\":\n",
        "    Z, linear_cache = linear_forward(A_prev,W,b)\n",
        "    A, activation_cache = sigmoid(Z)\n",
        "  elif activation==\"relu\":\n",
        "    Z, linear_cache = linear_forward(A_prev,W,b)\n",
        "    A, activation_cache = relu(Z) \n",
        "  cache=(linear_cache,activation_cache)\n",
        "  return A,cache  "
      ],
      "metadata": {
        "id": "KB_nAXj8J9oc"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: L_model_forward\n",
        "def L_model_forward(X, parameters):\n",
        "  caches = []\n",
        "  A = X\n",
        "  L = len(parameters) // 2 \n",
        "  for l in range(1,L):\n",
        "    A_prev = A\n",
        "    A, cache = linear_activation_forward(A_prev,parameters['W' + str(l)], parameters['b' + str(l)], \"relu\")\n",
        "    caches.append(cache) \n",
        "  AL, cache = linear_activation_forward(A,parameters['W' + str(l)], parameters['b' + str(l)], \"sigmoid\")\n",
        "  caches.append(cache) \n",
        "  return AL, caches\n"
      ],
      "metadata": {
        "id": "ujXQsUexLDr8"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: compute_cost\n",
        "def compute_cost(AL, Y):\n",
        "  m = Y.shape[1]\n",
        "  cost = (-1/m)* (np.dot(Y,np.log(AL).T) +  np.dot((1-Y),np.log(1-AL).T))\n",
        "  cost = np.squeeze(cost)\n",
        "  return cost"
      ],
      "metadata": {
        "id": "0qelEygDMuIM"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: linear_backward\n",
        "def linear_backward(dZ, cache):\n",
        "  A_prev, W, b = cache\n",
        "  m = A_prev.shape[1]\n",
        "  dW = (1/m)*np.dot(dZ,A_prev.T) \n",
        "  db = (1/m)*np.sum(dZ,axis=1,keepdims=True)\n",
        "  dA_prev = np.dot(W.T,dZ)\n",
        "  return dA_prev, dW, db"
      ],
      "metadata": {
        "id": "E2eLWB6FNi-U"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: linear_activation_backward\n",
        "def linear_activation_backward(dA, cache, activation):\n",
        "  linear_cache, activation_cache = cache\n",
        "  if activation == \"relu\":\n",
        "    #(≈ 2 lines of code)\n",
        "    # dZ =  ...\n",
        "    # dA_prev, dW, db =  ...\n",
        "    # YOUR CODE STARTS HERE\n",
        "    dZ = relu_backward(dA, activation_cache)\n",
        "    dA_prev, dW, db =  linear_backward(dZ,linear_cache)\n",
        "    # YOUR CODE ENDS HERE\n",
        "        \n",
        "  elif activation == \"sigmoid\":\n",
        "    #(≈ 2 lines of code)\n",
        "    # dZ =  ...\n",
        "    # dA_prev, dW, db =  ...\n",
        "    # YOUR CODE STARTS HERE\n",
        "    dZ = sigmoid_backward(dA, activation_cache)\n",
        "    dA_prev, dW, db = linear_backward(dZ,linear_cache)\n",
        "  return dA_prev, dW, db  "
      ],
      "metadata": {
        "id": "4DiMV_LTP2so"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: L_model_backward\n",
        "def L_model_backward(AL, Y, caches):\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",
        "  dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\n",
        "  current_cache = caches[L-1]\n",
        "  dA_prev_temp, dW_temp, db_temp = linear_activation_backward(dAL, current_cache, \"sigmoid\")\n",
        "  grads[\"dA\" + str(L-1)]=dA_prev_temp\n",
        "  grads[\"dW\" + str(L)]=dW_temp\n",
        "  grads[\"db\" + str(L)] =db_temp\n",
        "  # Loop from l=L-2 to l=0\n",
        "  for l in reversed(range(L-1)):\n",
        "        # lth layer: (RELU -> LINEAR) gradients.\n",
        "        # Inputs: \"grads[\"dA\" + str(l + 1)], current_cache\". Outputs: \"grads[\"dA\" + str(l)] , grads[\"dW\" + str(l + 1)] , grads[\"db\" + str(l + 1)] \n",
        "        #(approx. 5 lines)\n",
        "        # current_cache = ...\n",
        "        # dA_prev_temp, dW_temp, db_temp = ...\n",
        "        # grads[\"dA\" + str(l)] = ...\n",
        "        # grads[\"dW\" + str(l + 1)] = ...\n",
        "        # grads[\"db\" + str(l + 1)] = ...\n",
        "        # YOUR CODE STARTS HERE\n",
        "    current_cache = caches[l]\n",
        "    dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads[\"dA\" + str(l + 1)], current_cache, activation = \"relu\")\n",
        "    grads[\"dA\" + str(l)] =dA_prev_temp\n",
        "    grads[\"dW\" + str(l + 1)] =dW_temp\n",
        "    grads[\"db\" + str(l + 1)] =db_temp\n",
        "    # YOUR CODE ENDS HERE\n",
        "  return grads  \n",
        "  "
      ],
      "metadata": {
        "id": "8SSOyce6S-Yk"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRADED FUNCTION: update_parameters\n",
        "def update_parameters(params, grads, learning_rate):\n",
        "    \"\"\"\n",
        "    Update parameters using gradient descent\n",
        "    \n",
        "    Arguments:\n",
        "    params -- 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",
        "    parameters = params.copy()\n",
        "    L = len(parameters) // 2 # number of layers in the neural network\n",
        "\n",
        "    # Update rule for each parameter. Use a for loop.\n",
        "    #(≈ 2 lines of code)\n",
        "    for l in range(L):\n",
        "        # parameters[\"W\" + str(l+1)] = ...\n",
        "        # parameters[\"b\" + str(l+1)] = ...\n",
        "        # YOUR CODE STARTS HERE \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",
        "        # YOUR CODE ENDS HERE\n",
        "    return parameters"
      ],
      "metadata": {
        "id": "kHu8ekQAV2YN"
      },
      "execution_count": 24,
      "outputs": []
    }
  ]
}