2-and-L-Layer-NN-CatvNoCat.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "#Imports\n",
    "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\n",
    "plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "np.random.seed(1)\n",
    "\n",
    "#Setup some test cases\n",
    "%run testCases_v2.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [],
   "source": [
    "#one extra unit test....\n",
    "def L_model_forward_test_case_2hidden():\n",
    "    np.random.seed(6)\n",
    "    X = np.random.randn(5, 4)\n",
    "    W1 = np.random.randn(4, 5)\n",
    "    b1 = np.random.randn(4, 1)\n",
    "    W2 = np.random.randn(3, 4)\n",
    "    b2 = np.random.randn(3, 1)\n",
    "    W3 = np.random.randn(1, 3)\n",
    "    b3 = np.random.randn(1, 1)\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2,\n",
    "                  \"W3\": W3,\n",
    "                  \"b3\": b3}\n",
    "\n",
    "    return X, parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset():\n",
    "    train_dataset = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n",
    "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
    "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
    "\n",
    "    test_dataset = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n",
    "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
    "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
    "\n",
    "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
    "    \n",
    "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
    "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
    "    \n",
    "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "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": [
    "#Load Training Data\n",
    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()\n",
    "\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",
    "\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))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = [0], it's a 'non-cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztvWmsXdl1HrjWGe78ZpKPYxWrSlQNKtmlckFDS1FkKQrK7iBCA3YQO2ioG2rUH3fgIGlEUgcIkqAbkP/E7h+JgULbHf1wIjuJ3RKEdBKlIrW7E1uquYpFFmeySD7yzdMdz7Tz417e9a31+MhHVfGylLs/gOC5b+97zj77nHPPWvtb61vsnCMPD4/xQvCgB+Dh4TF6+Affw2MM4R98D48xhH/wPTzGEP7B9/AYQ/gH38NjDOEffA+PMcT7evCZ+XlmPsPM55n5Gx/UoDw8PO4v+KcN4GHmkIjOEtGXiegaEb1MRL/mnDv1wQ3Pw8PjfiB6H9/9JBGdd85dJCJi5u8Q0VeIaNcHf2qq5g4emCIiojDUhw4Clg8u1190xXCToVsY6H2k3XS43ct6qq1Sr8mxWL5XpJnqV6qWdxs+JansM8kTacBBEVEYynZkxsgkfR0Vqi0rZCwFnieXVL8IPgfm2IXLbrvtnD4Ww/dwTP3vSd+8kG29B6IoiGGMoWrb9TzNtXWwfzvGLIfrCduF3QfsP2BtxOK1xvslCMx44Xt6NohieExi1vdHkcsc99rN4Xa7p++rckXuv1Ko95EWXdlfIfdVJaiqfgnBHBT6hR0G/fHfXN2mjWbXnsIOvJ8H/wgRXYXP14joU3f6wsEDU/RPf+erREQ0N3NAtdWq8DD2NlWby1rD7VJJLthkZU71u/nuwnD7/Ool1faxzzwjxwrle83FddXvyNOPyYdCX7yrixdle+36cDss65utMSnncmBiWrVFJA9t4rqqbbWzNNzuwKWbqj6i+u2PDg+3S0FFtXXSleF2K5X95XlH9StF8ECY26CVtofbW235seuwvtlmq/PD7el4RrXF8GAVcJ5Fb1v1y9ryuZfp+Vhu3hxuX9m8NtxupluqX+FkvJWwrtrqZbnWjZps1yuzerwlmcfY/AAdCg4Otw8E+lp0ttaG2xff+n+H22+cWVX9PvLkc8PtozMPq7ab2+8Ot7fb8kg9NfFzqt97xQ05ble/2CYrE0RE9D99649pL3g/Pv7tflV2+A3M/AIzv8LMr2xstm/zFQ8Pj1Hj/bzxrxHRMfh8lIgWbCfn3ItE9CIR0ZOPH3a1St/MKZf0oas1+B0px6rN9cRMYjBfg1D/znAYQz/9m8bgSqQdeLNMa7OxXBbzKk30m6UUy9s6DmTbuhWdXN4YqXl7VCIx8+wYY2jrOTDFc/0b60I0jxPVVmTyZs8TNCH125SDhuyD9RjDQsYVwpt7otpQ/SbgLV9ifc0yGFc3kx98Nq5Vkcuxepm+FoGTOZ6uiOVUK2krh8ANiArdFjOY2GCmx4UebymT+zEy77S8J+eSlfV8Z3Dtk1Tux05HW1gby2IBHJg6rtpWU7Fo5+tHhttpqMdxfV0suCA1rnLW71vk1iG7Pd7PG/9lIjrBzI8wc4mI/joRfe997M/Dw2NE+Knf+M65jJn/ZyL6d0QUEtHvO+fe+cBG5uHhcd/wfkx9cs79GyL6Nx/QWDw8PEaE9/Xg3yuYA6pU+z50paR9rEoovlluqJYsl5XfAHzfMNT7CIEmcWadEWm1IBE/c/7YYdUvBOcnNY5QGIrPWWZYC3Cp6pdnsv+UtE8YwapzZGIo4ljOM2mKT9guNPNQByo0M7TOdk9WwpOe0EuhnlJyGVBFpg0noTY5KdvRIT0OFp/friF0c/nc7sl2bFxQB9czIH09a7HMVQzXOjTXJU9l/72OXicI4b4KC6BBU+0/x5kMrBzocRSwxtKr6uuZAzvSzuRa2HWTrSXxz9f2ram2ek3WSuaBKdl0mhlIYC2jahjvdrO/HlUUpmEX+JBdD48xhH/wPTzGECM19YMgoGq1b76Vyjp6KSqJ6RmHOmIpB5OPILjEZXr4Dky5zFo8CUOb7KNcPar7IYViTL4ITP1qPCFD6mkzN3RiO5fdhGrjVOil1GkaMAbTOcskQGgbgnKIiKpAnZUNJZinQG2pCELVTUW/2Wi3SgVM7EiCVyqsg5ECEpemkxuaLhWTGKnPZqHPOYeou8jQsxWSe6QGtFw1qql+RSjHauUt1cZACWYQJZgnhsaFeQwKbaaXK2J+NyaeVm2JExO+iOS+nZrXAU3dZRnj8qJmvZ98Vu7BErg726kOdppqyP1R7ZqQmQHlyLy3EHz/xvfwGEP4B9/DYwzhH3wPjzHEiOm8kMLSgB6KtP8cxOK/lCMdGkrgg3ZToUJ6HU13pD3x21ITGtpaF78+LokfHJhsKwKfkA0lWArFX69C4kluwkTrFaHAJmvHdVssiSKFoQGzrow/Bj++a8I/M1gbqJuklMDJsfMA1h5MRlsAv/nlqvaZKyWh7WISXzVkkw0J43e53n8jgPDjssxj04SU9nCdwIQ3V+F4DVj/KJv5zjO5Zs7Qm71EPhcprGskJruN5VzCXPOb18/+aLi9cvWCautWpG/PyTU7fuhjqt+Fzu5JRpNwrTuhtMUm4/HInKy3uI4JE2/21wNs1uFu8G98D48xhH/wPTzGECM19YlDiuK+EEfBhm+DSLgQzFUiohyz3dpiCq2tahptY1voj05Pm0LrqxL9NnlITMUsNyYffC3raHchaYq7kBHkgE+ZHPAaUGChPhfMwMszI+ABpmIpuAPtB5FkNivOgVuUgqhDQXq+SzWZ70ZZR+SVItFKYKCXcjOODCi7kg3/iyESE0RLysZdyIAyberppgTGzJDF5wxXmzVl/+2mTv3uJJBZB+5OyZjzPRhW3RlXYl1cysvnT6u2Yz8nefbz00L7RYZWq06BwEZJH7vbFgpyubo83J6s63unWpFxtUJznreekWBv73L/xvfwGEP4B9/DYwwxWlOfmCjvr8A6toIGYoZ1C73anWzLqvbmmphdq+s6om1lW6KoslTvY2NDXIRwn5haG+sbql8MMk5c0iZlBEF4FZDQokL/foZwLiiMQUSUgiBIN22qtm5HXBVOZYypnQ9IgElZRzkGITADaPbFul+jJmZpvaRN/QgiJTOIyMsSPd4Iot2cif5L4fqirl7FaBBmoB/YKnTbBgh4VCBis9rRLlJnU6Ta1teWVVsXx1WW/TvSfkWcgxBHT5/L2qbcI1mhzfTpqghnZCW4toW5r2pyXfbV9qu2lUKYqsXu4nB7dlbLg1VgrpJcu118y60LfeSeh4fHLvAPvofHGMI/+B4eY4jR+viOqBj4v2zovARkl/NUUxVIo7U74tfnRp46APonNPSSA/+xsyl+0Gq8qPodmBMqq2xolxx9WhRdyPR6RS8Qn9OZqLstEMzvtXUmWdqSvhlo+HcTPR8bCchmB7otLsm4JuvTsK39+FpFPpfKOuuOIWIsy+VcbOIXaudbyrFLcm0yEBwpG/oxD6QtMpFqHRDHWOvI+kKlo99X3ZZQtRtNHc3ZhQjCiIQOK4yPH4BQJnX1vZkCzepMlGMKGZthTe6DAzOPqn4tWIuZynVkaqsk6xJBF0RWMjPGmowxrpuo0kEUJQfex/fw8NgF/sH38BhDjJjOc+QGZYCciSTrJWIqFh1tvnbbYgJ3MqHlJho6wqoyL9RK+z1NPaFoRxs034tAm1MZ7D/o6NJVRYClmoB+TLQ530yFyil6Ro+vAiWujOADVuVqwz6y3GjngxvDgR5jCDRjDGIn1aqmkMoxUEVW4xAq2uSpnJtzRmwDRDV6ub5m7QIFU2T/NbK697IdGc29Akz/FEp+2dJpPRAUzBrmmsFthvdYHBhKsA3jNwle5dmp4fbcpJ7HOmgSVvcLDTpz8DHVbzsHQZAFXSmqTGL6R06uezvT9/A0JJSVK/o8p7jPNYdWkHAX+De+h8cYwj/4Hh5jCP/ge3iMIUbq4xeUUW8Qnlg2tcsIM8msTwsCDfW6+EMzU1rIMpuSfp3mDdVWPya+Jc8LJdNua0HDVlN8vyLRFBWVwCcPxHfPDJXV6co6AScm5QyczjTU6xwtoO0SqMkWGI12F0lbVDG1+SDrbnJa1jxqlWOqXwA0V278804P1hegUrFZlqEU1jY6iZ7HNopNgH8b51r4JAMR1MJo3TugCwtUDjWUYFCRcw5CTbcxjDHvYNlwU9MAhVVrhgquy302c/gh1Vabk9Dn6rT4+3GkKzknIFSyvqXDeUtVGct2JuG7zlTEnYX6gZWKDsGuD8KAAyMQuxvu+sZn5t9n5iVmPgl/m2XmHzDzucH/M3fah4eHx4cLezH1/xkRPW/+9g0iesk5d4KIXhp89vDw+BnBXU1959yfMvNx8+evENEXBtvfJqIfEdHX77avvOjRevsyERHVYh29VIVSR7Ghdap1oDHq0jY5cVD1A7aNQqNJXj0u9NW2k0ivqz3tEnR7YhqGuf5dDFIQBAmhbFOmI/BCKAsVsRF1gMy6PDAmPFKLkWyXSpoSjGLQh6toV6I+I8ZXvSZmaRRpt6gA96TT0yW6WvAZKnJTZDLTMijD3e3q+d7oSERkgZp4Rigi68n1THp6HpVOINCxzmgVBmUs661v6RCOV4JIzCDR46iCOV+p67manto33J6d0HReEYhbikIl7U1dJmvh+sXh9sr1JdU2NyM0YCcGbciOfg5ScAnqFX1flQalwwO+v5p78865G0REg/8P3KW/h4fHhwj3fVWfmV9g5leY+ZWN9fbdv+Dh4XHf8dOu6i8y8yHn3A1mPkRES7t1dM69SEQvEhF95KNzbnX7ChERtSOtJzZXl6q1E8GUaivVxXypTImpFZe1SRaC1btR6Gi6mbqYwA6SH0pVndThQHbZmbJQOQhDUCTmZiXSZpeDCqqBWbnPAvnsQr2KXa6CtDckIIWmxGwZ5KrLNR3BNdGQckwRyIHfipi8hSSDxJaeFjRhcGliiBYrMiueInPcM2b6xrbsswORcJ1Yj4MTGSMbAgTroGWJjKlrZLhdKPvkSM9pKZZV/jIcIOrpeZufknmbnn1YtTUqskJfYr3/ta5UJy4nMlcb6zr56/rV88PtZluLhRBE/+UVmWOOjcALrNhHpFf1w0HyF+/xXf7TvvG/R0RfHWx/lYi++1Pux8PD4wFgL3TevyCiPyOix5n5GjN/jYi+RURfZuZzRPTlwWcPD4+fEexlVf/Xdmn60gc8Fg8PjxFhpJF7jgpKqO8XBrHJsMrFX6xXjRZ9Q3z+chlKOpW0n9aE8sNvnX1TtR17+gnZH5QzrjRMua4e+IHG53RAXwWgvR7HerygtUEu1L5vzKDBH2j/vwARjTKUGHORjvSqlGXNo1HVEXnlUGhLhhLUSaL3sdaTMtw9k11YA//RgRhGu6n3sbIkvuryhm5rb6N4KoiPBrp8VASU3aRZ9wmhhBmWNi/sOgEIajZiE0sWC8W2Vcg5c6jXK+pTch/MTevoPKXpb8p8N6ri/0ep+PjL26dUv+02rHnMaAq5vF/mf7oha10HKnqtIcxlvSIxCyJRqX+/OL0EsSt8rL6HxxjCP/geHmOI0VbLDZhKg+qigbGjQxBGcCb4KICyU0hpsNGzb6Zi6pfruqxVJxGTuwYJDjVDCXarIn4QaAuYilRcC9Roi2NN53EgnxPS1BOWDuvmWjMwBv22MohoFKaycAOiHqs0r9qCBCiwUM5l3UQoYiJO5HRiS74t1+bmGfne0oLex+aa7L/b1bdSkQLtCn9PMp0c04Hp6ZW0WxQ15Ju1fXKt4zntIlVi6Vc3mnidUEQvurlQmD1jE7cyoXWDnr5m211oMwlZjbqY412W8a/n7+kxzoBbOqddmqOHnhxuH3aPS4NJJFoOZP7ny/q6Vyr9GDpmL8Th4eGxC/yD7+ExhvAPvofHGGKkPn4YhDQxoObYiLTHkFVky39h6CzWPOs1dQZUURefuT6lw36b2+KP1kviB5ZMJmAH6p8VPcuNyBhzCFeNjQ57BPvInKYceyxjzgNNgRUQpou+WsmIK1RY1iWKtqa2elsSKppWZJ2glZuoahhXsqLXW5bfkX0sXZeQ1E5Liz8mUJ8wTY3vDrRoBwQ2cpM9VkQyjqJlwptvyHyUr8g+jj2lr0v9aTl2u3Fdta27KzLeHOY70eNdWROffF/7imrrwj3SmNRrQimEFfdiubazM/r+O3RY6hiUo4+qtoOhZJlugcjqSqrDfieqcuxDJU3j0q159XSeh4fHbvAPvofHGGK0pj6HNDuIvEuNgFsB9ErS1XRKrw5adG0xp1prF1S/+gExr2omqq+1CUIR02J2sRWXABekMBrlEWjW5yA8kZoSVyEIh7AxbbuZfK9V0ZRP5iSqrQrfqwa6/FWQSnTatQva3Vm/KNF0tQNC+00d0RRS+6rQUmsXtEm5vipRZmsrsv+O0dzrtmQfzujUt3MoGZ3JPAaFCYcESrPY3jRtoMMIWYjtl/X9QQ+LUEZ3XmcaEguF10iEZs1b2n3a3hQq7mJ6VrUdP/LJ4Tbq6BMRrXROD7ejSPZxaFab4svL4iZt9rSLd7VzZrjdgyzE3ETn1SJxCeJC05a9rf4cF/nebH3/xvfwGEP4B9/DYwwxUlM/4IDKg1XcyJgkBYspl5oV/601iZyqQ5DcRkeLaBwJxOSbMsk3W5vSF1ejs9SsJBdy7JT0OCKolpsnso+kMMIKkGyTmUiqgsR87ZHWuisKWUGfDMSkrNCs6heAdPXZK+dV2zt/Jqb5k5+QKLDDy3q+uytiYm9salflxqqY8Eurci6JdVtAeGKrq5NeVpuyj31zEik5H+lwyAawHEtGp64MSVGVrhzb6Twf2jovYyw9rt2FY/HTw+253rPD7bXuRdVvpS5RcRNzWhp79oCUw4pMglABLl8pl2hRV5gSXS0Z12J3QbVNV0C4JYHI1IqWIm8EMq71K/q+Xb/av5eSllUzuT38G9/DYwzhH3wPjzGEf/A9PMYQIy6TTUQDP9n+4kQsQ9ns6Qyo1k3xz4u6bO87oSmTdlN81amajrB676b4dBsb4ku3ekZAEsQOuybqDrUPi7L0cyaNL59A/86sE0AZ7orxF0tl8RHnIhF/rDnt4zNkA574qK4tcOF1KNG9IGNcj/R6CJXEl2wV+jwzWEiJQ6EOI7teAX59sqhptG4u1NbSupzny5d0BGEIlNUTs3r/87H49Tebso8l1uM99TKIaJDWvf/5o/IZkh+pk+q1gNpD0nhw3oiblKHEtSk3FvZkrrZbcs5Jqu+JrCvrFTWnffcQskxziFJtpPpcmmflGdm+qSlBHpQpy00E5W7wb3wPjzGEf/A9PMYQI9bcI8oHwhQ2OcYlkADjtEBFCnpui1DT6bHqL6h+y1fEnG03dUmnJlTF3ehIFFXHcEMYUVgKNK2Tg15+DElAYUVHUUXTYpbmpE3grHlV9mE09/eXhDaacFLploxQBrog5YYWAfnIYdFsiyDUjktah32jK/O/bspJdTKg7SAiL0+NWwRuUjnX7lm1EJN4fUVM4JWmnu9qRY7VTjVduAT3RCeDxKeSno/WTZnj8v+jz/N0IOM4NCdz/6kva9rrUweE9pupaM29zea7w+3QlEvrdGWfLYjIS3PtarZ7cv/Vyzr6rw7XM4cox3j1qOrXbsv9x4WOXsyHZcW8qe/h4bEL/IPv4TGG8A++h8cYYrQ+PjtKByKbFad90wIENkoVQ+vMQijkQfGt3Y4aauJ/tTaM9npbfL8MwkSLmg6fLAI4VkVrtEcsvmWtLAWCK8bHDytC5XRMzboVd072QXoNoe4elWMV4gd2nfZH27AEsnnGCE92of5eWS5vz+k1lRaoXPa6JswTxE17IKjRbGkqq9WWz60tTY8FUG58H2jR1/fpWy4Gyq6cGVGRXPzVuQNCaX78l3W2YuNRmZA41fuIF2Qf03UJ6X7i0Z9T/Sa7ct03u5dU25XO94fbR8N9qi2CEOyiJD5+r2PWQ+A+qOcmFDeR80m25f4uOvq+YvTfTbnxYQ0C/oCy85j5GDP/kJlPM/M7zPybg7/PMvMPmPnc4P+Zu+3Lw8Pjw4G9mPoZEf0d59yTRPRpIvoNZn6KiL5BRC85504Q0UuDzx4eHj8D2EvtvBtEdGOwvc3Mp4noCBF9hYi+MOj2bSL6ERF9/U77CpiHpaHKmaZdOmUwhXr692gbqKKoJGZSmmtqaN9h+V67qWmX8ppEd6Uswgflio6wCnIx5fJI04ouENMrhoyqalVr+IehmOlFoem8WkXayulh1YbHTkE8bctEMq6fkvNcP2fEK8DS66XSb7tnNPHAEnWhvg0S0JFbXRPzdX1DH6vXkTmOEz3fdQfXM5Dx5067JjlkaaJbQUS0b0rm+/NfEdP8oU9rqmy7EEGTlHVE2+Q+2f9jmcx3bO6/a6ehZsCkFiZxE3INA9JUHMMcV0oSaZeFOrowwqzERN8vbhW+14Qy7UaIIwAzPjCm/q3y2HuU3Lu3xT1mPk5EnyCiHxPR/OBH4daPw4Hdv+nh4fFhwp4ffGZuENG/JqK/5ZzNiL7j915g5leY+ZW11fbdv+Dh4XHfsacHn5lj6j/0f+Cc++PBnxeZ+dCg/RARLd3uu865F51zzznnnpudq92ui4eHx4hxVx+fmZmIfo+ITjvn/jE0fY+IvkpE3xr8/927Hi0LKFrt+zdBXXsjIaS+hamhr4DOQs+smWrDo1QCP+2gFrIMLsmPTp6C/nnFiESCXn5G2kLpsfh3KfqtrKmykKbluKSVgOqhhGEGiabzigwyFLclxHPpgp6P7hWh4gJTV6+bStsGqLE0M+1zbkNo6FZH77/ZljnYWBeVoHKi5ztOZX6iVPv4QSbzw0CxlUgfKwdVo5q5Fo8/LnP19F+QEGauaX3/qCfX1mp5NmK5Y1qLcn+8/e6rqt82iK4+8ey0apuffmq4HXR0pqSD84whLDo23vYclO8Om5oSzEmo7TCQE8jMyWRQSy+0YrW3xrPHkN298PifJaL/nojeZuY3Bn/7X6n/wP8RM3+NiN4jol/d0xE9PDweOPayqv//0+6LhV/6YIfj4eExCow2ci9nSjb6dFwc68gmAgqpaBqKrSrmMhoynUTvI4GSyGQ08dNMNPgToExKpl5XzmDC5zrDLw2AdgFB0MyUTo5yMMVJl1Kqh4/I/kOdjba5Iqbze++Iic1b+jJFkZybUZinAKjPdg9KaBl6abMtpvnmhjbht1dEPDRbE/N4ytCnk5GY8K7Q89jsgSkKmWShme9KJJ8nJrRb9PTnPiLHLsE5d7W5TRtiYoemDFcVIvIuL0jU5JXLmprMqzI/B1p6VmdScSXWN/T+N9pijk9D1qBb1pRddQsy8EyJbnytOqDsODQZrJkcy2jEQiCf19X38PDYBf7B9/AYQ4y2hFZcoulD/YSEdluXv+oUYnq6NaPLNjc/3M4g8isvtClUKiSiKyh08k3tsAgmbK1CkkehEybiQEzPwOmVageGtYOV/MIkCxUMSSPBpGmT4210tY78uT+XiMJkVdyYalWb6TmIYzSbOilldVs+b2YyH5umoq9ridked3W0W6UtkWtFF1yOQrtWeQ+ObZJDami+okdjLFGsLPzYk4+qtqMPiUnfviDu37ZJclnZkjE2W7pWwb5QmJMLK3LOK2beju2Tlfzp+iOqrQjkMXlr+YZq21qS++CxFdHqyzvm0cKoO6NdGMD1DMD9Swo9RtSlzI1rteeQvVvHubfuHh4e/zXAP/geHmMI/+B7eIwhRqur73LKBn5zy2RzJSBU6DIdMRfF4uOiOENh6pMFPaFQirLWkW8cFP908bpsp4YaKkOJ64i1X8woiOHEf3aFPpc8EKooZJOBBxF0535yUrWtnBcarRxBBFdPi5Zsb8u4ri9p6vMaBLUt5eIjzpX1OsThzrXhdi3TWYilnsxdXgbBzsxk+PVg/o3PiQl/YQQUlXnVRKG0HT/+hGprOIl2u7glVNwlNrUK4ZqFk/oAMy2JkisHEIVoavgdmBQaNKyYiDlYl5kKH1NtExCRl4KAqT3RELPpTBvOXAHrSJGhYPFrRaDnO7slCPJBCXF4eHj81wf/4Ht4jCFGrLlXDMtNZRUd7eZ6Ym4WJR3RhqIDBeqJ53r4DnTqS2YflVn5Xrkqx+pu6WixCRDVqBjGJCEwiQtxEXLz+5mRnFuQaRP7xlmhGRdPXVZtAWjRd9tyLsmWKUG9JSb8uZs6YeUUsFmlupisYaH7lVtCSxXGpUlzpC3FdCysljuYm4WJJIvAJauCBVyOjCkK/fJMj3GtEFpx+2ExeydineTi8DYo9HVfviDl0ppQqroyq90nd1g+W+ozOQ1luNb1/YLjd2jNm8hRBzRdYNoIkm8idS+ZEu7wOQ/0PdEdJAu5HbGct4d/43t4jCH8g+/hMYbwD76HxxhixGWyHWVh38dPSNMpkQN98kgPiyETLgKHrki0E55WxX+MWAsylkGrf/9+OXbTMEOHZ8WHK1shhFDGyOhLFvpYmOG3ekOHkL7zw9dlfz1No+UZzAFkYmWp9otvboqvd3ZVh3W2Q6GeJiEUN+/qcSx3ZYxlcxf0gDdKoOxyYKgihvdGYAQgwG2lCFzVknnV4LLBWnZTtTUb8sXoiNBmsRlHKZVFhGpPqzxtk9CWzskaysQxHUpdm3hyuM3XdOnxBLIcs0zfEynUAiiXQYgj1pMaRHK/RCYrM00hIxT2b/31PIBaCLm+7lXu37fBHt/l/o3v4TGG8A++h8cYYqSmfk45tfJblIo2DYMcoukCYyaBqV+FyLfNwkT45dIWGfM7Bm26xqyY+jdOaRP4kWMSace2RBeIh2DGWRBo0YWsJaboqR++qdreuyQ0WhzqiL8Ust2Q8nnvpqZu3rgmn1cyPVfIYjrQwWMTnRcEKEaimlSEWAbvhjQ3OokqykzPFfaMdQCaQgFUbfKo1rqffUiyMtMyREN2Ne1Xj2X+H2s8rdrShx+W7Y3/MNwOsAw5EU2sSEYe5zrrE5LiyMV6jARzx+CCWO07dN16xl1wkHHKOHORvjAhuLk10hmKwWCQ7E1qABpfAAAgAElEQVR9Dw+P3eAffA+PMcRITf2iSKndGSyj53pV36VivmahXpltwMpyN4FKtBVtAqeZmD/VwlSwZYnMqs9AVd2mFuxorp8YbpeqenryHKLpqrISWyF9rGuvXh9ur146q9q6HVlp7xqp6ZVNMfMyEGE4c0Of5ybYnpYBgeKzFMPKvbHmqQomZWiiC4MSnGeAkXt6H6CITtVYm7ZoLKtYNJPMs/+wmOLPfvYvqrbOjAiydNENinTU5xT4KnPV/aotOyTXff/lTwy3k2Wj2+d2fxRYJdjYRjgfoDJyM1kZToIVI0GWAsP/zFxxANF/xg24dTwr57cb/Bvfw2MM4R98D48xhH/wPTzGEKPNzisK6nT7goeRM6WU2kLNZXWtRZ/1IKKthFFUOnsJtR9zUwbZAeUTVYXCq1a1VvzakmjpH35Yi2gQZK11sNTWkvbnzv+5lGdaWNChgWtQArxi0v/WgXFbhbJWW7H256DCFYWmLU6gpBNElRWGXmrh9FuNdvBVE9DBN24l1SOoH2CiKAvYRxf8ztiU/PrYZ58Zbj/80MOqbRFKnWEJhYj1sWahPHWQ6Ky79y7JPrYXILPO+M9BIHNl55QYzjPQTrQDpzqByMvcjDEC/jewfjhE8hUQLZoasc1SIPf+Zkvft6+f7wu1NjuaIt4Nd33jM3OFmX/CzG8y8zvM/A8Hf3+EmX/MzOeY+Q+Z+Q5srYeHx4cJezH1e0T0RefczxPRM0T0PDN/moh+i4h+2zl3gojWiehr92+YHh4eHyT2UjvPEdGtUKl48M8R0ReJ6NcHf/82Ef0DIvrdO++M6JbkfGFMvrQpJkpY0sZDt47JN7Kd59rE7gEtlaXa1I8qkpQRh7J9cF73W1+WqLCHHtFVU8tgevVAf27htXdVv6WbQuc1c202bicyxmtbOppuqSdzksUxfMfQOmCKKi03IkqhWu42mJdsuTgwddk0oRgECnGEuXbPCqA3U22VKnsW81Xm9uuIyid+SSriVo3ROOuEJt0Ajca4p6PWovz4cPvUmzrRZ/EKCLwwzFtZXxeMziuMLZ7DeVszHWUf0TQvlfUYc3S7dpS/krFgElBgrsvNFaE3//SkjghdWFohIqJWV99Tu2FPi3vMHA4q5S4R0Q+I6AIRbTg3dNSvEdGR3b7v4eHx4cKeHnznXO6ce4aIjhLRJ4noydt1u913mfkFZn6FmV/Z2Njbr5GHh8f9xT3Rec65DSL6ERF9moimmYcG0lEiWtjlOy86555zzj03PV25XRcPD48R464+PjPvJ6LUObfBzFUi+kvUX9j7IRH9ChF9h4i+SkTfvdu+gjSkxo0+VVc98pBqawVCtbRL2j8KwbVkoJAMY0Ip0HtZrv3FaiH18kpO/Pr9M1o88doFofp62qWlEMTii474bDfOX1X9oHwdbbS187uwJYO+1tK/u1FNxhyTbFeqJiuugIy51GTFgRgEM1BDhuZBn98ZJ78AiiqGeszO6QnHStilUI8REyxj4AGP/wW9ptI4LH6rS3Tp6koqL4psU8a4/J4W0WgtCL/ZWjcXDZzwoCSD4tj48VgX0YhcOHg/stHEz8FhT+B73ZYOK65BVl9g4mqzRMacAB177rq+r05fvTLcXlwyCjK3Qn3dbQ3vHdgLj3+IiL7NzCH1LYQ/cs59n5lPEdF3mPl/I6LXiej39nREDw+PB469rOq/RUSfuM3fL1Lf3/fw8PgZw4h19QPqRv0IuuyMNsnaqxKJVJs9pNq6VekbQfRSYHLOUA/eRu7FiZQwDnPRZa+XdGYdJW8PNzc2tNDH9EGh99oXhbJbW9Plrle3ZRHz+ro2o6fn5dwef3ZetTW7cj6dDpTJWtVRWlstGFdgTWxxEXIS0zM1JcsK0AwMjAZcAaZ/FUz4knHByiSRarHRh4tgXJPTMt9PfmlG9ct6Yuq36LLev5Pvta49O9y+8a7R9wNNwjQxWo5loUVjzb2pfp1Erlm5oteiCuDVChNxihGKqHvfKGlxljiAMnAdfV9lQMGdvHppuP3mBV1KPunCuRl61u3YuDN8rL6HxxjCP/geHmOIkZr6YTmgmcf6pvXN/7yt2l5+XQQrHuvo0KaJZ8U8ru+D1VFbugpWWItUm1oOquIWTkyrkPWq/mxZEkWWBtFQw7a5A9J2Skz9K8sbqt+pm7L/qKETjp7/3KPD7VKox5hD5dWVFiRuGNagfUlWd7NCrx4z2Hp5CJGAkWFK4GNkwu5KkGyCgg/l/XOqXwXmMUj1OHIoQ3XiF0TP7tjsMdUvAJN7aUPP49pZMblXr4FLlujx5qBZl6RatCSBtipY8M0t7RKEoDGeG33CDmQI5Ym+N2s1GddkTdiGwLgSKbgSW4Zhee2C3Ptnr8t9lSf6XCJl3puwvqEXszdb37/xPTzGEP7B9/AYQ/gH38NjDDFSHz/giOpxn8IKGhdVW/kh8XfXprUPV6mC7672ZzLTcvEzs8xQfYmsDWTg92Wp9ucaU+KnnbtxTrXNT4gwxxtvSITyy9e0v7gIrtnzz2i/GEUuux0jXgHhbh0QJkmbej2kBBr2ViMSg/CwNHM8oaPd4gii0UxGF3chU7IqNFR1QlNxEWjzY/YZEVGpCSWp54HyWjug+rXbstiwuqCjLZurUIIaahyEhn7EIgflkinzBbRiCdY5qhUbDQmiokbgZQKiIW1WXwjrKLWK9OuRpuyWN2U+3r16XbWdvylReD0UFTXu+p2898LUgLgb/Bvfw2MM4R98D48xxGir5bqIirxvLj70EZ2ks1oIpTHxMV2tNIXoKAcCGDWnxTwyoGEyk6yQg9gBQ/RVM1lU/Xo1Mas767q81p++dHK4/R9OS8TZVqp/PxugPDE9oaPAUrDNt1M9xoVLUtl1ZXVV+m3rcZQjKH8VGEEJlHkHEZB+fpWgVpZx8YQWxygSiVCcmoPqwQ1NP6qSXz1t2p44IceuZkJ5LV3QLkfelmPnmZ6POJL9o8nOJsklgOSpLht6E4REIhAtCYxQRrkk9xIb4XsUI4lshQLQwU/bcl+dvXZNdXv7olCwS9s6GanTEVcRj2zLcJHS3zdzYDPW7gL/xvfwGEP4B9/DYwzhH3wPjzHEaEN2o5CmZ/s+3lZLh2dOzUlIbRQY3x1DSsHPmWAthtnpin+eTxj1Ryj0FkK2FZd0+GSnLNRKEehMrP/0mtB7qL3+mceOqn5V8J8313VJ59Up8YW3O5qCWVsTX35jUzLyOl09jgrUigtjfQnR/8US13mhf+NjyOKrlkz9PajHVwU6z+p1NiBr8vhh7fsem5HQ5FpdMuuoq69ZCJxVGOsDxCC+GTD6+HocBVBxpar23R0SwPi9Ha88aLQCpgXWJ9C+dasn/vlbl84Pt189e0b1a/eAas41XajHCLTljiGCQKpZw7o3D9+/8T08xhL+wffwGEOM1tQPI5qc7pc7Wjqvteirdci+amnTdho08iIohbXR1RFtm1A+2ZboclC4OQCT0lV1BpQDS7Qyo2nFTkdMuUkw59EcJiJ65BFxW1bXtMuxtikuztqGHn9rW9wApGcmTLnuAgRHuh29/0ZN5qpal++FrN2nOtBZJVNqO4KovhiiCecPajN65pD020ePqbZa8FE4tlCCztRC0LSUfg8Fwe3fS5ndB9YI4N2pOIyEs6Yxat07U14LzfuVzVXV9uN3Tw23L1yTLMokM/cf0q7mvFwOUZRw6MIWPFCjtv6Op/M8PDzuAv/ge3iMIUYcuefIDcoRNbtapy6agMipjqkOCxFdKUOEmJGdpkR+xzJTpyjLpC2C8l1hWUejzc5IUs31TbP6ml0ebtdAv6PZ1Zp47UxM/2c/oyMUE1gF/sn/pyPyMFItAtPcagu2muAGlPVv93RFLilWpo3C3c35cqT3MQH7mJ+Xc3nsUX0uWSpt5UQzGwHIg6tVbFspVn02JjCuXENCFtskHWQGrBkN5jJWtrUy1A7GmJvaVcsgEHLyynnVdvGGJNxgSTHLPGTKNNeTUKgWcE12TNbu5jzzDg7gjvBvfA+PMYR/8D08xhD+wffwGEOM2McnogHLkRtRxHIi/sxmS4tcNmfl96kWi3Md5ZqiCiBTygoTYFmoKBQBzEb4qOoXbUOm1/Jrqm12Wva/0RRfPeroafzY548Pt586roUnakCPRZke//f/41vDbSwB3qho/21iSqjEUskIQ+DaAPj1NlqsGgv1OTehqad6RaIZG7Hwm2Frn+oXFDKPRW791gy2BTv0ItDXNjUCdlB/t8YRGj8eqKw8Nbr36Bfz7j5+pyfnfBXKURMRnVmQTLsLpqxVAVGlqLGf2jUE+JiZSWA1RBAEsRQdnPa9RupZ7PmNPyiV/Tozf3/w+RFm/jEzn2PmP2Q2xc09PDw+tLgXU/83ieg0fP4tIvpt59wJIlonoq99kAPz8PC4f9iTqc/MR4novyWi/52I/jb37ZEvEtGvD7p8m4j+ARH97p32UxQF9Zp9k6rb1Uk6PAsCGLFuKyKh2BxSLcYUZKBynOFTwliizioR6O9lms5776T8tiXNG6ptuy1jbEHZps/9RU1zHXlYTGIOjTtSyOfLJ7XW3YXzYjaWYzHNP/7Zw6rfdDWGfvoSomneheSVU2/piLO4LGIQQUmbx6WSzPdU+Nxwu9fW5cYYzHlnhCGQiUIRjR3VXMG03SE8AZ+xuu+O7BWcApOMhKMqYB/tVOsknrp2WbYvaXNeRes57TLhEXD/9o2aO6QVzR4wAQn2x7tP6Y7GHfN/F+z1jf87RPR3Sdy1OSLacG4YF3uNiI7c05E9PDweGO764DPzXyGiJefcq/jn23S97XoDM7/AzK8w8yura5u36+Lh4TFi7MXU/ywR/VVm/mUiqhDRJPUtgGlmjgZv/aNEtHC7LzvnXiSiF4mIPvHxj77fxUgPD48PAHd98J1z3ySibxIRMfMXiOh/cc79DWb+l0T0K0T0HSL6KhF99277KlxBnV7fr22HOsx1qgaiES0tmOgIhRBy+Lv2nyOVAaWPzVBemwvx69ev3lT9Lr0sIZknL+oxLjfFTzsKmWpPPaXr48WgvZ6T9p974CI+clSXA//vviiDPvmOlEt+6Ki9TEI97avqDMI6lAdfWZVz2zet1xOCUDyzA7Na+38yOD7cjiOhT3NDCWrtijuE2xZ38j9392mVjw/X1tavU5G45roXucz/zVWhiV87e1b1u7gkc9UzNetCCPvdIQKCPj78PTAhtGmB+9BrU9jXEaYJGkpQ1ZEwdDXdG95PAM/Xqb/Qd576Pv/vvY99eXh4jBD3FMDjnPsREf1osH2RiD75wQ/Jw8PjfmOkkXuuIOoNrKjGtKbApqpCFV2O9HJBBmWb8wDdAC0MEUFUnKXzcvjY2hZT+fJ/PqX6vfaOmHzvLms9vtlpMXv/m1+Qcs9bi5f1sT6yXz6w1pEPINrwc59/SrU9uSTfa62Im1Era937iSmhC4/GOiuud1Oyxba2JOLs6RPPqH4Xrwjtd/TYp1QbgT58ty3jsCZwCbL/TDUzCsE0V5atsefVR2MCK0sXPmDpbiKiAgzdbqL1/c9eEWru1bPixq20tBuXQBnr2JyLY6xPoMeP7g/DJKQmOxS/Zku/4WkWd6DlMBp1p0aJF+Lw8PC4C/yD7+ExhhipqV+4glqdvvl8YP7jqi1GvbxYm8cJ2OmF0tLTpiGu6mcmwsrBqurqGSln9PKfX1D9XrsmsQbzh/Rq/V/7dZGJPnZETOUzr/4n1a+7LCIjtYauMJulYh4XmR5/JZDkm8kpWZ1PjdvyyLzo2dW6uu1kS0zWm01xhfYVOlmoUpbvnX/9tGo7cFDOLcNKutbMxZJUZKDMdLRzbcddvtM/IHwPErDMdW9D+a5X39Vajm+eF/O+CYlheaHZlnKI1ICJCIXtHdLY4IKE6BIYNgeFMqwbgKcTYZLOjglBiXHDDNzjO9y/8T08xhD+wffwGEP4B9/DYwwxWh8/T6nV6tNl8wc/qtoCoGEOTDyp2pZaQrGh72QDwmKgSXKy0V3iL22uyHrCkq5wRb/4+ceH21/6JT3GA8fF599oSaZeXNFZa2vviY9fPXpctbU7QhE2C33wRk9ou4Mzss4xU9MlrqcC6XduXdORpxaEclxcF637zg1NxVUrstaweO26apualbWBiEE4xIhcRhhxZtzRHBxXpMBCU9YbM/LsPpAjjKBk2WZL53z86RtvDLcvXNdUcLMnaxQM90Bs1oBU8p8R+sClGGfSVDKIDExgnyUzV4U6OZtZJ9/DSEAmO1cQtWrnKvB0noeHx13gH3wPjzHEaCP3XEZpt58oUao8rdpQX+Pw5EdUWwrUy2YqLoGlO8I7/IwhBXTwmYeH27/2qDa7yjUxiaequrJrmkJpKSjrNbv/mOq3dlVM5+kJnRzT7co4tnvvqbZHQf9vfkISZw5WNCV4c1UEQhaWtZDIQ4fnh9tHgcGzevMBaPVtb+gx3lwSIZTjsD80+y2sxmGAJr2aYt0PtQXZRLRxIKZtqyvX/eW3T6p+567eoXQV0L+Bso/NfIQY9amaKAf6DUuKERFxCHp/YLLb+W4n4l5ivYPBwXHAtz0uEamndYfiPu/SsAv8G9/DYwzhH3wPjzGEf/A9PMYQI/Xx8yKnVqdfLy4wvlLO4s80avOqbSIRnfOtLfH1HO0eWsmWMgEqpDIh/nmjVFH9NreEpouamgLLCwgJBhpnrqHDYde7Qj9urev6eDkIfa43tW/dmZeMsYeOyLrB4rKuM7AZCd3WiHWWY2VSqEXUmy8SXU4bhSGPHNGCIOfPAr13FMJybQoeuMyhKbWtInbhWFZXH6m+1FCwF69JaPXbZyS0emFVzwd69XcK1UaazrrCKGGfpHquQvDJ88KsUYAfjvdcakJ7Ge53NmtTeGyVqXcHh30HeXdrXHtk9fwb38NjDOEffA+PMcRoTf08ofXNvhnZSrUJzGBVV6s6Eq5Wkoi5Uihmf2B4lwhMucicGmq7Y5mpUqDpsCKTaLpmS0fWbSVCc4VAE80WurTUTF2i7pZXrqm2xn4xzacqDdU2U5fPmyviBrx+SWsQlieFZqyXtVlahQjIEmjuR1ajHUzCySk9DozQW1uXOTg0p2lFRtPZcqlY1gquE5uS3J2u7P+1c1oH79V3JWtwHa5FLdZFm1RMnMm60+eNH6wmnnzPim0EcO+k1g1ALUA45yzX/VAkZofgCLx/lYDJjvA8gXUXJAJyb7a+f+N7eIwh/IPv4TGGGK2p71JqJn1Tf7H7smqbSGQlfzJ/TLcFYmLuC8CsjvSKfL0kySuJWSFuBGLO1hgq7lZ0AaBOSVbMVxe16bndk1X3OphUqVntjsH87i3rhJLpA9J24qiu1FusyrjOXhLTNnVaW7DXE1Nxo2dls8VkReu7ZOYjBmu2UdG3QXlOXK3XTl8ebn/+k9otqkRicgemsqu2UiFBCpKbiIhOX5HV+pdP6YSjLmgtRqEcyzIIBVZe3hH9x7dt26GJR7ujA3O8IwISTPg0F5fMRiHG8L3MMAMIHJeNIFQJTTsSfe5NYNu/8T08xhD+wffwGEP4B9/DYwwxUh8/5JAmK30qije1r5cX4qe1E60jH7D4dw6yyto9rXuPEVc942NhxBWWe9pu6yiwq5vi13dz7T9XyuKD7wuEsqtk2t9aLSPtp33JSaCi0huaRrvyHohBZtKvVjGZbyU4NxMB2c7keL1UtjeNJv7auqxXhIZiCyB57OUL4oPX9msR1If2Sx2AasmUMwPxyi0Qznj7zDnV7+qyRDkWhkYLwa/P4Vr0OqbEFejsRzsE50GcRYXI6WOVYB+dRNOnuFbC5ntJCvcILGxE5v7rQdagLTeG3CqrGmB63SRT97D16e+tTPaeHnxmvkxE20SUE1HmnHuOmWeJ6A+J6DgRXSaiv+acW99tHx4eHh8e3Iup/4vOuWecc88NPn+DiF5yzp0gopcGnz08PH4G8H5M/a8Q0RcG29+mfk29r9/pC70ioYvtfiTbpZvnVdtjgejbPVTVEWJHGk8Mt8tVcQO6bkP1IzC5ralVqMqr2KZNpJTEjIxZm+lzsdBZ06FEE7LpNzklFWzTdS3m0b4oSTqrTe3uZDDmLuqwm0SilWX5XqWq25Q4CZiQlu5hcBcuXdHRhUUk3+vAub15WevZdSF5pWzKWq0sSYTljYXL8h3jnuG1cOY9lAKd52Dbmsp4ZDb7SCAiDxN2SkYMowdJTFZUpAy0cdcIfWAUXgnEPEKbhJbh/vUucnARWP3dRPhh9KnexW00+O+Mvb7xHRH9e2Z+lZlfGPxt3jl3g4ho8P+BXb/t4eHxocJe3/ifdc4tMPMBIvoBM797128MMPiheIGIaHpmpGuJHh4eu2BPb3zn3MLg/yUi+hPql8deZOZDRESD/5d2+e6LzrnnnHPP1RvWQPHw8HgQuOsrmJnrRBQ457YH23+ZiP4REX2PiL5KRN8a/P/du+0rdRktpMtERFRqm8y6ptBqi4EWU5x8REJ4YxY/O4h0SWQU2t9Zihh93937haBPHhkqrgSUWBYuD7fTXPuLRUtCXqOOztxr9yCby1AyBYRrhqFsB05fpqwtdFO1bkJUYW2glUG22I6ITtlnvaFpuq0tWTuZm5M1ii2TrfjupcvSb0KvNSzdEDGPdkfWJGplHX6MYhMuM5lvILSClJ0Nmw2BIk1yfaJZjn69nHNm/OeswFBn/YLCfQQ7MuakbwDbucnOI0UJ6n1wAdl5MB9Gy4Og245y2pJRuDdaby+29zwR/clgxxER/XPn3L9l5peJ6I+Y+WtE9B4R/eqejujh4fHAcdcH3zl3kYh+/jZ/XyWiL92PQXl4eNxfjHS1LQojmpvuU3XlqjYbZ8E0WmxdVW0vL/1kuP3EjGjuu7I2sUH2nlxXR3cFWG8LN020WARRbLGlBLsyxpWOmPq9TNOPnSUhOFzXiDqg+3AHBiZod4bbiTEN84aYnq1URxdOgNlbAnM2dPpcGlXpN3dov2pbg+jIG0uLw+1mSZvHqytC763eNGY6pP9VQBDEZs+lCWS+GfMbDW5FwAb6uqM2f5DZ8tfSF0tcO5utCPSeTXRLIao0YO0GxBDWh/vPjZsYASWY3aGEdgD3Y2QER+IylNDu6ehCJEX3Ah+r7+ExhvAPvofHGMI/+B4eY4jRlsnmjNphv4R0FGkf6MCEUGBxT/s251YkvLdUl5Dd+bqmypZaUotuYUVTgofmRKe+1gB/q6bXAipY8jrQvlg7kc/Npvj1vDWn+gUd8MUK7fuiD8eGr0F2jyG8dGtVq/hsrgo9Nv2I9s9XuuIzb3VkvPvLmm47PCPzaOmrA7HQe+WSjPH8yqLqt31DaL9GbEJlc9lnXJc5LRK9JhFBWHFgRS6xZDSsDWRGPSfDrDgTOowZeVg/MbIhtTD3vcyMEUJx4x0KPEjhyfcsTYwfi8TWGcTFKdTpN4+nUhOy2vz3lp3n3/geHmMI/+B7eIwhRmvqU0Hdom8O1TpahOLGhphMFyKdChBPAT0WnRhurxhK4/yWiDUGkTaxKzUxjzvhRdmuaA1/npTsubiszUZMLAs3hf5hI8SBgXZsRSjBynPGtKUQGsF0PjStRS7nYYy1WI9xsylzUoff9YmqpsCqUN65Y7Tor6+uDrcvLAhld21dR2WjdnxQ1dezill3YIqXjCmONrbNIEQTuAdRfbaMVQwCqc7QWRhBF0DkHhv3Bstph8ZMLwFlZ4+NpbLQ+uZQ7z8BQVBXGAoZvohlvm3FsiKBCD93+/HvNUfPv/E9PMYQ/sH38BhDjNTUZya6tUB6ID+o2jbzteF2M9ar2EEbV6pFA266rHXpnzj05HB7X1mv1mf8g+H2RiaRgFmmq80mTiIDqa2ryLotKBkFpiebKDBGkzXXZrQDE3DnQqzsvwRm7kxDJ7Y4XII2iRzlWVm9DyBizpqAHYj4O3Vdr9afuX5juL2ZSoRlbpNowFw2C9WEFn0JEp+wHFV/p1Bqy0b1oVmt3AWjqw/9stzo5UHkHjMk6Ri2JQMhjjiyZjRWwTVzAKcTBqCnaFyCbg8EXkxEHjPSORiDZ9wW0JSMrZt4bzoc/o3v4TGO8A++h8cYwj/4Hh5jiBHr6kc0U+5Huc3nR1Xbn4U/Hm47E5WUgABGsy067B87+qzqF8fiC3fTt1VbKxEqqgOZe50NQ/udE5+/vKhpNIZIvjCGiLDMOFgQWWaj0Qh9/MzWbwNxTBRuSI1gB64hxJqmCyFjMYP9La5tqX6nrwtNd2VNq6I3wf/vpeIz26i4MtBSKJpBRBSBLx8pv17PRwE+rV1DCFDIEtYrrNhGjlScichDcYwOnIsVyijB90JzzVJYX0ChFiIixhxC+F5hsgQDoAQDQ1sWoLCBFKYV/ezC/AShHmNs6Mm7wb/xPTzGEP7B9/AYQ4zU1J8Mp+jLM88TEdGlm1psY6IEYhas6as2ibbe4qaY+hvdZdVvNpSS1+2W/k1rbgg1x5uS3NO4/ITqF998WPoZ2TTUVsDkDDbJPK4As6uiqRvVLzS/u2jCgpkXmX4Oo+IMPZYBNXRpVSjSN8/r+V7eFvO+Z5KF0JiNUN/fCPeFQFmVjQkfgVhGCPtgwzv1UhS50G0BJMegt9OzZjqIaARGpCNF2hUuYCWyJb/kWLaKdQDUn5Xci2A/qJnIZj5icPFKZowFuCoY5ehMRCVGNia5vifEndpbso5/43t4jCH8g+/hMYbwD76HxxhitKVt8oKKzb6IpI0wfLj0C8PtVqhFIwjcZGYRodxe0rr6nVyEOPLLWgCztvUrw+1yV+reuY6mQQr0dwsd9ovuk6JrTNgsV2T8hRGNIFUnzVJb8CG9vd9HRMSQudc2/u7Z92QN5K0bEnq7YWrWoZhFYcNQI5nwCLYLsr61jKNsXEukMVVGm8lW1BW6zVoGnDfSb2WT+RYCpdZNTSgu+OcxCmrY9a1xFe4AAAk+SURBVBW4FoWhJpVjb6g+rKXHDurjmXPBtQAr8KqjuqHOgHlIHMwdruUQEfUGbfZe2Q3+je/hMYbwD76HxxhipKa+yzNKNvsU3MdCXT56OZHPV+ua7kA7MkykbfusNsUn1oWyq25rUz+EUy0CjJQyNBS4FS40umxdNNsx/cxGTYFW3A5uCNrMsZVoB5izSPcQEa1ui9n+7tKaajsDEXnbYJrbklHogsShnm8UqUgxutDsA/XndpS1QiouxXkzYhuEkWraTM2AfgtV2TNT4gp8LedMPQXoG+N8G4s4QaEPZ1yfEKlJfU90e+J6omBHycwpluFKzf7xMYwwstPUQggLjC7Ue7h9oe3dsac3PjNPM/O/YuZ3mfk0M3+GmWeZ+QfMfG7w/8zd9+Th4fFhwF5N/f+DiP6tc+4J6pfTOk1E3yCil5xzJ4jopcFnDw+PnwHspVruJBF9noj+ByIi17elEmb+ChF9YdDt20T0IyL6+h13ljG5lb4JtFLW5uvmlCRQbGRvqbbelphvR7Y/Ptw+uPox1S9MRYuOI2NGw7ZatTWru5jkYbXRAthn2kO9ZJNsAyal08vWxKgxZ60yCFjMEtnn4npHdTt5RYQzrqxqEY0emLo5mMdJapNS0OUwpcJQFwLM7di4Jsq8t+XGMIotQEPUiFyAmV7YJB0wq3GuEpMAgy6I1cvDy4sah9mOJXMsf2U09yDSLs20KxGqKMoSbOvdoxvQbJvxw7lVwYa352nFxxG3mJMPUnPvUSJaJqL/i5lfZ+b/c1Aue945d4OIaPD/gTvtxMPD48ODvTz4ERE9S0S/65z7BBG16B7MemZ+gZlfYeZXNlrJ3b/g4eFx37GXB/8aEV1zzt1KmP9X1P8hWGTmQ0REg/+Xbvdl59yLzrnnnHPPTdd3T1jx8PAYHe7q4zvnbjLzVWZ+3Dl3hoi+RESnBv++SkTfGvz/3bvtq5u16czSa0REtHFU+8U90JSfKGZV28Mbn5e2tcdk8Gw08e9A1zhwXEPlqxpBQ8hAc0bwwYHgBmbn7QixAgTWf4Z92gixFMZyfU3qALx54Yrqd31TdO+taAkKWxSQ3RWZfiEWVjaLDRhYhi1VQ286PJYRFUX1TQ5R9NNQdkq05A6UIO7f0JsYkWfZLCbxz0HXk/JUi3LiqOLIiJvi94xIJ1JuKiDPOPkprLHYkmURiIeqNQRzXZQIqC2d7u5NiGOvPP7fJKI/YOYSEV0kov+R+tbCHzHz14joPSL61Xs6soeHxwPDnh5859wbRPTcbZq+9MEOx8PDYxQYaeReWida/nTfBIrKutLtTEf07fYvfkK11bePD7dDBuEDk6igLGdjfStLV+ldmAQYMKFsxBxST1jZ1lr6ypw3CTBIq2319P63SczPk1clAm9hc0XvH07GGbPRlni6hR3ReUCr2W/gmJHCs/0yML/ZUJq7CVsUxe50GMfaxE5g/0kmc1M2Loei1GzJMlWIVvZhmdQwQDEPbab34Nhsogax6i5+yzkjbgJzEJnxYwRkCjSuTeZBarUwN3hxK0lnj4Sej9X38BhD+Affw2MM4R98D48xxEh9/Ciu0eyh/hphaVHXzpu+IYF/lZbO3GPM4IK/F9adwT8YxxuFIQIVNmp8JV3HWrU5DCGFMFRb7tpBVlyno329rY74iwvNpmq7uCDCGastoexy0msBuRN/NDHrBCEsPsQoKBlYwREUdTT+OficuJ0YUU6Gz4ERx8DacSgOYQUwsJx0bscI+v4BXiezjqG0+a24SS5rCnhtQ7PmEQGFl2Rd1YZrPQHb76GPj2W9NV2ImYeBCVvOcswuBAETWz8Ac/DMfJcG6wZW3GU3+De+h8cYwj/4Hh5jCN6rRtcHcjDmZSK6QkT7iGjlLt3vNz4MYyDy47Dw49C413E87Jzbf7dOI33whwdlfsU5d7uAoLEagx+HH8eDGoc39T08xhD+wffwGEM8qAf/xQd0XMSHYQxEfhwWfhwa92UcD8TH9/DweLDwpr6HxxhipA8+Mz/PzGeY+Twzj0yVl5l/n5mXmPkk/G3k8uDMfIyZfziQKH+HmX/zQYyFmSvM/BNmfnMwjn84+PsjzPzjwTj+cKC/cN/BzOFAz/H7D2oczHyZmd9m5jeY+ZXB3x7EPTISKfuRPfjcz2f8J0T0S0T0FBH9GjM/NaLD/zMiet787UHIg2dE9Hecc08S0aeJ6DcGczDqsfSI6IvOuZ8nomeI6Hlm/jQR/RYR/fZgHOtE9LX7PI5b+E3qS7bfwoMaxy86554B+uxB3COjkbJ3zo3kHxF9hoj+HXz+JhF9c4THP05EJ+HzGSI6NNg+RERnRjUWGMN3iejLD3IsRFQjoteI6FPUDxSJbne97uPxjw5u5i8S0fepnyr/IMZxmYj2mb+N9LoQ0SQRXaLB2tv9HMcoTf0jRHQVPl8b/O1B4YHKgzPzcSL6BBH9+EGMZWBev0F9kdQfENEFItpwbpiRMqrr8ztE9HdJ8q/mHtA4HBH9e2Z+lZlfGPxt1NdlZFL2o3zwb5c2NJaUAjM3iOhfE9Hfcs5tPYgxOOdy59wz1H/jfpKInrxdt/s5Bmb+K0S05Jx7Ff886nEM8Fnn3LPUd0V/g5k/f7cv3Ae8Lyn7e8EoH/xrRHQMPh8looVd+o4Ce5IH/6DBzDH1H/o/cM798YMcCxGRc26D+lWQPk1E08zD3ONRXJ/PEtFfZebLRPQd6pv7v/MAxkHOuYXB/0tE9CfU/zEc9XV5X1L294JRPvgvE9GJwYptiYj+OhF9b4THt/ge9WXBifYoD/5+wX0Rtd8jotPOuX/8oMbCzPuZeXqwXSWiv0T9RaQfEtGvjGoczrlvOueOOueOU/9++I/Oub8x6nEwc52ZJ25tE9FfJqKTNOLr4py7SURXmfnxwZ9uSdl/8OO434smZpHil4noLPX9yb83wuP+CyK6QUQp9X9Vv0Z9X/IlIjo3+H92BOP4HPXN1reI6I3Bv18e9ViI6OeI6PXBOE4S0d8f/P1RIvoJEZ0non9JROURXqMvENH3H8Q4Bsd7c/DvnVv35gO6R54holcG1+b/JqKZ+zEOH7nn4TGG8JF7Hh5jCP/ge3iMIfyD7+ExhvAPvofHGMI/+B4eYwj/4Ht4jCH8g+/hMYbwD76HxxjivwBETDiF1OfPRgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 10\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": "code",
   "execution_count": 378,
   "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",
      "train_x's shape: (12288, 209)\n",
      "test_x's shape: (12288, 50)\n",
      "(1, 209)\n",
      "(1, 50)\n"
     ]
    }
   ],
   "source": [
    "# Reshape the training and test examples\n",
    "\n",
    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
    "\n",
    "#standardize our dataset\n",
    "#see lab 1 notes for more info\n",
    "train_x = train_set_x_flatten/255\n",
    "test_x = test_set_x_flatten/255\n",
    "\n",
    "#Hack\n",
    "train_y = train_set_y\n",
    "test_y = test_set_y\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]))\n",
    "\n",
    "\n",
    "print (\"train_x's shape: \" + str(train_x.shape))\n",
    "print (\"test_x's shape: \" + str(test_x.shape))\n",
    "print (train_y.shape)\n",
    "print (test_y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "#debug data\n",
    "#X\n",
    "#training_set_inputs = np.array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]).T\n",
    "training_set_inputs = np.array([[1, 1, 0]]).T\n",
    "train_x = training_set_inputs\n",
    "\n",
    "#Y\n",
    "#training_set_outputs = np.array([[0, 1, 1, 0]])\n",
    "training_set_outputs = np.array([[1]])\n",
    "train_y = training_set_outputs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters(n_x, n_h, n_y):\n",
    "    \"\"\"\n",
    "    Argument:\n",
    "    n_x -- size of the input layer\n",
    "    n_h -- size of the hidden layer\n",
    "    n_y -- size of the output layer\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- python dictionary containing your parameters:\n",
    "                    W1 -- weight matrix of shape (n_h, n_x)\n",
    "                    b1 -- bias vector of shape (n_h, 1)\n",
    "                    W2 -- weight matrix of shape (n_y, n_h)\n",
    "                    b2 -- bias vector of shape (n_y, 1)\n",
    "    \"\"\"\n",
    "    \n",
    "    np.random.seed(1)\n",
    "    \n",
    "    W1 = np.random.randn(n_h, n_x) * 0.01\n",
    "    b1 = np.zeros(shape=(n_h,1))\n",
    "    W2 =  np.random.randn(n_y, n_h) * 0.01\n",
    "    b2 = np.zeros(shape=(n_y,1))\n",
    "    \n",
    "    print (\"the shape of w1 at init is\" + str(W1.shape))\n",
    "    print (\"the shape of w2 at init is\" + str(W2.shape))\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\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the shape of w1 at init is(2, 3)\n",
      "the shape of w2 at init is(1, 2)\n",
      "W1 = [[ 0.01624345 -0.00611756 -0.00528172]\n",
      " [-0.01072969  0.00865408 -0.02301539]]\n",
      "b1 = [[0.]\n",
      " [0.]]\n",
      "W2 = [[ 0.01744812 -0.00761207]]\n",
      "b2 = [[0.]]\n"
     ]
    }
   ],
   "source": [
    "#Unit Test for initialize_parameters\n",
    "parameters = initialize_parameters(3,2,1)\n",
    "print(\"W1 = \" + str(parameters[\"W1\"]))\n",
    "print(\"b1 = \" + str(parameters[\"b1\"]))\n",
    "print(\"W2 = \" + str(parameters[\"W2\"]))\n",
    "print(\"b2 = \" + str(parameters[\"b2\"]))\n",
    "\n",
    "#Expected output\n",
    "#W1 = [[ 0.01624345 -0.00611756 -0.00528172]\n",
    "# [-0.01072969  0.00865408 -0.02301539]]\n",
    "#b1 = [[0.]\n",
    "# [0.]]\n",
    "#W2 = [[ 0.01744812 -0.00761207]]\n",
    "#b2 = [[0.]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 488,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters_deep(layer_dims, debug = \"N\"):\n",
    "    \"\"\"\n",
    "    Arguments:\n",
    "    layer_dims -- python array (list) containing the dimensions of each layer in our network\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", ..., \"WL\", \"bL\":\n",
    "                    Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])\n",
    "                    bl -- bias vector of shape (layer_dims[l], 1)\n",
    "    \"\"\"\n",
    "    #######################################\n",
    "    np.random.seed(1)\n",
    "    #first np.random.seed(3)\n",
    "    ####################################### \n",
    "    \n",
    "    parameters = {}\n",
    "    L = len(layer_dims)            # number of layers in the network\n",
    "\n",
    "    for l in range(1, L):\n",
    "                \n",
    "        if debug == \"Y\":\n",
    "            parameters['W' + str(l)] = np.zeros((layer_dims[l], layer_dims[l-1]))\n",
    "            parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))\n",
    "\n",
    "        else:\n",
    "            parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) / np.sqrt(layer_dims[l-1]) #*0.01\n",
    "            #first!!!!! \n",
    "            #parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * 0.01\n",
    "            parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))\n",
    "            \n",
    "              \n",
    "        assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l-1]))\n",
    "        assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))\n",
    "\n",
    "    #print (parameters)    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 489,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W1 = [[ 0.72642933 -0.27358579 -0.23620559 -0.47984616  0.38702206]\n",
      " [-1.0292794   0.78030354 -0.34042208  0.14267862 -0.11152182]\n",
      " [ 0.65387455 -0.92132293 -0.14418936 -0.17175433  0.50703711]\n",
      " [-0.49188633 -0.07711224 -0.39259022  0.01887856  0.26064289]]\n",
      "b1 = [[0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]]\n",
      "W2 = [[-0.55030959  0.57236185  0.45079536  0.25124717]\n",
      " [ 0.45042797 -0.34186393 -0.06144511 -0.46788472]\n",
      " [-0.13394404  0.26517773 -0.34583038 -0.19837676]]\n",
      "b2 = [[0.]\n",
      " [0.]\n",
      " [0.]]\n"
     ]
    }
   ],
   "source": [
    "parameters = initialize_parameters_deep([5,4,3])\n",
    "print(\"W1 = \" + str(parameters[\"W1\"]))\n",
    "print(\"b1 = \" + str(parameters[\"b1\"]))\n",
    "print(\"W2 = \" + str(parameters[\"W2\"]))\n",
    "print(\"b2 = \" + str(parameters[\"b2\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_forward(A, W, b):\n",
    "    \"\"\"\n",
    "    Implement the linear part of a layer's forward propagation.\n",
    "\n",
    "    Arguments:\n",
    "    A -- activations from previous layer (or input data): (size of previous layer, number of examples)\n",
    "    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)\n",
    "    b -- bias vector, numpy array of shape (size of the current layer, 1)\n",
    "\n",
    "    Returns:\n",
    "    Z -- the input of the activation function, also called pre-activation parameter \n",
    "    cache -- a python dictionary containing \"A\", \"W\" and \"b\" ; stored for computing the backward pass efficiently\n",
    "    \"\"\"\n",
    "    #print (W.shape)\n",
    "    #print (A.shape)\n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    Z = np.dot(W, A) + b\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    assert(Z.shape == (W.shape[0], A.shape[1]))\n",
    "    cache = (A, W, b)\n",
    "    \n",
    "    return Z, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z = [[ 3.26295337 -1.23429987]]\n"
     ]
    }
   ],
   "source": [
    "A, W, b = linear_forward_test_case()\n",
    "\n",
    "Z, linear_cache = linear_forward(A, W, b)\n",
    "print(\"Z = \" + str(Z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_activation_forward(A_prev, W, b, activation):\n",
    "    \"\"\"\n",
    "    Implement the forward propagation for the LINEAR->ACTIVATION layer\n",
    "\n",
    "    Arguments:\n",
    "    A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples)\n",
    "    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)\n",
    "    b -- bias vector, numpy array of shape (size of the current layer, 1)\n",
    "    activation -- the activation to be used in this layer, stored as a text string: \"sigmoid\" or \"relu\"\n",
    "\n",
    "    Returns:\n",
    "    A -- the output of the activation function, also called the post-activation value \n",
    "    cache -- a python dictionary containing \"linear_cache\" and \"activation_cache\";\n",
    "             stored for computing the backward pass efficiently\n",
    "    \"\"\"\n",
    "    \n",
    "    if activation == \"sigmoid\":\n",
    "        # Inputs: \"A_prev, W, b\". Outputs: \"A, activation_cache\".\n",
    "        ### START CODE HERE ### (≈ 2 lines of code)\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = sigmoid(Z)\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    elif activation == \"relu\":\n",
    "        # Inputs: \"A_prev, W, b\". Outputs: \"A, activation_cache\".\n",
    "        ### START CODE HERE ### (≈ 2 lines of code)\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = relu(Z)\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    assert (A.shape == (W.shape[0], A_prev.shape[1]))\n",
    "    cache = (linear_cache, activation_cache)\n",
    "\n",
    "    \n",
    "    #print (\"activation= \" + str(activation))\n",
    "    #print (\"W= \" + str(W))\n",
    "    #print (\"b= \" + str(b))\n",
    "    #print (\"Z= \" + str(Z))\n",
    "    #print (\"A= \" + str(A))\n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "activation= sigmoid\n",
      "W= [[ 0.50288142 -1.24528809 -1.05795222]]\n",
      "b= [[-0.90900761]]\n",
      "Z= [[ 3.43896131 -2.08938436]]\n",
      "A= [[0.96890023 0.11013289]]\n",
      "With sigmoid: A = [[0.96890023 0.11013289]]\n",
      "activation= relu\n",
      "W= [[ 0.50288142 -1.24528809 -1.05795222]]\n",
      "b= [[-0.90900761]]\n",
      "Z= [[ 3.43896131 -2.08938436]]\n",
      "A= [[3.43896131 0.        ]]\n",
      "With ReLU: A = [[3.43896131 0.        ]]\n"
     ]
    }
   ],
   "source": [
    "A_prev, W, b = linear_activation_forward_test_case()\n",
    "\n",
    "A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = \"sigmoid\")\n",
    "print(\"With sigmoid: A = \" + str(A))\n",
    "\n",
    "A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = \"relu\")\n",
    "print(\"With ReLU: A = \" + str(A))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [],
   "source": [
    "def L_model_forward(X, parameters):\n",
    "    \"\"\"\n",
    "    Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation\n",
    "    \n",
    "    Arguments:\n",
    "    X -- data, numpy array of shape (input size, number of examples)\n",
    "    parameters -- output of initialize_parameters_deep()\n",
    "    \n",
    "    Returns:\n",
    "    AL -- last post-activation value\n",
    "    caches -- list of caches containing:\n",
    "                every cache of linear_activation_forward() (there are L-1 of them, indexed from 0 to L-1)\n",
    "    \"\"\"\n",
    "\n",
    "    caches = []\n",
    "    A = X\n",
    "    L = len(parameters) // 2                  # number of layers in the neural network\n",
    "    \n",
    "    # Implement [LINEAR -> RELU]*(L-1). Add \"cache\" to the \"caches\" list.\n",
    "    for l in range(1, L):\n",
    "        #print(\"The Layer is: \" + str (l))\n",
    "        \n",
    "        A_prev = A \n",
    "        #print(A_prev.shape)\n",
    "        ### START CODE HERE ### (≈ 2 lines of code)\n",
    "        A, cache = linear_activation_forward(A_prev,\n",
    "                                             parameters['W' + str(l)],\n",
    "                                             parameters['b' + str(l)],\n",
    "                                             activation='relu')\n",
    "        caches.append(cache)\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    # Implement LINEAR -> SIGMOID. Add \"cache\" to the \"caches\" list.\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    AL, cache =  linear_activation_forward(A, \n",
    "                                          parameters['W' + str(L)], \n",
    "                                          parameters['b' + str(L)], \n",
    "                                          activation='sigmoid')\n",
    "    caches.append(cache)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    assert(AL.shape == (1,X.shape[1]))\n",
    "            \n",
    "    return AL, caches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Layer is: 1\n",
      "Z= [[-5.23825714  3.18040136  0.4074501  -1.88612721]\n",
      " [-2.77358234 -0.56177316  3.18141623 -0.99209432]\n",
      " [ 4.18500916 -1.78006909 -0.14502619  2.72141638]\n",
      " [ 5.05850802 -1.25674082 -3.54566654  3.82321852]]\n",
      "A= [[0.         3.18040136 0.4074501  0.        ]\n",
      " [0.         0.         3.18141623 0.        ]\n",
      " [4.18500916 0.         0.         2.72141638]\n",
      " [5.05850802 0.         0.         3.82321852]]\n",
      "The Layer is: 2\n",
      "Z= [[ 2.2644603   1.09971298 -2.90298027  1.54036335]\n",
      " [ 6.33722569 -2.38116246 -4.11228806  4.48582383]\n",
      " [10.37508342 -0.66591468  1.63635185  8.17870169]]\n",
      "A= [[ 2.2644603   1.09971298  0.          1.54036335]\n",
      " [ 6.33722569  0.          0.          4.48582383]\n",
      " [10.37508342  0.          1.63635185  8.17870169]]\n",
      "Z= [[-3.19864676  0.87117055 -1.40297864 -3.00319435]]\n",
      "A= [[0.03921668 0.70498921 0.19734387 0.04728177]]\n",
      "AL = [[0.03921668 0.70498921 0.19734387 0.04728177]]\n",
      "Length of caches list = 3\n"
     ]
    }
   ],
   "source": [
    "X, parameters = L_model_forward_test_case_2hidden()\n",
    "AL, caches = L_model_forward(X, parameters)\n",
    "print(\"AL = \" + str(AL))\n",
    "print(\"Length of caches list = \" + str(len(caches)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(AL, Y):\n",
    "    \"\"\"\n",
    "    Implement the cost function defined by equation (7).\n",
    "\n",
    "    Arguments:\n",
    "    AL -- probability vector corresponding to your label predictions, shape (1, number of examples)\n",
    "    Y -- true \"label\" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples)\n",
    "\n",
    "    Returns:\n",
    "    cost -- cross-entropy cost\n",
    "    \"\"\"\n",
    "    \n",
    "    m = Y.shape[1]\n",
    "\n",
    "    # Compute loss from aL and y.\n",
    "    cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))\n",
    "    # different from dnn_app_utils_v3   cost = (1./m) * (-np.dot(Y,np.log(AL).T) - np.dot(1-Y, np.log(1-AL).T))\n",
    "    \n",
    "    \n",
    "    cost = np.squeeze(cost)      # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost = 0.41493159961539694\n"
     ]
    }
   ],
   "source": [
    "Y, AL = compute_cost_test_case()\n",
    "\n",
    "print(\"cost = \" + str(compute_cost(AL, Y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_backward(dZ, cache):\n",
    "    \"\"\"\n",
    "    Implement the linear portion of backward propagation for a single layer (layer l)\n",
    "\n",
    "    Arguments:\n",
    "    dZ -- Gradient of the cost with respect to the linear output (of current layer l)\n",
    "    cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer\n",
    "\n",
    "    Returns:\n",
    "    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev\n",
    "    dW -- Gradient of the cost with respect to W (current layer l), same shape as W\n",
    "    db -- Gradient of the cost with respect to b (current layer l), same shape as b\n",
    "    \"\"\"\n",
    "    A_prev, W, b = cache\n",
    "    m = A_prev.shape[1]\n",
    "\n",
    "    ### START CODE HERE ### (≈ 3 lines of code)\n",
    "    dW = np.dot(dZ, cache[0].T) / m\n",
    "    db = np.sum(dZ, axis=1, keepdims=True) / m\n",
    "    dA_prev = np.dot(cache[1].T, dZ)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    assert (dA_prev.shape == A_prev.shape)\n",
    "    assert (dW.shape == W.shape)\n",
    "    assert (db.shape == b.shape)\n",
    "    \n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dA_prev = [[ 0.51822968 -0.19517421]\n",
      " [-0.40506361  0.15255393]\n",
      " [ 2.37496825 -0.89445391]]\n",
      "dW = [[-0.10076895  1.40685096  1.64992505]]\n",
      "db = [[0.50629448]]\n"
     ]
    }
   ],
   "source": [
    "# Set up some test inputs\n",
    "dZ, linear_cache = linear_backward_test_case()\n",
    "\n",
    "dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
    "print (\"dA_prev = \"+ str(dA_prev))\n",
    "print (\"dW = \" + str(dW))\n",
    "print (\"db = \" + str(db))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_activation_backward(dA, cache, activation):\n",
    "    \"\"\"\n",
    "    Implement the backward propagation for the LINEAR->ACTIVATION layer.\n",
    "    \n",
    "    Arguments:\n",
    "    dA -- post-activation gradient for current layer l \n",
    "    cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently\n",
    "    activation -- the activation to be used in this layer, stored as a text string: \"sigmoid\" or \"relu\"\n",
    "    \n",
    "    Returns:\n",
    "    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev\n",
    "    dW -- Gradient of the cost with respect to W (current layer l), same shape as W\n",
    "    db -- Gradient of the cost with respect to b (current layer l), same shape as b\n",
    "    \"\"\"\n",
    "    linear_cache, activation_cache = cache\n",
    "    \n",
    "    if activation == \"relu\":\n",
    "        ### START CODE HERE ### (≈ 2 lines of code)\n",
    "        dZ = relu_backward(dA, activation_cache)\n",
    "        dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "    elif activation == \"sigmoid\":\n",
    "        ### START CODE HERE ### (≈ 2 lines of code)\n",
    "        dZ = sigmoid_backward(dA, activation_cache)\n",
    "        dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid:\n",
      "dA_prev = [[ 0.11017994  0.01105339]\n",
      " [ 0.09466817  0.00949723]\n",
      " [-0.05743092 -0.00576154]]\n",
      "dW = [[ 0.10266786  0.09778551 -0.01968084]]\n",
      "db = [[-0.05729622]]\n",
      "\n",
      "relu:\n",
      "dA_prev = [[ 0.44090989 -0.        ]\n",
      " [ 0.37883606 -0.        ]\n",
      " [-0.2298228   0.        ]]\n",
      "dW = [[ 0.44513824  0.37371418 -0.10478989]]\n",
      "db = [[-0.20837892]]\n"
     ]
    }
   ],
   "source": [
    "dAL, linear_activation_cache = linear_activation_backward_test_case()\n",
    "\n",
    "dA_prev, dW, db = linear_activation_backward(dAL, linear_activation_cache, activation = \"sigmoid\")\n",
    "print (\"sigmoid:\")\n",
    "print (\"dA_prev = \"+ str(dA_prev))\n",
    "print (\"dW = \" + str(dW))\n",
    "print (\"db = \" + str(db) + \"\\n\")\n",
    "\n",
    "dA_prev, dW, db = linear_activation_backward(dAL, linear_activation_cache, activation = \"relu\")\n",
    "print (\"relu:\")\n",
    "print (\"dA_prev = \"+ str(dA_prev))\n",
    "print (\"dW = \" + str(dW))\n",
    "print (\"db = \" + str(db))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "def L_model_backward(AL, Y, caches):\n",
    "    \"\"\"\n",
    "    Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group\n",
    "    \n",
    "    Arguments:\n",
    "    AL -- probability vector, output of the forward propagation (L_model_forward())\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat)\n",
    "    caches -- list of caches containing:\n",
    "                every cache of linear_activation_forward() with \"relu\" (it's caches[l], for l in range(L-1) i.e l = 0...L-2)\n",
    "                the cache of linear_activation_forward() with \"sigmoid\" (it's caches[L-1])\n",
    "    \n",
    "    Returns:\n",
    "    grads -- A dictionary with the gradients\n",
    "             grads[\"dA\" + str(l)] = ... \n",
    "             grads[\"dW\" + str(l)] = ...\n",
    "             grads[\"db\" + str(l)] = ... \n",
    "    \"\"\"\n",
    "    grads = {}\n",
    "    L = len(caches) # the number of layers\n",
    "    m = AL.shape[1]\n",
    "    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\n",
    "    \n",
    "    # Initializing the backpropagation\n",
    "    ### START CODE HERE ### (1 line of code)\n",
    "    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: \"dAL, current_cache\". Outputs: \"grads[\"dAL-1\"], grads[\"dWL\"], grads[\"dbL\"]\n",
    "    ### START CODE HERE ### (approx. 2 lines)\n",
    "    current_cache = caches[-1]\n",
    "    grads[\"dA\" + str(L-1)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_activation_backward(dAL, current_cache, activation=\"sigmoid\")\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Loop from l=L-2 to l=0\n",
    "    for l in reversed(range(L-1)):\n",
    "        # lth layer: (RELU -> LINEAR) gradients.\n",
    "        # Inputs: \"grads[\"dA\" + str(l + 1)], current_cache\". Outputs: \"grads[\"dA\" + str(l)] , grads[\"dW\" + str(l + 1)] , grads[\"db\" + str(l + 1)] \n",
    "        ### START CODE HERE ### (approx. 5 lines)\n",
    "        current_cache = caches[l]\n",
    "        #print (l)\n",
    "        #print (grads)\n",
    "        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads[\"dA\" + str(l + 1)], current_cache, activation=\"relu\")\n",
    "        grads[\"dA\" + str(l)] = dA_prev_temp\n",
    "        grads[\"dW\" + str(l + 1)] = dW_temp\n",
    "        grads[\"db\" + str(l + 1)] = db_temp\n",
    "        ### END CODE HERE ###\n",
    "\n",
    "    return grads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'dA1': array([[ 0.12913162, -0.44014127],\n",
      "       [-0.14175655,  0.48317296],\n",
      "       [ 0.01663708, -0.05670698]]), 'dW2': array([[-0.39202432, -0.13325855, -0.04601089]]), 'db2': array([[0.15187861]]), 'dA0': array([[ 0.        ,  0.52257901],\n",
      "       [ 0.        , -0.3269206 ],\n",
      "       [ 0.        , -0.32070404],\n",
      "       [ 0.        , -0.74079187]]), 'dW1': array([[0.41010002, 0.07807203, 0.13798444, 0.10502167],\n",
      "       [0.        , 0.        , 0.        , 0.        ],\n",
      "       [0.05283652, 0.01005865, 0.01777766, 0.0135308 ]]), 'db1': array([[-0.22007063],\n",
      "       [ 0.        ],\n",
      "       [-0.02835349]])}\n"
     ]
    }
   ],
   "source": [
    "AL, Y_assess, caches = L_model_backward_test_case()\n",
    "grads = L_model_backward(AL, Y_assess, caches)\n",
    "print(grads)\n",
    "######maybe wrong"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    \"\"\"\n",
    "    Update parameters using gradient descent\n",
    "    \n",
    "    Arguments:\n",
    "    parameters -- python dictionary containing your parameters \n",
    "    grads -- python dictionary containing your gradients, output of L_model_backward\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- python dictionary containing your updated parameters \n",
    "                  parameters[\"W\" + str(l)] = ... \n",
    "                  parameters[\"b\" + str(l)] = ...\n",
    "    \"\"\"\n",
    "    \n",
    "    # Number of layers in the neural network\n",
    "    L = len(parameters) // 2\n",
    "\n",
    "    # Update rule for each parameter\n",
    "    for l in range(L):\n",
    "        #print(\"upate info begin\")\n",
    "        #print(\"dW = \" + str(grads[\"dW\" + str(l+1)]))\n",
    "        #print (\"W = \" + str(parameters[\"W\" + str(l+1)]))\n",
    "        #print(\"upate info end\")  \n",
    "        parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)] - learning_rate * grads[\"dW\" + str(l+1)]\n",
    "        parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)] - learning_rate * grads[\"db\" + str(l+1)]\n",
    "      \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W1 = [[-0.59562069 -0.09991781 -2.14584584  1.82662008]\n",
      " [-1.76569676 -0.80627147  0.51115557 -1.18258802]\n",
      " [-1.0535704  -0.86128581  0.68284052  2.20374577]]\n",
      "b1 = [[-0.04659241]\n",
      " [-1.28888275]\n",
      " [ 0.53405496]]\n",
      "W2 = [[-0.55569196  0.0354055   1.32964895]]\n",
      "b2 = [[-0.84610769]]\n"
     ]
    }
   ],
   "source": [
    "parameters, grads = update_parameters_test_case()\n",
    "parameters = update_parameters(parameters, grads, 0.1)\n",
    "\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": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(Z):\n",
    "    \"\"\"\n",
    "    Implements the sigmoid activation in numpy\n",
    "    \n",
    "    Arguments:\n",
    "    Z -- numpy array of any shape\n",
    "    \n",
    "    Returns:\n",
    "    A -- output of sigmoid(z), same shape as Z\n",
    "    cache -- returns Z as well, useful during backpropagation\n",
    "    \"\"\"\n",
    "    \n",
    "    A = 1/(1+np.exp(-Z))\n",
    "    cache = Z\n",
    "    \n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu(Z):\n",
    "    \"\"\"\n",
    "    Implement the RELU function.\n",
    "    Arguments:\n",
    "    Z -- Output of the linear layer, of any shape\n",
    "    Returns:\n",
    "    A -- Post-activation parameter, of the same shape as Z\n",
    "    cache -- a python dictionary containing \"A\" ; stored for computing the backward pass efficiently\n",
    "    \"\"\"\n",
    "    \n",
    "    A = np.maximum(0,Z)\n",
    "    \n",
    "    assert(A.shape == Z.shape)\n",
    "    \n",
    "    cache = Z \n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu_backward(dA, cache):\n",
    "    \"\"\"\n",
    "    Implement the backward propagation for a single RELU unit.\n",
    "    Arguments:\n",
    "    dA -- post-activation gradient, of any shape\n",
    "    cache -- 'Z' where we store for computing backward propagation efficiently\n",
    "    Returns:\n",
    "    dZ -- Gradient of the cost with respect to Z\n",
    "    \"\"\"\n",
    "    \n",
    "    Z = cache\n",
    "    dZ = np.array(dA, copy=True) # just converting dz to a correct object.\n",
    "    \n",
    "    # When z <= 0, you should set dz to 0 as well. \n",
    "    dZ[Z <= 0] = 0\n",
    "    \n",
    "    assert (dZ.shape == Z.shape)\n",
    "    \n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid_backward(dA, cache):\n",
    "    \"\"\"\n",
    "    Implement the backward propagation for a single SIGMOID unit.\n",
    "    Arguments:\n",
    "    dA -- post-activation gradient, of any shape\n",
    "    cache -- 'Z' where we store for computing backward propagation efficiently\n",
    "    Returns:\n",
    "    dZ -- Gradient of the cost with respect to Z\n",
    "    \"\"\"\n",
    "    \n",
    "    Z = cache\n",
    "    \n",
    "    s = 1/(1+np.exp(-Z))\n",
    "    dZ = dA * s * (1-s)\n",
    "    \n",
    "    assert (dZ.shape == Z.shape)\n",
    "    \n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, y, parameters):\n",
    "    \"\"\"\n",
    "    This function is used to predict the results of a  L-layer neural network.\n",
    "    \n",
    "    Arguments:\n",
    "    X -- data set of examples you would like to label\n",
    "    parameters -- parameters of the trained model\n",
    "    \n",
    "    Returns:\n",
    "    p -- predictions for the given dataset X\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    n = len(parameters) // 2 # number of layers in the neural network\n",
    "    p = np.zeros((1,m))\n",
    "    \n",
    "    # Forward propagation\n",
    "    probas, caches = L_model_forward(X, parameters)\n",
    "\n",
    "    \n",
    "    # convert probas to 0/1 predictions\n",
    "    for i in range(0, probas.shape[1]):\n",
    "        if probas[0,i] > 0.5:\n",
    "            p[0,i] = 1\n",
    "        else:\n",
    "            p[0,i] = 0\n",
    "    \n",
    "    #print results\n",
    "    #print (\"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": 321,
   "metadata": {},
   "outputs": [],
   "source": [
    "def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
    "    \"\"\"\n",
    "    Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input data, of shape (n_x, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)\n",
    "    layers_dims -- dimensions of the layers (n_x, n_h, n_y)\n",
    "    num_iterations -- number of iterations of the optimization loop\n",
    "    learning_rate -- learning rate of the gradient descent update rule\n",
    "    print_cost -- If set to True, this will print the cost every 100 iterations \n",
    "    \n",
    "    Returns:\n",
    "    parameters -- a dictionary containing W1, W2, b1, and b2\n",
    "    \"\"\"\n",
    "    \n",
    "    np.random.seed(1)\n",
    "    grads = {}\n",
    "    costs = []                              # to keep track of the cost\n",
    "    m = X.shape[1]                           # number of examples\n",
    "    (n_x, n_h, n_y) = layers_dims\n",
    "    \n",
    "    # Initialize parameters dictionary\n",
    "    parameters = initialize_parameters(n_x, n_h, n_y)\n",
    "    print (parameters)\n",
    "    \n",
    "    # Get W1, b1, W2 and b2 from the dictionary parameters.\n",
    "    W1 = parameters[\"W1\"]\n",
    "    b1 = parameters[\"b1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    b2 = parameters[\"b2\"]\n",
    "    \n",
    "    # Loop (gradient descent)\n",
    "\n",
    "    for i in range(0, num_iterations):\n",
    "\n",
    "        # Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: \"X, W1, b1, W2, b2\". Output: \"A1, cache1, A2, cache2\".\n",
    "        ### START CODE HERE ### (≈ 2 lines of code)\n",
    "        A1, cache1 = linear_activation_forward(X, W1, b1, activation='relu')\n",
    "        A2, cache2 = linear_activation_forward(A1, W2, b2, activation='sigmoid')\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Compute cost\n",
    "        ### START CODE HERE ### (≈ 1 line of code)\n",
    "        cost = compute_cost(A2, Y)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Initializing backward propagation\n",
    "        dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))\n",
    "        \n",
    "        # Backward propagation. Inputs: \"dA2, cache2, cache1\". Outputs: \"dA1, dW2, db2; also dA0 (not used), dW1, db1\".\n",
    "        ### START CODE HERE ### (≈ 2 lines of code)\n",
    "        dA1, dW2, db2 =  linear_activation_backward(dA2, cache2, activation='sigmoid')\n",
    "        dA0, dW1, db1 =  linear_activation_backward(dA1, cache1, activation='relu')\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2\n",
    "        grads['dW1'] = dW1\n",
    "        grads['db1'] = db1\n",
    "        grads['dW2'] = dW2\n",
    "        grads['db2'] = db2\n",
    "        \n",
    "        # Update parameters.\n",
    "        ### START CODE HERE ### (approx. 1 line of code)\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "        ### END CODE HERE ###\n",
    "\n",
    "        # Retrieve W1, b1, W2, b2 from parameters\n",
    "        W1 = parameters[\"W1\"]\n",
    "        b1 = parameters[\"b1\"]\n",
    "        W2 = parameters[\"W2\"]\n",
    "        b2 = parameters[\"b2\"]\n",
    "        \n",
    "        # Print the cost every 100 training example\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n",
    "        if print_cost and i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "       \n",
    "    # plot the cost\n",
    "\n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (per tens)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the shape of w1 at init is(7, 12288)\n",
      "the shape of w2 at init is(1, 7)\n",
      "{'W1': array([[ 0.01624345, -0.00611756, -0.00528172, ..., -0.00527214,\n",
      "        -0.0038034 ,  0.00949412],\n",
      "       [ 0.01009231,  0.00229889, -0.00664099, ...,  0.00689859,\n",
      "        -0.00488322,  0.0020761 ],\n",
      "       [-0.0035634 , -0.00195481,  0.00636803, ...,  0.00822751,\n",
      "        -0.00104425, -0.00657957],\n",
      "       ...,\n",
      "       [-0.00315398,  0.0124543 , -0.01304592, ...,  0.00370126,\n",
      "         0.01033177, -0.00896044],\n",
      "       [ 0.00487913,  0.00350058, -0.00084749, ..., -0.00559281,\n",
      "         0.00325022,  0.00231429],\n",
      "       [ 0.00534074,  0.02512388, -0.01044755, ...,  0.0216518 ,\n",
      "        -0.00842579,  0.00359795]]), 'b1': array([[0.],\n",
      "       [0.],\n",
      "       [0.],\n",
      "       [0.],\n",
      "       [0.],\n",
      "       [0.],\n",
      "       [0.]]), 'W2': array([[-8.53306509e-03,  2.62677554e-02,  1.44462274e-03,\n",
      "         2.81582154e-02, -4.48247037e-05,  1.56583537e-02,\n",
      "        -2.90084643e-03]]), 'b2': array([[0.]])}\n",
      "Cost after iteration 0: 0.693049735659989\n",
      "Cost after iteration 100: 0.6464320953428849\n",
      "Cost after iteration 200: 0.6325140647912678\n",
      "Cost after iteration 300: 0.6015024920354665\n",
      "Cost after iteration 400: 0.5601966311605747\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-400-7165cf29897f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mlayers_dims\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mn_x\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_h\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_y\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mparameters\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtwo_layer_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain_x\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrain_y\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlayers_dims\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mn_x\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_h\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_y\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnum_iterations\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2500\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprint_cost\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-321-18f651f7c187>\u001b[0m in \u001b[0;36mtwo_layer_model\u001b[1;34m(X, Y, layers_dims, learning_rate, num_iterations, print_cost)\u001b[0m\n\u001b[0;32m     52\u001b[0m         \u001b[1;31m### START CODE HERE ### (≈ 2 lines of code)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     53\u001b[0m         \u001b[0mdA1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdW2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdb2\u001b[0m \u001b[1;33m=\u001b[0m  \u001b[0mlinear_activation_backward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdA2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcache2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mactivation\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'sigmoid'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 54\u001b[1;33m         \u001b[0mdA0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdW1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdb1\u001b[0m \u001b[1;33m=\u001b[0m  \u001b[0mlinear_activation_backward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdA1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcache1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mactivation\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'relu'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     55\u001b[0m         \u001b[1;31m### END CODE HERE ###\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     56\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-185-2fc21da85069>\u001b[0m in \u001b[0;36mlinear_activation_backward\u001b[1;34m(dA, cache, activation)\u001b[0m\n\u001b[0;32m     18\u001b[0m         \u001b[1;31m### START CODE HERE ### (≈ 2 lines of code)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m         \u001b[0mdZ\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrelu_backward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdA\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mactivation_cache\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m         \u001b[0mdA_prev\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdW\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlinear_backward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdZ\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlinear_cache\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     21\u001b[0m         \u001b[1;31m### END CODE HERE ###\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     22\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-183-6eae2efef1d3>\u001b[0m in \u001b[0;36mlinear_backward\u001b[1;34m(dZ, cache)\u001b[0m\n\u001b[0;32m     18\u001b[0m     \u001b[0mdW\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdZ\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m     \u001b[0mdb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdZ\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m     \u001b[0mdA_prev\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcache\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdZ\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     21\u001b[0m     \u001b[1;31m### END CODE HERE ###\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     22\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "### CONSTANTS DEFINING THE MODEL ####\n",
    "n_x = 12288     # num_px * num_px * 3\n",
    "n_h = 7\n",
    "n_y = 1\n",
    "layers_dims = (n_x, n_h, n_y)\n",
    "\n",
    "parameters = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9999999999999998\n"
     ]
    }
   ],
   "source": [
    "predictions_train = predict(train_x, train_y, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.72\n"
     ]
    }
   ],
   "source": [
    "pred_test = predict(test_x, test_y, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12288, 7, 1)\n"
     ]
    }
   ],
   "source": [
    "print (layers_dims)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "metadata": {},
   "outputs": [],
   "source": [
    "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):#lr was 0.009\n",
    "    \"\"\"\n",
    "    Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.\n",
    "    \n",
    "    Arguments:\n",
    "    X -- data, numpy array of shape (number of examples, num_px * num_px * 3)\n",
    "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)\n",
    "    layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).\n",
    "    learning_rate -- learning rate of the gradient descent update rule\n",
    "    num_iterations -- number of iterations of the optimization loop\n",
    "    print_cost -- if True, it prints the cost every 100 steps\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- parameters learnt by the model. They can then be used to predict.\n",
    "    \"\"\"\n",
    "\n",
    "    np.random.seed(1)\n",
    "    costs = []                         # keep track of cost\n",
    "    \n",
    "    # Parameters initialization\n",
    "    parameters = initialize_parameters_deep(layers_dims, debug = \"N\")\n",
    "    #print (parameters)\n",
    "        \n",
    "    # Loop (gradient descent)\n",
    "    for i in range(0, num_iterations):\n",
    "\n",
    "        # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.\n",
    "        AL, caches = L_model_forward(X, parameters)\n",
    "        \n",
    "        \n",
    "        # Compute cost.\n",
    "        cost = compute_cost(AL, Y)\n",
    "        \n",
    "        \n",
    "        # Backward propagation.\n",
    "        grads = L_model_backward(AL, Y, caches)\n",
    "        \n",
    " \n",
    "        # Update parameters.\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "        \n",
    "                \n",
    "        # Print the cost every 100 training example\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "           # print (\"dW4 = \" + str(grads[\"dW4\"]))\n",
    "            #print (\"dW3 = \" + str(grads[\"dW3\"]))\n",
    "            #print (grads[\"dW2\"])\n",
    "        if print_cost and i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "    \n",
    "    #print final grads\n",
    "    print (grads)\n",
    "    \n",
    "    # plot the cost\n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (per tens)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 490,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.771749\n",
      "Cost after iteration 100: 0.672053\n",
      "Cost after iteration 200: 0.648263\n",
      "Cost after iteration 300: 0.611507\n",
      "Cost after iteration 400: 0.567047\n",
      "Cost after iteration 500: 0.540138\n",
      "Cost after iteration 600: 0.527930\n",
      "Cost after iteration 700: 0.465477\n",
      "Cost after iteration 800: 0.369126\n",
      "Cost after iteration 900: 0.391747\n",
      "Cost after iteration 1000: 0.315187\n",
      "Cost after iteration 1100: 0.272700\n",
      "Cost after iteration 1200: 0.237419\n",
      "Cost after iteration 1300: 0.199601\n",
      "Cost after iteration 1400: 0.189263\n",
      "Cost after iteration 1500: 0.161189\n",
      "Cost after iteration 1600: 0.148214\n",
      "Cost after iteration 1700: 0.137775\n",
      "Cost after iteration 1800: 0.129740\n",
      "Cost after iteration 1900: 0.121225\n",
      "Cost after iteration 2000: 0.113821\n",
      "Cost after iteration 2100: 0.107839\n",
      "Cost after iteration 2200: 0.102855\n",
      "Cost after iteration 2300: 0.100897\n",
      "Cost after iteration 2400: 0.092878\n",
      "{'dA3': array([[-0.06628231, -0.06615294,  0.00293107, ..., -0.06615294,\n",
      "        -0.06519955, -0.06578337],\n",
      "       [ 0.01470369,  0.01467499, -0.00065021, ...,  0.01467499,\n",
      "         0.0144635 ,  0.01459301],\n",
      "       [ 0.06856161,  0.0684278 , -0.00303186, ...,  0.0684278 ,\n",
      "         0.06744162,  0.06804551],\n",
      "       [ 0.1125871 ,  0.11236736, -0.00497871, ...,  0.11236736,\n",
      "         0.11074793,  0.1117396 ],\n",
      "       [ 0.0101493 ,  0.01012949, -0.00044881, ...,  0.01012949,\n",
      "         0.00998351,  0.0100729 ]]), 'dW4': array([[ 0.0339978 , -0.00271707, -0.01332154, -0.00744551, -0.00112082]]), 'db4': array([[0.03614488]]), 'dA2': array([[-0.01144396, -0.01385228, -0.00169384, ..., -0.01385228,\n",
      "        -0.02331207,  0.04647937],\n",
      "       [ 0.02537058, -0.01454044, -0.00565897, ..., -0.01454044,\n",
      "        -0.01737507,  0.12250497],\n",
      "       [-0.0412088 , -0.05102801, -0.00454623, ..., -0.05102801,\n",
      "        -0.04489548,  0.10258817],\n",
      "       ...,\n",
      "       [ 0.04197766,  0.04254102, -0.00372262, ...,  0.04254102,\n",
      "         0.03800988,  0.08012104],\n",
      "       [ 0.08742401,  0.01594057, -0.00489118, ...,  0.01594057,\n",
      "         0.01777287,  0.09864812],\n",
      "       [ 0.00457528,  0.01033754,  0.00013229, ...,  0.01033754,\n",
      "         0.00431196,  0.00206768]]), 'dW3': array([[ 0.00000000e+00,  3.40968504e-03,  1.66111953e-03,\n",
      "         9.35418887e-05,  1.42990920e-04,  1.48395507e-03,\n",
      "         0.00000000e+00],\n",
      "       [ 0.00000000e+00, -7.60945216e-04, -4.70287867e-04,\n",
      "        -3.78223686e-05, -3.17202886e-05, -3.60159709e-04,\n",
      "         0.00000000e+00],\n",
      "       [ 0.00000000e+00, -3.54820024e-03, -2.12234080e-03,\n",
      "        -1.82760891e-02, -1.47908066e-04, -1.68065785e-03,\n",
      "         0.00000000e+00],\n",
      "       [ 0.00000000e+00, -5.92290653e-03, -3.29194412e-03,\n",
      "        -2.89608338e-04, -2.42884314e-04, -2.83544629e-03,\n",
      "         0.00000000e+00],\n",
      "       [ 0.00000000e+00, -1.51498463e-04, -2.53534084e-04,\n",
      "        -1.17594006e-05, -2.18951077e-05, -2.51774204e-04,\n",
      "         0.00000000e+00]]), 'db3': array([[-0.03445838],\n",
      "       [ 0.00079412],\n",
      "       [-0.00020911],\n",
      "       [ 0.00383474],\n",
      "       [ 0.00125051]]), 'dA1': array([[-0.00890365,  0.        , -0.00236364, ...,  0.        ,\n",
      "        -0.01331148,  0.03041732],\n",
      "       [ 0.01103292,  0.        , -0.00112407, ...,  0.        ,\n",
      "        -0.0109104 ,  0.02493075],\n",
      "       [ 0.02829323,  0.        , -0.00309911, ...,  0.        ,\n",
      "         0.00055205, -0.00126146],\n",
      "       ...,\n",
      "       [-0.02203651,  0.        , -0.00013951, ...,  0.        ,\n",
      "        -0.0061034 ,  0.01394654],\n",
      "       [ 0.01617143,  0.        , -0.00347509, ...,  0.        ,\n",
      "        -0.01890477,  0.04319825],\n",
      "       [-0.04175691,  0.        ,  0.00387678, ...,  0.        ,\n",
      "         0.01216988, -0.02780871]]), 'dW2': array([[ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00],\n",
      "       [-2.51094117e-03, -7.68018569e-03, -6.15776131e-03,\n",
      "        -3.49679889e-04, -3.30572616e-03, -5.99039479e-05,\n",
      "        -5.18626343e-05, -3.85186671e-03, -2.07586383e-04,\n",
      "        -2.26214309e-03, -4.85429377e-03, -4.79569287e-03,\n",
      "        -4.09562613e-04, -2.88641744e-03, -5.70295613e-03,\n",
      "        -5.19868807e-04,  2.04468487e-04,  0.00000000e+00,\n",
      "        -5.23633944e-04, -2.76914057e-03],\n",
      "       [-2.93397737e-04, -5.15121325e-03, -7.51455911e-03,\n",
      "        -5.50950184e-04, -4.50574112e-03,  1.36524600e-05,\n",
      "        -7.92717124e-05, -1.67730058e-03,  6.56476484e-04,\n",
      "        -1.04715725e-03, -2.10839130e-03, -1.50150304e-03,\n",
      "        -6.98737907e-04, -2.30333733e-03, -4.15994846e-03,\n",
      "        -9.71736983e-04,  1.20050456e-03,  0.00000000e+00,\n",
      "        -2.89862483e-04,  2.90405466e-04],\n",
      "       [-9.12595607e-04, -8.20901662e-03, -1.15693223e-02,\n",
      "        -1.33516595e-03, -5.00018705e-03, -6.25100916e-06,\n",
      "        -7.64093983e-07, -5.97756420e-04, -6.65183711e-05,\n",
      "        -2.66574835e-04, -1.01402446e-02,  5.92497699e-04,\n",
      "        -2.76221245e-06, -2.11152473e-04, -3.78368454e-03,\n",
      "        -6.61841017e-03, -1.86316117e-03,  0.00000000e+00,\n",
      "         0.00000000e+00, -1.63123966e-03],\n",
      "       [-1.72089741e-05, -1.97133274e-03, -4.02791278e-04,\n",
      "        -1.57590818e-04, -1.07623617e-03, -4.60687897e-05,\n",
      "        -2.25139033e-06, -2.23935261e-05, -8.59446457e-05,\n",
      "        -5.81357063e-05, -2.45886040e-04, -8.93754365e-04,\n",
      "        -3.93681161e-05, -3.76693712e-05, -9.42065976e-04,\n",
      "        -6.52006540e-04, -2.24408150e-05,  0.00000000e+00,\n",
      "        -3.16769652e-05, -1.85691587e-04],\n",
      "       [ 1.42315237e-04,  2.92919926e-02,  1.37894362e-02,\n",
      "        -1.15785461e-04,  1.28467040e-02,  3.33855680e-04,\n",
      "         5.12753298e-04,  4.53109714e-03,  5.85594894e-04,\n",
      "         1.49021933e-04,  1.81005730e-02,  1.48213586e-02,\n",
      "         3.69645597e-04,  1.47251181e-03,  1.57677330e-02,\n",
      "         1.41580423e-02,  2.14912810e-03,  0.00000000e+00,\n",
      "        -2.30434516e-04,  1.10961502e-02],\n",
      "       [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "         0.00000000e+00,  0.00000000e+00]]), 'db2': array([[ 0.        ],\n",
      "       [-0.00142711],\n",
      "       [-0.00106683],\n",
      "       [-0.00176459],\n",
      "       [-0.00026868],\n",
      "       [ 0.00426417],\n",
      "       [ 0.        ]]), 'dA0': array([[ 7.54990628e-04,  0.00000000e+00, -1.97542340e-05, ...,\n",
      "         0.00000000e+00, -6.06583768e-04,  5.49193691e-04],\n",
      "       [-6.49939589e-04,  0.00000000e+00,  1.25897882e-04, ...,\n",
      "         0.00000000e+00, -1.39000822e-04, -5.93167512e-04],\n",
      "       [-1.65017606e-03,  0.00000000e+00,  1.47673746e-04, ...,\n",
      "         0.00000000e+00,  2.24468138e-04, -1.11488287e-03],\n",
      "       ...,\n",
      "       [ 1.97944011e-04,  0.00000000e+00, -8.91677522e-08, ...,\n",
      "         0.00000000e+00, -1.03762302e-04,  1.23548587e-03],\n",
      "       [-4.71672329e-04,  0.00000000e+00,  6.25249007e-05, ...,\n",
      "         0.00000000e+00, -4.68337079e-04,  1.05322664e-03],\n",
      "       [ 1.29186173e-03,  0.00000000e+00, -7.84165787e-05, ...,\n",
      "         0.00000000e+00, -7.93996375e-04,  5.48071227e-04]]), 'dW1': array([[-7.55276089e-04, -6.99809595e-04, -6.72908950e-04, ...,\n",
      "        -5.72002363e-04, -5.90851631e-04, -5.55027350e-04],\n",
      "       [ 6.15093164e-04,  6.02592431e-04,  5.47757106e-04, ...,\n",
      "         1.86606127e-04,  6.66222422e-05,  3.14187680e-05],\n",
      "       [-2.86880349e-04, -2.34919114e-04, -2.41495610e-04, ...,\n",
      "         1.83590125e-04,  2.30526500e-04,  1.98340962e-04],\n",
      "       ...,\n",
      "       [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00, ...,\n",
      "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00],\n",
      "       [-3.53271835e-06,  6.55335970e-05, -2.88429914e-05, ...,\n",
      "         9.58701117e-05,  8.01603179e-05,  3.88068564e-05],\n",
      "       [-6.29252104e-04, -6.35533725e-04, -5.50919807e-04, ...,\n",
      "        -5.07867330e-04, -4.03028689e-04, -3.45636499e-04]]), 'db1': array([[-1.51612423e-03],\n",
      "       [ 1.01149691e-03],\n",
      "       [-2.39903418e-04],\n",
      "       [ 8.34228461e-05],\n",
      "       [ 1.00415592e-03],\n",
      "       [ 9.67605268e-04],\n",
      "       [ 3.16446309e-05],\n",
      "       [-1.35427347e-03],\n",
      "       [ 1.29008207e-03],\n",
      "       [-1.22853261e-04],\n",
      "       [-1.72155915e-03],\n",
      "       [ 9.32757618e-04],\n",
      "       [-8.22867417e-05],\n",
      "       [-2.09949984e-03],\n",
      "       [ 8.50924554e-04],\n",
      "       [-1.14633272e-03],\n",
      "       [-4.45137616e-04],\n",
      "       [ 0.00000000e+00],\n",
      "       [ 4.47087969e-04],\n",
      "       [-1.41338370e-03]])}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'W1': array([[ 0.01672799, -0.00641608, -0.00338875, ..., -0.00685887,\n",
      "        -0.00593783,  0.01060475],\n",
      "       [ 0.01395808,  0.00407498, -0.0049068 , ...,  0.01317046,\n",
      "         0.00221326,  0.00930175],\n",
      "       [-0.00123843, -0.00597204,  0.00472214, ...,  0.00101904,\n",
      "        -0.00862638, -0.00505112],\n",
      "       ...,\n",
      "       [ 0.00140823, -0.00137711,  0.0163992 , ..., -0.00846451,\n",
      "        -0.00761603, -0.00149162],\n",
      "       [-0.00168698, -0.00618577, -0.01023935, ...,  0.02050705,\n",
      "        -0.00428185,  0.00149319],\n",
      "       [-0.01770891, -0.0067836 ,  0.00756873, ...,  0.01730701,\n",
      "         0.01297081, -0.00322241]]), 'b1': array([[ 3.85542520e-03],\n",
      "       [ 8.18087056e-03],\n",
      "       [ 6.52138546e-03],\n",
      "       [ 2.85633678e-03],\n",
      "       [ 6.01081275e-03],\n",
      "       [ 8.17122684e-04],\n",
      "       [ 3.72986493e-04],\n",
      "       [ 7.05992009e-04],\n",
      "       [ 4.36344692e-04],\n",
      "       [ 1.90827285e-03],\n",
      "       [-6.51686461e-03],\n",
      "       [ 6.97258125e-03],\n",
      "       [-1.08988113e-03],\n",
      "       [ 5.40858776e-03],\n",
      "       [ 8.16752511e-03],\n",
      "       [-1.05298871e-02],\n",
      "       [-9.05267219e-05],\n",
      "       [-5.13240993e-04],\n",
      "       [ 1.42355924e-03],\n",
      "       [-2.40912130e-03]]), 'W2': array([[ 2.02109232e-01, -3.08645240e-01, -3.77620591e-01,\n",
      "        -4.02563039e-02,  5.90753267e-02,  1.23345558e-01,\n",
      "         3.08047246e-01,  4.71201576e-02,  5.29892230e-02,\n",
      "         1.34732883e-01,  2.15804697e-01, -6.34295948e-01,\n",
      "        -1.56081006e-01,  1.01905466e-01, -1.50584386e-01,\n",
      "         5.31219819e-02,  1.14257132e-01,  4.20697960e-01,\n",
      "         1.08551174e-01, -2.18735332e-01],\n",
      "       [ 3.57091131e-01, -1.40997155e-01,  3.70857247e-01,\n",
      "         2.53207014e-01, -1.12596978e-01, -3.15179195e-01,\n",
      "        -2.48100731e-01,  4.72723584e-01, -7.71870940e-02,\n",
      "         5.39834663e-01, -1.17927181e-02,  6.45463019e-02,\n",
      "         2.73704423e-02,  4.30157714e-01,  1.59318390e-01,\n",
      "        -6.48089126e-01, -1.71894333e-01,  1.77933527e-01,\n",
      "         1.54736463e-01, -7.26815274e-02],\n",
      "       [ 2.96501527e-01,  2.43056424e-01, -1.22400000e-02,\n",
      "         2.69275366e-02,  3.76041647e-01, -1.70245407e-01,\n",
      "        -2.95343754e-02, -7.35716150e-02, -1.80179693e-01,\n",
      "        -5.77515859e-03, -6.38323383e-01,  6.94950669e-02,\n",
      "         7.66137263e-02,  3.66599261e-01,  5.40904716e-02,\n",
      "        -1.51814996e-01, -2.61672559e-01,  1.35946854e-01,\n",
      "         4.21086332e-01, -2.71073484e-01],\n",
      "       [ 1.42186042e-01, -2.66789439e-01,  4.57188131e-01,\n",
      "         2.84732743e-02, -5.49143391e-02, -3.96786581e-02,\n",
      "        -1.68668726e-01, -1.46525541e-01,  3.25325993e-03,\n",
      "        -1.13045329e-01,  4.03935681e-01, -3.92214264e-01,\n",
      "         5.25325051e-04, -3.69642647e-01, -1.15812921e-01,\n",
      "         1.32695899e-01,  3.20810624e-01,  1.88127350e-01,\n",
      "        -4.82784806e-02, -1.48816756e-01],\n",
      "       [-1.65469406e-01,  4.24741323e-01, -5.76900900e-01,\n",
      "         1.58084434e-01, -2.90965849e-01,  3.40124014e-02,\n",
      "        -2.62189635e-01,  2.66917709e-01,  4.77530579e-01,\n",
      "        -1.73491365e-01, -1.48434710e-01, -6.91270097e-02,\n",
      "         5.42923817e-03, -2.85173244e-01,  6.40701002e-02,\n",
      "        -7.33126171e-02,  1.43543481e-01,  7.82250247e-02,\n",
      "        -1.47535352e-01, -3.99073661e-01],\n",
      "       [-2.05468389e-01,  1.66914752e-01,  2.15918881e-01,\n",
      "         2.21774761e-01,  2.52527888e-01,  2.64464223e-01,\n",
      "        -3.07796263e-02, -3.06999665e-01,  3.45835418e-01,\n",
      "         1.05973413e-01, -3.47687682e-01,  9.13383273e-02,\n",
      "         3.97150339e-02, -3.14285982e-01,  2.22363710e-01,\n",
      "        -3.93921988e-01, -9.70224337e-02, -3.03701358e-01,\n",
      "         1.40075127e-01, -4.56621577e-01],\n",
      "       [ 2.06819296e-01, -2.39537245e-01, -4.06133490e-01,\n",
      "         5.92692802e-02,  8.95374287e-02, -3.27700300e-01,\n",
      "        -6.89856027e-02, -6.13447906e-01,  1.89927573e-01,\n",
      "        -1.42814095e-01,  1.77958823e-03, -1.34407806e-01,\n",
      "         9.34036862e-02, -2.00549616e-02,  9.01789763e-02,\n",
      "         3.81627943e-01,  3.30416268e-01, -1.76566228e-02,\n",
      "         9.28388267e-02, -1.16167106e-01]]), 'b2': array([[-0.00088887],\n",
      "       [ 0.02357712],\n",
      "       [ 0.01858614],\n",
      "       [-0.00567557],\n",
      "       [ 0.00636179],\n",
      "       [ 0.02362429],\n",
      "       [-0.00173074]]), 'W3': array([[ 0.20939786,  0.21977478,  0.77135171, -1.07520777, -0.64307173,\n",
      "        -0.24097649, -0.15626735],\n",
      "       [-0.57997618,  0.30851841, -0.03802324, -0.13489975,  0.23488207,\n",
      "         0.76248961, -0.34515092],\n",
      "       [ 0.15990295,  0.5163969 ,  0.15284381,  0.42790606, -0.05980168,\n",
      "         0.87865156, -0.01031899],\n",
      "       [ 0.52908282,  0.93882471,  1.23044256, -0.01481286,  0.41024244,\n",
      "         0.18731983, -0.01414658],\n",
      "       [-0.96753783, -0.30492002,  0.54060558, -0.18776932, -0.39245146,\n",
      "         0.20654634, -0.58863038]]), 'b3': array([[ 0.8623361 ],\n",
      "       [-0.00826002],\n",
      "       [-0.01151116],\n",
      "       [-0.06844291],\n",
      "       [-0.00833715]]), 'W4': array([[-0.83045967,  0.18418824,  0.85885352,  1.41024115,  0.12713131]]), 'b4': array([[-1.73123633]])}\n"
     ]
    }
   ],
   "source": [
    "### CONSTANTS ###\n",
    "#layers_dims = [12288, 7, 1] #  Copy 2 layer above for debug purposes\n",
    "#layers_dims = [12288, 7, 5, 1] #  Copy 2 layer above for debug purposes\n",
    "layers_dims = [12288, 20, 7, 5, 1] #  4-layer model\n",
    "\n",
    "\n",
    "#layers_dims = [12288, 1000, 100, 10, 1] #  4-layer model\n",
    "#layers_dims = [12288, 20, 7, 5, 1] #  4-layer model\n",
    "#layers_dims = [12288, 20, 5, 1] #  test diff arch\n",
    "\n",
    "#layers_dims = [3, 20, 7, 5, 1] #  4-layer model\n",
    "\n",
    "parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)\n",
    "print (parameters)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 491,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9856459330143539\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict(train_x, train_y, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 492,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8\n"
     ]
    }
   ],
   "source": [
    "pred_test = predict(test_x, test_y, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 493,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  import sys\n",
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:8: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``skimage.transform.resize`` instead.\n",
      "  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.0\n",
      "y = 0.0, your L-layer model predicts a \"non-cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#test with custom image\n",
    "my_image = \"meandog.JPG\" # change this to the name of your image file \n",
    "my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)\n",
    "## END CODE HERE ##\n",
    "\n",
    "fname = \"datasets/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))\n",
    "my_image = my_image/255.\n",
    "my_predicted_image = predict(my_image, my_label_y, parameters)\n",
    "\n",
    "plt.imshow(image)\n",
    "print (\"y = \" + str(np.squeeze(my_predicted_image)) + \", your L-layer model predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}