log-reg-as-neural-net.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 0, it's a 'non-cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABAtElEQVR4nO29aZBk13Ue+J2XW1XW2tXVeze60dgXAQ0Q3ERIgsghRdGyaY84tGSHTY84xh/NBB2jCZG0IibsiZkI6Y9k/bDlwIiyaYVsirZEEUE5SFEAN5EUwAYBNEA0Gr3v3VVde1blnnd+ZNY7S9Z7nb1lY5Dni+jo+/LcvO++l+/WO+eec75DIQQ4HI53PqLbPQGHw9Ef+GJ3OAYEvtgdjgGBL3aHY0Dgi93hGBD4Ync4BgQ3tNiJ6KNEdISIjhHR527WpBwOx80HXa+fnYgyAN4C8GEA5wD8CMCvhhDeuHnTczgcNwvZG/juewAcCyGcAAAi+hKAjwNIXOyTExNh+/bt7YPQUjL5RyeX0dMq17g9u9rk71znxFNB1yNK+dItmMfNON8tHl4NQht/fEtA1z1+b1+8FfftZt6S1fmLqKwubjjkjSz2XQDOiuNzAN6b9oXt27fjC8/8ewBAs1ZRsnqVj3dMbFay18RZnvnRUtxu2NVOCQ+Y+YDSbm+UsqQTnqSkz6+9L1tVIaWfHCNtPC0KRnbt41ubT41oxtNjSEHyudLmkfa5PlfyK+B6ztWWbdy+WeNnUuacPMbG4339dz+V+P1bvkFHRE8T0UEiOri4tHT1LzgcjluCG3mznwewRxzv7nymEEJ4BsAzAPDoo4+G/ffcBwC4cOaU6rcq3hOXS4tKtntqJG6/b08hbv/tuZrq1xR/IO1f0pCgS6arZdf3l7rXfqkyqItRsqDeqXaMjWXXMo/E90eKumSHV2MkHqTPI0nW/WZPnmTSkOlj2L5pst7usb5X5k2epMGknOt6cCNv9h8BuIeI7iSiPIBfAfDsDc3G4XDcMlz3mz2E0CCi/xXANwBkAPxRCOEnN21mDofjpuJG1HiEEP47gP9+k+bicDhuIW5osV8zQkDUqAMA9t51jxKdP3sqbi8vzClZs16O27/4UDFu53N6+n9zmvs1Q4oRqT5Otu2vf/f2xu153fF6x+/tO1YWJXyvy/mRYrNL+/B6PQvJu/FdnwhZb16HmzFG+vj2RwtCpkVJOzBdXqPUPZ4NBjDwcFmHY0Dgi93hGBD0VY1vrq5i6W8PAgCKDz2gZLvv2Be3Z/N5JZubuRy3Q6sat3/hwaLql6GhuP29M1Ulq1u1fh1pbqdb7V67zvHT1OKe3W1CV+/WaIXq3qNL6nrdZkn9umUhpV+a7MbHSL+PGwfEXIuXTN0fJN/7tHmI2Sf28Te7wzEg8MXucAwIfLE7HAOCvtrs2SiD6ZFxAMDyG28q2apIhNm69w4ly+VycfvyhQtxu9nSyTQfvJf7LdcLSvbSxXpPc0xM4Gh/ctXvdMt675sU0pu2r9CrLO1Suue4ccdrCtdMsNPTbeW04Xq1+9OOrzN8ODF++FrCZZPHvxmyXuBvdodjQOCL3eEYEPRVjSciUCfqbXJiUslWT5+L28trZSXbdB9H22Vz7Ja7eP6s6tdqMLHFgT1KhDMl/rt2pcTEGTfHNZYm692Nk5wq1vu8EhPArsHFeD15+7273rqkKbKkMex8rz2HvTvCLXke6S67q5/rarKEacDaDGmyXuBvdodjQOCL3eEYEPRVja/Xqrh87hQAYHh8QskmJ5mKqjK3pGRLhzhzdvyh++P2nn37Vb/zghBj7+aGkj22i1Wx548J+qcURqDrVcvkrnpXtFvPKvj17YKrvmkqYa9zuu7ot41V32tLMkn6vHe1PVGNT3vNpXlQ+qrG22ld3buS9n1/szscAwJf7A7HgMAXu8MxIOirzV5tNHB0ZgYAcOw7zynZh372Q3F77x3aFs9WmViy9Crb7yMP3af67b3r7rj9xpFTSnZsbnXDOaW7wmy2mRCl9EtzJ10XEUKXEZk4RGLU3LVFjMkL7c0+7roDaszkKLneb3+Ki079Lr1dS+oYaVGJKZPsff8hzaUmeyX/7jbZLi07Mf7O1bs4HI53AnyxOxwDgr6q8a0oi0pxCgDwZjSuZEM/fCFu7965V8lyw8Nxe6LBCS2l13UyTf7eu/hcxW1KdnHlZNzunfstWd1KU+NTI50CR/m1mppgI4r454iynMgTWk3VDy2+B1FuWMvE+VKK25h7oEtxqWo9Yo5RJqf6KRU2XzQyfo9EUfI7JTXJBBvf8DRuti4zQar/Ka+2NPda72r8xp9fbYxk8y25n/3K+qWlncff7A7HgMAXu8MxIPDF7nAMCPpqs0cEDBXap8yPaZu9mM/EbTI23vzsRe43Phm3xwvaXl07eiJuL9dG7dl5/BTDRrvXrH9DhOA22W6ul+dNP5bZMcoLXA5vbfGiko1t5lS93Di3a1XtNmyuXeHv7H5Un7vBbspQK8Xt6sqC6Sf2C1qa2KOyOMvd1hbjdjarH5ecIAYd2nqXkuXHt8bt4e1CFmVUv5bYj4gyWgbxHKTvkaTUvktwHabvI6RZvnq8VoMzNBtNvvfZ3JDqhyzvdxDp64zEHIP63Nr9vWXfJeGqb3Yi+iMimiGi18VnU0T0TSI62vl/0zWf2eFw9BW9qPH/EcBHzWefA/BcCOEeAM91jh0Ox9sYV1XjQwjfJaJ95uOPA3iq0/4igG8D+OzVxqIownCxrd7kC5obPoo2drMAwHGRzXb2KLvbPvjRj6t+U9Nb4vbCOa36tkR6WxDur2ZtRfers+qL8qySZVYv8fcq/L2VVZ2lJ8cn0m4tqbbmzO2P5tjltXbxCI9nVEcCj7Fy5ZiSVcqsngeh0reM+y4j3Tgm9U+eLyt+i5b2FKK6xu+KyvIVJSuMTfIYNTZdKKNNr5qos12Y2Kpk0RBnRmaEWhwVRlQ/qRank1KkuNeSHz+duVjTvIelw8/H7VaOTceJOx7W4+fYlZqxU8zzPaEMPxNpbsREH9styHrbFkJYNzgvAdiW1tnhcNx+3PBufAghoLvmXwwiepqIDhLRwaWVlaRuDofjFuN6d+MvE9GOEMJFItoBYCapYwjhGQDPAMB9++8KlG2r7zt3b1f98ld4R7srOmjLjrj95ssvx+273zqu+k1tEwqG2dltVnn8lQuv8tgrp1S/LLHqW6toLjy96csHraZW1esNPs6Yi8mIP682Mq5UFjvpYkh7P+oNoWZbnTBsfBCa+u+xPHMmq8cI0uQRKnLGvhpEv5owGQCgucom0Nwp9gRkWnqQXI7Hb1w0Zk1eRBFmuJ0fmdTTyLP6XOhEaMbnG2PTIDPEHqAopyP+pJptQ+2Uip/TFOXj+9/N44/yPnWU1WaqSuRpaO9HKPHyqZTYHBrZ+ZAeIWPHZET1jtkaWsl9EiXpeBbApzrtTwH46nWO43A4+oReXG//BcAPAdxHROeI6NMAfhvAh4noKID/oXPscDjexuhlN/5XE0QfSvjc4XC8DdHfCLqIUCy0I4lCU9urqoSwMVKnt7AtNLWT7ffCsMn4Et9rLGmXVOMEZ9UVVufids6wAAwVeF61gp7H0rKIoBPnytj9SWE25c21VIXtnDNpadJ2zgqdq9LQdlg+y3buSF7bkBVRRqtaEza12VdotoTLy8wjK4zzat1k3AmMDPHjkzO3oFbn8+Wq0hWpO5YEMYkx5xHleM+kFViYW5zTHUXYY8Hs1USizgAJuz87PKb6FSbZts+Oa+dSboxdutlhHfmZmWBZZCLjJOQznTElyUOGzxet8F5HZNy22vOmZXSpvZdF9bXEOXhsvMMxIPDF7nAMCPqqxjcaDSzMt10LzZJOHsmmuBWyeU4iKIjIu6xJZlDcASY5JSqze6NaYxWo1tJq5cPbWVV/9/t1ksnzL16O268dZRdJzajZ0iQpGzW4EXFfqY4DQEWo3Zk8X1vLmBpbJliVfOqn36dkP3jxR3H75HlWCfMmL0NUykJkwq7kccjwfIfNfKXGHGWNa0+MX8iJa+myCvhceePykr9TucG/S9b4AAsi6gx2/Jp0n3I7U1pW3cpzXB3Yum2zQ0OirdX/3Ph03B6eZHdyYdK4lqW7MKt/DGlqFMZ4vK5ELGECReb5Xjv+fQBAq7ox1yLgb3aHY2Dgi93hGBD4Ync4BgR9LtkcIdtxO8xd0RG2e4a51putv5YRNpQMr4xsWKO0NZu61lu1wiGK0hYcLWj76e49T8Ttu/a9S8keeIzTvv7wj78Rt1/48QXVb63ChmMw9rDcc8jlNYHj8PDGstERTcSxeRO7e3bfsVvJfnk7uyn/3R9/OW4vlnTorwyJNdNQbrPiMN/jrHk1rNb4ngbzo0XCIxgJm31kRJ+sIEgdbFxwQ+yn1Jssk78fANRENl6zadM0hDtWhJLmzB5DS4zfMvssWUFK0Srp/I4wyxl9mWxM+YDhonYLD49yGG92RNM/FCfZ9ZZt8RxDTt+rSIQFZy+8omVrM+uTRxL8ze5wDAh8sTscA4L+R9ANtfW70RHDMy40JxtBV6uwO2F0dET000O0qqzPjaxpF8TdwudTENFHm0lna01HQnWKNEnC+OSdcfvX/znLtj/7XdXv1AX+G1oY0hFuI0Ilzxk1TXOTiWi6rFHnhFlTNFGEjzzGJbHeOnUqbv/l899T/VZW2MypkCG2EO+AgnAB2hJDkpKvZU0vmXEnZLmccfOJJ7BlBinmWBjEyUl7v9AUJ1hZ0Sr+8iofk1DVa8ZFJyMFo8hGPQrzsGWzygRPf5ZVaGkKAUBpRUS2ReeVLBcdjtsFGb1I+tkZFi7AXc1zSjY91TaDs5nkJe1vdodjQOCL3eEYEPRVjS+vreGNV18CACxe0ZxlYVLsKtvqqYIYYWWBv9fK6V3Ny6eYSjr38iEl+4hQK5si4SSYhIKcyMbYtnOXlg2x6dFq8Rj/5Ff+rur3+pun4vaxMyaCrsUqeMuohA2RrFJXamUymYKlG54a5zn+jx/7hbh96uxZ1e/FV5j4o9EwEXpT7BWYKLIJUYP2cJTFzne1rK9lVJgoQzLyzqjPMsknayL0muI3kxF/WRvxJ1TfyQl9r8ZF3srCEg8yt6yvJa00VEOo5JbtWpVkEqZGy3gFgjAFbL5MQ5iYtcCmaBPag7JZRJnmGpoaPOTuaP+fciH+Znc4BgS+2B2OAYEvdodjQNBXmx0hoNGJunrz8FtK9Oi7JGGAccEU2eUwPMztSkVzeB8/xnbozKy2aSZF5BqJMkZkSB2qh9nWXziheczvfvJjcTuf5+ykBVNZ6ZGH7o7bhcIpJXvzBLtnVte0268o9gRWQ3J0mjTTrSMoJ8or7d3BkXb/8ON6X+HkmS/E7ZWSdlPKDLMRETZnS0Dnh4SLzpSGmhiRx8I9ZQhBMsKWLQyZCDpxe0hk34WW7tcU+yzWHs4KV9/0ZkG2YZIsZ+b4mqsmCC1n5qzGF5epSjfZymFyr8LI5JaMdGcOF/TFFJtcn2BiVLuFbdTpRvA3u8MxIPDF7nAMCPqqxk+OjeMfPNV2B/3UfZoTuznPZZe6yu8IHUXK5ud0Av/LBzkRoVjRtYpGhHsmL/nuYKqKLrKqVF85rWQz5zn5ZdMWJo3YunWH6jc7yyQX9911t5Jlo6Nx+6VXdDLQQ3ftj9tvnWEX48JyMq/YWlmbAgsi4WVqjE2eRx+4R/W79+59cfuV199QMslLL9s2iWVLgY9tUVRFJCLcQcEQzeWlmWD46wtSRRbqvqEvRKMung+jz7aEO0ySckyOGyIOMa2ZeZNEJca35BtVcX8ymWRzQplexvaSgYNS/R/N6Y4FiCqxI1uULHQiP9Oqu/qb3eEYEPhidzgGBL7YHY4BQX+z3ohQ7JBXPLpvv5K19ojsJGN35GSdL8GcODt7SfVbK7Ftm21o46ouXGxZQWKQMX/v0jwYBCYuWJj9TtwemXhE9du+nTPPrsxpv9z+fffH7YkRndVEGb62iYm74vaLh3RNu8VldpXVG9q+vLLAc5Q2ezGnr7MhiSeMDSnt6KIwnHPGEJUcD1HGkFfICFnRbziv5yHJI1vJ5qZ2a5lz5SWhpcmck0cZSLtf96tU5fOnZaNDsp+e5KoME5bzMja7DLOtmWdTzll62ywJ68QUk1g2jeHP9yT5Ce6l/NMeIvoWEb1BRD8hos90Pp8iom8S0dHO/5uuNpbD4bh96EWNbwD4jRDCgwDeB+DXiehBAJ8D8FwI4R4Az3WOHQ7H2xS91Hq7COBip71CRIcB7ALwcQBPdbp9EcC3AXz2auNR/L+JpBJ6juXL3pThyLKf2sOurEOHL6t+EKp606hzMsNMERBEWh0iIaM0ooKIVbHV5ZdVr0aNXYLTm9+tZEtL7K7asl1HQY2OsXI0L9T/n37X/arfD18+wjOypZsE0UVZhIJ1l3Hia7PEExNjIsIwI9VU4woSrrLIqK1ySEV6YULLmoI4w5JjVKqifJXIPBsZ0e+oTEppaqme54R/0Ja63ryJL2BszPDSF2SIm5bNL/D85xe5XdEeUbTEHO39VuWcRcmn7dOaezCX4UGti7ErlHIDXNMGHRHtA/AYgBcAbOv8IQCASwC2JX3P4XDcfvS82IloFMCfAfgXIQRVTiO0o1423BkgoqeJ6CARHZxbWtqoi8Ph6AN6WuxElEN7of9JCOHPOx9fJqIdHfkOADMbfTeE8EwI4YkQwhObJyZuxpwdDsd14Ko2O7X9YF8AcDiE8LtC9CyATwH47c7/X+3lhKHjVrN/ZYJi/NCyjHBV7NvM1kJ4XLu8Dr30GsvqZhBp46T416QtZLPN9HjctNlgtcqpuD1/WdcUm9j8nrjdDPqPX0a4WrZt5xBcmtF7E+87wKGvly5rxp96ne30suDKL9d0Ktf4hDyXDoMdHRbc/MK2zRk7tyA4/JuWN152lSSTtiyz+N1bZoyRIstGBDOl5a+XWXDGq4UgTrg4xzZvzlDOTGyS9QQNM1Ak74GWTYoQ4u1MDY9LV/RE5kt8bptVJ/cPRqTvraXdqi1hz1tiydZ6nYSUR7YXP/sHAPwTAK8R0Sudz/4l2ov8y0T0aQCnAXyyh7EcDsdtQi+78X+D7tyUdXzo5k7H4XDcKvSXvIK6ud43QjB6MQlfRUbICqZukVS3ulRwmTmnVPrkfhVDolipCRKNIaGmWXIJ6WYxxIALMxx5N7bpMSUrTjzM3xOn3rZNOzqk6jta1FF45VUm9JCRiFbte/BOJtNcndcc5JHSuvkgY0Lt9k1z5tXxK4tKVm1x1qFUz8tlrd6Ojko3nyGSFL64QuDfumHUWxkNZx8v+ewoYk1zLfJ5qZW1np0R7sxMQd/HpnAlDguzY/8d+tnctsbHJy/oLEY5/+lJQWpqSphJr1+Xth6zY9xABJ3D4XhnwBe7wzEg6Ksa32q2UFpp704PjejosVyG1ZzkOpz6KGt2VC2/ukTAxrvxaYkvCwsldfzKc8xP967H98TtndtNPSJN3WAmwruyq8uvK9GYKC+Vz0/yCMb22bqNEyLmrswqWU7dAxE1GLT6/NQHnorbtWXtMTh/njnm67JEqmFu2DPNEX9N6KSN5w8xx2BNcMMvLuvQsh1b2DSaHDaJH8t8X+8VHP6v1zSpSDnDhB1knoG88ARMTvAzVrfeGnFpQ0WtgmdEAtCQcQWUK6xqt0REoU1UqYt7V62a8Drxzh0d5iXZqGkClqbwBNgI0awxbTaCv9kdjgGBL3aHY0Dgi93hGBD01WZfLa/hhUOvAABm5+eU7MB9D8bte/ffpWTSvJJRW91uPFnDrcsJE7daMlrP/r0T7p58XmcdEbFNOTvLkWs7tutIOHVmkw5Gwna22X3NhnD5CPM1azjZpQ0/vXlKyRolzj8orbKLp2nIHKcnOELv53/xl5Xs6Ftsbx8/9jdx+/I5TRYyuWkybj8xpekMTs5w9PTFBZ5T0RB2tIQtu7aq7c4JUepsZYkPFpa0zbuUY3fj2Jj+zaIi37tJkc2HnCGVbPKYjYa+3/VV6VLTRI8rDd7XCcINt1DTc5xZEsQqVb0XJGnpm6u8X9BsaRdgMytqH8DsK3TmT5aJRMDf7A7HgMAXu8MxIOirGl8NhNONtqvlRxd0ZFnUZNUxa/4GnZxh9fGJhx6I2zb5QrrXrIocemjbTyzBxvAo1//N5aqinx6lVGK18sx5rc7dcxer/DnDOPDyyy/G7Yce/kDcnpiYVP0k0UfIanVOhr8Vh1jty5t7Wi+yurttp1atR4UqvGMXt//6L7+i+pUFN/+dO7cr2UNbeM5VwWWPgr5XhSybIURDSoaI711NqNkZY78N5/h7mfxuLdt2R9zelVvkoRtalX79DEcRPvbAw0q2tMQq/4WyPnd+bDJuHzpyOG7Xr1xU/VqillXB/O6jwqWWbXG/ehcBCx9nm7r0GYIlJ+mGv9kdjgGBL3aHY0Dgi93hGBD01WYfKhRw9z1tvvgrQbsVRoXb4uy580p2cZHdOP/5CIeYPrJzn+pHKda4zHSTnIeRdVUImQ29HBnl8E0C7zmsmlJssoTwa2+cVbKJMba1du/W9uWVeR5zZYX530dHtTtJztHwK6JUY9ttRPCp2x+6Jmz9Zlbb7GPCvTk0zPbrw49o11t9XvxOhtRh51Z2Ub3yGte3i+r6fudG2WU3tUW7MNeybFcvivLWw0M6PHlKhF7v2KUzBI9d5ntanUwOzX1kP4+xan7QKwu857B587SSnThxMm6vnOcw3siE1RbHeL9H3l8A2BR4/GFBgFqqJ9vsZMJjw/qegLveHA6HL3aHY0DQZzU+j/v27QQAbLlLq7C1N9n1tqmuVZTcxHDc/mGZVaxq3argyaQUWsGX2WCGb0wOUS0r2e6t7F4qLXG2Wbm8qvplhAq3ZiKpdPadcUMVWJ2uVFjdv3Txguq3uLgYt3ftvkPJfnLkWNx+14PMsW8zAtfKfG2Z0Uklk1We8kLDnzAq7OwCu6vqhuOuXOP5V8rCzVXXKuySKIt9eVZz7VVElFhLvJcyJqJwUrgbT5zRpbLmRUbfcJOjBpdJPzubJ3nMxVWdBVit8b06/MYZJVteZnMrZEV0p8l62zLOZsJmE/U4KTjvqstsdpCJtJMkINKVBwDoHKfxJvqb3eEYEPhidzgGBH1V4yuVCo4eaZcu+sHhY0r2Mw9wZNyje/coWXlGEBDM8s58tqWjx1qyjI6pJdRM0J6DjaETh7WqJg8YFaU5J8Z5h3zS0OGX1nhHvNVVQophSzdt27I1bi8ucvJIZJJMqsLMsep5XfCsXREJKMEQfZxaYXVx+506ci0Dvu5REfFWo+Qora55iHJTNUH13Krq+5HNC+ruqt4Fr9d4zoUx5mazpY+uXGQvwfguPY+xEX7EL1w4wQL90+KtwB80slooeVauLGgTs1ERNNaCxjsy1WpbxMc2gYvm2HyJavIe2GeYr7tZ13MM9fXdeFfjHY6Bhy92h2NA4Ivd4RgQ9Jc3HogNFku6t7LCbgaKdiiZdLUMF9l2y5TT3GuGGEJyuYt2lOKiW13RLphIZN9t38X7BdmMJfsTZZ+pd/fgiDAOh4Y5Emx4WNvUpVXtkpGQmXqyNHWlZtyZEc//xBkdsTghuNzX8vw7NU10Vn6I/XIjhkBUEmw0xDyypmRzPivu1ZCOaquKOa6UxR5GVrtEC0WO1lteM5zyYg+j2eTxl9b0GCQiOtdWFvUYwsUbmobQMi/KUonIuIoJbZwt8R7GVE4XOG2U+HxNYdvXmvp+SLQM+Wdoto+79qAErvpmJ6IhInqRiF4lop8Q0b/ufH4nEb1ARMeI6E9J0rg4HI63HXpR46sAPhhCeBTAAQAfJaL3AfgdAL8XQrgbwAKAT9+yWTocjhtGL7XeAoB1vTHX+RcAfBDAP+p8/kUA/wrAH6SNRUQx8UIup91mlgNeYmSMEx+Koh1VjDorI4yseq5kEG3DSi/6TYxol9eWLcxd3mpyAkTVmBNN4TLaPq2jzjJKjdVqsXRfjYyyWpwxbi3LI6/H4PawULNrq9pVMyEIKtYqWiWU3sJLMxwp2ITuVxPun/OmWm1eJJoMF4Uq3TD3SvDuSZUeAILwj82vMGdhRNoEHB3naL1s3fL18Q1pNDgSc25RR/xNjQvXGPSzmBWqeqOp51gT6nRLXFtlzZRqLbBLrWJcmHVh6jVFCKd128rjkNGKdFh3YVLy+7vX+uyZTgXXGQDfBHAcwGIIYd1AOgdgV8LXHQ7H2wA9LfYQQjOEcADAbgDvAXB/rycgoqeJ6CARHVwyG14Oh6N/uCbXWwhhEcC3ALwfwCQRres3uwGcT/jOMyGEJ0IIT0yInF6Hw9FfXNVmJ6ItAOohhEUiGgbwYbQ3574F4BMAvgTgUwC+erWxQmixjWbskZxK9td2XSRcMCMj7HrDbO+agrbZhe1j5iG9S2uzWjZ3VtivLbbrZqNh1a8lMunu3Krtv+EhzpJqmMylmXmuJXfp0htxu2r2Ji5e4MyroZzmfJf2vKw3ZmuP5cX9HhvV5BVVkaUmiTMay/pxWS1xv+PHFpVMWqUtsE2dyesxmjW2PVdK+nevV/j+ZAUpR6ao3XzZSJQ5bphyyA0RWpwV45knX9UPiMwcpa2sv6b2WSoik7C0pucxMsH3oNEyvPTYePxAdt9JfCdv7sH6e5eS97568bPvAPBFIsqgrQl8OYTwNSJ6A8CXiOj/BvAygC/0MJbD4bhN6GU3/hCAxzb4/ATa9rvD4fj/AfoaQRdaLTRW20QPExntPmoJFej0Rc111hpjlaUquMpHmiYLS+g5NolfHgfhPmmZiC5JOtCoGLWyzGpgJFgdgtn6kKpdzpQZkqWTl5Y0WcPzf/3luF2tsIlSr+vxg6gNded+/Xd4YhOXzrqywvd0yZRlJnFs70GlxLL8NEenlVBU/eYqfK8yQUeFzc3z7yQjFjORcScJhb9Z0fdquMzm22TgZ2Bs87263xDLrqzoMtiluozMFOqyieCcF6QoltCk2eR51aqar31CuIJJqNCWv1A+m1TQZl9DqPzSvdaMtPuuIebRDNr0ikKyOzbuc9UeDofjHQFf7A7HgKCvanyrWkPpZJtzbKtRhy6+/krcnjFbnk/8wkfi9piMoIt0CSmZBGBz+FsJKr6NUopE1dVgItUiEeWXERGAZGiUg4hikrxyAJDL8ZhzC4tKNjvHO/VDYue4FezPxMdkdmxlotCaoETOmDJRuSbLlk+8oWQlQWldvvfJuH2EdAXT7GY2GeZPf0PLJK9aQ5hbZrOYMszfly9qMyFq8r0bEre4Oq9NhpDhZ2nFJLi0soJEQyS0tIyqHpH83fUcm8LsKxT0HCnD97U4zM9mfljvlkeR8Dqs6WjGYXHuhvKgaDO1KUhAgplkI7TH6K5eLOaQKHE4HO8o+GJ3OAYEvtgdjgFBf0s2l0s4fugH7QNja0bC7i0WdLmjnHBN3LmZ7cbqDm37TO9gwsaVoGUkXF7NFAIJGV1n7XlpJknXCtlMI2HrRyYaqyhsOUnYAQDjIzt5jg12PzYNj35G3KtcVhvBe3YzWefsLEf8LSzo/Y0hYnt4+oFHlezEW1x6eNsUhzhTfrPql9387ri9rM15XH7t1bj9SI7v4+FjmtddkXsYAs6KIAUZmhAZfEXN01+pzMfteln/Zlun98bt1TUS/fT9kNF6IafJQoIo59VoaDu6ITLdcmK+2azOShuSezekXWq1Ec6MrIpNjcbcrOpXKvEzPWYILRcW2/sW9YaXf3I4Bh6+2B2OAUFf1XiKCNmxjqvCqPFa9dWqaVmUFopK7FrZ9S6tfn7yIY6sKs9pNW11hvnml85yZdWF87q00pJQfWuGqCBINVNGSGXS/mba6De+7m1bdRmgf/iJX+J5LLJqOiO48gGgUmOV8Mqsvs6lRT7eu5dV2M2btQp+6TSr09PTmopgeIRdSJfqrI6+b+9O1W92SfC6b3tSyb57hu/xwzt4/GHzyP34InO5l407dniS5zw9zVnVpapWb1fLXIZqc1Zf544tXAJr727mNnz+299V/WbmRRmnSKvxuQwf52uGl1BEH46NcmTcjh26LJckZ8mYdJq18pW4Xa2widKoanOltsb9Zpf0GDl0nommIc2Qc02UOByOdxR8sTscAwJf7A7HgKC/WW/oJoJch3S62BLIL3zrubg9vZNLPd9xQNvsE3uYa71p6rS1ROnkVpltw/qiDr1866WX4/bLr7+lZJtk+Ky007synEQzNRlJC4eG2DYc3s7XuXPnXtXv0ix/7+IFbeeeO32Kv7eLbWVL8Cn3Dix/pczaqwvyB5tJ+OpBvldHD/1IyWbO8V7IrNgvGJ26U/XLrQpu+1n9uzdXee9gNcu2crWq73etzuOPDWs2pEsX2J4PgthChp4CwIooldwwz44khBiPtOttSrh7IxE6i7J+rhoiy3PJclG2hNuvId2sxi4P3K8wtFXJRrf8FAAg8+YpJMHf7A7HgMAXu8MxIOh/+acO35bV5iUBRNOoSleWTsft4XGRbZbVkWUy0ygM6+ykJIQ9+lxDQo2qiSw0AKiLSLlhGUFn1PggiOmt6qthdXzJRSbUZ9OrUWXZhfNaXSw3WaV9/D3CddidBhg3m6ZUUU2UWy6vserYmNGkIl//sz+P26fP6Mi4gjAbGmUeLz+u1exWjU2N4qhWn7PC9dRYYLdTw0Qlri5xJOJyS2e9bZ5kU2B2hrnnryxqjjgSSyG0tGnUFHx9yyZtb0zcq/ocz7G4ou9pdhO7WRdL+twTIsIwU17kOQVtepFYFyOTu5UsM952K8osPAt/szscAwJf7A7HgKDvavy64mpV0yA5nE1Emkz8kFTE2WFTAielgqWag1DHMzl9CzIFET2V1ypRS25bJ7WhCSVstc2WiMqLDB+bjCoMsqyQmT9E1FbD8PCdOskehG89z14MWzJqTfDpvZad1GMcfzNuS89IK/tj1a8oVPXtUzoKb2J8Im7v387tS2ua+60odpgjU8V1RSSrXJnn3fimibBcFjvpNvFodJiPZTVgTV0ObBOVa0tVwz0oo9JM0tOSiNSUXH6VcR2FlxWJNqtr2uswJHNkRHJUPW+IMob5frcymscu0+x8L3gijMMx8PDF7nAMCHyxOxwDgj7b7AHr1rpNelORZibsTFohayIr6OwxHeE2JTxxUzu1a4JUSehk215Nw3LPC7tX8RVeQ5Sc5I1vBW1vq3si+3WRYrLtVmlod9UPXmTyyLOX2BX0sb/zUdXvzbeOxu3cJp2hder8xbjdLHPGXYM0eea8yBBcXtFuytoquwTzgd2BM4Zkc0mUkp4oaps9J+7x1h2CtKRqufj5xi0sa7fZibM8f7l/srQwp/rtGhF7QVn9uywv85yzxmYnQeQZcvyMLVdMdGSBr7NS1SF0csZZsadTMddZJj6eu3BUyXbd2bHvb4bN3inb/DIRfa1zfCcRvUBEx4joT4kof7UxHA7H7cO1qPGfAXBYHP8OgN8LIdwNYAHAp2/mxBwOx81FT2o8Ee0G8HcA/D8A/ndq+3E+COAfdbp8EcC/AvAHVxuLFSRLXiH+7pBVfbk9s8Bq2V/8v/p07/35D8btJ3/11/TwGXZjaN54U0JK69J6Huo4WXfX/PXJZagoWI47yWuXfK5SiVXQH//4kJK9eYRV9+MnOeLtxIlzql9RRBj+2q89oGTTRT6ulFnF/+vvvKT6VYU6WhPlqgBg5hzPMZ9lAolsRrvNJot8bJN16oLfbXGOXVJVU7qpJHjYS2sm+q0pzSFWg23yz+yqiNaradOoXhfnsxZgk2VDWXYxzpsouSKJiMKGVs/rgkcwEr91q6n7VUUlW5o/o2RnC+0IvVpd3xuJXt/s/wbAb4LN580AFkMI67M5B2DXBt9zOBxvE1x1sRPRLwGYCSG8dLW+Cd9/mogOEtHB1Vrj6l9wOBy3BL2o8R8A8PeI6GMAhgCMA/h9AJNElO283XcDOL/Rl0MIzwB4BgB2TY72FuLmcDhuOnqpz/55AJ8HACJ6CsD/EUL4x0T0XwF8AsCXAHwKwFevNlamMIyJfQ8CABpZ7cZpZvi4ldEb+y0RAtkQNu+qqet1ucEhimXj3hjR0YsxrE0tw0qtTIa6Sn75qEtBChu01k8gz2VFMustGaHK171nYlLJ9n2cSziPjPJFL81pG7J15ljc3kVaduDJ98bty5d5j+TZZ7+u+s3PsV2eCdpWHhKhzAvC3TY2pue7tMo25tLKvJJVRIhpvcG/Z8sQgSpCFEvEIdry98yY7LAg7Pma2cfRdBKm3oFwiw4VZX03PZFlYcN3hS6LsOmGyKJrmT2MRWGzD5mVuyOz0Vk1biSo5rNob9YdQ9uG/8INjOVwOG4xrimoJoTwbQDf7rRPAHjPzZ+Sw+G4FehrBF12ZBJbf/rvAgBeO3pSyWS00MyVRSVbWmYVaO8u5v4+elGr8a9dYndEqfA3SvbLf/+puD0+rsvpSpBUhKzbTKh30qVjKejU96yHUXdUR83mxq4hinS/QpaFOzfrukvNKSZJWCvzfZvatEn1y41z6abFjM6umj3MUXiy7HNpWUedra2yu21qkyalgCBaWBE/0+Kq5rmviU3buimt1BIEG1A8HDb8Urgzu9ylDEohEgkiKnF4ZELLZBllW0sg8PyLokx1zpQwy4qMu9KKdlMurrAJJJ+xoSF9PyLxUCxW9bO/cvwnAICK+Vx9P1HicDjeUfDF7nAMCPqqxheGC9j/wD0AgD//5veV7PJlVu9WDD+YjLqKWty+a/d21a8i1P1Dh3XEGOh7cfN/+gc/F7dHzTZ9WSTaVCp6h7kh1OxGnXeHKWN2aIUKbpNYZKLCFWOu/PhV5nGbEOQH73rsLj3+EPOqNY1JUhIJKdWKjKbSUWFB0COfNCWw8nmWvfgiU0RXKlpFlNR1CyUdQ5EVHhQdHKnvR14QhNiKtFoJT4teZFlkRUL1bYrItZKJcGu2xFIgvSwoIzwvZv7yeyurfH+mDDnGaJHJJixxxlqJowPL4h7XTFyKvHctU+apXmlHTjabybEs/mZ3OAYEvtgdjgGBL3aHY0DQV5s9l81i57a2q2jzlHZvVErCPm4Yl1SL/yatlNj23CXccAAw02Q7fesubc+/coRLCBf+8jtx+8692nV1+QJH/dbr2i6qiWyoel3w1xuXTkb44oLNbBOulb/69k+U7DvfZ6LHn7qf599Y03+Tz51hG++F1zRpRKUm3ETiPtZqOhuqIQzug69oIsndO/ncp08zZ//2bfpe7Rb330aFSbeZtJXrJuPLurIkImGA63Zk+vFxZOYhCTlPn2ZSjuXlkuon3Xddrj0V9WjIK4SsXOFrWyRNKrlpgjsOFTRZZC7H0aO5Vf49V1d0TYAgfrOMId1sNJKz3dbhb3aHY0Dgi93hGBD0VY2PogjFjgti165tSnb+PLvemjmtopTWWJ1uCnfEhRkdjVUR+tbFwyeUbGSIx/zDP/oPcfvKglaDn3zvgbg9NqznsVJi1WxIuIyCca9lhG6XibQpsLbGqlh5Wf+t3ToyHbebK6zqPf9tHW34xlEmpTh5blHJ8gWeVyRUzoaZY1EkbWwyKuD0JsH5vn9/3A6GG7AhIt4axuUjSUHSKsbKmgDWFNDU/ClqvCJ80Nd56TJH/V0S5Z8aDf27RMo/aCPtxLnJmmwbl9Faq1hXJLv6JnRwHbJZdrMWRQmzrFHVV5ZZrW819W+2bnmkJVD5m93hGBD4Ync4BgS+2B2OAUH/SzZ3bMddO7UbJ5NjHuzSmrbFyxW2ryrClXXkqObOvu8uHvNvv6+z3gpDbAMPZdie/Lmf0Vm6738/Z4NdvqjJd1o14RaZORW3G+ZPpgyHNFV3ce4KuxgP7NNEjw/uf4LPlWPb7cVX3lD9ppZ40Omtmh9fevqkS6c4osNqc3mWZbOaLCQjwpOlrd9saHtYuiZtzbmGJPqwIcMC0kq39nwv3wGAptgfuDK3qGQXBHe+DrhNyz80eweSoNR65cSkpY1t9zAqcotgxbjlRvn+ZEUNt1Zeh3KPTvK5VgWXPQBUa53nKsVo9ze7wzEg8MXucAwI+qrG12o1nD7TjmSbMv6HbVvZ3bOyrNX4+hDrQBOjTLRwx54p1e/xAw/H7YcevNeMzyr+xJjIQMppFTYrMq/uueduJSstMUfa0pEf8HdWZ1W/luAIrzW0Hl+OJvlgRN8D6dqbn2Hut5xRK/fvZtW9afRKEqpkJHjWrHbXEm6ipuXaCzL6jVVkm4Ulo9+sa0+Se0hVN8Wr1eV6k5FsMjLO9pMYG9Xmyt138r06d4Hv6eKidrkqbjnLjZF4Ng05K+serNf53kkXHQBQ4N99XHCyZg2piORmHBvXz36r3lbjS11pf2JOiRKHw/GOgi92h2NA0F8OumwGU5vbXGhT01oNkbvDrebPKNmmTZNxe3KCiRuGhw0/tFD7vv/9HyhRRpCYSSKBalUTVFQEPXXWkCkcPsK7/6MtPvdQQV9LVfCZVY3KVl7i8RdOXVKyxcXFuC2pk22yiDwkU04pJ9R4qeHb5A6pdtvd8rrY3ZbUxlb9lKq6TfiREWmSdtvugst+lqZZRc3J0ljQyOf4MbY5LHI3fkUSVlh1N7nqV6oeL0XNFIKNkEI9Xg+CAEOUryoW9ImzGX7mWia6bqJTzmthSSfPSPib3eEYEPhidzgGBL7YHY4BQZ9t9iy2btkMAKjVdcTVow89GLfjaKAOvvGN5+L2E48/HrcLJjtOEkROGCJGSRqxJOwaW+JWunhef+0VJfvj//THcfuf/y9Px+1yQ893rcTjLyxoG2p5iV0+NvNK2rbSzZUxZYAKgvwgpLirZOaZddE1hZ1uo73qCXZ6N2e6zGbrzW0WdZE/iHJbxjiWJCDalaX7rQo79+QZsw+yxCQVQcfrmXkgGSkyvUcgM+fsECIS0QQUVmQkoiBUbTQ0wedIgfvl87p8Wr1js1NXEQNGr/XZTwFYQbu8eiOE8AQRTQH4UwD7AJwC8MkQwkLSGA6H4/biWtT4nw8hHAghrAdwfw7AcyGEewA81zl2OBxvU9yIGv9xAE912l9EuwbcZ9O+UC1X8NahtwAAO/bvUbKm4MGuGr72LdOTcbteZ9Vmbs5yxLFKnjfJHeUyf0+q+zbSSUaPXbig+dRHRzii6dTpU3G70NSJDcvCTGiaBBGtThuVVriDcnmhwmb0z1QTPG5WPZeHUlXv5sKTyR3Wpbax6m5ddJHi2rNuM9mmDT8HrhK5JiP5pBlm+ONOnWXVfXVVPztqSGV22HPJyWsZCdKOYGXyOPlSkPZelb+hfF6qZpSKMDmHstr8HBlaf96T/YS9vtkDgL8iopeIaN1Y3RZCWGfwuwRg28ZfdTgcbwf0+mZ/MoRwnoi2AvgmEb0phSGEQNQV9QwA6PxxeBoAdmzfsVEXh8PRB/T0Zg8hnO/8PwPgK2iXar5MRDsAoPP/TMJ3nwkhPBFCeGKTqSTqcDj6h6u+2YloBEAUQljptD8C4P8C8CyATwH47c7/X73aWCuLy/ju174OAPjIP/2Ekkn7LGdcarv3sH2/KupiWV535cYxtlVOuK8awua19dykvb1a0rb4gcce436L7HjINrWLJM0elscN6/bLiLpkYgxbAa0l/kbbEFY1vioxre1tyeserFuuubHdF0XWvSbDZbuKrG04hrWV5akj8x255zA3z2WOZQgsAFRr/BxY3ng135T5tYRrrDtatse8t5TsPnl7unjpE+6V7VYVdQCqhkik1An7rqfw8Peixm8D8JXOQsoC+M8hhK8T0Y8AfJmIPg3gNIBP9jCWw+G4TbjqYg8hnADw6AafzwH40K2YlMPhuPnoawRdQAvNVruE0uLCopLt2sGb+YcOHVKy4yeZC+6ee7l8cbGok/uler5ksn9WRCnjhlD7SiVNYnDyBJdNXlnWavxjjz8St08d5T3KVt1GlnGbTHZSVvKkG5lS3aNkUyAtck1G4UmCCsunLtV4yf/eOQPPN8uPiA3Okl5F62KUnHRlYSplszoaMJeVj6C+zgURbXh5djFu2xJS6g5Y7nklktF6GlFIdiPKKMUumSwblTgp/UGXSI5BKf3kPIy2Hj87zkHncDh8sTscAwJf7A7HgKCvNvvw6Aju/0Cbl71mGGJefIGZZX7rX/6WkpFgfvnMb/xm3J7eohliasIWX1leVrL5Oa7zVVlj910m0sbPieNsiy8vaZdaBLbZo5awG43trW325Cyvrtpm0m0mCRttOKuYcsuG4wr3jHKvpYSiWm+VLUscj23sfjl/WbPNjpkZkSWKDVONDLk1BufkJLMSTYwzOacMnQUM202KWyslIUzdn4bJyGxB7p/o78kQYrlv0RUmLck5zR6JrpnXTOwnx7Q8/evEoGlknP5mdzgGBL7YHY4BQZ9LNmcwMjYOAMgYMsfvfO97cXtiUofVnj/Prrcjbx6O27XaPtVvbo4jq1ZXtBo/PMTJ/jkRqTZ7UWe2nT7OrjdkNEHAldnLcVuqnJG5FkmS0JWVpjLRkgklZIKZ5WSXpZWatlRygjvMZqzJQxsZp+ak1MW0ksr6ezlBAtmSbqeu8knJvqJCnjMX09xrErZ8tjSjJBlGxXDgyyjCmimzLe+PdR0WhvhYlv3qVqdlxGKSxDwDXRmTyc/OegTj9743hyT4m93hGBD4Ync4BgT9reJKvCN6/vw5JZqf48SSA48/pmSSI+3MqRNxu9Wsqn6y9E9xWJNXnD55Mm4fFaZA3XgFcmJXeWZeJ1wcO/pW3N4k+OszGaOyCbXPllaSx92q9cYkBpYjTlZTteqcHKOVwg0vESzHeUvu1KcQT0ieuTSvg0x2SStPZMaQ9zVSHo9k1b/V0iaVNBPktwp5E70oTKMosstCeh2sRCYDyfOmXGeX50KYCeJcIeiTaRPQzoM6c09+f/ub3eEYEPhidzgGBL7YHY4BQV9t9nq9josX27R1x44d1UJhnxx47N1KVKuxbT4xPhG3R03J45NizNdff03JLl9mt5l0VxWLw6rfiMik27ZtWsnyeXaztFTUluqGViPZNaaypLrsbcktnhxJFVIi43T9teRzSdvOZsRJpEX8Sfvb2oqaN37j8QCd0Wdt2YxwZaXZompOxtWZRDwRRfZ+CLLPnL2WBFbJtjButlRkX/J8rbsxyb5vmWuRZC2Wf399X6E7grCXGTkcjncUfLE7HAOCvqrxtVoN586cBQCcFrzrADC5aXPc3rplq5Lt2Lkzbh9+jdXzt44cUf3mRLLL9NSEkj3y4N1xuzDEpW+LRV0mKi9kUUZHS8m/jSpKzkQ6hVT32saJE92yjUkobL9UMoUU11iautcrpPpprzMkkDVQSE6msSqyHFOZE5Y/LiS7GNPMEAntEkwuZZXKtUfJZlPSeGlztJF29Rp/kM/reRQK7Wc1jYPP3+wOx4DAF7vDMSDwxe5wDAj6arM36nVcutR2vZ07o8NlJ8a3xO1KRYfBVqvscvjhD38Yt7m+VRsHHr4nbm/dot1m0v5Wtnhk4x/FcRfnu2i3NnZxtWXJNmRaJlqSrGntYUlekVJ/TZJQtAzhg7QN09xaaXZuqt0fpL0tXWjJmXO2Hl2rlWRvG5vdXJseP5ksUk03hcRT36u0EtnJBeNkxp0lzNR7Fcl7E7k8L1d7JetrxJKTSvib3eEYEPhidzgGBH1V4xcXFvHVr/wFAGDF8LX/7M99OG5XKqackijn/MA9e+P2jq1aVc/l2W3Wsn/HIqm6i8um5AykrtJNCap7FwlFKhdZsvqvShQ3pXstmXgiDUGp0lp2PWp8mnqbFqGnvmfnIU5t5xElnLt7Hmx6panqvZokaa6xXl2WXb9Zl8tu476k3LsacgQbXQebebkBenqzE9EkEf03InqTiA4T0fuJaIqIvklERzv/e9VGh+NtjF7V+N8H8PUQwv1ol4I6DOBzAJ4LIdwD4LnOscPheJuilyquEwB+FsA/A4AQQg1AjYg+DuCpTrcvAvg2gM+mjVWtVXGqQz6Rzemd9OPHj8XtB87fr2RLgkRin6joGmwygFDnMpZMQR6nqIRpEW5JkXFdpY/EbmvaGBZqN15G0HWRliWr4GkkFRJpJBIS6apvcj85L6XSRynRY3aOkshBfW7mIb0OMJ6LhPudpqqn9U3rl4Z0k0p6TSRXnZmjuHBL3d2LedHLm/1OALMA/gMRvUxEf9gp3bwthHCx0+cS2tVeHQ7H2xS9LPYsgMcB/EEI4TEAqzAqe2j/WdnwTwsRPU1EB4no4M2Ix3Y4HNeHXhb7OQDnQggvdI7/G9qL/zIR7QCAzv8zG305hPBMCOGJEMIT16sCORyOG0cv9dkvEdFZIrovhHAE7Zrsb3T+fQrAb3f+/+rVxoqiCMVi2z3WMIQJFy+cjdvfef55JZsc5WlKUkkb/RZlenOpSQ2jYaKZ0jLKZF9pRjeammdcEUJ2ZXKlcbnL47QMLW4HWBu9tz+ovWpZrQTySXvuDCXbkPK6Mta2T3FrtUQWGQVpvycTVHTb8xuT26eVQ7ZIc8sloetehY3bnU82nkaP5af1CMno1c/+vwH4EyLKAzgB4H9G+75+mYg+DeA0gE/2OJbD4bgN6GmxhxBeAfDEBqIP3dTZOByOW4a+RtARAdkO8baNAGrUmb+9XtXRdcWtu+O2TmKxrrfkLYgkV9m1JapsTChhXWPyuDv6Tcism0y5sridMWTl6nwpVUt7JW5IUzmheMz193p136mxjcIpufYs8YLms5dmgR1TtC15hXBRparB16Gqp6E7OjJZJu+jliWP0a243xzXm8PheAfAF7vDMSDwxe5wDAj6arPnslls29YmqZic1ISQ05s5g218fEzJMlkZWisyw2zmD5IzyqTbTNnilgZcjp+asSa+E2yIZjJ5hYwWtTXWdBiv+Bimm/ikYS5AZZFRmr29cfjw+sw2andbhdeeDUbm/SKPyLpLE/YEuu6pvM4UW7yXz68mS5tLWlittMvtdSad24b+IoHEE+gmp9wI/mZ3OAYEvtgdjgEB9TNenYhm0Q7AmQZw5SrdbzXeDnMAfB4WPg+Na53H3hDClo0EfV3s8UnbSTEbBekM1Bx8Hj6Pfs7D1XiHY0Dgi93hGBDcrsX+zG06r8TbYQ6Az8PC56Fx0+ZxW2x2h8PRf7ga73AMCPq62Inoo0R0hIiOEVHf2GiJ6I+IaIaIXhef9Z0Km4j2ENG3iOgNIvoJEX3mdsyFiIaI6EUierUzj3/d+fxOInqh8/v8aYe/4JaDiDIdfsOv3a55ENEpInqNiF4hooOdz27HM3LLaNv7ttipzeT/bwH8IoAHAfwqET3Yp9P/RwAfNZ/dDirsBoDfCCE8COB9AH69cw/6PZcqgA+GEB4FcADAR4nofQB+B8DvhRDuBrAA4NO3eB7r+Aza9OTruF3z+PkQwgHh6rodz8ito20PIfTlH4D3A/iGOP48gM/38fz7ALwujo8A2NFp7wBwpF9zEXP4KoAP3865ACgC+DGA96IdvJHd6Pe6heff3XmAPwjga2iHfd+OeZwCMG0+6+vvAmACwEl09tJu9jz6qcbvAnBWHJ/rfHa7cFupsIloH4DHALxwO+bSUZ1fQZso9JsAjgNYDCGsZwz16/f5NwB+E4izPjbfpnkEAH9FRC8R0dOdz/r9u9xS2nbfoEM6FfatABGNAvgzAP8ihLB8O+YSQmiGEA6g/WZ9D4D7079x80FEvwRgJoTwUr/PvQGeDCE8jraZ+etE9LNS2Kff5YZo26+Gfi728wD2iOPdnc9uF3qiwr7ZIKIc2gv9T0IIf3475wIAIYRFAN9CW12eJKL1tOd+/D4fAPD3iOgUgC+hrcr//m2YB0II5zv/zwD4Ctp/APv9u9wQbfvV0M/F/iMA93R2WvMAfgXAs308v8WzaFNgAz1SYd8oqJ3k/AUAh0MIv3u75kJEW4hostMeRnvf4DDai/4T/ZpHCOHzIYTdIYR9aD8Pz4cQ/nG/50FEI0Q0tt4G8BEAr6PPv0sI4RKAs0R0X+ejddr2mzOPW73xYTYaPgbgLbTtw9/q43n/C4CLAOpo//X8NNq24XMAjgL4awBTfZjHk2irYIcAvNL597F+zwXAIwBe7szjdQD/Z+fz/QBeBHAMwH8FUOjjb/QUgK/djnl0zvdq599P1p/N2/SMHABwsPPb/AWATTdrHh5B53AMCHyDzuEYEPhidzgGBL7YHY4BgS92h2NA4Ivd4RgQ+GJ3OAYEvtgdjgGBL3aHY0Dw/wEGltT9H6gZDgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index =1\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print (\"y = \" + str(train_set_y[0, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inspecting matrix dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(209, 64, 64, 3)"
      ]
     },
     "execution_count": 299,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_x_orig.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: m_train = 209\n",
      "Number of testing examples: m_test = 50\n",
      "Height/Width of each image: num_px = [[[196 192 190]\n",
      "  [193 186 182]\n",
      "  [188 179 174]\n",
      "  ...\n",
      "  [ 90 142 200]\n",
      "  [ 90 142 201]\n",
      "  [ 90 142 201]]\n",
      "\n",
      " [[230 229 229]\n",
      "  [204 199 197]\n",
      "  [193 186 181]\n",
      "  ...\n",
      "  [ 91 143 201]\n",
      "  [ 91 143 201]\n",
      "  [ 91 143 201]]\n",
      "\n",
      " [[232 225 224]\n",
      "  [235 234 234]\n",
      "  [208 205 202]\n",
      "  ...\n",
      "  [ 91 144 202]\n",
      "  [ 91 144 202]\n",
      "  [ 92 144 202]]\n",
      "\n",
      " ...\n",
      "\n",
      " [[ 18  17  15]\n",
      "  [ 14  14  13]\n",
      "  [ 29  29  32]\n",
      "  ...\n",
      "  [ 83  81  81]\n",
      "  [ 84  82  83]\n",
      "  [ 82  81  82]]\n",
      "\n",
      " [[ 22  20  18]\n",
      "  [ 16  15  14]\n",
      "  [ 25  24  24]\n",
      "  ...\n",
      "  [ 82  80  80]\n",
      "  [ 83  81  82]\n",
      "  [ 82  81  81]]\n",
      "\n",
      " [[ 45  43  39]\n",
      "  [ 61  59  54]\n",
      "  [ 81  78  74]\n",
      "  ...\n",
      "  [ 83  82  81]\n",
      "  [ 84  82  82]\n",
      "  [ 82  80  81]]]\n",
      "Each image is of size: ([[[196 192 190]\n",
      "  [193 186 182]\n",
      "  [188 179 174]\n",
      "  ...\n",
      "  [ 90 142 200]\n",
      "  [ 90 142 201]\n",
      "  [ 90 142 201]]\n",
      "\n",
      " [[230 229 229]\n",
      "  [204 199 197]\n",
      "  [193 186 181]\n",
      "  ...\n",
      "  [ 91 143 201]\n",
      "  [ 91 143 201]\n",
      "  [ 91 143 201]]\n",
      "\n",
      " [[232 225 224]\n",
      "  [235 234 234]\n",
      "  [208 205 202]\n",
      "  ...\n",
      "  [ 91 144 202]\n",
      "  [ 91 144 202]\n",
      "  [ 92 144 202]]\n",
      "\n",
      " ...\n",
      "\n",
      " [[ 18  17  15]\n",
      "  [ 14  14  13]\n",
      "  [ 29  29  32]\n",
      "  ...\n",
      "  [ 83  81  81]\n",
      "  [ 84  82  83]\n",
      "  [ 82  81  82]]\n",
      "\n",
      " [[ 22  20  18]\n",
      "  [ 16  15  14]\n",
      "  [ 25  24  24]\n",
      "  ...\n",
      "  [ 82  80  80]\n",
      "  [ 83  81  82]\n",
      "  [ 82  81  81]]\n",
      "\n",
      " [[ 45  43  39]\n",
      "  [ 61  59  54]\n",
      "  [ 81  78  74]\n",
      "  ...\n",
      "  [ 83  82  81]\n",
      "  [ 84  82  82]\n",
      "  [ 82  80  81]]], [[[196 192 190]\n",
      "  [193 186 182]\n",
      "  [188 179 174]\n",
      "  ...\n",
      "  [ 90 142 200]\n",
      "  [ 90 142 201]\n",
      "  [ 90 142 201]]\n",
      "\n",
      " [[230 229 229]\n",
      "  [204 199 197]\n",
      "  [193 186 181]\n",
      "  ...\n",
      "  [ 91 143 201]\n",
      "  [ 91 143 201]\n",
      "  [ 91 143 201]]\n",
      "\n",
      " [[232 225 224]\n",
      "  [235 234 234]\n",
      "  [208 205 202]\n",
      "  ...\n",
      "  [ 91 144 202]\n",
      "  [ 91 144 202]\n",
      "  [ 92 144 202]]\n",
      "\n",
      " ...\n",
      "\n",
      " [[ 18  17  15]\n",
      "  [ 14  14  13]\n",
      "  [ 29  29  32]\n",
      "  ...\n",
      "  [ 83  81  81]\n",
      "  [ 84  82  83]\n",
      "  [ 82  81  82]]\n",
      "\n",
      " [[ 22  20  18]\n",
      "  [ 16  15  14]\n",
      "  [ 25  24  24]\n",
      "  ...\n",
      "  [ 82  80  80]\n",
      "  [ 83  81  82]\n",
      "  [ 82  81  81]]\n",
      "\n",
      " [[ 45  43  39]\n",
      "  [ 61  59  54]\n",
      "  [ 81  78  74]\n",
      "  ...\n",
      "  [ 83  82  81]\n",
      "  [ 84  82  82]\n",
      "  [ 82  80  81]]], 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": [
    "m_train = train_set_x_orig.shape[0]\n",
    "m_test = test_set_x_orig.shape[0]\n",
    "num_px = train_set_x_orig[1]\n",
    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flattening the images to feed the network\n",
    "We want to reshape the image of shape (width, height, color channel) to (width * height * color channel, 1 ) which is basically a vector with one column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_x_flatten shape: (12288, 209)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x_flatten shape: (12288, 50)\n",
      "test_set_y shape: (1, 50)\n",
      "sanity check after reshaping: [17 31 56 22 33]\n"
     ]
    }
   ],
   "source": [
    "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",
    "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))\n",
    "print (\"sanity check after reshaping: \" + str(train_set_x_flatten[0:5,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standardizing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x = train_set_x_flatten/255\n",
    "test_set_x = test_set_x_flatten/255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building the Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "  return 1 / (1 + np.exp(-z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initializing parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_with_zeros(dim):\n",
    "  \"\"\"\n",
    "  This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n",
    "  \n",
    "  Argument:\n",
    "  dim -- size of the w vector we want (or number of parameters in this case)\n",
    "  \n",
    "  Returns:\n",
    "  w -- initialized vector of shape (dim, 1)\n",
    "  b -- initialized scalar (corresponds to the bias)\n",
    "  \"\"\"\n",
    "  w = np.zeros((dim, 1))\n",
    "  b = 0\n",
    "\n",
    "  assert(w.shape == (dim, 1))\n",
    "  assert(isinstance(b, float) or isinstance(b, int))\n",
    "  return w, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.]\n",
      " [0.]]\n",
      "b = 0\n"
     ]
    }
   ],
   "source": [
    "dim = 2\n",
    "w, b = initialize_with_zeros(dim)\n",
    "print (\"w = \" + str(w))\n",
    "print (\"b = \" + str(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [],
   "source": [
    "def propagate(w, b, X, Y):\n",
    "  \"\"\"\n",
    "  Implement the cost function and its gradient for the propagation explained above\n",
    "\n",
    "  Arguments:\n",
    "  w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "  b -- bias, a scalar\n",
    "  X -- data of size (num_px * num_px * 3, number of examples)\n",
    "  Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n",
    "\n",
    "  Return:\n",
    "  cost -- negative log-likelihood cost for logistic regression\n",
    "  dw -- gradient of the loss with respect to w, thus same shape as w\n",
    "  db -- gradient of the loss with respect to b, thus same shape as b\n",
    "  \n",
    "  Tips:\n",
    "  - Write your code step by step for the propagation. np.log(), np.dot()\n",
    "  \"\"\"\n",
    "  m = X.shape[1]\n",
    "  # forward propagation\n",
    "  z= w.T.dot(X)+b\n",
    "  A = sigmoid(z)\n",
    "  J = np.sum(Y*np.log(A)+(1-Y)*np.log((1-A)))\n",
    "  cost = -J/m\n",
    "\n",
    "  #Backpropagation\n",
    "  dz = A - Y\n",
    "  dw = np.dot(X, dz.T)/m\n",
    "  db = np.sum(dz)/m\n",
    "\n",
    "  assert(dw.shape == w.shape)\n",
    "  assert(db.dtype == float)\n",
    "  cost = np.squeeze(cost)\n",
    "  assert(cost.shape == ())\n",
    "  \n",
    "  grads = {\"dw\": dw,\n",
    "            \"db\": db}\n",
    "    \n",
    "  return grads, cost\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dw = [[0.99845601]\n",
      " [2.39507239]]\n",
      "db = 0.001455578136784208\n",
      "cost = 5.801545319394553\n"
     ]
    }
   ],
   "source": [
    "w, b, X, Y = np.array([[1.],[2.]]), 2., np.array([[1.,2.,-1.],[3.,4.,-3.2]]), np.array([[1,0,1]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimization\n",
    "We will update the parameters of our model with gradient descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n",
    "  \"\"\"\n",
    "  This function optimizes w and b by running a gradient descent algorithm\n",
    "  \n",
    "  Arguments:\n",
    "  w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "  b -- bias, a scalar\n",
    "  X -- data of shape (num_px * num_px * 3, number of examples)\n",
    "  Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n",
    "  num_iterations -- number of iterations of the optimization loop\n",
    "  learning_rate -- learning rate of the gradient descent update rule\n",
    "  print_cost -- True to print the loss every 100 steps\n",
    "  \n",
    "  Returns:\n",
    "  params -- dictionary containing the weights w and bias b\n",
    "  grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n",
    "  costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n",
    "  \n",
    "  Tips:\n",
    "  You basically need to write down two steps and iterate through them:\n",
    "      1) Calculate the cost and the gradient for the current parameters. Use propagate().\n",
    "      2) Update the parameters using gradient descent rule for w and b.\n",
    "  \"\"\"\n",
    "  costs =[]\n",
    "  for i in range(num_iterations):\n",
    "    grads, cost = propagate(w,b,X,Y)\n",
    "    dw = grads[\"dw\"]\n",
    "    db = grads[\"db\"]\n",
    "    w = w - learning_rate*dw\n",
    "    b = b - learning_rate*db\n",
    "    costs.append(cost)\n",
    "    if i % 100 == 0:\n",
    "      print(\"Cost after iteration %i: %f\" %(i, cost))\n",
    "\n",
    "  \n",
    "    params = {\"w\": w,\n",
    "              \"b\": b}\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "              \"db\": db}\n",
    "    \n",
    "  return params, grads, costs\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 5.801545\n",
      "w = [[0.19033591]\n",
      " [0.12259159]]\n",
      "b = 1.9253598300845747\n",
      "dw = [[0.67752042]\n",
      " [1.41625495]]\n",
      "db = 0.21919450454067657\n"
     ]
    }
   ],
   "source": [
    "params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)\n",
    "\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1fe57004220>]"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(costs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(w, b, X):\n",
    "  '''\n",
    "  Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n",
    "  \n",
    "  Arguments:\n",
    "  w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "  b -- bias, a scalar\n",
    "  X -- data of size (num_px * num_px * 3, number of examples)\n",
    "  \n",
    "  Returns:\n",
    "  Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n",
    "  '''\n",
    "  m = X.shape[1]\n",
    "  w = w.reshape(X.shape[0], 1)\n",
    "  \n",
    "  A = sigmoid(np.dot(w.T, X)+b)\n",
    "  Y_prediction = (A > 0.5) * 1.0\n",
    "  assert(Y_prediction.shape == (1, m))\n",
    "    \n",
    "  return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictions = [[1. 1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "w = np.array([[0.1124579],[0.23106775]])\n",
    "b = -0.3\n",
    "X = np.array([[1.,-1.1,-3.2],[1.2,2.,0.1]])\n",
    "print (\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
    "  \"\"\"\n",
    "  Builds the logistic regression model by calling the function you've implemented previously\n",
    "  \n",
    "  Arguments:\n",
    "  X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n",
    "  Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n",
    "  X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n",
    "  Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n",
    "  num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n",
    "  learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n",
    "  print_cost -- Set to true to print the cost every 100 iterations\n",
    "  \n",
    "  Returns:\n",
    "  d -- dictionary containing information about the model.\n",
    "  \"\"\"\n",
    "  w, b = initialize_with_zeros(X_train.shape[0])\n",
    "  params, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost = False)\n",
    "  w = params[\"w\"]\n",
    "  b = params[\"b\"]\n",
    "  Y_prediction_train = predict(w, b, X_train)\n",
    "  Y_prediction_test = predict(w, b, X_test)\n",
    "  print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
    "  print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n",
    "  \n",
    "\n",
    "    \n",
    "  d = {\"costs\": costs,\n",
    "        \"Y_prediction_test\": Y_prediction_test, \n",
    "        \"Y_prediction_train\" : Y_prediction_train, \n",
    "        \"w\" : w, \n",
    "        \"b\" : b,\n",
    "        \"learning_rate\" : learning_rate,\n",
    "        \"num_iterations\": num_iterations}\n",
    "  \n",
    "  return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.584508\n",
      "Cost after iteration 200: 0.466949\n",
      "Cost after iteration 300: 0.376007\n",
      "Cost after iteration 400: 0.331463\n",
      "Cost after iteration 500: 0.303273\n",
      "Cost after iteration 600: 0.279880\n",
      "Cost after iteration 700: 0.260042\n",
      "Cost after iteration 800: 0.242941\n",
      "Cost after iteration 900: 0.228004\n",
      "Cost after iteration 1000: 0.214820\n",
      "Cost after iteration 1100: 0.203078\n",
      "Cost after iteration 1200: 0.192544\n",
      "Cost after iteration 1300: 0.183033\n",
      "Cost after iteration 1400: 0.174399\n",
      "Cost after iteration 1500: 0.166521\n",
      "Cost after iteration 1600: 0.159305\n",
      "Cost after iteration 1700: 0.152667\n",
      "Cost after iteration 1800: 0.146542\n",
      "Cost after iteration 1900: 0.140872\n",
      "train accuracy: 99.04306220095694 %\n",
      "test accuracy: 70.0 %\n"
     ]
    }
   ],
   "source": [
    "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "only integer scalar arrays can be converted to a scalar index",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mg:\\ml_env\\log-reg-as-neural-net.ipynb Cell 27'\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/g%3A/ml_env/log-reg-as-neural-net.ipynb#ch0000027?line=0'>1</a>\u001b[0m index \u001b[39m=\u001b[39m \u001b[39m25\u001b[39m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/g%3A/ml_env/log-reg-as-neural-net.ipynb#ch0000027?line=1'>2</a>\u001b[0m plt\u001b[39m.\u001b[39mimshow(test_set_x[:,index]\u001b[39m.\u001b[39;49mreshape((num_px, num_px, \u001b[39m3\u001b[39;49m)))\n\u001b[0;32m      <a href='vscode-notebook-cell:/g%3A/ml_env/log-reg-as-neural-net.ipynb#ch0000027?line=2'>3</a>\u001b[0m \u001b[39mprint\u001b[39m (\u001b[39m\"\u001b[39m\u001b[39my = \u001b[39m\u001b[39m\"\u001b[39m \u001b[39m+\u001b[39m \u001b[39mstr\u001b[39m(test_set_y[\u001b[39m0\u001b[39m,index]) \u001b[39m+\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m, you predicted that it is a \u001b[39m\u001b[39m\\\"\u001b[39;00m\u001b[39m\"\u001b[39m \u001b[39m+\u001b[39m classes[d[\u001b[39m\"\u001b[39m\u001b[39mY_prediction_test\u001b[39m\u001b[39m\"\u001b[39m][\u001b[39m0\u001b[39m,index]]\u001b[39m.\u001b[39mdecode(\u001b[39m\"\u001b[39m\u001b[39mutf-8\u001b[39m\u001b[39m\"\u001b[39m))\n",
      "\u001b[1;31mTypeError\u001b[0m: only integer scalar arrays can be converted to a scalar index"
     ]
    }
   ],
   "source": [
    "index = 25\n",
    "plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))\n",
    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[d[\"Y_prediction_test\"][0,index]].decode(\"utf-8\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.11 ('env': venv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.11"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f7c3a54a9154ab0113f48d48b1eef31653434e6001d3e1c35c5f0767e2012325"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}