From 00ce02a032c85a4adce4bd4d9b3fc01b988348d9 Mon Sep 17 00:00:00 2001
From: Pegah-Ardehkhani <89220787+Pegah-Ardehkhani@users.noreply.github.com>
Date: Wed, 29 Jun 2022 11:31:53 +0430
Subject: [PATCH] Add files via upload
---
...ing Deep Neural Network From Scratch.ipynb | 1607 +++++++++++++++++
1 file changed, 1607 insertions(+)
create mode 100644 Building Deep Neural Network From Scratch.ipynb
diff --git a/Building Deep Neural Network From Scratch.ipynb b/Building Deep Neural Network From Scratch.ipynb
new file mode 100644
index 0000000..53f8760
--- /dev/null
+++ b/Building Deep Neural Network From Scratch.ipynb
@@ -0,0 +1,1607 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
\n",
+ "\n",
+ "
\n",
+ "Building Deep Neural Network From Scratch
\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MFK8bZ4Zy4zk"
+ },
+ "source": [
+ "**Notation**:\n",
+ "- Superscript $[l]$ denotes a quantity associated with the $l^{th}$ layer. \n",
+ " - Example: $a^{[L]}$ is the $L^{th}$ layer activation. $W^{[L]}$ and $b^{[L]}$ are the $L^{th}$ layer parameters.\n",
+ "- Superscript $(i)$ denotes a quantity associated with the $i^{th}$ example. \n",
+ " - Example: $x^{(i)}$ is the $i^{th}$ training example.\n",
+ "- Lowerscript $i$ denotes the $i^{th}$ entry of a vector.\n",
+ " - Example: $a^{[l]}_i$ denotes the $i^{th}$ entry of the $l^{th}$ layer's activations).\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "id": "GFpKYwFhyhHN"
+ },
+ "outputs": [],
+ "source": [
+ "#Import libraries\n",
+ "import numpy as np\n",
+ "import h5py\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "np.random.seed(1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "l6dqdk3m1lf0"
+ },
+ "source": [
+ "**Outline:**\n",
+ "\n",
+ "- Initialize the parameters for a two-layer network and for an $L$-layer neural network\n",
+ "- Implement the forward propagation module (shown in purple in the figure below)\n",
+ " - Complete the LINEAR part of a layer's forward propagation step (resulting in $Z^{[l]}$).\n",
+ " - The ACTIVATION function is provided for you (relu/sigmoid)\n",
+ " - Combine the previous two steps into a new [LINEAR->ACTIVATION] forward function.\n",
+ " - Stack the [LINEAR->RELU] forward function L-1 time (for layers 1 through L-1) and add a [LINEAR->SIGMOID] at the end (for the final layer $L$). This gives you a new L_model_forward function.\n",
+ "- Compute the loss\n",
+ "- Implement the backward propagation module (denoted in red in the figure below)\n",
+ " - Complete the LINEAR part of a layer's backward propagation step\n",
+ " - The gradient of the ACTIVATE function is provided for you(relu_backward/sigmoid_backward) \n",
+ " - Combine the previous two steps into a new [LINEAR->ACTIVATION] backward function\n",
+ " - Stack [LINEAR->RELU] backward L-1 times and add [LINEAR->SIGMOID] backward in a new L_model_backward function\n",
+ "- Finally, update the parameters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SJKHVve61t23"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ba6L4aMi2OP1"
+ },
+ "source": [
+ "**Initialization:**\n",
+ "\n",
+ "We will write two helper functions to initialize the parameters for your model. The first function will be used to initialize parameters for a two layer model. The second one generalizes this initialization process to $L$ layers.\n",
+ "\n",
+ "- The model's structure is: *LINEAR -> RELU -> LINEAR -> SIGMOID*. \n",
+ "- We will use random initialization for the weight matrices\n",
+ "- We will use zero initialization for the biases"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "id": "NMRNbfopzQS7"
+ },
+ "outputs": [],
+ "source": [
+ "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, 'b1': b1, 'W2': W2, 'b2': b2}\n",
+ " \n",
+ " return parameters "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "n6wTp7Ui3gLb"
+ },
+ "source": [
+ "L-layer Neural Network:\n",
+ "\n",
+ "The initialization for a deeper L-layer neural network is more complicated because there are many more weight matrices and bias vectors. When completing the `initialize_parameters_deep` function, we should make sure that our dimensions match between each layer. Recall that $n^{[l]}$ is the number of units in layer $l$. For example, if the size of your input $X$ is $(12288, 209)$ (with $m=209$ examples) then:\n",
+ "\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
Shape of W
\n",
+ "
Shape of b
\n",
+ "
Activation
\n",
+ "
Shape of Activation
\n",
+ "
\n",
+ "
\n",
+ "
Layer 1
\n",
+ "
$(n^{[1]},12288)$
\n",
+ "
$(n^{[1]},1)$
\n",
+ "
$Z^{[1]} = W^{[1]} X + b^{[1]} $
\n",
+ "
$(n^{[1]},209)$
\n",
+ "
\n",
+ "
\n",
+ "
Layer 2
\n",
+ "
$(n^{[2]}, n^{[1]})$
\n",
+ "
$(n^{[2]},1)$
\n",
+ "
$Z^{[2]} = W^{[2]} A^{[1]} + b^{[2]}$
\n",
+ "
$(n^{[2]}, 209)$
\n",
+ "
\n",
+ "
\n",
+ "
$\\vdots$
\n",
+ "
$\\vdots$
\n",
+ "
$\\vdots$
\n",
+ "
$\\vdots$
\n",
+ "
$\\vdots$
\n",
+ "
\n",
+ "
\n",
+ "
Layer L-1
\n",
+ "
$(n^{[L-1]}, n^{[L-2]})$
\n",
+ "
$(n^{[L-1]}, 1)$
\n",
+ "
$Z^{[L-1]} = W^{[L-1]} A^{[L-2]} + b^{[L-1]}$
\n",
+ "
$(n^{[L-1]}, 209)$
\n",
+ "
\n",
+ "
\n",
+ "
Layer L
\n",
+ "
$(n^{[L]}, n^{[L-1]})$
\n",
+ "
$(n^{[L]}, 1)$
\n",
+ "
$Z^{[L]} = W^{[L]} A^{[L-1]} + b^{[L]}$
\n",
+ "
$(n^{[L]}, 209)$
\n",
+ "
\n",
+ "
\n",
+ "\n",
+ "Remember that when you compute $W X + b$ in python, it carries out broadcasting. For example, if: \n",
+ "\n",
+ "$$ W = \\begin{bmatrix}\n",
+ " w_{00} & w_{01} & w_{02} \\\\\n",
+ " w_{10} & w_{11} & w_{12} \\\\\n",
+ " w_{20} & w_{21} & w_{22} \n",
+ "\\end{bmatrix}\\;\\;\\; X = \\begin{bmatrix}\n",
+ " x_{00} & x_{01} & x_{02} \\\\\n",
+ " x_{10} & x_{11} & x_{12} \\\\\n",
+ " x_{20} & x_{21} & x_{22} \n",
+ "\\end{bmatrix} \\;\\;\\; b =\\begin{bmatrix}\n",
+ " b_0 \\\\\n",
+ " b_1 \\\\\n",
+ " b_2\n",
+ "\\end{bmatrix}\\tag{2}$$\n",
+ "\n",
+ "Then $WX + b$ will be:\n",
+ "\n",
+ "$$ WX + b = \\begin{bmatrix}\n",
+ " (w_{00}x_{00} + w_{01}x_{10} + w_{02}x_{20}) + b_0 & (w_{00}x_{01} + w_{01}x_{11} + w_{02}x_{21}) + b_0 & \\cdots \\\\\n",
+ " (w_{10}x_{00} + w_{11}x_{10} + w_{12}x_{20}) + b_1 & (w_{10}x_{01} + w_{11}x_{11} + w_{12}x_{21}) + b_1 & \\cdots \\\\\n",
+ " (w_{20}x_{00} + w_{21}x_{10} + w_{22}x_{20}) + b_2 & (w_{20}x_{01} + w_{21}x_{11} + w_{22}x_{21}) + b_2 & \\cdots\n",
+ "\\end{bmatrix}\\tag{3} $$\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "id": "SPiTQfHR3M4L"
+ },
+ "outputs": [],
+ "source": [
+ "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",
+ " np.random.seed(1)\n",
+ " parameters = {}\n",
+ " #Number of layers in the network\n",
+ " L = len(layer_dims)\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",
+ " return parameters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KG7B9fX_4wqB"
+ },
+ "source": [
+ "**Forward Propagation:**\n",
+ "\n",
+ "Now that we have initialized our parameters, we can do the forward propagation module. We will start by implementing some basic functions that we can use again later when implementing the model. Now, we'll complete three functions in this order:\n",
+ "\n",
+ "- LINEAR\n",
+ "- LINEAR -> ACTIVATION where ACTIVATION will be either ReLU or Sigmoid. \n",
+ "- [LINEAR -> RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID (whole model)\n",
+ "\n",
+ "The linear forward module (vectorized over all the examples) computes the following equations:\n",
+ "\n",
+ "$$Z^{[l]} = W^{[l]}A^{[l-1]} +b^{[l]}\\tag{4}$$\n",
+ "\n",
+ "where $A^{[0]} = X$. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "id": "9eegkVll4t_0"
+ },
+ "outputs": [],
+ "source": [
+ "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 tuple containing \"A\", \"W\" and \"b\" ; stored for computing the backward pass efficiently\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": "markdown",
+ "metadata": {
+ "id": "PlLAs_Nc5tTr"
+ },
+ "source": [
+ "**Linear Activation Forward:**\n",
+ "\n",
+ "In this project, we will use two activation functions:\n",
+ "\n",
+ "- **Sigmoid**: $\\sigma(Z) = \\sigma(W A + b) = \\frac{1}{ 1 + e^{-(W A + b)}}$. You've been provided with the `sigmoid` function which returns **two** items: the activation value \"`a`\" and a \"`cache`\" that contains \"`Z`\" (it's what we will feed in to the corresponding backward function). To use it you could just call: \n",
+ "``` python\n",
+ "A, activation_cache = sigmoid(Z)\n",
+ "```\n",
+ "\n",
+ "- **ReLU**: The mathematical formula for ReLu is $A = RELU(Z) = max(0, Z)$. You've been provided with the `relu` function. This function returns **two** items: the activation value \"`A`\" and a \"`cache`\" that contains \"`Z`\" (it's what you'll feed in to the corresponding backward function). To use it you could just call:\n",
+ "``` python\n",
+ "A, activation_cache = relu(Z)\n",
+ "```\n",
+ "\n",
+ "For added convenience, we're going to group two functions (Linear and Activation) into one function (LINEAR->ACTIVATION). Hence, we'll implement a function that does the LINEAR forward step, followed by an ACTIVATION forward step.\n",
+ "\n",
+ "We will implement the forward propagation of the *LINEAR->ACTIVATION* layer. Mathematical relation is: $A^{[l]} = g(Z^{[l]}) = g(W^{[l]}A^{[l-1]} +b^{[l]})$ where the activation \"g\" can be sigmoid() or relu(). Use `linear_forward()` and the correct activation function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "id": "g131xJVa66j5"
+ },
+ "outputs": [],
+ "source": [
+ "def sigmoid(Z):\n",
+ " \"\"\"\n",
+ " Implements the sigmoid activation in numpy\n",
+ " \n",
+ " Arguments:\n",
+ " Z -- numpy array of any shape\n",
+ " \n",
+ " Returns:\n",
+ " A -- output of sigmoid(z), same shape as Z\n",
+ " cache -- returns Z as well, useful during backpropagation\n",
+ " \"\"\"\n",
+ " A = 1/(1+np.exp(-Z))\n",
+ " cache = Z\n",
+ " \n",
+ " return A, cache"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "id": "YROzjeZc6_MR"
+ },
+ "outputs": [],
+ "source": [
+ "def relu(Z):\n",
+ " \"\"\"\n",
+ " Implement the RELU function.\n",
+ "\n",
+ " Arguments:\n",
+ " Z -- Output of the linear layer, of any shape\n",
+ "\n",
+ " Returns:\n",
+ " A -- Post-activation parameter, of the same shape as Z\n",
+ " cache -- a python dictionary containing \"A\" ; stored for computing the backward pass efficiently\n",
+ " \"\"\" \n",
+ " A = np.maximum(0,Z)\n",
+ " \n",
+ " assert(A.shape == Z.shape)\n",
+ " \n",
+ " cache = Z \n",
+ " return A, cache"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "id": "LN5tpQMF5nA1"
+ },
+ "outputs": [],
+ "source": [
+ "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 tuple containing \"linear_cache\" and \"activation_cache\";\n",
+ " stored for computing the backward pass efficiently\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": "markdown",
+ "metadata": {
+ "id": "QueKHkgH7oWs"
+ },
+ "source": [
+ "**L-Layer Model:**\n",
+ "\n",
+ "For even *more* convenience when implementing the $L$-layer Neural Net, we will need a function that replicates the previous one (`linear_activation_forward` with RELU) $L-1$ times, then follows that with one `linear_activation_forward` with SIGMOID. In the code below, the variable `AL` will denote $A^{[L]} = \\sigma(Z^{[L]}) = \\sigma(W^{[L]} A^{[L-1]} + b^{[L]})$. (This is sometimes also called `Yhat`, i.e., this is $\\hat{Y}$.) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xQjvWAVa8N0c"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "id": "p4osaE_l7fUr"
+ },
+ "outputs": [],
+ "source": [
+ "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",
+ " 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",
+ " 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)], activation = 'relu')\n",
+ " caches.append(cache)\n",
+ " \n",
+ " #Implement LINEAR -> SIGMOID. Add \"cache\" to the \"caches\" list.\n",
+ " AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], activation = 'sigmoid')\n",
+ " caches.append(cache)\n",
+ " \n",
+ " assert(AL.shape == (1,X.shape[1]))\n",
+ " \n",
+ " return AL, caches"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "C2kZnIyN9FPZ"
+ },
+ "source": [
+ "**Compute Cost:**\n",
+ "\n",
+ "Compute the cross-entropy cost $J$, using the following formula: $$-\\frac{1}{m} \\sum\\limits_{i = 1}^{m} (y^{(i)}\\log\\left(a^{[L] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[L](i)}\\right))Â \\tag{7}$$\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "id": "RAwpyQEu8_aG"
+ },
+ "outputs": [],
+ "source": [
+ "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",
+ " 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",
+ " #To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n",
+ " cost = np.squeeze(cost) \n",
+ " assert(cost.shape == ())\n",
+ " \n",
+ " return cost"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uvOOzYLO9mLP"
+ },
+ "source": [
+ "**Backward Propagation:**\n",
+ "\n",
+ "Just as we did for the forward propagation, we'll implement helper functions for backpropagation. Backpropagation is used to calculate the gradient of the loss function with respect to the parameters. \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vzJqIrl79uSN"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "j2IQ004i-PFk"
+ },
+ "source": [
+ "Similarly to forward propagation, we're going to build the backward propagation in three steps:\n",
+ "1. LINEAR backward\n",
+ "2. LINEAR -> ACTIVATION backward where ACTIVATION computes the derivative of either the ReLU or sigmoid activation\n",
+ "3. [LINEAR -> RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID backward (whole model)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EXqxNkPT_N28"
+ },
+ "source": [
+ "**Linear Backward:**\n",
+ "\n",
+ "For layer $l$, the linear part is: $Z^{[l]} = W^{[l]} A^{[l-1]} + b^{[l]}$ (followed by an activation).\n",
+ "\n",
+ "Suppose you have already calculated the derivative $dZ^{[l]} = \\frac{\\partial \\mathcal{L} }{\\partial Z^{[l]}}$. You want to get $(dW^{[l]}, db^{[l]}, dA^{[l-1]})$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Fj4W87cq-jnD"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "l56844DE_TWo"
+ },
+ "source": [
+ "The three outputs $(dW^{[l]}, db^{[l]}, dA^{[l-1]})$ are computed using the input $dZ^{[l]}$.\n",
+ "\n",
+ "Here are the formulas we need:\n",
+ "$$ dW^{[l]} = \\frac{\\partial \\mathcal{J} }{\\partial W^{[l]}} = \\frac{1}{m} dZ^{[l]} A^{[l-1] T} \\tag{8}$$\n",
+ "$$ db^{[l]} = \\frac{\\partial \\mathcal{J} }{\\partial b^{[l]}} = \\frac{1}{m} \\sum_{i = 1}^{m} dZ^{[l](i)}\\tag{9}$$\n",
+ "$$ dA^{[l-1]} = \\frac{\\partial \\mathcal{L} }{\\partial A^{[l-1]}} = W^{[l] T} dZ^{[l]} \\tag{10}$$\n",
+ "\n",
+ "\n",
+ "$A^{[l-1] T}$ is the transpose of $A^{[l-1]}$. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "I3y9p1ib_Xpb"
+ },
+ "source": [
+ "**Linear Backward:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "id": "KHrBXz_G9e3b"
+ },
+ "outputs": [],
+ "source": [
+ "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, axis = 1, keepdims = True)\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 (db.shape == b.shape)\n",
+ " \n",
+ " return dA_prev, dW, db"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FHFMI2wv_tkf"
+ },
+ "source": [
+ "**Linear Activation Backward:**\n",
+ "\n",
+ "Next, we will create a function that merges the two helper functions: **`linear_backward`** and the backward step for the activation **`linear_activation_backward`**. \n",
+ "\n",
+ "To help implement `linear_activation_backward`, two backward functions have been written:\n",
+ "- **`sigmoid_backward`**: Implements the backward propagation for SIGMOID unit. You can call it as follows:\n",
+ "\n",
+ "```python\n",
+ "dZ = sigmoid_backward(dA, activation_cache)\n",
+ "```\n",
+ "\n",
+ "- **`relu_backward`**: Implements the backward propagation for RELU unit. You can call it as follows:\n",
+ "\n",
+ "```python\n",
+ "dZ = relu_backward(dA, activation_cache)\n",
+ "```\n",
+ "\n",
+ "If $g(.)$ is the activation function, \n",
+ "`sigmoid_backward` and `relu_backward` compute $$dZ^{[l]} = dA^{[l]} * g'(Z^{[l]}). \\tag{11}$$ "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "id": "XhOZ404MA0MM"
+ },
+ "outputs": [],
+ "source": [
+ "def sigmoid_backward(dA, cache):\n",
+ " \"\"\"\n",
+ " Implement the backward propagation for a single SIGMOID unit.\n",
+ "\n",
+ " Arguments:\n",
+ " dA -- post-activation gradient, of any shape\n",
+ " cache -- 'Z' where we store for computing backward propagation efficiently\n",
+ "\n",
+ " Returns:\n",
+ " dZ -- Gradient of the cost with respect to Z\n",
+ " \"\"\" \n",
+ " Z = cache\n",
+ " \n",
+ " s = 1/(1+np.exp(-Z))\n",
+ " dZ = dA * s * (1-s)\n",
+ " \n",
+ " assert (dZ.shape == Z.shape)\n",
+ " \n",
+ " return dZ"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "id": "SeN0Jqc6A5j_"
+ },
+ "outputs": [],
+ "source": [
+ "def relu_backward(dA, cache):\n",
+ " \"\"\"\n",
+ " Implement the backward propagation for a single RELU unit.\n",
+ "\n",
+ " Arguments:\n",
+ " dA -- post-activation gradient, of any shape\n",
+ " cache -- 'Z' where we store for computing backward propagation efficiently\n",
+ "\n",
+ " Returns:\n",
+ " dZ -- Gradient of the cost with respect to Z\n",
+ " \"\"\" \n",
+ " Z = cache\n",
+ " dZ = np.array(dA, copy=True) # just converting dz to a correct object.\n",
+ " \n",
+ " #When z <= 0, you should set dz to 0 as well. \n",
+ " dZ[Z <= 0] = 0\n",
+ " \n",
+ " assert (dZ.shape == Z.shape)\n",
+ " \n",
+ " return dZ"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "id": "04QiujiM_mxD"
+ },
+ "outputs": [],
+ "source": [
+ "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": "markdown",
+ "metadata": {
+ "id": "us3JwSFGDRH0"
+ },
+ "source": [
+ "**L-Model Backward:**\n",
+ "\n",
+ "Now we will implement the backward function for the whole network!.\n",
+ "\n",
+ "Recall that when we implemented the `L_model_forward` function, at each iteration, we stored a cache which contains (X,W,b, and z). In the back propagation module, we'll use those variables to compute the gradients. Therefore, in the `L_model_backward` function, we'll iterate through all the hidden layers backward, starting from layer $L$. On each step, we will use the cached values for layer $l$ to backpropagate through layer $l$. Figure 5 below shows the backward pass. \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vcJVsJc3DgOf"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Jx8gH1v6Dr31"
+ },
+ "source": [
+ "**Initializing backpropagation:**\n",
+ "\n",
+ "To backpropagate through this network, we know that the output is: \n",
+ "$A^{[L]} = \\sigma(Z^{[L]})$. Our code thus needs to compute `dAL` $= \\frac{\\partial \\mathcal{L}}{\\partial A^{[L]}}$.\n",
+ "To do so, we use this formula:\n",
+ "```python\n",
+ "dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL)) # derivative of cost with respect to AL\n",
+ "```\n",
+ "We can then use this post-activation gradient `dAL` to keep going backward. We can now feed in `dAL` into the LINEAR->SIGMOID backward function we implemented (which will use the cached values stored by the L_model_forward function). \n",
+ "\n",
+ "After that, we will have to use a `for` loop to iterate through all the other layers using the LINEAR->RELU backward function. We should store each dA, dW, and db in the grads dictionary. To do so, we use this formula: \n",
+ "\n",
+ "$$grads[\"dW\" + str(l)] = dW^{[l]}\\tag{15} $$\n",
+ "\n",
+ "For example, for $l=3$ this would store $dW^{[l]}$ in `grads[\"dW3\"]`.\n",
+ "\n",
+ "We will implement backpropagation for the *[LINEAR->RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID* model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "id": "Lo54gOhUBCZw"
+ },
+ "outputs": [],
+ "source": [
+ "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\" (it's caches[l], for l in range(L-1) i.e l = 0...L-2)\n",
+ " the cache of linear_activation_forward() with \"sigmoid\" (it's caches[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",
+ " #Number of layers\n",
+ " L = len(caches)\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-1)], 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 + 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",
+ "\n",
+ " return grads"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "I6YW_pBxF0d7"
+ },
+ "source": [
+ "**Update Parameters:**\n",
+ "\n",
+ "Now we'll update the parameters of the model, using gradient descent: \n",
+ "\n",
+ "$$ W^{[l]} = W^{[l]} - \\alpha \\text{ } dW^{[l]} \\tag{16}$$\n",
+ "$$ b^{[l]} = b^{[l]} - \\alpha \\text{ } db^{[l]} \\tag{17}$$\n",
+ "\n",
+ "where $\\alpha$ is the learning rate. \n",
+ "\n",
+ "After computing the updated parameters, we store them in the parameters dictionary. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "id": "jJuJdK9dFwtX"
+ },
+ "outputs": [],
+ "source": [
+ "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",
+ " 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": "markdown",
+ "metadata": {
+ "id": "Q98tUpzKUaen"
+ },
+ "source": [
+ "# Test the Model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "I92qmVLUG6wS"
+ },
+ "source": [
+ "Now The model is compeleted. Let's test the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "id": "_4GrkSQjGIyx"
+ },
+ "outputs": [],
+ "source": [
+ "#Loading the data (cat/non-cat)\n",
+ "def load_data():\n",
+ " train_dataset = h5py.File('./train_catvnoncat.h5', \"r\")\n",
+ " train_set_x_orig = np.array(train_dataset['train_set_x'][:]) #Train set features\n",
+ " train_set_y_orig = np.array(train_dataset['train_set_y'][:]) #Train set labels\n",
+ "\n",
+ " test_dataset = h5py.File('./test_catvnoncat.h5', \"r\")\n",
+ " test_set_x_orig = np.array(test_dataset['test_set_x'][:]) #Test set features\n",
+ " test_set_y_orig = np.array(test_dataset['test_set_y'][:]) #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",
+ " \n",
+ " return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n",
+ "\n",
+ "train_x_orig, train_y, test_x_orig, test_y, classes = load_data()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 286
+ },
+ "id": "TuA3NKTHH3yw",
+ "outputId": "76697136-ac53-4ed4-ed1b-ceab45847bea"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "y = 0. It's a non-cat picture.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#Example of a picture\n",
+ "index = 9\n",
+ "plt.imshow(train_x_orig[index])\n",
+ "print (\"y = \" + str(train_y[0,index]) + \". It's a \" + classes[train_y[0,index]].decode(\"utf-8\") + \" picture.\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "eMoVojdZH832",
+ "outputId": "fb3924fd-3787-4df7-8499-9d09720cc6a6"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of training examples: 209\n",
+ "Number of testing examples: 50\n",
+ "Each image is of size: (64, 64, 3)\n",
+ "train_x_orig shape: (209, 64, 64, 3)\n",
+ "train_y shape: (1, 209)\n",
+ "test_x_orig shape: (50, 64, 64, 3)\n",
+ "test_y shape: (1, 50)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Explore dataset \n",
+ "m_train = train_x_orig.shape[0]\n",
+ "num_px = train_x_orig.shape[1]\n",
+ "m_test = test_x_orig.shape[0]\n",
+ "\n",
+ "print('Number of training examples: ' + str(m_train))\n",
+ "print('Number of testing examples: ' + str(m_test))\n",
+ "print('Each image is of size: (' + str(num_px) + ', ' + str(num_px) + ', 3)')\n",
+ "print('train_x_orig shape: ' + str(train_x_orig.shape))\n",
+ "print('train_y shape: ' + str(train_y.shape))\n",
+ "print('test_x_orig shape: ' + str(test_x_orig.shape))\n",
+ "print('test_y shape: ' + str(test_y.shape))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3hpb1rhWJHgy"
+ },
+ "source": [
+ "As usual, we reshape and standardize the images before feeding them to the network."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MfN4biXII_Ba"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "JNfX613cIfWo",
+ "outputId": "83fa58dd-a0b3-4a37-dd0c-1b23dec58180"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "train_x's shape: (12288, 209)\n",
+ "test_x's shape: (12288, 50)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Reshape the training and test examples \n",
+ "train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T #The \"-1\" makes reshape flatten the remaining dimensions\n",
+ "test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T\n",
+ "\n",
+ "#Standardize data to have feature values between 0 and 1.\n",
+ "train_x = train_x_flatten/255.\n",
+ "test_x = test_x_flatten/255.\n",
+ "\n",
+ "print(\"train_x's shape: \" + str(train_x.shape))\n",
+ "print(\"test_x's shape: \" + str(test_x.shape))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "id": "6lVL4UteQ6Iy"
+ },
+ "outputs": [],
+ "source": [
+ "#Constants for 2-layer 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": "lM2vJgizQ7V7"
+ },
+ "outputs": [],
+ "source": [
+ "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",
+ " 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",
+ " parameters = initialize_parameters(n_x, n_h, n_y)\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",
+ " 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",
+ " A1, cache1 = linear_activation_forward(X, W1, b1, activation='relu')\n",
+ " A2, cache2 = linear_activation_forward(A1, W2, b2, activation='sigmoid')\n",
+ "\n",
+ " #Compute cost\n",
+ " cost = compute_cost(A2, Y)\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",
+ " dA1, dW2, db2 = linear_activation_backward(dA2, cache2, activation='sigmoid')\n",
+ " dA0, dW1, db1 = linear_activation_backward(dA1, cache1, activation='relu')\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",
+ " parameters = update_parameters(parameters, grads, learning_rate)\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/"
+ },
+ "id": "5f9HiX71RDj0",
+ "outputId": "64aa3049-c4b2-40b8-d367-5feca2eb7068"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Cost after iteration 0: 0.693049735659989\n",
+ "Cost after iteration 100: 0.6464320953428849\n",
+ "Cost after iteration 200: 0.6325140647912678\n",
+ "Cost after iteration 300: 0.6015024920354665\n",
+ "Cost after iteration 400: 0.5601966311605748\n",
+ "Cost after iteration 500: 0.515830477276473\n",
+ "Cost after iteration 600: 0.47549013139433255\n",
+ "Cost after iteration 700: 0.4339163151225749\n",
+ "Cost after iteration 800: 0.4007977536203889\n",
+ "Cost after iteration 900: 0.3580705011323798\n",
+ "Cost after iteration 1000: 0.3394281538366412\n",
+ "Cost after iteration 1100: 0.30527536361962637\n",
+ "Cost after iteration 1200: 0.27491377282130164\n",
+ "Cost after iteration 1300: 0.24681768210614818\n",
+ "Cost after iteration 1400: 0.1985073503746612\n",
+ "Cost after iteration 1500: 0.17448318112556635\n",
+ "Cost after iteration 1600: 0.1708076297809699\n",
+ "Cost after iteration 1700: 0.11306524562164708\n",
+ "Cost after iteration 1800: 0.09629426845937154\n",
+ "Cost after iteration 1900: 0.08342617959726871\n",
+ "Cost after iteration 2000: 0.07439078704319087\n",
+ "Cost after iteration 2100: 0.06630748132267933\n",
+ "Cost after iteration 2200: 0.05919329501038172\n",
+ "Cost after iteration 2300: 0.053361403485605585\n",
+ "Cost after iteration 2400: 0.048554785628770226\n",
+ "Cost after iteration 2499: 0.044214982158689575\n"
+ ]
+ }
+ ],
+ "source": [
+ "parameters, costs = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 295
+ },
+ "id": "PnrBgQrgSSAU",
+ "outputId": "0a2efce9-de2d-4e59-a2dc-c8d14d4e0b59"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_costs(costs, learning_rate)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "id": "piJLevvGKZmL"
+ },
+ "outputs": [],
+ "source": [
+ "def predict(X, y, parameters):\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",
+ " 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",
+ " probas, caches = L_model_forward(X, parameters)\n",
+ " \n",
+ " #Convert probas to 0/1 predictions\n",
+ " for i in range(0, probas.shape[1]):\n",
+ " if probas[0,i] > 0.5:\n",
+ " p[0,i] = 1\n",
+ " else:\n",
+ " p[0,i] = 0\n",
+ " \n",
+ " #Print results\n",
+ " print('Accuracy: ' + str(np.sum((p == y)/m)))\n",
+ " \n",
+ " return p"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "po61fcpTTwoO",
+ "outputId": "bf366585-c959-4ab3-aa75-8ea3b92c2eb2"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Accuracy: 0.9999999999999998\n"
+ ]
+ }
+ ],
+ "source": [
+ "predictions_train = predict(train_x, train_y, parameters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "fyqCX05ETyiR",
+ "outputId": "7b4cc2df-787d-4948-fd3f-570c0f10d44e"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Accuracy: 0.72\n"
+ ]
+ }
+ ],
+ "source": [
+ "predictions_test = predict(test_x, test_y, parameters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "id": "wspJ_snpT3gu"
+ },
+ "outputs": [],
+ "source": [
+ "#Constants for 4-layer model\n",
+ "layers_dims = [12288, 20, 7, 5, 1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "id": "hpy98OwLJPfP"
+ },
+ "outputs": [],
+ "source": [
+ "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
+ " \"\"\"\n",
+ " Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.\n",
+ " \n",
+ " Arguments:\n",
+ " X -- data, numpy array of shape (num_px * num_px * 3, number of examples)\n",
+ " Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)\n",
+ " layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).\n",
+ " learning_rate -- learning rate of the gradient descent update rule\n",
+ " num_iterations -- number of iterations of the optimization loop\n",
+ " print_cost -- if True, it prints the cost every 100 steps\n",
+ " \n",
+ " Returns:\n",
+ " parameters -- parameters learnt by the model. They can then be used to predict.\n",
+ " \"\"\"\n",
+ " np.random.seed(1)\n",
+ " costs = [] #Keep track of cost\n",
+ " \n",
+ " #Parameters initialization.\n",
+ " parameters = initialize_parameters_deep(layers_dims)\n",
+ " \n",
+ " #Loop (gradient descent)\n",
+ " for i in range(0, num_iterations):\n",
+ "\n",
+ " #Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.\n",
+ " AL, caches = L_model_forward(X, parameters)\n",
+ " \n",
+ " #Compute cost\n",
+ " cost = compute_cost(AL, Y)\n",
+ "\n",
+ " #Backward propagation.\n",
+ " grads = L_model_backward(AL, Y, caches)\n",
+ " \n",
+ " #Update parameters\n",
+ " parameters = update_parameters(parameters, grads, learning_rate)\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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "cNgG68tPKTAP",
+ "outputId": "03ccc5ee-0f6a-4dca-ee54-6d82023b812d"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Cost after iteration 0: 0.7717493284237686\n",
+ "Cost after iteration 100: 0.6720534400822914\n",
+ "Cost after iteration 200: 0.6482632048575212\n",
+ "Cost after iteration 300: 0.6115068816101354\n",
+ "Cost after iteration 400: 0.5670473268366111\n",
+ "Cost after iteration 500: 0.5401376634547801\n",
+ "Cost after iteration 600: 0.5279299569455267\n",
+ "Cost after iteration 700: 0.46547737717668514\n",
+ "Cost after iteration 800: 0.36912585249592794\n",
+ "Cost after iteration 900: 0.39174697434805344\n",
+ "Cost after iteration 1000: 0.3151869888600617\n",
+ "Cost after iteration 1100: 0.2726998441789385\n",
+ "Cost after iteration 1200: 0.23741853400268137\n",
+ "Cost after iteration 1300: 0.19960120532208644\n",
+ "Cost after iteration 1400: 0.18926300388463305\n",
+ "Cost after iteration 1500: 0.1611885466582775\n",
+ "Cost after iteration 1600: 0.14821389662363316\n",
+ "Cost after iteration 1700: 0.13777487812972944\n",
+ "Cost after iteration 1800: 0.12974017549190123\n",
+ "Cost after iteration 1900: 0.12122535068005212\n",
+ "Cost after iteration 2000: 0.1138206066863371\n",
+ "Cost after iteration 2100: 0.10783928526254132\n",
+ "Cost after iteration 2200: 0.10285466069352679\n",
+ "Cost after iteration 2300: 0.10089745445261787\n",
+ "Cost after iteration 2400: 0.09287821526472397\n",
+ "Cost after iteration 2499: 0.08843994344170202\n"
+ ]
+ }
+ ],
+ "source": [
+ "parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "AMljAW58K8JN",
+ "outputId": "f7eecd65-c5f8-47e5-a703-25a7674b5a02"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Accuracy: 0.9856459330143539\n"
+ ]
+ }
+ ],
+ "source": [
+ "pred_train = predict(train_x, train_y, parameters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "mPgHlEgWK_Ml",
+ "outputId": "c8a767a9-a1b4-4795-9c96-2feff29c8ff3"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Accuracy: 0.8\n"
+ ]
+ }
+ ],
+ "source": [
+ "pred_test = predict(test_x, test_y, parameters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "id": "LVwXM_71LA76"
+ },
+ "outputs": [],
+ "source": [
+ "def print_mislabeled_images(classes, X, y, p):\n",
+ " \"\"\"\n",
+ " Plots images where predictions and truth were different.\n",
+ " X -- dataset\n",
+ " y -- true labels\n",
+ " p -- predictions\n",
+ " \"\"\"\n",
+ " a = p + y\n",
+ " mislabeled_indices = np.asarray(np.where(a == 1))\n",
+ " plt.rcParams['figure.figsize'] = (40.0, 40.0) #Set default size of plots\n",
+ " num_images = len(mislabeled_indices[0])\n",
+ " for i in range(num_images):\n",
+ " index = mislabeled_indices[1][i]\n",
+ " \n",
+ " plt.subplot(2, num_images, i + 1)\n",
+ " plt.imshow(X[:,index].reshape(64,64,3), interpolation='nearest')\n",
+ " plt.axis('off')\n",
+ " plt.title(\"Prediction: \" + classes[int(p[0,index])].decode(\"utf-8\") + \" \\n Class: \" + classes[y[0,index]].decode(\"utf-8\"))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mVBqgxuZLvuP"
+ },
+ "source": [
+ "Let's take a look at some images the L-layer model labeled incorrectly. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 134
+ },
+ "id": "h1jS65nkLI22",
+ "outputId": "877683e4-672d-4306-ace4-d3a157ef72c2"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print_mislabeled_images(classes, test_x, test_y, pred_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ClSGts8FLWjP"
+ },
+ "source": [
+ "A few types of images the model tends to do poorly on include:\n",
+ "\n",
+ "- Cat body in an unusual position\n",
+ "- Cat appears against a background of a similar color\n",
+ "- Unusual cat color and species\n",
+ "- Camera Angle\n",
+ "- Brightness of the picture\n",
+ "- Scale variation (cat is very large or small in image)"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "collapsed_sections": [],
+ "name": "Building Deep Neural Network From Scratch.ipynb",
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}