Taller5_RedesNeuronalesProfundas_aplicacion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EoMRmCh3H7a_"
   },
   "source": [
    "# Redes neuronales profundas para clasificación de imagenes: aplicación \n",
    "\n",
    "En este taller va a utilizar las funciones que implementó en el taller anterior: \"Taller4_RedesNeuronalesProfundas\", y va a construir una red neuronal profunda, aplicandola a la clasificación de imagenes. \n",
    "\n",
    "El modelo se va a aplicar sobre las imagenes de ´gato, no-gato', y esperamos ver una mejoría en la precisión relativa (accuracy) con respecto a la regresión logística implementada anteriormente.  \n",
    "\n",
    "**Tras este taller va a ser capaz de:**\n",
    "- Construir y aplicar una red neuronal profunda para el aprendizaje supervisado. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ObG47jqdIQ8P"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fCXdw26RH7bB"
   },
   "source": [
    "## 1 - Paquetes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qEzbNOiiH7bE"
   },
   "source": [
    "Primero se deben importar todos los paquetes que se van a necesitar durante este taller.\n",
    "- [numpy](www.numpy.org) paquete básico para ciencias computacionales con Python.\n",
    "- [matplotlib](http://matplotlib.org) librería para graficar en Python.\n",
    "- [h5py](http://www.h5py.org) paquete para interactuar con datos guardados como archivo H5.\n",
    "- [PIL](http://www.pythonware.com/products/pil/) y [scipy](https://www.scipy.org/) usados para probar el modelo con imagenes propias al final del taller.\n",
    "- dnn_app_utils provee las funciones implementadas en el taller anterior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SwLXmOAcH7bF"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "from dnn_app_utils_v3 import *\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (5.0, 4.0) # tamaño de las graficas por defecto\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) # se utiliza para replicar las funciones aleatorias "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ggaNJm8CH7bP"
   },
   "source": [
    "## 2 - Conjunto de datos\n",
    "\n",
    "Vamos a usar el mismo conjunto de datos del Taller 2 \"RegresiónLogística\". El modelo que construyó tenía un 70% de precisión de prueba (test) al clasificar imagenes de gatos y todo aquello que no era gato (no-gato). Ahora vamos a implementar un modelo de redes profundas, y esperamos que su desempeño sea mejor!\n",
    "\n",
    "**Problema**: Dado el conjunto de datos (\"data.h5\") con:\n",
    "    - un conjunto de datos de entrenamiento (CE) con imagenes etiquetadas como gato (1) y no-gato(0)\n",
    "    - un conjunto de prueba (test) con imagenes etiquetadas como gato y no-gato\n",
    "    - cada imagen es de tamaño (num_px, num_px, 3) donde 3 es para los canales (RGB).\n",
    "\n",
    "A continuación exploramos el conjunto de datos. Cargue los datos ejecutando la celda abajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1QGEh-XGH7bQ"
   },
   "outputs": [],
   "source": [
    "train_x_orig, train_y, test_x_orig, test_y, classes = load_data()\n",
    "clases=[\"no-gato\", \"gato\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OSAJSBywH7bU"
   },
   "source": [
    "El siguiente código muestra una imagen del conjunto de datos. Puede cambiar el índice y volver a ejecutar para cambiar de imagen.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2CRKEvBAH7bV",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La imagen #200, es un 'gato'\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Ejemplo de una imagen\n",
    "indice = 200\n",
    "plt.imshow(train_x_orig[indice])\n",
    "print (\"La imagen #\" + str(indice) + \", es un '\" + str(clases[np.squeeze(train_y[:, indice])]) + \"'\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V3-8Aq-CH7bZ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de ejemplos de entrenamiento: m_train = 209\n",
      "Número de ejemplos de prueba: m_test = 50\n",
      "Cada imagen es de tamaño: (64, 64, 3)\n",
      "Dimensión del train_x_orig: (209, 64, 64, 3)\n",
      "Dimensión del train_y: (1, 209)\n",
      "Dimensión del test_x_orig: (50, 64, 64, 3)\n",
      "Dimensión del test_y: (1, 50)\n"
     ]
    }
   ],
   "source": [
    "# Explore los datos\n",
    "m_train = train_x_orig.shape[0]\n",
    "m_test = test_x_orig.shape[0]\n",
    "num_px = train_x_orig.shape[1]\n",
    "\n",
    "print (\"Número de ejemplos de entrenamiento: m_train = \" + str(m_train))\n",
    "print (\"Número de ejemplos de prueba: m_test = \" + str(m_test))\n",
    "print (\"Cada imagen es de tamaño: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "\n",
    "print (\"Dimensión del train_x_orig: \" + str(train_x_orig.shape))\n",
    "print (\"Dimensión del train_y: \" + str(train_y.shape))\n",
    "print (\"Dimensión del test_x_orig: \" + str(test_x_orig.shape))\n",
    "print (\"Dimensión del test_y: \" + str(test_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3qz2OVsTH7bf"
   },
   "source": [
    "**Salida esperada para m_train, m_test y tamaño de la imagen**: \n",
    "<table style=\"width:25%\">\n",
    "  <tr>\n",
    "    <td>**m_train**</td>\n",
    "    <td> 209 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**m_test**</td>\n",
    "    <td> 50 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**num_px**</td>\n",
    "    <td> (64, 64, 3) </td> \n",
    "  </tr>\n",
    "  \n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "m3b4zeeoH7bh"
   },
   "source": [
    "Como de costumbre, cambiamos las dimensiones (reshape) y estandarizamos las imagenes antes de alimentarlas a la red. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kLm_J1O0H7bi"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensiones de train_x: (12288, 209)\n",
      "Dimensiones de test_x: (12288, 50)\n"
     ]
    }
   ],
   "source": [
    "# Cambiamos la dimensión de los ejemplos de entrenamiento y prueba\n",
    "train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T   # El \"-1\" hace que la función reshape() aplane (flatten) las restantes dimensiones\n",
    "test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T\n",
    "\n",
    "# Normalizamos los datos para tener valores entre 0 y 1.\n",
    "train_x = train_x_flatten/255.\n",
    "test_x = test_x_flatten/255.\n",
    "\n",
    "print (\"Dimensiones de train_x: \" + str(train_x.shape))\n",
    "print (\"Dimensiones de test_x: \" + str(test_x.shape))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SQ9aM0SSH7bm"
   },
   "source": [
    "$12,288$ equivale a $64 \\times 64 \\times 3$, el cual es el tamaño de un vector de imagen transformado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wzRaiIJdH7bn"
   },
   "source": [
    "## 3 - Arquitectura del modelo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_WGW7Ha8H7bo"
   },
   "source": [
    "Ahora es el momento de construir una red neuronal profunda para la clasificación de imagenes.\n",
    "\n",
    "Va a construir dos modelos distintos:\n",
    "- Una red neuronal de dos capas\n",
    "- Una red neuronal profunda de L capas\n",
    "\n",
    "Luego va a comparar el desempeño de los modelos, y va a intentar con distintos valores para $L$. \n",
    "\n",
    "Veamos las dos arquitecturas.\n",
    "\n",
    "### 3.1 - Red neuronal de 2 capas\n",
    "\n",
    "- El input es una imagen de dimensiones (64,64,3) que es aplanada a un vector de tamaño $(12288,1)$. \n",
    "- El vector correspondiente: $[x_0,x_1,...,x_{12287}]^T$ es multiplicado por una matriz de pesos $W^{[1]}$ de tamaño $(n^{[1]}, 12288)$.\n",
    "- Le añade el intercepto o término de sesgo, y le aplica ReLU para conseguir el vector: $[a_0^{[1]}, a_1^{[1]},..., a_{n^{[1]}-1}^{[1]}]^T$.\n",
    "- Repite el mismo proceso.\n",
    "- Multiplica el vector resultante por $W^{[2]}$ y le añade el sesgo. \n",
    "- Finalmente, toma el sigmoide del resultado. Si es mayor que 0.5, clasifica como de clase 1.\n",
    "\n",
    "### 3.2 - Red neuronal profunda de L capas\n",
    "\n",
    "- El input es una imagen de dimensiones (64,64,3) que es aplanada a un vector de tamaño $(12288,1)$. \n",
    "- El vector correspondiente: $[x_0,x_1,...,x_{12287}]^T$ es multiplicado por una matriz de pesos $W^{[1]}$, y le añade el sesgo $b^{[1]}$. Al resultado se le llama \"unidad lineal\".\n",
    "- Luego, toma la ReLU para esta unidad. Este proceso se repite tantas veces como sea necesario para cada $(W^{[l]}, b^{[l]})$, dependiendo de la arquitectura del modelo.\n",
    "- Finalmente, toma el sigmoide de la última unidad lineal. Si es mayor que 0.5, clasifica como de clase 1.\n",
    "\n",
    "### 3.3 - Metodología general\n",
    "\n",
    "Como es usual, seguirá una metodología de aprendizaje profundo para consturir el modelo:\n",
    "    1. Inicialización de parámetros y definición de hiper-parámetros\n",
    "    2. Bucle para el total de iteraciones (num_iterations):\n",
    "        a. Propagación hacia delante\n",
    "        b. Cálculo de la función de coste\n",
    "        c. Retro-propagación\n",
    "        d. Actualización de parámetros \n",
    "    4. En base a los parámetros aprendidos, predecir las etiquetas de clases\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RaUaDiy0H7bp"
   },
   "source": [
    "## 4 - Red neuronal de 2 capas\n",
    "\n",
    "**Ejercicio**:  Utilice las funciones auxiliares que ha implementado en el taller anterior para construir una red de dos capas con la siguiente estructura: *LINEAL -> RELU -> LINEAL -> SIGMOIDE*. Las funciones que va a necesitar y sus entradas son:\n",
    "```python\n",
    "def initialize_parameters(n_x, n_h, n_y):\n",
    "    ...\n",
    "    return parameters \n",
    "def linear_activation_forward(A_prev, W, b, activation):\n",
    "    ...\n",
    "    return A, cache\n",
    "def compute_cost(AL, Y):\n",
    "    ...\n",
    "    return cost\n",
    "def linear_activation_backward(dA, cache, activation):\n",
    "    ...\n",
    "    return dA_prev, dW, db\n",
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    ...\n",
    "    return parameters\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yWMAKwFeH7bs"
   },
   "outputs": [],
   "source": [
    "### DEFINICIÓN DE CONSTANTES (HIPER-PARÁMETROS) DEL MODELO ####\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9lHidy9hH7cB"
   },
   "outputs": [],
   "source": [
    "# FUNCIÓN A CALIFICAR: two_layer_model\n",
    "\n",
    "def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
    "    \"\"\"\n",
    "    Implemente una red neuronal de dos capas: LINEAL->RELU->LINEAL->SIGMOIDE\n",
    "    Input:\n",
    "    X: datos de entrada de tamaño (n_x, número de ejemplos)\n",
    "    Y: vector de etiquetas observadas de tamaño (1, número de ejemplos)\n",
    "    layers_dims: dimensiones de las capas (n_x, n_h, n_y)\n",
    "    num_iterations: número de iteraciones del bucle de optimización\n",
    "    learning_rate: tasa de aprendizaje de la regla de actualización por G.D. \n",
    "    print_cost: si es verdadero \"True\", muestra el coste cada 100 iteraciones \n",
    "    Output:\n",
    "    parameters: diccionario con W1, W2, b1, y b2\n",
    "    \"\"\"\n",
    "    \n",
    "    np.random.seed(1)\n",
    "    grads = {}\n",
    "    costs = []                              \n",
    "    m = X.shape[1]                           \n",
    "    (n_x, n_h, n_y) = layers_dims\n",
    "    \n",
    "    # Inicialice el diccionario de parametros, llamando una de las funciones que ya implementó\n",
    "    ### EMPIEZE EL CÓDIGO AQUÍ ###  (≈ 1 línea de código)\n",
    "    parameters = \n",
    "    ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "    \n",
    "    # Obtenga W1, b1, W2 y b2 del diccionario de parámetros.\n",
    "    W1 = parameters[\"W1\"]\n",
    "    b1 = parameters[\"b1\"]\n",
    "    W2 = parameters[\"W2\"]\n",
    "    b2 = parameters[\"b2\"]\n",
    "    \n",
    "    # Bucle (G.D.)\n",
    "    for i in range(0, num_iterations):\n",
    "\n",
    "        # Propagación hacia delante: LINEAL -> RELU -> LINEAL -> SIGMOIDE. Inputs: \"X, W1, b1, W2, b2\". Outputs: \"A1, cache1, A2, cache2\".\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ###  (≈ 2 líneas de código)\n",
    "        A1, cache1 = \n",
    "        A2, cache2 = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "        \n",
    "        # Calcule el coste\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ###  (≈ 1 línea de código)\n",
    "        cost = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "        \n",
    "        # Inicialice la retro-propagación\n",
    "        dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))\n",
    "        \n",
    "        # Retro-propagación. Inputs: \"dA2, cache2, cache1\". Outputs: \"dA1, dW2, db2; , dW1, db1; dA0 no es utilizado\".\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ###  (≈ 2 líneas de código)\n",
    "        dA1, dW2, db2 = \n",
    "        dA0, dW1, db1 = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "        \n",
    "        # Iguale grads['dWl'] a dW1, grads['db1'] a db1, grads['dW2'] a dW2, grads['db2'] a db2\n",
    "        grads['dW1'] = dW1\n",
    "        grads['db1'] = db1\n",
    "        grads['dW2'] = dW2\n",
    "        grads['db2'] = db2\n",
    "        \n",
    "        # Actualice los parámetros.\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ###  (1 línea de código)\n",
    "        parameters = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "\n",
    "        # Recupere W1, b1, W2, b2 de parameters\n",
    "        W1 = parameters[\"W1\"]\n",
    "        b1 = parameters[\"b1\"]\n",
    "        W2 = parameters[\"W2\"]\n",
    "        b2 = parameters[\"b2\"]\n",
    "        \n",
    "        # Imprima el coste cada 100 iteraciones\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print(\"Coste tras la iteración {}: {}\".format(i, np.squeeze(cost)))\n",
    "        if print_cost and i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "       \n",
    "    # grafique el coste\n",
    "\n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iteraciones')\n",
    "    plt.title(\"Tasa de aprendizaje =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l7gD1ymPH7cG"
   },
   "source": [
    "Ejecute la siguente celda para aprender los parámetros. Asegúrese que su modelo corre bien: el coste debería decrecer. Puede tomar algunos minutos el ejecutar 2500 iteraciones. Revise que el \"Coste tras la iteración 0\" coincida con la salida esperada abajo, si no, haga click en el cuadrado de STOP (⬛) arriba en la barra del cuaderno para detener el proceso e intente encontrar su error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bgL_wczAH7cH"
   },
   "outputs": [],
   "source": [
    "parameters = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "huX7SrNeH7cM"
   },
   "source": [
    "**Salida esperada**\n",
    "<table> \n",
    "    <tr>\n",
    "        <td> **Coste tras la iteración 0**</td>\n",
    "        <td> 0.6930497356599888 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td> **Coste tras la iteración 100**</td>\n",
    "        <td> 0.6464320953428849 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td> **...**</td>\n",
    "        <td> ... </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td> **Coste tras la iteración 2400**</td>\n",
    "        <td> 0.048554785628770206 </td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jRYLCWlIH7cO"
   },
   "source": [
    "Nótese que gracias a la implementación vectorizada, el código no tarda demasiado en ejecutarse (de otro modo, podría haber llevado hasta 10 veces más tiempo).\n",
    "\n",
    "Ahora puede usar los parametros entrenados para clasificar las imagenes del conjunto de datos. Para ver las predicciones de entrenamiento y prueba (test), ejecute la celda abajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_OMTrwv7H7cP"
   },
   "outputs": [],
   "source": [
    "predictions_train = predict(train_x, train_y, parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GD9HB9ZWH7cU"
   },
   "source": [
    "**Salida esperada**\n",
    "<table> \n",
    "    <tr>\n",
    "        <td> **Precisión**</td>\n",
    "        <td> 1.0 </td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "evCE7RnKH7cV",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "predictions_test = predict(test_x, test_y, parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l40SxyXCH7cb"
   },
   "source": [
    "**Salida esperada**\n",
    "\n",
    "<table> \n",
    "    <tr>\n",
    "        <td> **Precisión**</td>\n",
    "        <td> 0.72 </td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mwOxCf77H7cc"
   },
   "source": [
    "**Nota**: Puede ver que si se ejecuta el modelo con menos iteraciones (e.g. 1500) se obtendría una mayor precisión de prueba. Esto se conoce como \"early stopping\" y es un criterio de parada, útil para prevenir el sobreajuste, que veremos más adelante. \n",
    "\n",
    "Muy bien! Parece que su modelo de red neuronal con 2 capas tiene un mejor desempeño (72%) que el de la regresión logística del Taller 2 (70%). Ahora vamos a ver si podemos mejorar los resultados con un modelo de $L$ capas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lffV--6_H7ce"
   },
   "source": [
    "## 5 - Red neuronal de L capas\n",
    "\n",
    "**Ejercicio**:  Utilice las funciones auxiliares que ha implementado en el anterior taller para construir una red de L capas con la siguiente estructura: *[LINEAL -> RELU]$\\times$(L-1) -> LINEAL -> SIGMOIDE*. Las funciones que va a necesitar y sus entradas son:\n",
    "\n",
    "```python\n",
    "def initialize_parameters_deep(layers_dims):\n",
    "    ...\n",
    "    return parameters \n",
    "def L_model_forward(X, parameters):\n",
    "    ...\n",
    "    return AL, caches\n",
    "def compute_cost(AL, Y):\n",
    "    ...\n",
    "    return cost\n",
    "def L_model_backward(AL, Y, caches):\n",
    "    ...\n",
    "    return grads\n",
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    ...\n",
    "    return parameters\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AU4OMoNhH7cj"
   },
   "outputs": [],
   "source": [
    "### CONSTANTES ###\n",
    "layers_dims = [12288, 20, 7, 5, 1] #  Modelo de 4 capas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-ooDOn_8H7cq"
   },
   "outputs": [],
   "source": [
    "# FUNCIÓN A CALIFICAR: L_layer_model\n",
    "\n",
    "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):#lr was 0.009\n",
    "    \"\"\"\n",
    "    Implemente una red neuronal de L capas: [LINEAL->RELU]*(L-1)->LINEAL->SIGMOIDE\n",
    "    Input:\n",
    "    X: datos de entrada de tamaño (n_x, número de ejemplos)\n",
    "    Y: vector de etiquetas observadas de tamaño (1, número de ejemplos)\n",
    "    layers_dims: dimensiones de las capas (n_x, n_h, n_y)\n",
    "    num_iterations: número de iteraciones del bucle de optimización\n",
    "    learning_rate: tasa de aprendizaje de la regla de actualización por G.D. \n",
    "    print_cost: si es verdadero \"True\", muestra el coste cada 100 iteraciones \n",
    "    Output:\n",
    "    parameters: diccionario con W1, W2, b1, y b2\n",
    "    \"\"\"\n",
    "\n",
    "    np.random.seed(1)\n",
    "    costs = []                         \n",
    "    \n",
    "    # Inicialización de parámetros. (≈ 1 linea de código)\n",
    "    ### EMPIEZE EL CÓDIGO AQUÍ ### \n",
    "    parameters = \n",
    "    ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "    \n",
    "    # Bucle (G.D.)\n",
    "    for i in range(0, num_iterations):\n",
    "\n",
    "        # Propagación hacia delante: [LINEAL -> RELU]*(L-1) -> LINEAL -> SIGMOIDE.\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ###  (≈ 1 línea de código)\n",
    "        AL, caches = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "        \n",
    "        # Calcule el coste.\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ###  (≈ 1 línea de código)\n",
    "        cost = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "    \n",
    "        # Retro-propagación.\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ### (≈ 1 línea de código)\n",
    "        grads = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    " \n",
    "        # Actualize los parámetros\n",
    "        ### EMPIEZE EL CÓDIGO AQUÍ ###  (≈ 1 línea de código)\n",
    "        parameters = \n",
    "        ### TERMINE EL CÓDIGO AQUÍ ###\n",
    "                \n",
    "        # Imprime el coste cada 100 iteraciones\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Coste tras la iteración %i: %f\" %(i, cost))\n",
    "        if print_cost and i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "            \n",
    "    # grafique el coste\n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('Coste')\n",
    "    plt.xlabel('Iteraciones')\n",
    "    plt.title(\"Tasa de aprendizaje =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "csXFDPlJH7ct"
   },
   "source": [
    "Ahora va a entrenar el modelo como una red neuronal de 4 capas. \n",
    "\n",
    "Ejecute la siguente celda para aprender los parámetros. Asegúrese que su modelo corre bien: el coste debería decrecer. Puede tomar algunos minutos el ejecutar 2500 iteraciones. Revise que el \"Coste tras la iteración 0\" coincida con la salida esperada abajo, si no, haga click en el cuadrado de STOP (⬛) arriba en la barra del cuaderno para detener el proceso e intente encontrar su error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qTXuPaB6H7cu",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s9-8qsALH7c4"
   },
   "source": [
    "**Salida esperada**\n",
    "<table> \n",
    "    <tr>\n",
    "        <td> **Coste tras la iteración 0**</td>\n",
    "        <td> 0.771749 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td> **Coste tras la iteración 100**</td>\n",
    "        <td> 0.672053 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td> **...**</td>\n",
    "        <td> ... </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td> **Coste tras la iteración 2400**</td>\n",
    "        <td> 0.092878 </td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QwAm1dgIH7c6",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pred_train = predict(train_x, train_y, parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XebBjdQaH7dE"
   },
   "source": [
    "**Salida esperada**\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "    <td>\n",
    "    **Precisión de entrenamiento**\n",
    "    </td>\n",
    "    <td>\n",
    "    0.985645933014\n",
    "    </td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VBqqlR4OH7dJ"
   },
   "outputs": [],
   "source": [
    "pred_test = predict(test_x, test_y, parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UvHV-Es2H7dN"
   },
   "source": [
    "**Salida esperada**\n",
    "\n",
    "<table> \n",
    "    <tr>\n",
    "        <td> **Precisión de prueba**</td>\n",
    "        <td> 0.8 </td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6Xi54lAaH7dO"
   },
   "source": [
    "Muy bien! Parece que la red neuronal de 4 capas tiene mejor desempeño (80%) que la red de 2 capas (72%) sobre el mismo conjunto de datos. \n",
    "\n",
    "Este es un buen desempeño! \n",
    "\n",
    "En las próximas clases veremos cómo podemos obtener una precisión aun mayor, buscando de manera sistemática mejores estimaciones para los hiper-parámetros (tasa de parendizaje, tamaño de las capas, número de iteraciones, entre otros). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HAgjBvu4H7dQ"
   },
   "source": [
    "##  6) Análisis de resultados\n",
    "\n",
    "Primero analicemos el error de manera manual. Revisemos algunas de las imagenes que el modelo de L capas etiquetó incorrectamente. Ejecute la celda abajo para visualizar algunos de estos errores. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PsayC-5GH7dR",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print_mislabeled_images(clases, test_x, test_y, pred_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NrH_VZjGH7dZ"
   },
   "source": [
    "**Las distintas imagenes sobre las que el modelo tiende a equivocarse incluyen:** \n",
    "- El cuerpo del gato está en una posición inusual\n",
    "- El gato aparece contra el fondo de un color similar\n",
    "- Color y especie de gato inusual \n",
    "- Angulo de la cámara inusual\n",
    "- Imagen muy/poco brillante\n",
    "- Escala de la variación (el gato aparece muy grande o muy pequeño en la imagen) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lNBLihmbH7db"
   },
   "source": [
    "## 7) Prueba con su propia imagen ##\n",
    "\n",
    "Ahora puede utilizar su propia imagen para probar el modelo. Para hacerlo agregue su(s) imagen(es) al directorio de este cuaderno en la carpeta \"images\", cambie el nombre de la (s) imagen(es) en el código siguiente, y compruebe si el algoritmo acierta (1=gato, 0=no-gato). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qzyp-RLgH7dd",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "### EMPIEZE EL CÓDIGO AQUÍ ### \n",
    "mi_imagen =   # el nombre debe coincidir con el de su imagen\n",
    "mi_etiqueta =  # la clase verdadera para su imagen (1 -> gato, 0 -> no-gato)\n",
    "## TERMINE EL CÓDIGO AQUÍ ##\n",
    "\n",
    "fname = \"images/\" + mi_imagen\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "mi_imagen = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))\n",
    "mi_imagen = mi_imagen/255.\n",
    "mi_imagen_pred = predict(mi_imagen, mi_etiqueta, parameters)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"y = \" + str(int(np.squeeze(mi_imagen_pred))) + \", el modelo predice que es una imagen de un \\\"\" + clases[int(np.squeeze(mi_imagen_pred))]+  \"\\\".\")\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Taller5_RedesNeuronalesProfundas_aplicacion.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}