codes/course1/Logistic Regression with a Neural Network mindset v4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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",
   "execution_count": 22,
   "metadata": {},
   "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
   },
   "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": 23,
   "metadata": {},
   "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": {},
   "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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = [1], it's a 'cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 2\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": {},
   "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": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": {},
   "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": {},
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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],\\\n",
    "                                               train_set_x_orig.shape[1]*train_set_x_orig.shape[2]*train_set_x_orig.shape[3]).T\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],\\\n",
    "                                               test_set_x_orig.shape[1]*test_set_x_orig.shape[2]*test_set_x_orig.shape[3]).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": {},
   "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": {},
   "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": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x = train_set_x_flatten/255.\n",
    "test_set_x = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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",
    "<img src=\"images/LogReg_kiank.png\" style=\"width:650px;height:400px;\">\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": {},
   "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": 46,
   "metadata": {},
   "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",
    "    if z.any() >= 0:\n",
    "        s = 1/(1+np.exp(-z))\n",
    "    else:\n",
    "        s = np.exp(z)/(1+np.exp(z))\n",
    "    ### END CODE HERE ###\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid([0, 2]) = [0.5        0.88079708]\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))\n",
    "#help(sigmoid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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": 30,
   "metadata": {},
   "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((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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": {},
   "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": {},
   "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": 32,
   "metadata": {},
   "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": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dw = [[0.99845601]\n",
      " [2.39507239]]\n",
      "db = 0.001455578136784208\n",
      "cost = 5.801545319394553\n"
     ]
    }
   ],
   "source": [
    "w, b, X, Y = np.array([[1.],[2.]]), 2., np.array([[1.,2.,-1.],[3.,4.,-3.2]]), np.array([[1,0,1]])\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": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table style=\"width:50%\">\n",
    "    <tr>\n",
    "        <td>  ** dw **  </td>\n",
    "      <td> [[ 0.99845601]\n",
    "     [ 2.39507239]]</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** db **  </td>\n",
    "        <td> 0.00145557813678 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** cost **  </td>\n",
    "        <td> 5.801545319394553 </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 34,
   "metadata": {},
   "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 = propagate(w,b,X,Y)\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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.19033591]\n",
      " [0.12259159]]\n",
      "b = 1.9253598300845747\n",
      "dw = [[0.67752042]\n",
      " [1.41625495]]\n",
      "db = 0.21919450454067652\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": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\">\n",
    "    <tr>\n",
    "       <td> **w** </td>\n",
    "       <td>[[ 0.19033591]\n",
    " [ 0.12259159]] </td>\n",
    "    </tr>\n",
    "    \n",
    "    <tr>\n",
    "       <td> **b** </td>\n",
    "       <td> 1.92535983008 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **dw** </td>\n",
    "       <td> [[ 0.67752042]\n",
    " [ 1.41625495]] </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **db** </td>\n",
    "       <td> 0.219194504541 </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 36,
   "metadata": {},
   "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",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    for i in range(A.shape[1]):\n",
    "        \n",
    "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
    "        ### START CODE HERE ### (≈ 4 lines of code)\n",
    "        Y_prediction[0,i] = 0 if A[0,i] <= 0.5 else 1\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    assert(Y_prediction.shape == (1, m))\n",
    "    \n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictions = [[1. 1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "w = np.array([[0.1124579],[0.23106775]])\n",
    "b = -0.3\n",
    "X = np.array([[1.,-1.1,-3.2],[1.2,2.,0.1]])\n",
    "print (\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:30%\">\n",
    "    <tr>\n",
    "         <td>\n",
    "             **predictions**\n",
    "         </td>\n",
    "          <td>\n",
    "            [[ 1.  1.  0.]]\n",
    "         </td>  \n",
    "   </tr>\n",
    "\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "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": {},
   "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": 38,
   "metadata": {},
   "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",
    "\n",
    "    # Gradient descent (≈ 1 line of code)\n",
    "    parameters, grads, costs = optimize(w,b,X_train,Y_train,num_iterations,learning_rate,True)\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": {},
   "source": [
    "Run the following cell to train your model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.823921\n",
      "Cost after iteration 200: 0.418944\n",
      "Cost after iteration 300: 0.617350\n",
      "Cost after iteration 400: 0.522116\n",
      "Cost after iteration 500: 0.387709\n",
      "Cost after iteration 600: 0.236254\n",
      "Cost after iteration 700: 0.154222\n",
      "Cost after iteration 800: 0.135328\n",
      "Cost after iteration 900: 0.124971\n",
      "Cost after iteration 1000: 0.116478\n",
      "Cost after iteration 1100: 0.109193\n",
      "Cost after iteration 1200: 0.102804\n",
      "Cost after iteration 1300: 0.097130\n",
      "Cost after iteration 1400: 0.092043\n",
      "Cost after iteration 1500: 0.087453\n",
      "Cost after iteration 1600: 0.083286\n",
      "Cost after iteration 1700: 0.079487\n",
      "Cost after iteration 1800: 0.076007\n",
      "Cost after iteration 1900: 0.072809\n",
      "train accuracy: 99.52153110047847 %\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.01, print_cost = True)\n",
    "#d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 20000, learning_rate = 0.001, print_cost = True)\n",
    "#这么修改一下之后train集合的正确率上升了0.5％，但是test的集的正确率基本没变，或者变了但是低几个数量级。\n",
    "#可能是因为下文提到的“过拟合”吧！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\"> \n",
    "\n",
    "    <tr>\n",
    "        <td> **Cost after iteration 0 **  </td> \n",
    "        <td> 0.693147 </td>\n",
    "    </tr>\n",
    "      <tr>\n",
    "        <td> <center> $\\vdots$ </center> </td> \n",
    "        <td> <center> $\\vdots$ </center> </td> \n",
    "    </tr>  \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
   },
   "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": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 1, you predicted that it is a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO19baht53HeM/vjfN6rr9hSL5apEhBuTKjlIBwHl6BYUVDdEP1yiSFFLYL7xy0OTYnkFgopFFQKIf1RCqJxI4ib1CRxJUxIIm4iSiE4lms7sSM7cl3XVn2tm8j6uLrnnP05/bHXOeuZWfuds8655+594zUPHM5a+13rfWetvd69Zt6ZeUZUFYlE4vsfvXULkEgkVoOc7IlER5CTPZHoCHKyJxIdQU72RKIjyMmeSHQE1zXZReRhEfmaiHxdRJ44K6ESicTZQ07rZxeRPoC/BPAQgJcBfA7AR1T1L85OvEQicVYYXMe57wPwdVX9BgCIyG8BeARAcbL3ez3tDxZDiohp433bApR+jvxxIU508PV20vIHNDpMijtRU7GTU19+dGIgv5rG08mhwZ4F9+qO0+UtDTla3sdjLrp41Jk8OaZ/d3eql/Z0OsVsNls63PVM9ncA+Dbtvwzgx6IT+oMB/tZddwEAhgM79HBY7/sfAtU57ZUfHHOe+LYebUdSliEo929R/spYk9J5+ZGQHl+nHazXr6+l1ytbYvYHtPzj2rhXba+TrmU+n5umObVJ4boacrjbwX3YZ8DJS314TZXl4u3onvrnj2+Cn2TmHhh57XH2B7p8U/k0/3zMaH8ynZq2w/3vXv5Ose/rmezLJG485SJyEcBFAOj3+9cxXCKRuB5cz2R/GcA7af9uAI2fFVV9CsBTALC5uamHbyL/RhLab6rxhV//8g+weZMv9pdcwRLYX3X/FiqcpF6lqrfnrm1Gv8ij8bjYZt7KbuDhcHi0vbm5adr4vvI97XmzydzvwKSK3kL2JNtHy/54bG1oGKHivbSt12v5RQd9hGOVrQR3zU7jaml78e2Zu8F6tO9fnF6zWobrWY3/HIB7ReQHRWQDwM8BePY6+kskEjcQp36zq+pURP4pgD8A0AfwCVX9yplJlkgkzhTXo8ZDVX8PwO+dkSyJROIG4rom+2lwaGt42yqyDYstzeX4ZZvNg6PF5nAFu97WwA0ym8+OtifjiWkbjQ6Otvf2903bZGJXWOtxvc1ef23bW9u2baO25wfk8Rg470evV9t83v6TfnmFnBHFaEjRBm4Y5qUW84kZyY8bmNhmvYDXiU7Qh12b8KeZhaLl23H37troHDdHelLb5T1ngffm/WrY8kgZLptIdAQ52ROJjmClaryIBGo8bTulZ04+GZXlwRqL/WCv4Ppoxk+U1XircNXbs9nMHHVwUKvq+3tWVT8gNX42teeVgjK8sjwlF93UBVewW47Vc/4cADY2No62vfuOIXN2a5XfDY0gkoK7LbrfEdqqwa3j7BoRnG3HLvt7o2fYyujuVcF/572Ic63vf98HIA36TSEc8s2eSHQEOdkTiY4gJ3si0RGs1mYH0K/svighomGLs63IYYHePgmSO6xt1TIJJADb1+PRyLTtXdur28a2TWfkPgnsqyknbTQSgyghwrnr5rPl5x30rBybZLPzOQCgW7QuQvfeJy+hYJcDLmzXxpGWuohTxcy6jTssWN8oddh8dIK1mtCeL7jbotRxH3JbWIeKXJH+Nd2vxoue3nyzJxIdQU72RKIjWG0EnciRWiji3A8ldShqCwkwokwu2ztKu969Qar1bFJHxnlVfTqxUXOMPuVNz3wOOOUrcyqzd8Hwrs+qQ0H9V+ce1CD3ejKt5TduObUuOlbxfYSeUWN7ZfU5DKEzLildtrk4jL9bn4EYRlWyiJwt2C7Dzu+FLkCWq2GGLH+mvRRWLPue7rdgnMo3eyLREeRkTyQ6gpUnwhRXoI0mU45SUkMKECzflrtoHbXlqZBYPd/bpxX3kSWhaAuvgk9pVdwGVZX12wYpBd8ro6q7sUmt54g/wKrxvFLvaZIGlJDjIyKVovfaK8VtG0N9P+iOk2LKZt5xMXOlkWNVPeixZXRnwTlRHSvm/zLkmz2R6AhysicSHUFO9kSiI1i5zX5oUzQyf6JMtLBt2VHL7Nx2djrbXT6jjG3b8UHtbmOyCsBe27xBF10mFzf2d9nDCCWDzXfPpug8sBNn87KjaDpfTt3t1zA2deto27veBpxk15o30l9o6TifNRZERJr72I4uOsQpi6ogcA+WIz+D9Qd/D1qsQ+WbPZHoCHKyJxIdwcoTYY60jSZJOG0GbW0TJ1rmMvjoMeZu9wku0wm72Dh5wYIj7Zo8beXItSLnuVPRrHpeVgnZhPBdG8260T8l+VCizcB10qcIuslww7QNh7Vpw/333Pfu6dVNW+HL1uDZ8ffDjB1w5avpvyxT5PWLqtuoPbDYZ4Nvnvs4rQlRId/siURHkJM9kegIcrInEh3Byl1vZd9ZkM1mzB0mKmjpLvEIqo+Oqf4ac7z7Y9uOHNlZTWue3Vz15/2GS4oIMHyYqhmv3b1qrjmwrV++Vxw+PPGZf0SOEZFcWLdq2zDY9kZ127p1vIYkrv+gHqvjqwjkCl3GyzPdmr2V1xXa2PPHvtlF5BMickVEvkyf3SEiz4nIS9X/248dKZFIrBVt1PhfB/Cw++wJAJdU9V4Al6r9RCJxE+NYNV5V/4eI3OM+fgTAA9X20wCeB/D4saNJWZWK6eNYzQkUHZN0VNabDAmFi5Jj99rcET5whNuMI9WcehtxvvP1D/r2t3Y84fHK6icTYPSdGj+ZMnlFfVyD1522o1Jc3MfUcdXN5rUar2L58fsUUbdF3ffcNfdB2XFB5CTjtB4ovgfN0tF0XKMt4LhrKYslYAnaTN+2czavfDRjLUhZoNMu0N2lqpcXg+plAHeesp9EIrEi3PAFOhG5COAi0KxKkkgkVofTTvZXROSCql4WkQsArpQOVNWnADwFADs7O1qrT9e/chlR8vpG3mO12/PHjWg13qu+fapuSgU1G8cZdcuKaFT3aO3ZaNbuwGG//toaJkTbSDAey1cLpZJPrHVPPOV0YK70+7Va3yMiCy475fuIVtLt53bfqOfwbWav3Ddr2Q3rcPlq+aKtcJMjVT0wVzTwFGkYmXk8TqvGPwvg0Wr7UQDPnLKfRCKxIrRxvf0mgD8B8C4ReVlEHgPwJICHROQlAA9V+4lE4iZGm9X4jxSaHjxjWRKJxA3E6iPojlB2fURRSgyf/GR5IcpuOe7Ql1tmwoqBK1HMhIsTKrccudd89FuPrm3i3H583ZxR5o1vdrt40krO7FLDQ2/tP3apeQKMfn+5wjebeXcPt9n7OKK1kI1xbaf7MtVcVlrVjlsigRQ4OaJwxlJEYVBiOlxMaYlm5mZZSLbF54VtIF6bqDn8y+NkbHwi0RHkZE8kOoLVqvGqtWoZUIA1vSIlF0yQZOI0PVZjOTJOnarEKltTjaq3uXSTl6JIQuHkmDr9mVX+jUE5ci2KpOpLn3bq47wGbkpDOZV2OChwvgfqrY8GZNuAufs2N7fMYX0aq9frmzYp+MMi882jfJ1l5pPQKgja2vLH+WfOqO7Kz1XZ1Gi6Do9Pzco3eyLREeRkTyQ6gpzsiURHsFKbXVHbJFFJ5ZgtkuwWZ7yZUFEfLkt20YRCYieuvLLJiHP2MNuytu8yqWTjOoPyxZvDun8ea+rcWoZcwv1cK7mlxLjy/P0mskjX/7DP2XKmczdWOTR3Slz6yoQgLjx5e2cHJZRIGr29GoXctvebRUQf7YjvS3X2/H6jzkDj+an6k7IrspG1J/b/MuSbPZHoCHKyJxIdweoj6Cp1pqH4NvwpNc7CBcNqFJckHjfUeOY777k2VsXKkU6GGKJvhZzNylFcxu3C23OvEpKq7qLO5oafrkfb4o4z4YZW/sJXEfXhI/R4l69zOrblrZnHzpeQ6puyz6QiR9FpjWegRIARRNA1cLxby/fpXaLGVevdvQWikristFfxj5c13+yJREeQkz2R6AjWSCVdXq1srGSWEiICHrEmfxfzztWqul/pZhXLr3TPJhT9ZhJh7FgbpH56OcaU/OIj4zjxZt6v2wYDK8hsTNfio7E4qq3HRAhebWUeO9Nk1PVZwXQBLMGGf2vMTFYSJf84NZ4pqDe3bHRdUb31WvzyoVwPFk0qZjon1NrLJ7YlnmgkehXMragUVKN8VQtLI9/siURHkJM9kegIcrInEh3B6ks2V7ZGk3+7bLNzm8liOgFBALvUprPabm5mILHdZckl5mRjc0Ta0LmMOANs7MgaZvOyHc2EGBzFNnDuuzF7mtytYpuPu5/5zDbKiNsY+mwzGmtc3wNPUFGyNQFAZzweud4cYcf+/l4tx9a2ldGwEdN7KSghFWWz2c1y1GOIMIqQXaf+xLJLzbpI+TpdD20M8wD5Zk8kOoKc7IlER7A211uT37scfTQn9aUXJfAHiQisglt1tByGN3Uq+Aap1ttbNa/a9qblQmd33sy7vAIetGmBEIMjyRZ9TKitnCwxIvl77l5tUKJNiXMOcJFfQaRdg2uPTI/xlF2WNmLxrbdYjbdJMZubm3V/veVJSCeBVfbbq8Qm2DBIcAlJNEh173uSDlLdY4KKshxtkG/2RKIjyMmeSHQEOdkTiY5gtTa7SG2HNDwkQbhswT5pWOyBTTOmUszjcW03evIKDlHcdHXJzu/UNuTOdr3t3TjTa54PfrnUjVLMZLuZunKerIF7824cU956ed+L/su/8wcjzgosX4sNMXUhw+SOVGGb3a7HcLjs/t4103bu3Lmjbc6Ia4SRtvS8WaPXHRfWyIuIKktjWRTdayjb7CdCCxu+Tfmnd4rIH4vIiyLyFRH5WPX5HSLynIi8VP2//XRSJhKJVaCNGj8F8Iuq+sMA3g/goyLybgBPALikqvcCuFTtJxKJmxRtar1dBnC52r4qIi8CeAeARwA8UB32NIDnATzeeuRG3V3+3WmXEdfg6ApUZBuhV3+8s7trDju/W0dxbQ1dZBxznJOMBxQFBsRqmcnfcyKyCj7ol78a8el4BHaV9QO+uwG583yG1sGkkJnnzauAm43NhLedr9Xxt/YOzHHsetu7ZtX4/T1yy22QG65/crfTQsLlJChAKy34qJfiLnXSc88muw69Gl+O/DyBSi/u/xKcaIFORO4B8F4AnwVwV/VDcPiDcOdJ+kokEqtF6wU6ETkH4HcA/IKqvtl2IUFELgK4CPhY50QisUq0erOLyBCLif5JVf3d6uNXRORC1X4BwJVl56rqU6p6v6re7znGEonE6nDs7JPFK/zXALyoqr9CTc8CeBTAk9X/Z04ycKQZNF1ty2129XZX1AeNd+uttxxt33bLOXOYYQoJMqPm5LKbTMs84L4G2tZGbbtdOyiXHjbWsLP/2I3myyibysPmvLL7zoeO2lpyZWPWh8iWj6u3z5+zIbEzyoK7tm855V977bWj7a3t7aXbCyFbiVF2wx0HLa992DLhFNbtXZ28jhOsuYRiRGw6VVt0VW1etR8A8I8A/LmIfLH67F9iMck/JSKPAfgWgA+3ETiRSKwHbVbj/yfKPxgPnq04iUTiRuGmMaKlrYoVEVMGhH+8PxxSZFwQnebJJdiVxWQY3m9ju7RtUdaeKRFE6rk3BViOiYtI65Pqzq6xRtQW3WPP+T4vqO6eoILlCqpUmyxGdqEBwLndWq0fuWi9g/39o23rhrORjUYtjlR6Q14R6OPBeRF5hSHz8JmKgTu2vdvvdC7HI5mu6+xEIvE3BjnZE4mO4KZR41FI4ABgVffC5751NrMqISe/cDJGU/2s+xiPLMf59nbNa94jfjpPttEz6qLrPSBC4Gi1Ca1Sb27YrykyNXrkoWCptl00IBNleO58HoAj4bYdV53nrrN98HdGq9ROvWWVfNdVdH319TePtr/3vVfrcxxZyNZ2fV5cHZgbgg+8IwfcVM60CZNdAs9FqSkiCzkFd0W+2ROJriAneyLREeRkTyQ6gpvHZidEZA02Ysnaylz+19vbzFc+HNb9HxzYLCx2jRn3GoDRqD52GLhjLEGF/T1ld5UnlGCbnfnmfY01y51fNt6GZB/7sSbk5joYu7LVtAbB/PXeRudrkcCINC5Rb4eSjJxxCAB79B2+da12vb119S0rx2BI2+6RNlzrpW0fXBddi93n76J3ahKK0sPULvuT9yNbPt/siURHkJM9kegIbho13hBPNBuPwCrmzJUSukbkB/tOPVdDDFGrjlPnomM1yJdd4lLPrOp5TnbWvhpRZ1R+eXvT3v494n5jlb7pXqP+AiIELkvl1b59UpF9iSoxfRDpQoMshGTy5Z9oPONGtNIaV5z/3u+4rU5Y+n/f/eujbU6QAYCtrbpXdsMBME84J+547j5jGvkouUA3LpduKpOneBhTLCz7fHKeRiPrsUckEonvC+RkTyQ6gpzsiURHsFqbXbW2SU7Lj00YObv86lu1zd4oL0zD9TiLbGptHSai6Iu7PXQa2+kNm13MIoNpYjca11sDrM137aC2373NzvaZ539nM29g6q258GHa9/IPjMuOapS5NYwBE300yCjrNl7rmLjMtjmHm7rbuLtTu+LedsdtR9uvvva6OW6P+OYbYapKIc5RHTVDWlJef/DnmTUHXtMoL+MsWxQ42mQ7PbTZG+l3etRSQr7ZE4mOICd7ItERrNz1VlIyIqWetR7OZvNq/IRKPHlNyZQ9DtQyzmDzJA6bxP3NLjTv9uAyzZ5vrE988LO5jVzboTLQ3MfEqeBDo/57FXy5C4lLOi2Oq/vY3bKsv1ze2rjUnOuN75V3vVmmiPo8X24LdD/2R5aDrneu5vS/9dbzdR+u7POMTIPZ2EZOol9fm05ZzfYlmOr7ETmxvJnA7kgb2VhGo5x4QXWP3GkN8o2jscszKd/siURHkJM9kegI1hdBF2Tme+VlTqo7lwgaObWP1aiIV41X3BsrnibRpiH0MnEbl8L9q/s95RJSM5esw6rwFhFWvLk3Kh7nk2RAaiaTUvjjbiVK5y2X4MKUziyvT6YpkVwsYDitazmcCm4jAO2N5CSlzc16VX3TFRvh1X5Rt1puPCP0vcz9tZSJOEyyiyPfsNzd3J/vhZOB/Cp7vW9SdRpeHjonI+gSiUQJOdkTiY4gJ3si0RGs1mYXKSb12ygl2zYmd8qbV68ebc9ctla/x9FMLmNtvpzM0Zd4ilwfnInGkWVBQBT2x9be3u7VtucsiIzbIjfcVWez85rAbOblZzu9bttwhJPndupMsUZUG3XJhJB+fWM64SxAT7CI5W3uZo0P9umwMkkjrz80SnWbKlfl6DezHhPUFfDlsPqGH99nGfJgKO3Y/v06S4s54fcbNvpZRNCJyJaI/KmIfElEviIiv1x9foeIPCciL1X/bz+ur0QisT60UeNHAD6oqu8BcB+Ah0Xk/QCeAHBJVe8FcKnaTyQSNyna1HpTAIekX8PqTwE8AuCB6vOnATwP4PHj+jtUzRoqCm87NYfdNUxY4dVgVlV7Pesi4QgyVlu9BsUuurGL9hItJIg49XOHEjgQuKsa94Aue3O7di9tuwg3Lvkkji+tVLrp3M6W2ecIur09G4lo+qAbtO9chUIC9/uWlqJkrk1d1Vn22DmvmfkOh1Q2qtdzHPj8fbr7PTcccfRMOFehKeMUJbsEda64j/nMf7dsJrjzCv5en+wSudfa0Mi3rc/eryq4XgHwnKp+FsBdqnq5EuIygDvb9JVIJNaDVpNdVWeqeh+AuwG8T0R+pO0AInJRRF4QkRemLsY7kUisDidyvanq61io6w8DeEVELgBA9f9K4ZynVPV+Vb2/QfObSCRWhmNnn4i8HcBEVV8XkW0APwXg3wF4FsCjAJ6s/j/TZsCi3cEJ/I4EElq7XUy4qXMZsR06dCGgfUMMUbuyxpOytuE9JCNyNY3G9XlbG3asXcrk2nChnXz1PoOK782A+vD29mhEdeYaLh4iwiT7kokgvCTejjZhx5zB53rYJqLHvlsjMVGqLJMnhohITJgklO7jYGhrvQ03uXafc5vxOg69bLz7ju+iX4MpZbYBvnbffOk2YNdB1LtcC3vN7Dj+bn09gsP7X76fbV61FwA8LSJ9LDSBT6nqZ0TkTwB8SkQeA/AtAB9u0VcikVgT2qzG/xmA9y75/FUAD94IoRKJxNlj5Rx0RyqMd3lR5NfYkVJMKWKMSxp5UocZqT0bTt3a2CASA/rckwCMKFpv6so/sZnAbr/xviufJLX853ctj/kWyTFx0XUsGKuLW65EsRnLqeCmhDARWfgIujFlDHpzxZhDnPXmzAnu00fXsZLJqrUrDm3gI9dMGW9Spb1blct5NdxmpiRTeYkqymyLSjkZshMmoXAciCF/nOmv3MYm7NCZh4ekKF69Z2RsfCLREeRkTyQ6gpWq8Ypa7fHq595+XaVz5tRbpdX4IXG/9Rzd2D4lVfg1zk1Sny2ttE96YHpkVyKIySWocqgPquLoOs/91qNVdq+KcTfzoNSPMScizjGTrFNW9z3vxA6p6+wunc99Akq976m7Wf7ZLEguMhFjtv/NHTIh6Jp9lOBi7bh53GGvza3mHnsTGqpwQBrB6rqN7vT3m+Utl56KPufnxZsyUWTf0TnHHpFIJL4vkJM9kegIcrInEh3B2uJXJ1NrcF+9+ubRdr/hPqm32Q21u2kzrd64Vtv9ewfOrcXliGZcjsi5zcgka5R1IvTJDbLh7CV2Se2PrXvw1dfeoD1r/+1SRNqmFg8DX0uD8IF3gvLW7F5iogzA2oZzWreYukyuEa2tHDh3qbHZyX7d3vQRhbSu4G83E5rQPe65A7WQpQc416papyuj3y8Tn3D/Pr+Dnx+brVm2y09b+GwelPE+7DQsL33KcROJxN8w5GRPJDqC1avxlbox99Fv7LZwis4mJbVwJNJww0UR7de/XV59ns+Xu+W8C9Coiw03DvXH7iTnBmFVanvbRp29/ub3jrYn3l1F6uk5F3nHMK6heVl+dh32+q7EE7UdjK0coym5QVld9OWwNsrmStHd5ivGclTYwL572Nzi730wGBaP85F87KZEoErzPfWaMKvuDbOPOd9N/2W3bRyRR89mwJPXQIEUhpFv9kSiI8jJnkh0BDnZE4mOYMU2ux6FF3J5ZcDaTCNXdpfDZdn22XQ2uyVdsHboeFzbO+wa82GNPfr989aPCWclt5aLiDV29PbAurVuPV+XIX7jrT3Txjz4LFdj5YBtw4BrnT2CfWfnvvl6zb//vTetHPOCiX37refMcbecr8so+2jNEZGCsBt04rj+hxSOO3RMRmwr8/bQkVdE37v2OQy2bFPzGsNs5td7ltvlQHlNwKPEX199srT/yAWYtd4SiUQROdkTiY5gtVlvcz0q9zN2HOQzU94n6IO0Fe+J4MivLedSM2WaC4QDi7HbcaKZ88T2MWLetn2rIp/bqV1qA5dudkDq7nRc2wb9DceJRqp7M8eLOeMo+m1qZbx6bZ/OcWDuN5Lx1vNWjd+gaLiNsX2Ueo0Szgt4Nd5z9DG47BfzEnryBx6rqYLzc8XmmyeXYO75cnRdBG8amP7NWPNyWxsCeCx5Tlucl2/2RKIjyMmeSHQEq1XjVY8ikPpOzWN10WsorOptUlVRz0PfJ2II9VkVQpxrpCsNHTeb4SkLluOjVVPu33sd+FBP7zygUk5TUmE3hzYKj7VMn6zDBBC8QusTVZguecclFMGswNcr7kwdDQCj/brPqaPkZqthEkS4jam0l3qvBvcXFBhhqmcVq3LPC1F4jYSZ4Pu08OcFhzIK/IK+T0sycoLyT7kan0gkDpGTPZHoCHKyJxIdwUpt9l6/h93ztwAAps6W3dqq7dL53NpnbI6wXc7bADAl+2zDca1vkL3JNpO3BQ8Mn7rPMlpuF80dmWPP2H/22D6XCPL2/Jyzq+rt+dy6pwa0HiGNjDuSi65t5Gz2c1tcTsneR97fIHt+tL9vjjvYv3a0PXauvQNysTG/fyMbTMimDog12Q03dZlnPjrQDsDvM44u9Flp5RJPFt6ONr0s2VomU7lLSxIadXJcp020frNXZZu/ICKfqfbvEJHnROSl6v/tJxEtkUisFidR4z8G4EXafwLAJVW9F8Claj+RSNykaKXGi8jdAP4BgH8L4J9XHz8C4IFq+2ksSjk/HvXT6/WxvbOIwvJRUKYCplOfZ+SemdK25+Ha3KhVzp1z500b82zzeaMDq5qK1Aki40ZCznJCBu/mM1Fs4hNV6m1frZavjbnnZxNHcmHUTJfQQdfG6u7Ucf7tbNaRfENXhZYTka6RWTMaWV6/KZc7cu8NVkE5ycRHDfYC9XmLTIjNLXY/+uix5YkkjSNbJhBF/cfacomjftkHJZRNQOui8xx0Z+d6+1UAvwSAZ+Fdqnq5GvgygDtb9pVIJNaAYye7iPwMgCuq+vnTDCAiF0XkBRF5IQqMSCQSNxZt1PgPAPhZEfkQgC0At4jIbwB4RUQuqOplEbkA4Mqyk1X1KQBPAcDu7u6J1hcTicTZoU199o8D+DgAiMgDAP6Fqv68iPx7AI8CeLL6/0ybAQ9tI2/L9igjydvzTFYQcXj3B+yWs3YoE0OMRrUbKnKbMRniYmwKy5wvt98XfbKv0F5nn2vVuesckB15QK4sb9szkaSvR6d0nRzCOnQ2qlKf05HLwiIbm8tlj1xIrPJ36GzG6YzdbXQOLNi9ubNjSTZvu+MHjrbZZu/7Omds3AZus2h9wMLXkuP+3ZH8XZdp6cN6cba/slSl9YfG2AVcT1DNkwAeEpGXADxU7ScSiZsUJwqqUdXnsVh1h6q+CuDBsxcpkUjcCKyBN76gPhnutHZcXsNGthmpnw1+79nSba//cBacz6qbF8op+RLCLGMjK41cal495/FmZGp4njwezZd12t+v3WNvHdT3YHcriDILMCVX3jwoaeRJKWYzH324HGx67Z637tLhBmfZkdvJ9XGa0kpelY4430M7xPZK/bc6rNpdfrCXQwM7oTaPAzMmECmRSHwfISd7ItERrK2K60kIAkpUu3ArzFzdU+FUX1LBeVV20xM3kOro1SuOqKLTBZUAAA9zSURBVBtz1JZTWeeBrieUvOMjAJm8gj0BPtprOi9w4QE4mCyno/ZUz/b220YuqyWkZk/2bATd/oijGdup7Q0qZiIm8RTRjIhG2Q1QPC+KtLN9lJsaGj53z6ZAFEIXRMZFg7f3HyxHvtkTiY4gJ3si0RHkZE8kOoKbxmaPgqCMiRaaPpzV5FtLl2rtRCYPmDp3EoPdd1NYN58EZXfZlbXjyjlzVNsGEz44kg4buWbl4vu6NWQCTnscu+W2tm1E2pAi1PaI33/ksu/alyMqEzJEpZINQSTzgDYO5M0VR2QbO53lDULogha7xHC215Jv9kSiI8jJnkh0BKtX44uaSaTmkBpofB3lHtTZAtZ7xe4vlwhDKvNQPCHD8kqfXLoKsNxvHhxZpu63dnO75pFndf+Nq5ZgY2NQdiFxlNv5ndqNOBw6VZ3clJueD55KT40nzBHn3ZnLS015uRRldZ/dj3N195HdpZyE1Eg8oiqrLZ+j2I/lH6yWcXkRAUaItup6RGxxPPLNnkh0BDnZE4mOICd7ItERrM311nQZlRstR0LBfl98QpvlkNsel1h2oahcG6zn2jgrbTCoXXbDoS//y7Z92X03ceGyG/Tbu7NbZ4C9cdWWfX7rWr3vusAGhbpuE+lmr+fKHE9ZRldyerI8tHjDhbOOUbvlZs5NWcrP8msMRfIHh9jNx/JHRJLmpPJgvfbvwJCosohyEcHSWoc/rel+zFpviUSiQk72RKIjWAN5hflXfxyoQ9alVnb3tAapab15OWPNk1KwW85my9njWHX3qpgUjgNsxhqXpr711lvMca+99kbdv9Pebr/91qPtAck4c6WmZhQBOHIq+LSQweY5+URqGUew/c8NR1/9ec9FljFZSFPlLkXhORcgZQGKM1dM8KWUjAu3V9ayl0R+Ln9uY9dYuZZAxA1vnkdvv+H4rMN8sycSHUFO9kSiI1i5Gn+opDQXD9upQHGVm4AsrNSpLwNE2pAvQ2XV0VqlHbhV6q0tqmA6Ka/2+3vA1NgT4tCbjG2iDV8nr74D1tSw0W/2+qfUx7TBF1e39YkK20cbDgdlFXxECTRsymxt2eSfnZ3deqyBfxyXc8v5b9JE0GmknnMWled3K+9JYbUcAHrkKooorSNvU0lEr5oz9fi88Twf/97ON3si0RHkZE8kOoKc7IlER7C+CDoHNlUavPGlwLiQfzvIfgrWBHqB3eVLRR1iY2jtZrZlfYmq8ajOYPN88EPqZ4Ncb71GWWYqgezs3P6AyCID2Zlv/sCVrd7bqyP0eO3A2+x8e3zmHJffmtI6xblz58xxbLP7kmDWxRaG19FRQWkl2j4J3amU7HJYkhQvf+sBSoI1okD52Sy7dEtoW5/9mwCuApgBmKrq/SJyB4D/BuAeAN8E8A9V9bU2/SUSidXjJGr8T6rqfap6f7X/BIBLqnovgEvVfiKRuElxPWr8IwAeqLafxqIG3OPHn3Z8YkJb6q1mosDJObsaUVuslvlIpznLWHbjsArbd/xx1lUmrq1W3fuBW4uH9lF4rJ6zjF6Ofp9Mhk3rDtulBJqD/VrF9+o+R+Ftuj52dmt1nZNkdnZ3zXEbzNPvTI15kR+/zHenLrKM1ewomSaM4Awi6Nomv0Q89eY5voEUem3f7ArgD0Xk8yJysfrsLlW9DADV/ztvhICJROJs0PbN/gFV/Y6I3AngORH5atsBqh+Hi4B9cyUSidWi1ZtdVb9T/b8C4NMA3gfgFRG5AADV/yuFc59S1ftV9X6/cpxIJFaHY2efiOwC6Knq1Wr7pwH8GwDPAngUwJPV/2dajdjGxAmyjkKbJrCLpOzfcEdSRlzPu9o4dDSwszistu8znGp7vudcNf7YQzTt8jIJJNuGnnyjDHvfBuS+2z1XPyLbOztFuZocjZyJVsvR+MGn4+buOk0fJKK3y2dEVNlwj5L7yuTsNb6z5Rz1Xo6TEUly9+1cgtEDblo8gUcLGdq8au8C8OnqggcA/quq/r6IfA7Ap0TkMQDfAvDhFn0lEok14djJrqrfAPCeJZ+/CuDBGyFUIpE4e6wt6y1CU4tvq8dHfS7PoIrQyHAyajGTM5zSFeRJL4x6Xo4KizjdyqZMSJRebOH+vfuOM//C8k+BGmyyxiw3hjnPRAO66DFW3X2moqunRH2Xzbe4nLiD+Z6o+xMRuy/v4yTPeptSURkbn0h0BDnZE4mOICd7ItERrNxmP7QsmhZN2ZV1Kis9cN+xDdysURZwz9OuKTU89zYk2+wu24zro/W8/bo8486zr7TPAGPXVcTc47MM293xkJnF1Hcznbuh6P74sGNeE+BrmTuOejpu4tmFCnXmmpfY9ikrW9XhqshZhMEG8rfpP9/siURHkJM9kegI1lj+KcoC8h+Q6huSV5T3DGlgW+qCshZv4SOujCZZzq5q9Fe8J171LQlyHF95W7Rzdcaa4/Lot5gYoiyGmhpg9rAePx8uCi/KdCshej7a9rGs16M+wuPK8kZDp+stkUgcISd7ItERrFiNl0BFaqd/xtoKr7IXm8wie0OeQOUsy+RVdW7zxBPlFVWhhA7biTsuFGy5+hwnCTkZix6Jdl4AP56pTBosI/vEoJLN1uAb4XJevirvnEtx8bCReeK+Tz25Ct5A29t42v5zNT6RSBwiJ3si0RHkZE8kOoIV2+x6ZA9F7o04Xqyd6yPiv4iscSnu2A9Yfs8REbl7eD9aLzBjRWQKjci1wrUF19JwD57CZD898WLdqSee6GG5Wy7KRoxsdruu0N7+1aDAYFtPXNvnr22Hfl3h8LmKTs83eyLREeRkTyQ6grVF0ElDV6LNQNUrkQUs+uSdlskjoR8rUL44oEst64JV433Z53ZEEdaFFrkHW4b5nUAFL5pN3mSIyi4Vb7cr8RQlQJH6zO6vRgkm6pM5+wFffut0yS6OLqR4bORWjegAy0QX7c2H+jkrn5Nv9kSiI8jJnkh0BDnZE4mOYPU2u5p/SxHa88d3XfXR7HX5SVEsauzAW36OcxOpZ1EMsrCKF9cwZssitWVTiGDkL9+P1hawuU5HCMmhtMF1BklvhvSDSTB9m18/sTLStmtrHzZt9optjYrkhRsZElS4xnkLl12+2ROJjiAneyLREayBg66KoAv43ZawV0SNyztpqOfcxSlS2xBpyGWijDAKr6HOla7tLAjMToDWUWERAcnyThoZgsGeMjf/nPX48rPTa0TX1Wr9dFrm+i+5d31Tk2++BKdmkwXR63mz7+S2l1fbz4y8QkRuE5HfFpGvisiLIvLjInKHiDwnIi9V/29vJWUikVgL2qrx/wHA76vq38GiFNSLAJ4AcElV7wVwqdpPJBI3KdpUcb0FwE8A+McAoKpjAGMReQTAA9VhTwN4HsDjx/V3FLDvx+FjYolO0eJXQwO1qaWVYE2B9mp2uNZfiKQ6Ne3ZirX/IqLbbfgFy0o9J8n0GqR/tOkr4xZC18JyVWeBhiVACT+O7pplbFB+cx9BgtVhVeHrTYT5IQB/BeC/iMgXROQ/V6Wb71LVy9XAlwHc2aKvRCKxJrSZ7AMAPwrgP6nqewFcwwlUdhG5KCIviMgLNk45kUisEm0m+8sAXlbVz1b7v43F5H9FRC4AQPX/yrKTVfUpVb1fVe8fDNbHXJ1IdB1t6rN/V0S+LSLvUtWvYVGT/S+qv0cBPFn9f+bY0RQ4Mr16zmYyfOotiQVOYG67tLpSF7FXruSCCewzb4eexjKMyv+eua0ZSxLstowGDMX17lKyZfmohvuu/KX1KAuOj1vtfbNorBdw+TBT0tudF/XR4nravmr/GYBPisgGgG8A+CdYaAWfEpHHAHwLwIdb9pVIJNaAVpNdVb8I4P4lTQ+erTiJROJGYaVGtKJ2ofgIur7xjbnzCgkGsccrIHxoG7HU8I2dRZbJ2aJhJpyBemp5708nB8O4jIJyWM1EmNpFJeyeakTalc0mw0XPY/lqrxFvoHnmItdvxC9fvpHGrahUHdhfJ8k195WD50lekUgkKuRkTyQ6gpzsiURHsHLe+MNsnZ6zOfQU9nDDnjQemHKjt4XMUWy7BeGbNyvalmyOy/+eamTfS90S1K2LYGxn455yI0f9F2rONcge2srVksc0Oi5KyGRbvMENP2eb3a45nFW4bCKR+D5ATvZEoiOQVUYSichfAfi/AN4G4K9XNnAZKYdFymFxM8hxUhn+tqq+fVnDSif70aAiL6jqsiCdlCPlSDlukAypxicSHUFO9kSiI1jXZH9qTeN6pBwWKYfFzSDHmcmwFps9kUisHqnGJxIdwUonu4g8LCJfE5Gvi8jK2GhF5BMickVEvkyfrZwKW0TeKSJ/XNFxf0VEPrYOWURkS0T+VES+VMnxy+uQg+TpV/yGn1mXHCLyTRH5cxH5ooi8sEY5bhht+8omu4j0AfxHAH8fwLsBfERE3r2i4X8dwMPus3VQYU8B/KKq/jCA9wP4aHUPVi3LCMAHVfU9AO4D8LCIvH8NchziY1jQkx9iXXL8pKreR66udchx42jbVXUlfwB+HMAf0P7HAXx8hePfA+DLtP81ABeq7QsAvrYqWUiGZwA8tE5ZAOwA+F8AfmwdcgC4u3qAPwjgM+v6bgB8E8Db3GcrlQPALQD+D6q1tLOWY5Vq/DsAfJv2X64+WxfWSoUtIvcAeC+Az65Dlkp1/iIWRKHP6YJQdB335FcB/BJsedd1yKEA/lBEPi8iF9ckxw2lbV/lZF+Wj9VJV4CInAPwOwB+QVXfXIcMqjpT1fuweLO+T0R+ZNUyiMjPALiiqp9f9dhL8AFV/VEszMyPishPrEGG66JtPw6rnOwvA3gn7d8N4DsrHN+jFRX2WUNEhlhM9E+q6u+uUxYAUNXXsajm8/Aa5PgAgJ8VkW8C+C0AHxSR31iDHFDV71T/rwD4NID3rUGO66JtPw6rnOyfA3CviPxgxVL7cwCeXeH4Hs9iQYENtKXCvk7IIqH61wC8qKq/si5ZROTtInJbtb0N4KcAfHXVcqjqx1X1blW9B4vn4Y9U9edXLYeI7IrI+cNtAD8N4MurlkNVvwvg2yLyruqjQ9r2s5HjRi98uIWGDwH4SwD/G8C/WuG4vwngMoAJFr+ejwH4ASwWhl6q/t+xAjn+Hhamy58B+GL196FVywLg7wL4QiXHlwH86+rzld8TkukB1At0q74fPwTgS9XfVw6fzTU9I/cBeKH6bv47gNvPSo6MoEskOoKMoEskOoKc7IlER5CTPZHoCHKyJxIdQU72RKIjyMmeSHQEOdkTiY4gJ3si0RH8f3e7PrD7GsNmAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture that was wrongly classified.\n",
    "index = 1\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[int(d[\"Y_prediction_test\"][0,index])].decode(\"utf-8\") +  \"\\\" picture.\")\n",
    "#这里原来是，classes[d[\"Y_prediction_test\"][0,index]]，可能由于python或np版本显示下标数据类型错误，我查了半天最后给加了个int()套子，成功了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also plot the cost function and the gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot learning curve (with costs)\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "#print(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
   },
   "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": {},
   "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": {},
   "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": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learning rate is: 0.01\n",
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.607548\n",
      "Cost after iteration 200: 0.578985\n",
      "Cost after iteration 300: 0.556987\n",
      "Cost after iteration 400: 0.538636\n",
      "Cost after iteration 500: 0.522700\n",
      "Cost after iteration 600: 0.508518\n",
      "Cost after iteration 700: 0.495684\n",
      "Cost after iteration 800: 0.483930\n",
      "Cost after iteration 900: 0.473064\n",
      "Cost after iteration 1000: 0.462948\n",
      "Cost after iteration 1100: 0.453475\n",
      "Cost after iteration 1200: 0.444564\n",
      "Cost after iteration 1300: 0.436147\n",
      "Cost after iteration 1400: 0.428172\n",
      "train accuracy: 86.60287081339713 %\n",
      "test accuracy: 64.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.001\n",
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.646612\n",
      "Cost after iteration 200: 0.641080\n",
      "Cost after iteration 300: 0.635971\n",
      "Cost after iteration 400: 0.631195\n",
      "Cost after iteration 500: 0.626710\n",
      "Cost after iteration 600: 0.622480\n",
      "Cost after iteration 700: 0.618476\n",
      "Cost after iteration 800: 0.614673\n",
      "Cost after iteration 900: 0.611048\n",
      "Cost after iteration 1000: 0.607582\n",
      "Cost after iteration 1100: 0.604260\n",
      "Cost after iteration 1200: 0.601067\n",
      "Cost after iteration 1300: 0.597992\n",
      "Cost after iteration 1400: 0.595024\n",
      "train accuracy: 66.02870813397129 %\n",
      "test accuracy: 36.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.0001\n",
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.671913\n",
      "Cost after iteration 200: 0.661255\n",
      "Cost after iteration 300: 0.655695\n",
      "Cost after iteration 400: 0.652622\n",
      "Cost after iteration 500: 0.650779\n",
      "Cost after iteration 600: 0.649554\n",
      "Cost after iteration 700: 0.648644\n",
      "Cost after iteration 800: 0.647896\n",
      "Cost after iteration 900: 0.647234\n",
      "Cost after iteration 1000: 0.646617\n",
      "Cost after iteration 1100: 0.646027\n",
      "Cost after iteration 1200: 0.645452\n",
      "Cost after iteration 1300: 0.644886\n",
      "Cost after iteration 1400: 0.644329\n",
      "train accuracy: 65.55023923444976 %\n",
      "test accuracy: 34.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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": {},
   "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
   },
   "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": 54,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 1.0, your algorithm predicts a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
    "my_image = \"my_cat4.jpg\"   # change this to the name of your image file \n",
    "\n",
    "#这里我使用两张136*136px的图片，一张出overflow警告，一张没有，很迷惑\n",
    "\n",
    "#from matplotlib.pyplot import imread\n",
    "\n",
    "## END CODE HERE ##\n",
    "\n",
    "# We preprocess the image to fit your algorithm.\n",
    "import imageio\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(imageio.imread(fname))\n",
    "from PIL import Image\n",
    "#print(type(Image.fromarray(image).resize((num_px,num_px))))\n",
    "#这里由于我的scipy版本比较高，对所用函数进行了修改\n",
    "my_image = np.array(Image.fromarray(image).resize((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": {},
   "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": {},
   "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": {},
   "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.8.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "320.326px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}