CH_PCNA GH.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"right\" src=\"Imagenes/Logo Arauco 1.png\" style=\"width: 100px\">\n",
    "<img align=\"left\" src=\"Imagenes/Logo Arauco 2.png\" style=\"width: 100px\">\n",
    "\n",
    "   # <center>     Notebook Detección Corte de hoja </center>\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este notebook es creado para el entrenamiento de red neuronal para detección de corte de hoja de maquina L2.\n",
    "Es importante que cada vez que se realicen cambios al codigo queden documentados indicando:\n",
    "- Razon de la modificación\n",
    "- Fecha de modificación\n",
    "- Quien ejecuto la modificación\n",
    "\n",
    "Lo que buscamos con utilizar este notebook es que todos podamos documentar y aportar en la creación del modelo.\n",
    "Los integrantes del equipo de trabajo son:\n",
    "- Leonardo Bravo\n",
    "- Victor Encina\n",
    "- Yamil Avello\n",
    "- Guillermo Viñas\n",
    "- Felipe Santander\n",
    "\n",
    "El Notebook fue creado el 10.09.2019.\n",
    "\n",
    "1-. Instalado modulo de TensorFlow (10.09.2019)\n",
    "\n",
    "<rigth> **Felipe Santander** </right>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instalación de SW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already up-to-date: pip in /srv/conda/envs/notebook/lib/python3.7/site-packages (19.2.3)\n",
      "Requirement already satisfied: jupyter in /srv/conda/envs/notebook/lib/python3.7/site-packages (1.0.0)\n",
      "Requirement already satisfied: nbconvert in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter) (5.4.1)\n",
      "Requirement already satisfied: jupyter-console in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter) (6.0.0)\n",
      "Requirement already satisfied: qtconsole in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter) (4.5.5)\n",
      "Requirement already satisfied: ipywidgets in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter) (7.4.2)\n",
      "Requirement already satisfied: notebook in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter) (5.7.8)\n",
      "Requirement already satisfied: ipykernel in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter) (5.1.2)\n",
      "Requirement already satisfied: mistune>=0.8.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (0.8.4)\n",
      "Requirement already satisfied: jinja2 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (2.10.1)\n",
      "Requirement already satisfied: pygments in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (2.4.2)\n",
      "Requirement already satisfied: traitlets>=4.2 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (4.3.2)\n",
      "Requirement already satisfied: jupyter_core in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (4.4.0)\n",
      "Requirement already satisfied: nbformat>=4.4 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (4.4.0)\n",
      "Requirement already satisfied: entrypoints>=0.2.2 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (0.3)\n",
      "Requirement already satisfied: bleach in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (3.1.0)\n",
      "Requirement already satisfied: pandocfilters>=1.4.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (1.4.2)\n",
      "Requirement already satisfied: testpath in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (0.4.2)\n",
      "Requirement already satisfied: defusedxml in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbconvert->jupyter) (0.5.0)\n",
      "Requirement already satisfied: jupyter-client in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter-console->jupyter) (5.3.1)\n",
      "Requirement already satisfied: ipython in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter-console->jupyter) (7.8.0)\n",
      "Requirement already satisfied: prompt-toolkit<2.1.0,>=2.0.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter-console->jupyter) (2.0.9)\n",
      "Requirement already satisfied: ipython-genutils in /srv/conda/envs/notebook/lib/python3.7/site-packages (from qtconsole->jupyter) (0.2.0)\n",
      "Requirement already satisfied: widgetsnbextension~=3.4.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from ipywidgets->jupyter) (3.4.2)\n",
      "Requirement already satisfied: Send2Trash in /srv/conda/envs/notebook/lib/python3.7/site-packages (from notebook->jupyter) (1.5.0)\n",
      "Requirement already satisfied: pyzmq>=17 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from notebook->jupyter) (18.1.0)\n",
      "Requirement already satisfied: terminado>=0.8.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from notebook->jupyter) (0.8.2)\n",
      "Requirement already satisfied: tornado<7,>=4.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from notebook->jupyter) (6.0.3)\n",
      "Requirement already satisfied: prometheus-client in /srv/conda/envs/notebook/lib/python3.7/site-packages (from notebook->jupyter) (0.7.1)\n",
      "Requirement already satisfied: MarkupSafe>=0.23 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jinja2->nbconvert->jupyter) (1.1.1)\n",
      "Requirement already satisfied: six in /srv/conda/envs/notebook/lib/python3.7/site-packages (from traitlets>=4.2->nbconvert->jupyter) (1.12.0)\n",
      "Requirement already satisfied: decorator in /srv/conda/envs/notebook/lib/python3.7/site-packages (from traitlets>=4.2->nbconvert->jupyter) (4.4.0)\n",
      "Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from nbformat>=4.4->nbconvert->jupyter) (3.0.2)\n",
      "Requirement already satisfied: webencodings in /srv/conda/envs/notebook/lib/python3.7/site-packages (from bleach->nbconvert->jupyter) (0.5.1)\n",
      "Requirement already satisfied: python-dateutil>=2.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jupyter-client->jupyter-console->jupyter) (2.8.0)\n",
      "Requirement already satisfied: backcall in /srv/conda/envs/notebook/lib/python3.7/site-packages (from ipython->jupyter-console->jupyter) (0.1.0)\n",
      "Requirement already satisfied: jedi>=0.10 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from ipython->jupyter-console->jupyter) (0.15.1)\n",
      "Requirement already satisfied: pickleshare in /srv/conda/envs/notebook/lib/python3.7/site-packages (from ipython->jupyter-console->jupyter) (0.7.5)\n",
      "Requirement already satisfied: pexpect; sys_platform != \"win32\" in /srv/conda/envs/notebook/lib/python3.7/site-packages (from ipython->jupyter-console->jupyter) (4.7.0)\n",
      "Requirement already satisfied: setuptools>=18.5 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from ipython->jupyter-console->jupyter) (41.2.0)\n",
      "Requirement already satisfied: wcwidth in /srv/conda/envs/notebook/lib/python3.7/site-packages (from prompt-toolkit<2.1.0,>=2.0.0->jupyter-console->jupyter) (0.1.7)\n",
      "Requirement already satisfied: attrs>=17.4.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.4->nbconvert->jupyter) (19.1.0)\n",
      "Requirement already satisfied: pyrsistent>=0.14.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jsonschema!=2.5.0,>=2.4->nbformat>=4.4->nbconvert->jupyter) (0.15.4)\n",
      "Requirement already satisfied: parso>=0.5.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from jedi>=0.10->ipython->jupyter-console->jupyter) (0.5.1)\n",
      "Requirement already satisfied: ptyprocess>=0.5 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from pexpect; sys_platform != \"win32\"->ipython->jupyter-console->jupyter) (0.6.0)\n",
      "Requirement already satisfied: tensorflow==1.14 in /srv/conda/envs/notebook/lib/python3.7/site-packages (1.14.0)\n",
      "Requirement already satisfied: wrapt>=1.11.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.11.2)\n",
      "Requirement already satisfied: protobuf>=3.6.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (3.9.2)\n",
      "Requirement already satisfied: tensorboard<1.15.0,>=1.14.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.14.0)\n",
      "Requirement already satisfied: keras-applications>=1.0.6 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.0.8)\n",
      "Requirement already satisfied: numpy<2.0,>=1.14.5 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.17.2)\n",
      "Requirement already satisfied: keras-preprocessing>=1.0.5 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.1.0)\n",
      "Requirement already satisfied: six>=1.10.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.12.0)\n",
      "Requirement already satisfied: grpcio>=1.8.6 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.24.0)\n",
      "Requirement already satisfied: wheel>=0.26 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (0.33.6)\n",
      "Requirement already satisfied: termcolor>=1.1.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.1.0)\n",
      "Requirement already satisfied: tensorflow-estimator<1.15.0rc0,>=1.14.0rc0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (1.14.0)\n",
      "Requirement already satisfied: google-pasta>=0.1.6 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (0.1.7)\n",
      "Requirement already satisfied: astor>=0.6.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (0.8.0)\n",
      "Requirement already satisfied: absl-py>=0.7.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (0.8.0)\n",
      "Requirement already satisfied: gast>=0.2.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorflow==1.14) (0.3.2)\n",
      "Requirement already satisfied: setuptools in /srv/conda/envs/notebook/lib/python3.7/site-packages (from protobuf>=3.6.1->tensorflow==1.14) (41.2.0)\n",
      "Requirement already satisfied: markdown>=2.6.8 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorboard<1.15.0,>=1.14.0->tensorflow==1.14) (3.1.1)\n",
      "Requirement already satisfied: werkzeug>=0.11.15 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from tensorboard<1.15.0,>=1.14.0->tensorflow==1.14) (0.16.0)\n",
      "Requirement already satisfied: h5py in /srv/conda/envs/notebook/lib/python3.7/site-packages (from keras-applications>=1.0.6->tensorflow==1.14) (2.10.0)\n",
      "Requirement already satisfied: pandas in /srv/conda/envs/notebook/lib/python3.7/site-packages (0.25.1)\n",
      "Requirement already satisfied: python-dateutil>=2.6.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from pandas) (2.8.0)\n",
      "Requirement already satisfied: numpy>=1.13.3 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from pandas) (1.17.2)\n",
      "Requirement already satisfied: pytz>=2017.2 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from pandas) (2019.2)\n",
      "Requirement already satisfied: six>=1.5 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from python-dateutil>=2.6.1->pandas) (1.12.0)\n",
      "Requirement already satisfied: matplotlib in /srv/conda/envs/notebook/lib/python3.7/site-packages (3.1.1)\n",
      "Requirement already satisfied: numpy>=1.11 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from matplotlib) (1.17.2)\n",
      "Requirement already satisfied: python-dateutil>=2.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from matplotlib) (2.8.0)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from matplotlib) (2.4.2)\n",
      "Requirement already satisfied: cycler>=0.10 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from matplotlib) (0.10.0)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from matplotlib) (1.1.0)\n",
      "Requirement already satisfied: six>=1.5 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from python-dateutil>=2.1->matplotlib) (1.12.0)\n",
      "Requirement already satisfied: setuptools in /srv/conda/envs/notebook/lib/python3.7/site-packages (from kiwisolver>=1.0.1->matplotlib) (41.2.0)\n",
      "Requirement already satisfied: sklearn in /srv/conda/envs/notebook/lib/python3.7/site-packages (0.0)\n",
      "Requirement already satisfied: scikit-learn in /srv/conda/envs/notebook/lib/python3.7/site-packages (from sklearn) (0.21.3)\n",
      "Requirement already satisfied: numpy>=1.11.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from scikit-learn->sklearn) (1.17.2)\n",
      "Requirement already satisfied: scipy>=0.17.0 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from scikit-learn->sklearn) (1.3.1)\n",
      "Requirement already satisfied: joblib>=0.11 in /srv/conda/envs/notebook/lib/python3.7/site-packages (from scikit-learn->sklearn) (0.14.0)\n"
     ]
    }
   ],
   "source": [
    "#IMPORTANTE: Instalar tensorflow y pandas al correr por primera vez notebook\n",
    "!pip install --upgrade pip\n",
    "!pip install jupyter\n",
    "!pip install tensorflow==1.14\n",
    "#!conda install pandas\n",
    "!pip install pandas\n",
    "!pip install matplotlib\n",
    "!pip install sklearn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Importación \n",
    "### 1.1 Importación de librerias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/srv/conda/envs/notebook/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.14.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "import os\n",
    "print(tf.__version__)\n",
    "from tensorflow.python.framework import ops\n",
    "from sklearn import preprocessing\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.utils import shuffle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Importación de datasets\n",
    "Se importan los datasets previamente rescatados, estos deben ser guardados en la carpeta raiz de notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La dimension de set de datos de entrada es:  (53, 9904)\n",
      "La dimension de set de datos de salida es:  (1, 9904)\n"
     ]
    }
   ],
   "source": [
    "#Cargar datasets para entrenamiento\n",
    "#print(os.getcwd())\n",
    "#print(os.listdir())\n",
    "X_mean=[]\n",
    "X_Orig = pd.read_csv('/home/jovyan/Datos/X_Train_Jul2019.csv',delimiter=';',engine='python')\n",
    "Y_Orig = pd.read_csv('/home/jovyan/Datos/Y_Train_Jul2019.csv',delimiter=';',engine='python')\n",
    "#print(np.sum(X_Train.isnull()))\n",
    "X_Orig=X_Orig.values\n",
    "Y_Orig=Y_Orig.values\n",
    "X_Orig=X_Orig.astype(np.float).T\n",
    "Y_Orig=Y_Orig.astype(np.float).T\n",
    "X_Orig=np.delete(X_Orig,53,0)\n",
    "\n",
    "print(\"La dimension de set de datos de entrada es: \",X_Orig.shape)\n",
    "print(\"La dimension de set de datos de salida es: \",Y_Orig.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Normalización set de datos\n",
    "La normalización de datos tiene por objetivo normalizar a por unidad todos los datos de entrada, es decir en rango de $[0,1]$ para extraer efectivamente la información de cada una de las variables alimentada al modelo.\n",
    "\n",
    "Para la normalización de las variables se utilizaron dos formas:\n",
    "1. Normalización de datos:\n",
    "$$X_{norm}=\\frac{(X-X_{Min})}{(X_{Max}-X_{Min})}\\tag{1}$$\n",
    "2. Estandarización de datos\n",
    "$$X_{std}=\\frac{(X-\\bar{X})}{\\sigma}\\tag{2}$$\n",
    " (Desviación estandar): $ \\sigma = \\sqrt[]{\\frac{1}{N-1}\\sum_{i=1}^{N}X_i-\\bar{X}}\\tag{3}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(53, 9904)\n",
      "(1, 9904)\n",
      "La dimension de los datos originales es (53, 9904)\n",
      "La dimension de los datos normalizados es (53, 9904)\n",
      "La dimension de los datos estandarizados es (53, 9904)\n",
      "La dimension de los datos entrenamiento es (53, 6932)\n",
      "La dimension de los datos test es (53, 1485)\n",
      "La dimension de los datos dev es (53, 1485)\n"
     ]
    }
   ],
   "source": [
    "X_max=np.zeros((X_Orig.shape[0],1))\n",
    "X_min=np.zeros((X_Orig.shape[0],1))\n",
    "\n",
    "mean=np.reshape(np.mean(X_Orig,axis=1),(53,1),order='F')\n",
    "var=np.reshape(np.var(X_Orig,axis=1),(53,1),order='F')\n",
    "devstd=np.reshape(np.std(X_Orig,axis=1),(53,1),order='F')\n",
    "\n",
    "cont=X_Orig.shape[0]\n",
    "sample_cont=X_Orig.shape[1]\n",
    "\n",
    "train_cont=int(np.round(sample_cont*0.7))\n",
    "test_cont=int(np.round((sample_cont-1)*0.15))\n",
    "dev_cont=int(np.round((sample_cont-1)*0.15))\n",
    "i=0\n",
    "for i in range(cont):\n",
    "        X_max[i]=np.max(X_Orig[[i]])\n",
    "        X_min[i]=np.min(X_Orig[[i]])\n",
    "\n",
    "X_gain=X_max-X_min\n",
    "X_norm=np.divide(X_Orig-X_min,X_gain)\n",
    "X_std=np.divide((X_Orig-mean),devstd)\n",
    "print(X_std.shape)\n",
    "print(Y_Orig.shape)\n",
    "X_std, Y_Orig = shuffle(X_std.T, Y_Orig.T)\n",
    "X_std=X_std.T\n",
    "Y_Orig=Y_Orig.T\n",
    "X_train=X_std[:,1:train_cont]\n",
    "Y_train=Y_Orig[:,1:train_cont]\n",
    "X_test=X_std[:,train_cont+1:test_cont+train_cont+1]\n",
    "Y_test=Y_Orig[:,train_cont+1:test_cont+train_cont+1]\n",
    "X_dev=X_std[:,test_cont+train_cont+1:dev_cont+test_cont+train_cont+1]\n",
    "Y_dev=Y_Orig[:,test_cont+train_cont+1:dev_cont+test_cont+train_cont+1]\n",
    "\n",
    "\n",
    "print(\"La dimension de los datos originales es\",X_Orig.shape)\n",
    "print(\"La dimension de los datos normalizados es\",X_norm.shape)\n",
    "print(\"La dimension de los datos estandarizados es\",X_std.shape)\n",
    "print(\"La dimension de los datos entrenamiento es\",X_train.shape)\n",
    "print(\"La dimension de los datos test es\",X_test.shape)\n",
    "print(\"La dimension de los datos dev es\",X_dev.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.squeeze(Y_Orig[:,0:1000]), label='Modelo')\n",
    "plt.ylabel('costo')\n",
    "plt.xlabel('muestras')\n",
    "plt.title(\"Predicciones vs Real\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Creación de Minibatch\n",
    "Para acelerar los entrenamientos se crean sets de datos mas pequeños de forma que no es necesario explorar el sets de datos completos para obtener una aproximacion de las matrices de pesos y bias, y a cada exploracion de minibatch se obtiene una optimización de los parametros de la red neuronal.\n",
    "El ideal es que los tamaños de los minibatches sea de numero par consistentes con cuentas binarias (32,64,128,512...) de manera de optimizar el tamaño de uso de memoria RAM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):\n",
    "    \"\"\"\n",
    "    Creates a list of random minibatches from (X, Y)\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input data, of shape (input size, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)\n",
    "    mini_batch_size - size of the mini-batches, integer\n",
    "    seed -- this is only for the purpose of grading, so that you're \"random minibatches are the same as ours.\n",
    "    \n",
    "    Returns:\n",
    "    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]                  # number of training examples\n",
    "    mini_batches = []\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    # Step 1: Shuffle (X, Y)\n",
    "    permutation = list(np.random.permutation(m))\n",
    "    shuffled_X = X[:, permutation]\n",
    "    shuffled_Y = Y[:, permutation].reshape((Y.shape[0],m))\n",
    "\n",
    "    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.\n",
    "    num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning\n",
    "    for k in range(0, num_complete_minibatches):\n",
    "        mini_batch_X = shuffled_X[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]\n",
    "        mini_batch_Y = shuffled_Y[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    # Handling the end case (last mini-batch < mini_batch_size)\n",
    "    if m % mini_batch_size != 0:\n",
    "        mini_batch_X = shuffled_X[:, num_complete_minibatches * mini_batch_size : m]\n",
    "        mini_batch_Y = shuffled_Y[:, num_complete_minibatches * mini_batch_size : m]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    return mini_batches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprobación de correcto funcionamiento de función\n",
    "\n",
    "```Random_mini_batches(X_train,Y_Train,32,1)```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of the 1st mini_batch_X: (53, 32)\n",
      "shape of the 2nd mini_batch_X: (53, 32)\n",
      "shape of the 3rd mini_batch_X: (53, 32)\n",
      "shape of the 1st mini_batch_Y: (1, 32)\n",
      "shape of the 2nd mini_batch_Y: (1, 32)\n",
      "shape of the 3rd mini_batch_Y: (1, 32)\n",
      "mini batch check: [0.12015152 0.12069389 0.11688336]\n"
     ]
    }
   ],
   "source": [
    "mini_batches = random_mini_batches(X_test, Y_test,32,1)\n",
    "print (\"shape of the 1st mini_batch_X: \" + str(mini_batches[0][0].shape))\n",
    "print (\"shape of the 2nd mini_batch_X: \" + str(mini_batches[1][0].shape))\n",
    "print (\"shape of the 3rd mini_batch_X: \" + str(mini_batches[2][0].shape))\n",
    "print (\"shape of the 1st mini_batch_Y: \" + str(mini_batches[0][1].shape))\n",
    "print (\"shape of the 2nd mini_batch_Y: \" + str(mini_batches[1][1].shape)) \n",
    "print (\"shape of the 3rd mini_batch_Y: \" + str(mini_batches[2][1].shape))\n",
    "print (\"mini batch check: \" + str(mini_batches[0][0][0][0:3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Creación Red Neuronal\n",
    "\n",
    "### 2.1 Función para creación de vectores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_placeholders(n_x, n_y):\n",
    "    \"\"\"\n",
    "    Crea los placeholders para la sesion de tensorflow.\n",
    "    \n",
    "    Arguments:\n",
    "    n_x -- escalar, tamaño de variables de entradas\n",
    "    n_y -- escalar, numero de calisificadores (caso particular de detección corte de hoja 1)\n",
    "    \n",
    "    Returns:\n",
    "    X -- placeholder para los datos de entrada, de dimension [n_x, None] y dtype \"float\"\n",
    "    Y -- placeholder para las etiquetas de salida, de dimensión [n_y, None] y dtype \"float\"\n",
    "    \"\"\"\n",
    "    \n",
    "    X = tf.placeholder(tf.float32, shape=(n_x,None))\n",
    "    Y = tf.placeholder(tf.float32,  shape=(n_y,None))\n",
    "    \n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Función de inicialización de parametros\n",
    "Se inicializan las matrices de peso y bias de la red neuronal.\n",
    "En este bloque es donde se indica la cantidad de neuronas que tendra cada capa.\n",
    "\n",
    "Inicialmente la cantidad de neuronas en las capas ocultas es la siguiente:\n",
    "\n",
    "* $Capa_1: 15$\n",
    "* $Capa_2: 15$\n",
    "* $Capa_3: 1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters():\n",
    "    \"\"\"\n",
    "    Inicializa los parametros para crear la red neuronal en tensorflow. Las dimensiones son:\n",
    "                        W1 : [15, 53]\n",
    "                        b1 : [15, 1]\n",
    "                        W2 : [15, 15]\n",
    "                        b2 : [15, 1]\n",
    "                        W3 : [1, 15]\n",
    "                        b3 : [1, 1]\n",
    "    \n",
    "    Salida:\n",
    "    parameters -- dictionario que contiene W1, b1, W2, b2, W3, b3\n",
    "    \"\"\"\n",
    "    \n",
    "    tf.set_random_seed(1)\n",
    "    W1 =tf.get_variable(\"W1\", [53,53], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b1 = tf.get_variable(\"b1\", [53,1], initializer = tf.zeros_initializer())\n",
    "    W2 = tf.get_variable(\"W2\", [30,53], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b2 = tf.get_variable(\"b2\", [30,1], initializer = tf.zeros_initializer())\n",
    "    W3 = tf.get_variable(\"W3\", [1,30], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b3 = tf.get_variable(\"b3\", [1,1], initializer = tf.zeros_initializer())\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2,\n",
    "                  \"W3\": W3,\n",
    "                  \"b3\": b3}\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Función Feedforward\n",
    "\n",
    "Se construye red neuronal con funciones de activación sigmoidales de tres capas:\n",
    "<img src=\"Imagenes/Arquitectura Red.png\">\n",
    "\n",
    "---\n",
    "\n",
    "Matematicamente es:\n",
    "\n",
    "$$Z^{[1]}=W^{[1]}*X_{norm}+B_{[1]}\\small\\tag{1}$$\n",
    "$$Z^{[i]}=W^{[i]}*Z^{[i]}+B_{[i]}\\small\\tag{2}$$\n",
    "$$A^{[i]}=sigmoid(Z^{[i]})=\\sigma(Z^{[i]})\\small\\tag{3}$$\n",
    "$$\\hat{y}=\\sigma(Z^{[3]})\\small\\tag{4}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implementación de forward propagation: LINEAR -> SIGMOID -> LINEAR -> SIGMOID -> LINEAR -> SIGMOID\n",
    "    \n",
    "    Arguments:\n",
    "    X -- entrada dataset placeholder, de dimension (tamaño entrada, numero de muestras)\n",
    "    parameters -- contiene los parametros \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\"\n",
    "                  las dimensiones son dadas por la función de inicialización\n",
    "\n",
    "    Salida:\n",
    "    Z3 -- salida de la ultima función LINEAR\n",
    "    \"\"\"\n",
    "    \n",
    "    # Rescata los parametros desde el diccionario \"parameters\" \n",
    "    W1 = parameters['W1']\n",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "    W3 = parameters['W3']\n",
    "    b3 = parameters['b3']\n",
    "    \n",
    "    Z1 = tf.add(tf.matmul(W1,X),b1)\n",
    "    A1 = tf.nn.sigmoid(Z1)\n",
    "    Z2 = tf.add(tf.matmul(W2,A1),b2)\n",
    "    A2 = tf.nn.sigmoid(Z2)\n",
    "    Z3 = tf.add(tf.matmul(W3,A2),b3)\n",
    "    \n",
    "    return Z3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Función Costo\n",
    "\n",
    "La función de costo utilizada es:\n",
    "$$ J = - \\frac{1}{m}  \\sum_{i = 1}^m  \\large ( \\small y^{(i)} \\log a^{ [2] (i)} + (1-y^{(i)})\\log (1-a^{ [2] (i)} )\\large )\\small\\tag{5}$$\n",
    "La función de costo (5) es conocida como \"*sigmoid cross entropy*\" y en tensorflow puede ser llamada como:\n",
    "\n",
    "```tf.nn.sigmoid_cross_entropy_with_logits()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(Z3, Y):\n",
    "    \"\"\"\n",
    "    Calculo costo\n",
    "    \n",
    "    Argumentos:\n",
    "    Z3 -- salida de forward propagation (salida de la ultima función LINEAR), de dimension (1, numero de muestras)\n",
    "    Y -- \"true\" vector de etiquetas placeholder, misma dimension que Z3\n",
    "    \n",
    "    Salida:\n",
    "    cost - Tensor de la función de costo\n",
    "    \"\"\"\n",
    "    \n",
    "    logits = tf.transpose(Z3)\n",
    "    labels = tf.transpose(Y)\n",
    "    \n",
    "    cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = logits, labels = labels))\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Construcción del Modelo\n",
    "Se utilizan las funciones generadas antes para construir el modelo de la red neuronal y generar el entrenamiento utilizando los minibatch ya generados. Los parametros que pueden ser modificados para la busqueda de mejor comportamiento del modelo son los siguientes:\n",
    "* learning rate ```learning_rate```: tamaño de la corrección por cada iteración obtenida desde el algoritmo Adam.\n",
    "* numero de epocas ```num_epochs```: numero de veces que explorará todos los minibatches.\n",
    "* tamaño de minibatch ```minibatch_size```: tamaño de los minibatch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.001,\n",
    "          num_epochs = 2000, minibatch_size = 32, print_cost = True):\n",
    "    \"\"\"\n",
    "    Implementa tres-capas tensorflow red neuronal: LINEAR->SIGMOID->LINEAR->SIGMOID->LINEAR->SIGMOID.\n",
    "    \n",
    "    Argumentos:\n",
    "    X_train -- training set, de dimension (tamaño entradas = 53, numero de muestras = 1080)\n",
    "    Y_train -- test set, de dimension (tamaño salida = 1, numero de muestras = 1080)\n",
    "    X_test -- training set, de dimension (tamaño entradas = 53, numero de muestras = 1080)\n",
    "    Y_test -- test set, de dimension (tamaño salida = 1, numero de muestras = 1080)\n",
    "    learning_rate -- learning rate de la optimización\n",
    "    num_epochs -- number de epocas de ciclo de optimización\n",
    "    minibatch_size -- tamaño minibatch\n",
    "    print_cost -- True para imprimir el costo cada 100 epocas\n",
    "    \n",
    "    Salida:\n",
    "    parameters -- parametros aprendidos por el modelos.\n",
    "    \"\"\"\n",
    "    \n",
    "    ops.reset_default_graph()                         # para correr modelo sin sobreescribir tf variables\n",
    "    tf.set_random_seed(1)                             # para mantener resultados consistentes\n",
    "    seed = 3                                          # para mantener resultados consistentes\n",
    "    (n_x, m) = X_train.shape                          # (n_x: tamaño set entradas, m : numeros de muestras en el dataset)\n",
    "    n_y = Y_train.shape[0]                            # n_y : tamaño de salida\n",
    "    costs = []                                        # para mantener seguimiento de función de costo\n",
    "    print(\"n_x: \",n_x)\n",
    "    print(\"n_y: \",n_y)\n",
    "    # Crea variables de tf de orden (n_x, n_y)\n",
    "    X, Y = create_placeholders(n_x,n_y)\n",
    "\n",
    "    # Inicializa parametros\n",
    "    parameters = initialize_parameters()\n",
    "    \n",
    "    # Forward propagation: construye forward propagation en el grafico de tensorflow\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    \n",
    "    # Función de costo: Incluye la función de costo en el grafico de tensorflow\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    \n",
    "    # Backpropagation: Define el optimizador de tensorflow. Usa AdamOptimizer.\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)\n",
    "    \n",
    "    # Inicializa todas las variables\n",
    "    init = tf.global_variables_initializer()\n",
    "\n",
    "    # Inicia la sesión para computar el grafico de tensorflow\n",
    "    with tf.Session() as sess:\n",
    "        \n",
    "        # Corre initialization\n",
    "        sess.run(init)\n",
    "        \n",
    "        # Realiza training loop\n",
    "        for epoch in range(num_epochs):\n",
    "\n",
    "            epoch_cost = 0.                       # Defines a cost related to an epoch\n",
    "            num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
    "            seed = seed + 1\n",
    "            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
    "\n",
    "            for minibatch in minibatches:\n",
    "        \n",
    "                # Selecciona minibatch\n",
    "                (minibatch_X, minibatch_Y) = minibatch\n",
    "                #print(minibatch_X[1][0])\n",
    "                \n",
    "                #IMPORTANTE: Función que ejecuta optimización en tensorflow\n",
    "                _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "                \n",
    "                epoch_cost += minibatch_cost / num_minibatches\n",
    "\n",
    "            # Muestra el costo en cada epoca\n",
    "            if print_cost == True and epoch % 100 == 0:\n",
    "                print (\"Cost after epoch %i: %f\" % (epoch, epoch_cost))\n",
    "            if print_cost == True and epoch % 5 == 0:\n",
    "                costs.append(epoch_cost)\n",
    "                \n",
    "        # grafica el costo\n",
    "        plt.plot(np.squeeze(costs))\n",
    "        plt.ylabel('costo')\n",
    "        plt.xlabel('iteraciones (x10)')\n",
    "        plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "        plt.show()\n",
    "\n",
    "        # Guarda los parametros en una variable\n",
    "        parameters = sess.run(parameters)\n",
    "        print (\"Los parametros han sido entrenados!\")\n",
    "\n",
    "        # Calcula las predicciones correctas\n",
    "        correct_prediction = tf.equal(tf.cast(tf.greater_equal(tf.sigmoid(Z3),0.5), \"bool\"), tf.cast(tf.argmax(Y), \"bool\"))\n",
    "        #correct_prediction = tf.equal(tf.argmax(Z3),tf.argmax(Y))\n",
    "        # Calcula el accuracy en el test set\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "        print (\"Train Accuracy:\", accuracy.eval({X: X_train, Y: Y_train}))\n",
    "        print (\"Test Accuracy:\", accuracy.eval({X: X_test, Y: Y_test}))\n",
    "        W1 = parameters['W1']\n",
    "        b1 = parameters['b1']\n",
    "        W2 = parameters['W2']\n",
    "        b2 = parameters['b2']\n",
    "        W3 = parameters['W3']\n",
    "        b3 = parameters['b3']\n",
    "        print(\"W1= \", W1)\n",
    "        print(\"b1= \", b1)\n",
    "        print(\"W2= \", W2)\n",
    "        print(\"b2= \", b2)\n",
    "        print(\"W3= \", W3)\n",
    "        print(\"b3= \", b3)\n",
    "        return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.7 Entrenamiento Red Neuronal\n",
    "Se entrena la red neuronal utilizando el set de datos normalizado, como resultado se obtendra:\n",
    "1. Cada 100 epocas imprimira el valor de la función de costo que se esta optimizando\n",
    "2. Al finalizar la iteración por la cantidad de epocas imprimira el grafico de evolución de la función de costo\n",
    "3. Imprimira el valor de cada una de las matrices de pesos y bias de cada capa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_x:  53\n",
      "n_y:  1\n",
      "Cost after epoch 0: 0.688077\n",
      "Cost after epoch 100: 0.014564\n",
      "Cost after epoch 200: 0.010241\n",
      "Cost after epoch 300: 0.008976\n",
      "Cost after epoch 400: 0.009255\n",
      "Cost after epoch 500: 0.008447\n",
      "Cost after epoch 600: 0.008321\n",
      "Cost after epoch 700: 0.007957\n",
      "Cost after epoch 800: 0.007703\n",
      "Cost after epoch 900: 0.007759\n",
      "Cost after epoch 1000: 0.007621\n",
      "Cost after epoch 1100: 0.008306\n",
      "Cost after epoch 1200: 0.007133\n",
      "Cost after epoch 1300: 0.007264\n",
      "Cost after epoch 1500: 0.007266\n",
      "Cost after epoch 1600: 0.007110\n",
      "Cost after epoch 1700: 0.007031\n",
      "Cost after epoch 1800: 0.007023\n",
      "Cost after epoch 1900: 0.006924\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Los parametros han sido entrenados!\n",
      "Train Accuracy: 0.49076745\n",
      "Test Accuracy: 0.4888889\n",
      "W1=  [[-1.1799731  -1.034837   -1.5192719  ... -0.23081638 -1.2513177\n",
      "   0.73965865]\n",
      " [-1.1352651   4.896335   -0.47565785 ... -0.04809543 -1.2046288\n",
      "   0.7620145 ]\n",
      " [-0.9395166   2.2413657   0.44233763 ... -1.5261464   2.1043417\n",
      "  -1.7681111 ]\n",
      " ...\n",
      " [-0.33486873 -2.9536097   0.6526484  ...  0.94058776 -0.22436875\n",
      "   0.5105321 ]\n",
      " [ 1.3695015   1.5722281   0.8996436  ...  0.408262    0.88011354\n",
      "  -0.47875243]\n",
      " [-3.1439865   2.230666    1.5051761  ... -0.80590874  1.8120602\n",
      "   0.00695612]]\n",
      "b1=  [[-1.0757735 ]\n",
      " [-0.8162958 ]\n",
      " [-0.45131084]\n",
      " [-0.9174174 ]\n",
      " [-0.43591747]\n",
      " [-0.37780398]\n",
      " [-0.7970192 ]\n",
      " [-0.3692124 ]\n",
      " [-0.36075515]\n",
      " [-0.57175463]\n",
      " [-0.29290077]\n",
      " [-0.4735468 ]\n",
      " [-0.10566089]\n",
      " [-0.28871983]\n",
      " [ 0.12066074]\n",
      " [-1.2432655 ]\n",
      " [ 0.39300808]\n",
      " [-0.14963546]\n",
      " [-1.0325798 ]\n",
      " [ 0.20863853]\n",
      " [-0.09722045]\n",
      " [-0.17019206]\n",
      " [ 0.04714118]\n",
      " [-0.750995  ]\n",
      " [-0.644485  ]\n",
      " [-0.1752677 ]\n",
      " [ 0.00185937]\n",
      " [-0.19208129]\n",
      " [-0.05829533]\n",
      " [ 0.2569512 ]\n",
      " [-0.21615003]\n",
      " [-0.0903194 ]\n",
      " [-1.0488653 ]\n",
      " [-0.55351865]\n",
      " [ 0.9146423 ]\n",
      " [-1.371365  ]\n",
      " [-0.26015952]\n",
      " [ 0.5339418 ]\n",
      " [ 0.9612352 ]\n",
      " [-0.59008276]\n",
      " [-0.18871205]\n",
      " [-0.56123626]\n",
      " [-0.4631193 ]\n",
      " [ 0.8966951 ]\n",
      " [-0.28205013]\n",
      " [-1.038815  ]\n",
      " [-0.95918083]\n",
      " [ 0.5339521 ]\n",
      " [ 0.32477432]\n",
      " [-0.24566971]\n",
      " [-0.19111162]\n",
      " [ 0.16119745]\n",
      " [ 0.76531565]]\n",
      "W2=  [[-0.9961029  -1.3866754  -0.60288024 ... -1.1173488   1.3937905\n",
      "   0.72055274]\n",
      " [-1.8791754  -1.5426414  -1.5846918  ... -0.5739723   1.8668901\n",
      "   0.7721601 ]\n",
      " [-2.0828276  -1.3838797  -1.6705168  ... -0.77764374  1.872089\n",
      "   0.47759578]\n",
      " ...\n",
      " [ 2.531588   -2.0190446  -1.3571153  ... -1.2348642   1.2973161\n",
      "   1.0366921 ]\n",
      " [ 1.4694855  -1.9765726  -1.573124   ... -1.1719033   2.220263\n",
      "   0.5490648 ]\n",
      " [-0.8441161  -1.2184707  -0.5247786  ... -1.2728893   1.3359655\n",
      "   0.6095466 ]]\n",
      "b2=  [[-0.31103653]\n",
      " [ 0.06334712]\n",
      " [ 0.08554754]\n",
      " [-0.32629713]\n",
      " [-0.1145929 ]\n",
      " [-0.07085583]\n",
      " [ 0.19615035]\n",
      " [ 0.07934967]\n",
      " [ 0.29883105]\n",
      " [ 0.10204742]\n",
      " [ 0.02813295]\n",
      " [ 0.15378489]\n",
      " [ 0.04587486]\n",
      " [-0.03847256]\n",
      " [-0.05155832]\n",
      " [ 0.3259431 ]\n",
      " [-0.1196615 ]\n",
      " [ 0.14219278]\n",
      " [ 0.08470998]\n",
      " [ 0.02204651]\n",
      " [ 0.47166753]\n",
      " [ 0.40963176]\n",
      " [-0.07000192]\n",
      " [-0.21416332]\n",
      " [ 0.07933742]\n",
      " [ 0.04036249]\n",
      " [-0.34888735]\n",
      " [ 0.02735381]\n",
      " [ 0.22624183]\n",
      " [-0.39714286]]\n",
      "W3=  [[-3.2506988 -2.369185  -1.9612349 -3.0669842  2.0908082  2.3902116\n",
      "   2.495192  -1.9316291 -1.7575259 -2.1462362 -1.700985  -1.7818618\n",
      "   3.4319136  3.139281   2.887293   2.495537   2.1310642 -2.4146605\n",
      "  -2.00302   -2.0191147  2.0901043 -1.2900581  2.8336318  3.6160755\n",
      "  -2.0361865 -2.493373  -2.6521716 -2.1135223 -1.5060401 -2.5631492]]\n",
      "b3=  [[0.5172273]]\n"
     ]
    }
   ],
   "source": [
    "#parameters = model(X_train_norm, Y_Train, X_train_norm, Y_Train)\n",
    "parameters = model(X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.8 Validación Modelo\n",
    "Se genera funcion para validar modelo entrenado con distintos sets de datos para verificar la correcta predicción, para lo anterior se genera la función ```predict()``` que utiliza la función de modelo de red neuronal ya creado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, parameters, hys):\n",
    "    \n",
    "    W1 = tf.convert_to_tensor(parameters[\"W1\"])\n",
    "    b1 = tf.convert_to_tensor(parameters[\"b1\"])\n",
    "    W2 = tf.convert_to_tensor(parameters[\"W2\"])\n",
    "    b2 = tf.convert_to_tensor(parameters[\"b2\"])\n",
    "    W3 = tf.convert_to_tensor(parameters[\"W3\"])\n",
    "    b3 = tf.convert_to_tensor(parameters[\"b3\"])\n",
    "    \n",
    "    params = {\"W1\": W1,\n",
    "              \"b1\": b1,\n",
    "              \"W2\": W2,\n",
    "              \"b2\": b2,\n",
    "              \"W3\": W3,\n",
    "              \"b3\": b3}\n",
    "    (n_x, m) = X.shape \n",
    "    x = tf.placeholder(\"float\", [n_x, m])\n",
    "    \n",
    "    z3 = forward_propagation(x, params)\n",
    "    #p = tf.argmax(tf.sigmoid(z3))\n",
    "    p = tf.greater_equal(tf.sigmoid(z3),hys)\n",
    "    \n",
    "    with tf.Session() as sess:\n",
    "        prediction = sess.run(p, feed_dict = {x: X})\n",
    "        \n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se ejecuta la función predict con los sets de datos X_train, X_test y X_dev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('default')\n",
    "y_hat=predict(X_Orig, parameters,0.5)\n",
    "plt.plot(np.squeeze(y_hat), label='Modelo')\n",
    "plt.plot(np.squeeze(Y_Orig), label='Y_train')\n",
    "plt.ylabel('costo')\n",
    "plt.xlabel('muestras')\n",
    "plt.title(\"Predicciones vs Real\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "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.7.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}