Logistic_Regression_with_a_Neural_Network_mindset_v3.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hussain0048/Deep-Learning/blob/master/Logistic_Regression_with_a_Neural_Network_mindset_v3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XzEWo5dCoj0t"
      },
      "source": [
        "# Logistic Regression with a Neural Network mindset\n",
        "\n",
        "Welcome to your first (required) programming assignment! You will build a logistic regression classifier to recognize  cats. This assignment will step you through how to do this with a Neural Network mindset, and so will also hone your intuitions about deep learning.\n",
        "\n",
        "**Instructions:**\n",
        "- Do not use loops (for/while) in your code, unless the instructions explicitly ask you to do so.\n",
        "\n",
        "**You will learn to:**\n",
        "- Build the general architecture of a learning algorithm, including:\n",
        "    - Initializing parameters\n",
        "    - Calculating the cost function and its gradient\n",
        "    - Using an optimization algorithm (gradient descent) \n",
        "- Gather all three functions above into a main model function, in the right order."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AA4YQ4Oxoj1L"
      },
      "source": [
        "## 1 - Packages ##\n",
        "\n",
        "First, let's run the cell below to import all the packages that you will need during this assignment. \n",
        "- [numpy](www.numpy.org) is the fundamental package for scientific computing with Python.\n",
        "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n",
        "- [matplotlib](http://matplotlib.org) is a famous library to plot graphs in Python.\n",
        "- [PIL](http://www.pythonware.com/products/pil/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IGY-8ikO30KL",
        "outputId": "320a6c06-bd4a-4732-f8a6-6e13be800f69"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import h5py\n",
        "    \n",
        "    \n",
        "def load_dataset():\n",
        "    train_dataset = h5py.File('/content/drive/MyDrive/Courses /Data Science /Deep Learning/Theory /Neural netowrk and Deep learning/Week 2/Datasets/train_catvnoncat.h5', \"r\")\n",
        "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
        "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
        "\n",
        "    test_dataset = h5py.File('/content/drive/MyDrive/Courses /Data Science /Deep Learning/Theory /Neural netowrk and Deep learning/Week 2/Datasets/test_catvnoncat.h5', \"r\")\n",
        "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
        "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
        "\n",
        "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
        "    \n",
        "    train_set_y_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"
      ],
      "metadata": {
        "id": "boaDggEl1xBM"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "Nby8-t_xoj1N"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import h5py\n",
        "import scipy\n",
        "from PIL import Image\n",
        "from scipy import ndimage\n",
        "#from lr_utils import load_dataset\n",
        "\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "svhVLs6goj2A"
      },
      "source": [
        "## **2 - Overview of the Problem set** ##\n",
        "\n",
        "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n",
        "    - a training set of m_train images labeled as cat (y=1) or non-cat (y=0)\n",
        "    - a test set of m_test images labeled as cat or non-cat\n",
        "    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB). Thus, each image is square (height = num_px) and (width = num_px).\n",
        "\n",
        "You will build a simple image-recognition algorithm that can correctly classify pictures as cat or non-cat.\n",
        "\n",
        "Let's get more familiar with the dataset. Load the data by running the following code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "O06_RQGroj2C"
      },
      "outputs": [],
      "source": [
        "# Loading the data (cat/non-cat)\n",
        "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z21tk2Zvoj2H"
      },
      "source": [
        "We added \"_orig\" at the end of image datasets (train and test) because we are going to preprocess them. After preprocessing, we will end up with train_set_x and test_set_x (the labels train_set_y and test_set_y don't need any preprocessing).\n",
        "\n",
        "Each line of your train_set_x_orig and test_set_x_orig is an array representing an image. You can visualize an example by running the following code. Feel free also to change the `index` value and re-run to see other images. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "sEMcfK6Foj2L",
        "outputId": "92a7a949-c557-481f-b59f-77fd77ee5a9a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "y = [1], it's a 'cat' picture.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Example of a picture\n",
        "index = 25\n",
        "plt.imshow(train_set_x_orig[index])\n",
        "print (\"y = \" + str(train_set_y[:, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ht9kRFYMoj2X"
      },
      "source": [
        "Many software bugs in deep learning come from having matrix/vector dimensions that don't fit. If you can keep your matrix/vector dimensions straight you will go a long way toward eliminating many bugs. \n",
        "\n",
        "**Exercise:** Find the values for:\n",
        "    - m_train (number of training examples)\n",
        "    - m_test (number of test examples)\n",
        "    - num_px (= height = width of a training image)\n",
        "Remember that `train_set_x_orig` is a numpy-array of shape (m_train, num_px, num_px, 3). For instance, you can access `m_train` by writing `train_set_x_orig.shape[0]`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "scrolled": true,
        "id": "bRRq50Bwoj2i",
        "outputId": "2c093c42-a9bf-4450-c9c7-1744f92cbeef",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of training examples: m_train = 209\n",
            "Number of testing examples: m_test = 50\n",
            "Height/Width of each image: num_px = 64\n",
            "Each image is of size: (64, 64, 3)\n",
            "train_set_x shape: (209, 64, 64, 3)\n",
            "train_set_y shape: (1, 209)\n",
            "test_set_x shape: (50, 64, 64, 3)\n",
            "test_set_y shape: (1, 50)\n"
          ]
        }
      ],
      "source": [
        "### START CODE HERE ### (≈ 3 lines of code)\n",
        "m_train = train_set_x_orig.shape[0]\n",
        "m_test = test_set_x_orig.shape[0]\n",
        "num_px = train_set_x_orig.shape[1]\n",
        "### END CODE HERE ###\n",
        "\n",
        "print (\"Number of training examples: m_train = \" + str(m_train))\n",
        "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
        "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
        "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
        "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n",
        "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
        "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n",
        "print (\"test_set_y shape: \" + str(test_set_y.shape))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gr8rcF68oj2l"
      },
      "source": [
        "**Expected Output for m_train, m_test and num_px**: \n",
        "<table style=\"width:15%\">\n",
        "  <tr>\n",
        "    <td>**m_train**</td>\n",
        "    <td> 209 </td> \n",
        "  </tr>\n",
        "  \n",
        "  <tr>\n",
        "    <td>**m_test**</td>\n",
        "    <td> 50 </td> \n",
        "  </tr>\n",
        "  \n",
        "  <tr>\n",
        "    <td>**num_px**</td>\n",
        "    <td> 64 </td> \n",
        "  </tr>\n",
        "  \n",
        "</table>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tmOMgvYuoj2n"
      },
      "source": [
        "For convenience, you should now reshape images of shape (num_px, num_px, 3) in a numpy-array of shape (num_px $*$ num_px $*$ 3, 1). After this, our training (and test) dataset is a numpy-array where each column represents a flattened image. There should be m_train (respectively m_test) columns.\n",
        "\n",
        "**Exercise:** Reshape the training and test data sets so that images of size (num_px, num_px, 3) are flattened into single vectors of shape (num\\_px $*$ num\\_px $*$ 3, 1).\n",
        "\n",
        "A trick when you want to flatten a matrix X of shape (a,b,c,d) to a matrix X_flatten of shape (b$*$c$*$d, a) is to use: \n",
        "```python\n",
        "X_flatten = X.reshape(X.shape[0], -1).T      # X.T is the transpose of X\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "ocZQocI6oj20",
        "outputId": "5005dbfc-2074-4664-dd06-d9b1aec6b192",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_set_x_flatten shape: (12288, 209)\n",
            "train_set_y shape: (1, 209)\n",
            "test_set_x_flatten shape: (12288, 50)\n",
            "test_set_y shape: (1, 50)\n",
            "sanity check after reshaping: [17 31 56 22 33]\n"
          ]
        }
      ],
      "source": [
        "# Reshape the training and test examples\n",
        "\n",
        "### START CODE HERE ### (≈ 2 lines of code)\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",
        "### END CODE HERE ###\n",
        "\n",
        "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
        "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
        "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
        "print (\"test_set_y shape: \" + str(test_set_y.shape))\n",
        "print (\"sanity check after reshaping: \" + str(train_set_x_flatten[0:5,0]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D6S60Z7uoj26"
      },
      "source": [
        "**Expected Output**: \n",
        "\n",
        "<table style=\"width:35%\">\n",
        "  <tr>\n",
        "    <td>**train_set_x_flatten shape**</td>\n",
        "    <td> (12288, 209)</td> \n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>**train_set_y shape**</td>\n",
        "    <td>(1, 209)</td> \n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>**test_set_x_flatten shape**</td>\n",
        "    <td>(12288, 50)</td> \n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>**test_set_y shape**</td>\n",
        "    <td>(1, 50)</td> \n",
        "  </tr>\n",
        "  <tr>\n",
        "  <td>**sanity check after reshaping**</td>\n",
        "  <td>[17 31 56 22 33]</td> \n",
        "  </tr>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-QzSTv8oj3C"
      },
      "source": [
        "To represent color images, the red, green and blue channels (RGB) must be specified for each pixel, and so the pixel value is actually a vector of three numbers ranging from 0 to 255.\n",
        "\n",
        "One common preprocessing step in machine learning is to center and standardize your dataset, meaning that you substract the mean of the whole numpy array from each example, and then divide each example by the standard deviation of the whole numpy array. But for picture datasets, it is simpler and more convenient and works almost as well to just divide every row of the dataset by 255 (the maximum value of a pixel channel).\n",
        "\n",
        "<!-- During the training of your model, you're going to multiply weights and add biases to some initial inputs in order to observe neuron activations. Then you backpropogate with the gradients to train the model. But, it is extremely important for each feature to have a similar range such that our gradients don't explode. You will see that more in detail later in the lectures. !--> \n",
        "\n",
        "Let's standardize our dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "29r3ekFZoj3E"
      },
      "outputs": [],
      "source": [
        "train_set_x = train_set_x_flatten/255.\n",
        "test_set_x = test_set_x_flatten/255."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v4d6JpKRoj36"
      },
      "source": [
        "<font color='blue'>\n",
        "**What you need to remember:**\n",
        "\n",
        "Common steps for pre-processing a new dataset are:\n",
        "- Figure out the dimensions and shapes of the problem (m_train, m_test, num_px, ...)\n",
        "- Reshape the datasets such that each example is now a vector of size (num_px \\* num_px \\* 3, 1)\n",
        "- \"Standardize\" the data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c9O5i7yeoj37"
      },
      "source": [
        "## 3 - General Architecture of the learning algorithm ##\n",
        "\n",
        "It's time to design a simple algorithm to distinguish cat images from non-cat images.\n",
        "\n",
        "You will build a Logistic Regression, using a Neural Network mindset. The following Figure explains why **Logistic Regression is actually a very simple Neural Network!**\n",
        "\n",
        " ![](\n",
        "https://drive.google.com/uc?export=view&id=1g-3-WVfeObWjceSEIGyM5my7Uwj3bo_A)\n",
        "\n",
        "**Mathematical expression of the algorithm**:\n",
        "\n",
        "For one example $x^{(i)}$:\n",
        "$$z^{(i)} = w^T x^{(i)} + b \\tag{1}$$\n",
        "$$\\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\\tag{2}$$ \n",
        "$$ \\mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \\log(a^{(i)}) - (1-y^{(i)} )  \\log(1-a^{(i)})\\tag{3}$$\n",
        "\n",
        "The cost is then computed by summing over all training examples:\n",
        "$$ J = \\frac{1}{m} \\sum_{i=1}^m \\mathcal{L}(a^{(i)}, y^{(i)})\\tag{6}$$\n",
        "\n",
        "**Key steps**:\n",
        "In this exercise, you will carry out the following steps: \n",
        "    - Initialize the parameters of the model\n",
        "    - Learn the parameters for the model by minimizing the cost  \n",
        "    - Use the learned parameters to make predictions (on the test set)\n",
        "    - Analyse the results and conclude"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KD07MRt4oj4D"
      },
      "source": [
        "## 4 - Building the parts of our algorithm ## \n",
        "\n",
        "The main steps for building a Neural Network are:\n",
        "1. Define the model structure (such as number of input features) \n",
        "2. Initialize the model's parameters\n",
        "3. Loop:\n",
        "    - Calculate current loss (forward propagation)\n",
        "    - Calculate current gradient (backward propagation)\n",
        "    - Update parameters (gradient descent)\n",
        "\n",
        "You often build 1-3 separately and integrate them into one function we call `model()`.\n",
        "\n",
        "### 4.1 - Helper functions\n",
        "\n",
        "**Exercise**: Using your code from \"Python Basics\", implement `sigmoid()`. As you've seen in the figure above, you need to compute $sigmoid( w^T x + b) = \\frac{1}{1 + e^{-(w^T x + b)}}$ to make predictions. Use np.exp()."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "30u7uKRwoj4G"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: sigmoid\n",
        "\n",
        "def sigmoid(z):\n",
        "    \"\"\"\n",
        "    Compute the sigmoid of z\n",
        "\n",
        "    Arguments:\n",
        "    z -- A scalar or numpy array of any size.\n",
        "\n",
        "    Return:\n",
        "    s -- sigmoid(z)\n",
        "    \"\"\"\n",
        "\n",
        "    ### START CODE HERE ### (≈ 1 line of code)\n",
        "    s = 1/(1+np.exp(-z))\n",
        "    ### END CODE HERE ###\n",
        "    \n",
        "    return s"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "scrolled": true,
        "id": "qwxBxVL7oj4L",
        "outputId": "bc897b82-92b0-43b6-a154-d8b8b53ea67b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sigmoid([0, 2]) = [0.5        0.88079708]\n"
          ]
        }
      ],
      "source": [
        "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rvNwsvGboj4M"
      },
      "source": [
        "**Expected Output**: \n",
        "\n",
        "<table>\n",
        "  <tr>\n",
        "    <td>**sigmoid([0, 2])**</td>\n",
        "    <td> [ 0.5         0.88079708]</td> \n",
        "  </tr>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NANtpbR6oj4S"
      },
      "source": [
        "### 4.2 - Initializing parameters\n",
        "\n",
        "**Exercise:** Implement parameter initialization in the cell below. You have to initialize w as a vector of zeros. If you don't know what numpy function to use, look up np.zeros() in the Numpy library's documentation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "6fdft2TIoj4T"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: initialize_with_zeros\n",
        "\n",
        "def initialize_with_zeros(dim):\n",
        "    \"\"\"\n",
        "    This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n",
        "    \n",
        "    Argument:\n",
        "    dim -- size of the w vector we want (or number of parameters in this case)\n",
        "    \n",
        "    Returns:\n",
        "    w -- initialized vector of shape (dim, 1)\n",
        "    b -- initialized scalar (corresponds to the bias)\n",
        "    \"\"\"\n",
        "    \n",
        "    ### START CODE HERE ### (≈ 1 line of code)\n",
        "    w = np.zeros(shape=(dim,1))\n",
        "    b = 0\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    assert(w.shape == (dim, 1))\n",
        "    assert(isinstance(b, float) or isinstance(b, int))\n",
        "    \n",
        "    return w, b"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "LXztcW3poj4V",
        "outputId": "ecf0b415-905e-4b3c-88e4-a158ab86b249",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "w = [[0.]\n",
            " [0.]]\n",
            "b = 0\n"
          ]
        }
      ],
      "source": [
        "dim = 2\n",
        "w, b = initialize_with_zeros(dim)\n",
        "print (\"w = \" + str(w))\n",
        "print (\"b = \" + str(b))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t2LnHqpwoj4X"
      },
      "source": [
        "**Expected Output**: \n",
        "\n",
        "\n",
        "<table style=\"width:15%\">\n",
        "    <tr>\n",
        "        <td>  ** w **  </td>\n",
        "        <td> [[ 0.]\n",
        " [ 0.]] </td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>  ** b **  </td>\n",
        "        <td> 0 </td>\n",
        "    </tr>\n",
        "</table>\n",
        "\n",
        "For image inputs, w will be of shape (num_px $\\times$ num_px $\\times$ 3, 1)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1nQCl1VJoj4Y"
      },
      "source": [
        "### 4.3 - Forward and Backward propagation\n",
        "\n",
        "Now that your parameters are initialized, you can do the \"forward\" and \"backward\" propagation steps for learning the parameters.\n",
        "\n",
        "**Exercise:** Implement a function `propagate()` that computes the cost function and its gradient.\n",
        "\n",
        "**Hints**:\n",
        "\n",
        "Forward Propagation:\n",
        "- You get X\n",
        "- You compute $A = \\sigma(w^T X + b) = (a^{(0)}, a^{(1)}, ..., a^{(m-1)}, a^{(m)})$\n",
        "- You calculate the cost function: $J = -\\frac{1}{m}\\sum_{i=1}^{m}y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)})$\n",
        "\n",
        "Here are the two formulas you will be using: \n",
        "\n",
        "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T\\tag{7}$$\n",
        "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})\\tag{8}$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "eS_QsnQRoj4Z"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: propagate\n",
        "\n",
        "def propagate(w, b, X, Y):\n",
        "    \"\"\"\n",
        "    Implement the cost function and its gradient for the propagation explained above\n",
        "\n",
        "    Arguments:\n",
        "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
        "    b -- bias, a scalar\n",
        "    X -- data of size (num_px * num_px * 3, number of examples)\n",
        "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n",
        "\n",
        "    Return:\n",
        "    cost -- negative log-likelihood cost for logistic regression\n",
        "    dw -- gradient of the loss with respect to w, thus same shape as w\n",
        "    db -- gradient of the loss with respect to b, thus same shape as b\n",
        "    \n",
        "    Tips:\n",
        "    - Write your code step by step for the propagation. np.log(), np.dot()\n",
        "    \"\"\"\n",
        "    \n",
        "    m = X.shape[1]\n",
        "    \n",
        "    # FORWARD PROPAGATION (FROM X TO COST)\n",
        "    ### START CODE HERE ### (≈ 2 lines of code)\n",
        "    A = sigmoid(np.dot(w.T,X)+b)                                     # compute activation\n",
        "    cost = (1/m)*np.sum(-Y*np.log(A)-(1-Y)*np.log(1-A))                                  # compute cost\n",
        "    ### END CODE HERE ###\n",
        "    \n",
        "    # BACKWARD PROPAGATION (TO FIND GRAD)\n",
        "    ### START CODE HERE ### (≈ 2 lines of code)\n",
        "    dw = (1/m)*np.dot(X,(A-Y).T)\n",
        "    db = (1/m)*np.sum(A-Y)\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    assert(dw.shape == w.shape)\n",
        "    assert(db.dtype == float)\n",
        "    cost = np.squeeze(cost)\n",
        "    assert(cost.shape == ())\n",
        "    \n",
        "    grads = {\"dw\": dw,\n",
        "             \"db\": db}\n",
        "    \n",
        "    return grads, cost"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "cL4TxPtwoj4b",
        "outputId": "318724ec-55bf-406f-99e1-821c2cc20048",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dw = [[0.99993216]\n",
            " [1.99980262]]\n",
            "db = 0.49993523062470574\n",
            "cost = 6.000064773192205\n"
          ]
        }
      ],
      "source": [
        "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])\n",
        "grads, cost = propagate(w, b, X, Y)\n",
        "print (\"dw = \" + str(grads[\"dw\"]))\n",
        "print (\"db = \" + str(grads[\"db\"]))\n",
        "print (\"cost = \" + str(cost))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eJYzN8kUoj4o"
      },
      "source": [
        "**Expected Output**:\n",
        "\n",
        "<table style=\"width:50%\">\n",
        "    <tr>\n",
        "        <td>  ** dw **  </td>\n",
        "        <td> [[ 0.99993216]\n",
        " [ 1.99980262]]</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>  ** db **  </td>\n",
        "        <td> 0.499935230625 </td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "        <td>  ** cost **  </td>\n",
        "        <td> 6.000064773192205</td>\n",
        "    </tr>\n",
        "\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJ97Cpdloj46"
      },
      "source": [
        "### d) Optimization\n",
        "- You have initialized your parameters.\n",
        "- You are also able to compute a cost function and its gradient.\n",
        "- Now, you want to update the parameters using gradient descent.\n",
        "\n",
        "**Exercise:** Write down the optimization function. The goal is to learn $w$ and $b$ by minimizing the cost function $J$. For a parameter $\\theta$, the update rule is $ \\theta = \\theta - \\alpha \\text{ } d\\theta$, where $\\alpha$ is the learning rate."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "0fVIyncFoj4_"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: optimize\n",
        "\n",
        "def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n",
        "    \"\"\"\n",
        "    This function optimizes w and b by running a gradient descent algorithm\n",
        "    \n",
        "    Arguments:\n",
        "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
        "    b -- bias, a scalar\n",
        "    X -- data of shape (num_px * num_px * 3, number of examples)\n",
        "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n",
        "    num_iterations -- number of iterations of the optimization loop\n",
        "    learning_rate -- learning rate of the gradient descent update rule\n",
        "    print_cost -- True to print the loss every 100 steps\n",
        "    \n",
        "    Returns:\n",
        "    params -- dictionary containing the weights w and bias b\n",
        "    grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n",
        "    costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n",
        "    \n",
        "    Tips:\n",
        "    You basically need to write down two steps and iterate through them:\n",
        "        1) Calculate the cost and the gradient for the current parameters. Use propagate().\n",
        "        2) Update the parameters using gradient descent rule for w and b.\n",
        "    \"\"\"\n",
        "    \n",
        "    costs = []\n",
        "    \n",
        "    for i in range(num_iterations):\n",
        "        \n",
        "        \n",
        "        # Cost and gradient calculation (≈ 1-4 lines of code)\n",
        "        ### START CODE HERE ### \n",
        "        # grads, cost = None\n",
        "        grads, cost = propagate(w, b, X, Y)\n",
        "       \n",
        "        ### END CODE HERE ###\n",
        "        \n",
        "        # Retrieve derivatives from grads\n",
        "        dw = grads[\"dw\"]\n",
        "        db = grads[\"db\"]\n",
        "        \n",
        "        # update rule (≈ 2 lines of code)\n",
        "        ### START CODE HERE ###\n",
        "        w = w-learning_rate*dw\n",
        "        b = b-learning_rate*db\n",
        "        ### END CODE HERE ###\n",
        "        \n",
        "        # Record the costs\n",
        "        if i % 100 == 0:\n",
        "            costs.append(cost)\n",
        "        \n",
        "        # Print the cost every 100 training examples\n",
        "        if print_cost and i % 100 == 0:\n",
        "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
        "    \n",
        "    params = {\"w\": w,\n",
        "              \"b\": b}\n",
        "    \n",
        "    grads = {\"dw\": dw,\n",
        "             \"db\": db}\n",
        "    \n",
        "    return params, grads, costs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "cNx8Y_a0oj5w",
        "outputId": "fa8e0385-5f9b-4066-ce4a-08e82457fc54",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "w = [[0.1124579 ]\n",
            " [0.23106775]]\n",
            "b = 1.5593049248448891\n",
            "dw = [[0.90158428]\n",
            " [1.76250842]]\n",
            "db = 0.4304620716786828\n"
          ]
        }
      ],
      "source": [
        "params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)\n",
        "\n",
        "print (\"w = \" + str(params[\"w\"]))\n",
        "print (\"b = \" + str(params[\"b\"]))\n",
        "print (\"dw = \" + str(grads[\"dw\"]))\n",
        "print (\"db = \" + str(grads[\"db\"]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0zdSk844oj54"
      },
      "source": [
        "**Expected Output**: \n",
        "\n",
        "<table style=\"width:40%\">\n",
        "    <tr>\n",
        "       <td> **w** </td>\n",
        "       <td>[[ 0.1124579 ]\n",
        " [ 0.23106775]] </td>\n",
        "    </tr>\n",
        "    \n",
        "    <tr>\n",
        "       <td> **b** </td>\n",
        "       <td> 1.55930492484 </td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "       <td> **dw** </td>\n",
        "       <td> [[ 0.90158428]\n",
        " [ 1.76250842]] </td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "       <td> **db** </td>\n",
        "       <td> 0.430462071679 </td>\n",
        "    </tr>\n",
        "\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BBQUBk2zoj56"
      },
      "source": [
        "**Exercise:** The previous function will output the learned w and b. We are able to use w and b to predict the labels for a dataset X. Implement the `predict()` function. There is two steps to computing predictions:\n",
        "\n",
        "1. Calculate $\\hat{Y} = A = \\sigma(w^T X + b)$\n",
        "\n",
        "2. Convert the entries of a into 0 (if activation <= 0.5) or 1 (if activation > 0.5), stores the predictions in a vector `Y_prediction`. If you wish, you can use an `if`/`else` statement in a `for` loop (though there is also a way to vectorize this). "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "R-Dov6Bqoj7L"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: predict\n",
        "\n",
        "def predict(w, b, X):\n",
        "    '''\n",
        "    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n",
        "    \n",
        "    Arguments:\n",
        "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
        "    b -- bias, a scalar\n",
        "    X -- data of size (num_px * num_px * 3, number of examples)\n",
        "    \n",
        "    Returns:\n",
        "    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n",
        "    '''\n",
        "    \n",
        "    m = X.shape[1]\n",
        "    Y_prediction = np.zeros((1,m))\n",
        "    w = w.reshape(X.shape[0], 1)\n",
        "    \n",
        "    # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n",
        "    ### START CODE HERE ### (≈ 1 line of code)\n",
        "    A = sigmoid(np.dot(w.T,X)+b)     \n",
        "    # print(\"shape A = \" + str(A.shape))\n",
        "    ### END CODE HERE ###\n",
        "    \n",
        "    for i in range(A.shape[1]):\n",
        "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
        "        ### START CODE HERE ### (≈ 4 lines of code)\n",
        "        #   print(\"i = \" + str(i))\n",
        "        if A[0,i]<=0.5:\n",
        "            Y_prediction[0,i]=0\n",
        "        #   print(\"A[\" + str(i) + \"] menor o igual a 0.5\")\n",
        "        else:\n",
        "        #   print(\"A[\" + str(i) + \"] mayor que 0.5\")\n",
        "            Y_prediction[0,i]=1\n",
        "        \n",
        "        #Y_prediction[0,i] = np.where(A[0,i]<=0.5, 0, 1)\n",
        "        pass\n",
        "        ### END CODE HERE ###\n",
        "    \n",
        "    assert(Y_prediction.shape == (1, m))\n",
        "    \n",
        "    return Y_prediction"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "PSskn5kNoj7M",
        "outputId": "8bfbaf65-f06b-4b61-ee76-36e549d18e99",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "predictions = [[1. 1.]]\n"
          ]
        }
      ],
      "source": [
        "print (\"predictions = \" + str(predict(w, b, X)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q_QsMLtboj7P"
      },
      "source": [
        "**Expected Output**: \n",
        "\n",
        "<table style=\"width:30%\">\n",
        "    <tr>\n",
        "         <td>\n",
        "             **predictions**\n",
        "         </td>\n",
        "          <td>\n",
        "            [[ 1.  1.]]\n",
        "         </td>  \n",
        "   </tr>\n",
        "\n",
        "</table>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "PVxL4XFMoj7Q"
      },
      "source": [
        "<font color='blue'>\n",
        "**What to remember:**\n",
        "You've implemented several functions that:\n",
        "- Initialize (w,b)\n",
        "- Optimize the loss iteratively to learn parameters (w,b):\n",
        "    - computing the cost and its gradient \n",
        "    - updating the parameters using gradient descent\n",
        "- Use the learned (w,b) to predict the labels for a given set of examples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ryqI-Aupoj7R"
      },
      "source": [
        "## 5 - Merge all functions into a model ##\n",
        "\n",
        "You will now see how the overall model is structured by putting together all the building blocks (functions implemented in the previous parts) together, in the right order.\n",
        "\n",
        "**Exercise:** Implement the model function. Use the following notation:\n",
        "    - Y_prediction for your predictions on the test set\n",
        "    - Y_prediction_train for your predictions on the train set\n",
        "    - w, costs, grads for the outputs of optimize()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "P5SyPJ_doj-4"
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: model\n",
        "\n",
        "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
        "    \"\"\"\n",
        "    Builds the logistic regression model by calling the function you've implemented previously\n",
        "    \n",
        "    Arguments:\n",
        "    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n",
        "    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n",
        "    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n",
        "    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n",
        "    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n",
        "    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n",
        "    print_cost -- Set to true to print the cost every 100 iterations\n",
        "    \n",
        "    Returns:\n",
        "    d -- dictionary containing information about the model.\n",
        "    \"\"\"\n",
        "    \n",
        "    ### START CODE HERE ###\n",
        "    \n",
        "    # initialize parameters with zeros (≈ 1 line of code)\n",
        "    w, b = initialize_with_zeros(X_train.shape[0])\n",
        "    w = w.reshape(X_train.shape[0], 1)\n",
        "\n",
        "    # Gradient descent (≈ 1 line of code)\n",
        "    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost = False)\n",
        "    #print (\"w = \" + str(params[\"w\"]))\n",
        "    #print (\"b = \" + str(params[\"b\"]))\n",
        "    #print (\"dw = \" + str(grads[\"dw\"]))\n",
        "    #print (\"db = \" + str(grads[\"db\"]))\n",
        "    \n",
        "    # Retrieve parameters w and b from dictionary \"parameters\"\n",
        "    w = parameters[\"w\"]\n",
        "    b = parameters[\"b\"]\n",
        "    \n",
        "    # Predict test/train set examples (≈ 2 lines of code)\n",
        "    Y_prediction_test = predict(w, b, X_test)\n",
        "    Y_prediction_train = predict(w, b, X_train)\n",
        "\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    # Print train/test Errors\n",
        "    print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
        "    print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n",
        "\n",
        "    \n",
        "    d = {\"costs\": costs,\n",
        "         \"Y_prediction_test\": Y_prediction_test, \n",
        "         \"Y_prediction_train\" : Y_prediction_train, \n",
        "         \"w\" : w, \n",
        "         \"b\" : b,\n",
        "         \"learning_rate\" : learning_rate,\n",
        "         \"num_iterations\": num_iterations}\n",
        "    \n",
        "    return d"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OWS1iCBdoj-8"
      },
      "source": [
        "Run the following cell to train your model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "ajrzPhFqoj-9",
        "outputId": "520b1042-10a7-4c67-c0b5-1eaae0cba416",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train accuracy: 99.04306220095694 %\n",
            "test accuracy: 70.0 %\n"
          ]
        }
      ],
      "source": [
        "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9IsshRHJoj_W"
      },
      "source": [
        "**Expected Output**: \n",
        "\n",
        "<table style=\"width:40%\"> \n",
        "    \n",
        "    <tr>\n",
        "        <td> **Train Accuracy**  </td> \n",
        "        <td> 99.04306220095694 % </td>\n",
        "    </tr>\n",
        "\n",
        "    <tr>\n",
        "        <td>**Test Accuracy** </td> \n",
        "        <td> 70.0 % </td>\n",
        "    </tr>\n",
        "</table> \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "ffgzD5nGoj_e"
      },
      "source": [
        "**Comment**: Training accuracy is close to 100%. This is a good sanity check: your model is working and has high enough capacity to fit the training data. Test error is 68%. It is actually not bad for this simple model, given the small dataset we used and that logistic regression is a linear classifier. But no worries, you'll build an even better classifier next week!\n",
        "\n",
        "Also, you see that the model is clearly overfitting the training data. Later in this specialization you will learn how to reduce overfitting, for example by using regularization. Using the code below (and changing the `index` variable) you can look at predictions on pictures of the test set."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "xjZHX2saoj_f",
        "outputId": "075e7d73-f2bc-4db4-edf7-07db7d690706",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 651
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-21-0697835674fb>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_set_x\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_px\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_px\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"y = \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_set_y\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\", you predicted that it is a \\\"\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Y_prediction_test\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"utf-8\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m  \u001b[0;34m\"\\\" picture.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Example of a picture that was wrongly classified.\n",
        "index = 8\n",
        "plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))\n",
        "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[d[\"Y_prediction_test\"][0,index]].decode(\"utf-8\") +  \"\\\" picture.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ts75vhK1oj_o"
      },
      "source": [
        "Let's also plot the cost function and the gradients."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "pW26K1iXoj_q",
        "outputId": "5dce79e4-925d-4b2e-be9b-9fe909038b08",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Plot learning curve (with costs)\n",
        "costs = np.squeeze(d['costs'])\n",
        "plt.plot(costs)\n",
        "plt.ylabel('cost')\n",
        "plt.xlabel('iterations (per hundreds)')\n",
        "plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "HIjrc6QQoj_s"
      },
      "source": [
        "**Interpretation**:\n",
        "You can see the cost decreasing. It shows that the parameters are being learned. However, you see that you could train the model even more on the training set. Try to increase the number of iterations in the cell above and rerun the cells. You might see that the training set accuracy goes up, but the test set accuracy goes down. This is called overfitting. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-YWj-Xa1oj_t"
      },
      "source": [
        "## 6 - Further analysis (optional/ungraded exercise) ##\n",
        "\n",
        "Congratulations on building your first image classification model. Let's analyze it further, and examine possible choices for the learning rate $\\alpha$. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZFRnSvC9oj_w"
      },
      "source": [
        "#### Choice of learning rate ####\n",
        "\n",
        "**Reminder**:\n",
        "In order for Gradient Descent to work you must choose the learning rate wisely. The learning rate $\\alpha$  determines how rapidly we update the parameters. If the learning rate is too large we may \"overshoot\" the optimal value. Similarly, if it is too small we will need too many iterations to converge to the best values. That's why it is crucial to use a well-tuned learning rate.\n",
        "\n",
        "Let's compare the learning curve of our model with several choices of learning rates. Run the cell below. This should take about 1 minute. Feel free also to try different values than the three we have initialized the `learning_rates` variable to contain, and see what happens. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "ZGnAIAVDoj_4",
        "outputId": "bef26a2b-dd51-45bb-82a8-d843df0c97df",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 761
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "learning rate is: 0.01\n",
            "train accuracy: 99.52153110047847 %\n",
            "test accuracy: 68.0 %\n",
            "\n",
            "-------------------------------------------------------\n",
            "\n",
            "learning rate is: 0.001\n",
            "train accuracy: 88.99521531100478 %\n",
            "test accuracy: 64.0 %\n",
            "\n",
            "-------------------------------------------------------\n",
            "\n",
            "learning rate is: 0.0001\n",
            "train accuracy: 68.42105263157895 %\n",
            "test accuracy: 36.0 %\n",
            "\n",
            "-------------------------------------------------------\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "learning_rates = [0.01, 0.001, 0.0001]\n",
        "models = {}\n",
        "for i in learning_rates:\n",
        "    print (\"learning rate is: \" + str(i))\n",
        "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
        "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
        "\n",
        "for i in learning_rates:\n",
        "    plt.plot(np.squeeze(models[str(i)][\"costs\"]), label= str(models[str(i)][\"learning_rate\"]))\n",
        "\n",
        "plt.ylabel('cost')\n",
        "plt.xlabel('iterations')\n",
        "\n",
        "legend = plt.legend(loc='upper center', shadow=True)\n",
        "frame = legend.get_frame()\n",
        "frame.set_facecolor('0.90')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oiJKbVeLoj_6"
      },
      "source": [
        "**Interpretation**: \n",
        "- Different learning rates give different costs and thus different predictions results.\n",
        "- If the learning rate is too large (0.01), the cost may oscillate up and down. It may even diverge (though in this example, using 0.01 still eventually ends up at a good value for the cost). \n",
        "- A lower cost doesn't mean a better model. You have to check if there is possibly overfitting. It happens when the training accuracy is a lot higher than the test accuracy.\n",
        "- In deep learning, we usually recommend that you: \n",
        "    - Choose the learning rate that better minimizes the cost function.\n",
        "    - If your model overfits, use other techniques to reduce overfitting. (We'll talk about this in later videos.) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "BpNa5Nfwoj_8"
      },
      "source": [
        "## 7 - Test with your own image (optional/ungraded exercise) ##\n",
        "\n",
        "Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:\n",
        "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
        "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
        "    3. Change your image's name in the following code\n",
        "    4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "scrolled": false,
        "id": "auLckr21oj__",
        "outputId": "33704c2f-4955-4937-91b6-e2b86c31fc66",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-25-ccbbba68c486>\u001b[0m in \u001b[0;36m<cell line: 7>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# We preprocess the image to fit your algorithm.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mfname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"/content/drive/MyDrive/Jobs/Picture/IMG_5143.JPG\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mmy_image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mndimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflatten\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mmy_image\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmisc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimresize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_px\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnum_px\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_px\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnum_px\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mmy_predicted_image\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"w\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"b\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmy_image\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: module 'scipy.ndimage' has no attribute 'imread'"
          ]
        }
      ],
      "source": [
        "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
        "my_image = \"/content/drive/MyDrive/Jobs/Picture/IMG_5143.JPG\"   # change this to the name of your image file \n",
        "## END CODE HERE ##\n",
        "\n",
        "# We preprocess the image to fit your algorithm.\n",
        "fname = \"/content/drive/MyDrive/Jobs/Picture/IMG_5143.JPG\" + my_image\n",
        "image = np.array(ndimage.imread(fname, flatten=False))\n",
        "my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((1, num_px*num_px*3)).T\n",
        "my_predicted_image = predict(d[\"w\"], d[\"b\"], my_image)\n",
        "\n",
        "plt.imshow(image)\n",
        "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4caRuBnRokAA"
      },
      "source": [
        "<font color='blue'>\n",
        "**What to remember from this assignment:**\n",
        "1. Preprocessing the dataset is important.\n",
        "2. You implemented each function separately: initialize(), propagate(), optimize(). Then you built a model().\n",
        "3. Tuning the learning rate (which is an example of a \"hyperparameter\") can make a big difference to the algorithm. You will see more examples of this later in this course!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dnj2G4krokAG"
      },
      "source": [
        "Finally, if you'd like, we invite you to try different things on this Notebook. Make sure you submit before trying anything. Once you submit, things you can play with include:\n",
        "    - Play with the learning rate and the number of iterations\n",
        "    - Try different initialization methods and compare the results\n",
        "    - Test other preprocessings (center the data, or divide each row by its standard deviation)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dtxTTUFfokAJ"
      },
      "source": [
        "Bibliography:\n",
        "- http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/\n",
        "- https://stats.stackexchange.com/questions/211436/why-do-we-normalize-images-by-subtracting-the-datasets-image-mean-and-not-the-c"
      ]
    }
  ],
  "metadata": {
    "coursera": {
      "course_slug": "neural-networks-deep-learning",
      "graded_item_id": "XaIWT",
      "launcher_item_id": "zAgPl"
    },
    "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.5.2"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}