neural.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": "code",
   "execution_count": 2,
   "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": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 1, it's a 'cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index =13\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print (\"y = \" + str(train_set_y[0, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "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": "code",
   "execution_count": 8,
   "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 71 49 38 70]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 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[1]*train_set_x_orig.shape[2]*train_set_x_orig.shape[3],train_set_x_orig.shape[0])\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[1]*test_set_x_orig.shape[2]*test_set_x_orig.shape[3],test_set_x_orig.shape[0])\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": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardization\n",
    "train_set_x = train_set_x_flatten/255.\n",
    "test_set_x = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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",
    "    s = 1/(1+np.exp(-z))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "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]))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network model\n",
    "\n",
    "**Mathematically**:\n",
    "\n",
    "For one example $x^{(i)}$:\n",
    "$$z^{[1] (i)} =  W^{[1]} x^{(i)} + b^{[1]}\\tag{1}$$\n",
    "$$a^{[1] (i)} = \\tanh(z^{[1] (i)})\\tag{2}$$\n",
    "$$z^{[2] (i)} = W^{[2]} a^{[1] (i)} + b^{[2]}\\tag{3}$$\n",
    "$$\\hat{y}^{(i)} = a^{[2] (i)} = \\sigma(z^{ [2] (i)})\\tag{4}$$\n",
    "$$y^{(i)}_{prediction} = \\begin{cases} 1 & \\mbox{if } a^{[2](i)} > 0.5 \\\\ 0 & \\mbox{otherwise } \\end{cases}\\tag{5}$$\n",
    "\n",
    "Given the predictions on all the examples, you can also compute the cost $J$ as follows:\n",
    "$$J = - \\frac{1}{m} \\sum\\limits_{i = 0}^{m} \\large\\left(\\small y^{(i)}\\log\\left(a^{[2] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[2] (i)}\\right)  \\large  \\right) \\small \\tag{6}$$\n",
    "\n",
    "**Reminder**: The general methodology to build a Neural Network is to:\n",
    "    1. Define the neural network structure ( # of input units,  # of hidden units, etc).\n",
    "    2. Initialize the model's parameters\n",
    "    3. Loop:\n",
    "        - Implement forward propagation\n",
    "        - Compute loss\n",
    "        - Implement backward propagation to get the gradients\n",
    "        - Update parameters (gradient descent)\n",
    "\n",
    "You often build helper functions to compute steps 1-3 and then merge them into one function we call `nn_model()`. Once you've built `nn_model()` and learnt the right parameters, you can make predictions on new data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: layer_sizes\n",
    "\n",
    "def layer_sizes(X, Y):\n",
    "    \"\"\"\n",
    "    Arguments:\n",
    "    X -- input dataset of shape (input size, number of examples)\n",
    "    Y -- labels of shape (output size, number of examples)\n",
    "    \n",
    "    Returns:\n",
    "    n_x -- the size of the input layer\n",
    "    n_h -- the size of the hidden layer\n",
    "    n_y -- the size of the output layer\n",
    "    \"\"\"\n",
    "    ### START CODE HERE ### (≈ 3 lines of code)\n",
    "    n_x = X.shape[0] # size of input layer\n",
    "    n_h = 7\n",
    "    n_y = Y.shape[0] # size of output layer\n",
    "    ### END CODE HERE ###\n",
    "    return (n_x, n_h, n_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: initialize_parameters\n",
    "\n",
    "def initialize_parameters(n_x, n_h, n_y):\n",
    "    \"\"\"\n",
    "    Argument:\n",
    "    n_x -- size of the input layer\n",
    "    n_h -- size of the hidden layer\n",
    "    n_y -- size of the output layer\n",
    "\n",
    "    Returns:\n",
    "    params -- python dictionary containing your parameters:\n",
    "                    W1 -- weight matrix of shape (n_h, n_x)\n",
    "                    b1 -- bias vector of shape (n_h, 1)\n",
    "                    W2 -- weight matrix of shape (n_y, n_h)\n",
    "                    b2 -- bias vector of shape (n_y, 1)\n",
    "    \"\"\"\n",
    "\n",
    "    np.random.seed(2) # we set up a seed so that your output matches ours although the initialization is random.\n",
    "\n",
    "    ### START CODE HERE ### (≈ 4 lines of code)\n",
    "    W1 = np.random.randn(n_h,n_x) * 0.01\n",
    "    b1 = np.zeros((n_h,1))\n",
    "    W2 = np.random.randn(n_y,n_h) * 0.01\n",
    "    b2 = np.zeros((n_y,1))\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    assert (W1.shape == (n_h, n_x))\n",
    "    assert (b1.shape == (n_h, 1))\n",
    "    assert (W2.shape == (n_y, n_h))\n",
    "    assert (b2.shape == (n_y, 1))\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2}\n",
    "\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W1 = [[-0.00416758 -0.00056267 -0.02136196 ... -0.01275513  0.00733372\n",
      "   0.01166127]\n",
      " [ 0.00016076  0.00699494 -0.02144254 ... -0.00569705 -0.00276633\n",
      "   0.0011016 ]\n",
      " [-0.00553107  0.00678748 -0.00870469 ...  0.00174631  0.00395599\n",
      "  -0.00136441]\n",
      " ...\n",
      " [-0.01336063  0.00115223 -0.00207114 ...  0.0137649  -0.02380295\n",
      "  -0.01593256]\n",
      " [ 0.00056978 -0.0046458  -0.01014297 ...  0.0056625   0.00062091\n",
      "  -0.00094965]\n",
      " [ 0.00591403  0.00618356 -0.00613118 ... -0.00702644  0.00597732\n",
      "   0.00226512]]\n",
      "b1 = [[0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]]\n",
      "W2 = [[ 0.00137381  0.00531559 -0.00411322  0.02191349  0.00930161 -0.01318543\n",
      "  -0.00928439]]\n",
      "b2 = [[0.]]\n"
     ]
    }
   ],
   "source": [
    "n_x, n_h, n_y = layer_sizes(train_set_x_flatten,train_set_y)\n",
    "\n",
    "parameters = initialize_parameters(n_x, n_h, n_y)\n",
    "print(\"W1 = \" + str(parameters[\"W1\"]))\n",
    "print(\"b1 = \" + str(parameters[\"b1\"]))\n",
    "print(\"W2 = \" + str(parameters[\"W2\"]))\n",
    "print(\"b2 = \" + str(parameters[\"b2\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: forward_propagation\n",
    "\n",
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Argument:\n",
    "    X -- input data of size (n_x, m)\n",
    "    parameters -- python dictionary containing your parameters (output of initialization function)\n",
    "\n",
    "    Returns:\n",
    "    A2 -- The sigmoid output of the second activation\n",
    "    cache -- a dictionary containing \"Z1\", \"A1\", \"Z2\" and \"A2\"\n",
    "    \"\"\"\n",
    "    # Retrieve each parameter from the dictionary \"parameters\"\n",
    "    ### START CODE HERE ### (≈ 4 lines of code)\n",
    "    W1 = parameters[\"W1\"]\n",
    "    b1 = parameters[\"b1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    b2 = parameters[\"b2\"]\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Implement Forward Propagation to calculate A2 (probabilities)\n",
    "    ### START CODE HERE ### (≈ 4 lines of code)\n",
    "    Z1 = np.dot(W1,X) + b1\n",
    "    A1 = np.tanh(Z1)\n",
    "    Z2 = np.dot(W2,A1) + b2\n",
    "    A2 = sigmoid(Z2)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    assert(A2.shape == (1, X.shape[1]))\n",
    "\n",
    "    # Values needed in the backpropagation are stored in \"cache\". This will be given as an input to the backpropagation\n",
    "    cache = {\"Z1\": Z1,\n",
    "             \"A1\": A1,\n",
    "             \"Z2\": Z2,\n",
    "             \"A2\": A2}\n",
    "\n",
    "    return A2, cache"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have computed $A^{[2]}$ (in the Python variable \"`A2`\"), which contains $a^{[2](i)}$ for every example, you can compute the cost function as follows:\n",
    "\n",
    "$$J = - \\frac{1}{m} \\sum\\limits_{i = 1}^{m} \\large{(} \\small y^{(i)}\\log\\left(a^{[2] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[2] (i)}\\right) \\large{)} \\small\\tag{13}$$\n",
    "\n",
    "**Exercise**: Implement `compute_cost()` to compute the value of the cost $J$.\n",
    "\n",
    "**Instructions**:\n",
    "- There are many ways to implement the cross-entropy loss. To help you, we give you how we would have implemented\n",
    "$- \\sum\\limits_{i=0}^{m}  y^{(i)}\\log(a^{[2](i)})$:\n",
    "```python\n",
    "logprobs = np.multiply(np.log(A2),Y)\n",
    "cost = - np.sum(logprobs)                # no need to use a for loop!\n",
    "```\n",
    "\n",
    "(you can use either `np.multiply()` and then `np.sum()` or directly `np.dot()`).  \n",
    "Note that if you use `np.multiply` followed by `np.sum` the end result will be a type `float`, whereas if you use `np.dot`, the result will be a 2D numpy array.  We can use `np.squeeze()` to remove redundant dimensions (in the case of single float, this will be reduced to a zero-dimension array). We can cast the array as a type `float` using `float()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: compute_cost\n",
    "\n",
    "def compute_cost(A2, Y):\n",
    "    \"\"\"\n",
    "    Computes the cross-entropy cost given in equation (13)\n",
    "\n",
    "    Arguments:\n",
    "    A2 -- The sigmoid output of the second activation, of shape (1, number of examples)\n",
    "    Y -- \"true\" labels vector of shape (1, number of examples)\n",
    "\n",
    "    Returns:\n",
    "    cost -- cross-entropy cost given equation (13)\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    m = Y.shape[1] # number of example\n",
    "\n",
    "    # Compute the cross-entropy cost\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    logprobs = logprobs = np.multiply(Y ,np.log(A2)) + np.multiply((1-Y), np.log(1-A2))\n",
    "    cost = (-1/m) * np.sum(logprobs)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    cost = float(np.squeeze(cost))  # makes sure cost is the dimension we expect.\n",
    "                                    # E.g., turns [[17]] into 17\n",
    "    assert(isinstance(cost, float))\n",
    "\n",
    "    return cost"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/grad_summary.png\" style=\"width:600px;height:300px;\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: backward_propagation\n",
    "\n",
    "def backward_propagation(parameters, cache, X, Y):\n",
    "    \"\"\"\n",
    "    Implement the backward propagation using the instructions above.\n",
    "\n",
    "    Arguments:\n",
    "    parameters -- python dictionary containing our parameters\n",
    "    cache -- a dictionary containing \"Z1\", \"A1\", \"Z2\" and \"A2\".\n",
    "    X -- input data of shape (2, number of examples)\n",
    "    Y -- \"true\" labels vector of shape (1, number of examples)\n",
    "\n",
    "    Returns:\n",
    "    grads -- python dictionary containing your gradients with respect to different parameters\n",
    "    \"\"\"\n",
    "    m = X.shape[1]\n",
    "\n",
    "    # First, retrieve W1 and W2 from the dictionary \"parameters\".\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    W1 = parameters[\"W1\"]\n",
    "    b1 = parameters[\"b1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    b2 = parameters[\"b2\"]\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Retrieve also A1 and A2 from dictionary \"cache\".\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    A1 = cache[\"A1\"]\n",
    "    A2 = cache[\"A2\"]\n",
    "    Z1 = cache[\"Z1\"]\n",
    "    Z2 = cache[\"Z2\"]\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Backward propagation: calculate dW1, db1, dW2, db2.\n",
    "    ### START CODE HERE ### (≈ 6 lines of code, corresponding to 6 equations on slide above)\n",
    "    dZ2 = A2 - Y\n",
    "    dW2 = (1/m) * np.dot(dZ2,A1.T)\n",
    "    db2 = (1/m) *(np.sum(dZ2,axis=1,keepdims=True))\n",
    "    dZ1 = np.dot(W2.T,dZ2) * (1 - np.power(A1,2))\n",
    "    dW1 = (1/m) *(np.dot(dZ1,X.T))\n",
    "    db1 = (1/m) *(np.sum(dZ1, axis=1, keepdims=True))\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    grads = {\"dW1\": dW1,\n",
    "             \"db1\": db1,\n",
    "             \"dW2\": dW2,\n",
    "             \"db2\": db2}\n",
    "\n",
    "    return grads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: update_parameters\n",
    "\n",
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    \"\"\"\n",
    "    Updates parameters using the gradient descent update rule given above\n",
    "\n",
    "    Arguments:\n",
    "    parameters -- python dictionary containing your parameters\n",
    "    grads -- python dictionary containing your gradients\n",
    "\n",
    "    Returns:\n",
    "    parameters -- python dictionary containing your updated parameters\n",
    "    \"\"\"\n",
    "    # Retrieve each parameter from the dictionary \"parameters\"\n",
    "    ### START CODE HERE ### (≈ 4 lines of code)\n",
    "    W1 = parameters[\"W1\"]\n",
    "    b1 = parameters[\"b1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    b2 = parameters[\"b2\"]\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Retrieve each gradient from the dictionary \"grads\"\n",
    "    ### START CODE HERE ### (≈ 4 lines of code)\n",
    "    dW1 = grads[\"dW1\"]\n",
    "    db1 = grads[\"db1\"]\n",
    "    dW2 = grads[\"dW2\"]\n",
    "    db2 = grads[\"db2\"]\n",
    "    ## END CODE HERE ###\n",
    "\n",
    "    # Update rule for each parameter\n",
    "    ### START CODE HERE ### (≈ 4 lines of code)\n",
    "    W1 = W1 - learning_rate * dW1\n",
    "    b1 = b1 - learning_rate * db1\n",
    "    W2 = W2 - learning_rate * dW2\n",
    "    b2 = b2 - learning_rate * db2\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2}\n",
    "\n",
    "    return parameters"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note: They don't use the n\\_h returned from layer\\_sizes, may need more modification to make sense_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NN_model\n",
    "def nn_model(X, Y, n_h, learning_rate, num_iterations = 10000, print_cost=False):\n",
    "    n_x = layer_sizes(X, Y)[0]\n",
    "    n_y = layer_sizes(X, Y)[2]\n",
    "\n",
    "    # Initialize parameters\n",
    "    parameters = initialize_parameters(n_x, n_h, n_y)\n",
    "    W1 = parameters[\"W1\"]\n",
    "    b1 = parameters[\"b1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    b2 = parameters[\"b2\"]\n",
    "\n",
    "    # Loop (gradient descent)\n",
    "    for i in range(0, num_iterations):\n",
    "        # Forward propagation. Inputs: \"X, parameters\". Outputs: \"A2, cache\"\n",
    "        A2, cache = forward_propagation(X, parameters)\n",
    "        # Cost function. Inputs: \"A2, Y\". Outputs: \"cost\"\n",
    "        cost = compute_cost(A2, Y)\n",
    "        # Backpropagation. Inputs: \"parameters, cache, X, Y\". Outputs: \"grads\"\n",
    "        grads = backward_propagation(parameters, cache, X, Y)\n",
    "        # Update rule for each parameter\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "        # If print_cost=True, Print the cost every 1000 iterations\n",
    "        if print_cost and i % 1000 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "    # Returns parameters learnt by the model. They can then be used to predict output\n",
    "    return parameters\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: predict\n",
    "\n",
    "def predict(parameters, X):\n",
    "    \"\"\"\n",
    "    Using the learned parameters, predicts a class for each example in X\n",
    "\n",
    "    Arguments:\n",
    "    parameters -- python dictionary containing your parameters\n",
    "    X -- input data of size (n_x, m)\n",
    "\n",
    "    Returns\n",
    "    predictions -- vector of predictions of our model (red: 0 / blue: 1)\n",
    "    \"\"\"\n",
    "\n",
    "    # Computes probabilities using forward propagation, and classifies to 0/1 using 0.5 as the threshold.\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    A2, cache = forward_propagation(X, parameters)\n",
    "    predictions = (A2 > 0.5)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    return predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_many(X, y, parameters):\n",
    "    \"\"\"\n",
    "    This function is used to predict the results of a  L-layer neural network.\n",
    "    \n",
    "    Arguments:\n",
    "    X -- data set of examples you would like to label\n",
    "    parameters -- parameters of the trained model\n",
    "    \n",
    "    Returns:\n",
    "    p -- predictions for the given dataset X\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    n = len(parameters) // 2 # number of layers in the neural network\n",
    "    p = np.zeros((1,m))\n",
    "    \n",
    "    # Forward propagation\n",
    "    A2, cache = forward_propagation(X, parameters)\n",
    "\n",
    "    \n",
    "    # convert probas to 0/1 predictions\n",
    "    for i in range(0, A2.shape[1]):\n",
    "        if A2[0,i] > 0.5:\n",
    "            p[0,i] = 1\n",
    "        else:\n",
    "            p[0,i] = 0\n",
    "    \n",
    "    #print results\n",
    "    #print (\"predictions: \" + str(p))\n",
    "    #print (\"true labels: \" + str(y))\n",
    "    print(\"Accuracy: \"  + str(np.sum((p == y)/m)))\n",
    "        \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = nn_model(train_set_x_flatten, train_set_y, 7, learning_rate = 0.005)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'W1': array([[-0.00416758, -0.00056267, -0.02136196, ..., -0.01275513,\n",
       "          0.00733372,  0.01166127],\n",
       "        [ 0.00021461,  0.00703241, -0.02140161, ..., -0.00569705,\n",
       "         -0.00276633,  0.0011016 ],\n",
       "        [-0.00553303,  0.00675581, -0.00872868, ...,  0.00174631,\n",
       "          0.00395599, -0.00136441],\n",
       "        ...,\n",
       "        [-0.01336063,  0.00115223, -0.00207114, ...,  0.0137649 ,\n",
       "         -0.02380295, -0.01593256],\n",
       "        [ 0.00068   , -0.00449663, -0.00999963, ...,  0.0056625 ,\n",
       "          0.00062091, -0.00094965],\n",
       "        [ 0.00597653,  0.00624772, -0.00606136, ..., -0.00702644,\n",
       "          0.00597732,  0.00226512]]),\n",
       " 'b1': array([[ 0.00000000e+00],\n",
       "        [ 9.61108267e-07],\n",
       "        [-6.14077088e-07],\n",
       "        [-1.67683260e-06],\n",
       "        [ 0.00000000e+00],\n",
       "        [ 3.04157096e-06],\n",
       "        [ 1.54955033e-06]]),\n",
       " 'W2': array([[ 0.08274559, -0.18324103,  0.07439306,  0.09365652,  0.09067339,\n",
       "          0.04517414, -0.08240758]]),\n",
       " 'b2': array([[-0.08137178]])}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6555023923444976\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict_many(train_set_x_flatten, train_set_y, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.3400000000000001\n"
     ]
    }
   ],
   "source": [
    "pred_test = predict_many(test_set_x_flatten, test_set_y, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "        False, False]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(parameters,train_set_x_flatten)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.10.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}