Red_Neuronal_desde_cero.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Crea una Red Neuronal Artificial en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crearemos una red neuronal simple, con 3 capas, neuronas con valores de entrada/salida -1 a 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-25T10:30:57.447541Z",
     "start_time": "2018-07-25T10:30:56.855041Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1.0/(1.0 + np.exp(-x))\n",
    "\n",
    "def sigmoid_derivada(x):\n",
    "    return sigmoid(x)*(1.0-sigmoid(x))\n",
    "\n",
    "def tanh(x):\n",
    "    return np.tanh(x)\n",
    "\n",
    "def tanh_derivada(x):\n",
    "    return 1.0 - x**2\n",
    "\n",
    "\n",
    "class NeuralNetwork:\n",
    "\n",
    "    def __init__(self, layers, activation='tanh'):\n",
    "        if activation == 'sigmoid':\n",
    "            self.activation = sigmoid\n",
    "            self.activation_prime = sigmoid_derivada\n",
    "        elif activation == 'tanh':\n",
    "            self.activation = tanh\n",
    "            self.activation_prime = tanh_derivada\n",
    "\n",
    "        # inicializo los pesos\n",
    "        self.weights = []\n",
    "        self.deltas = []\n",
    "        # capas = [2,3,2]\n",
    "        # rando de pesos varia entre (-1,1)\n",
    "        # asigno valores aleatorios a capa de entrada y capa oculta\n",
    "        for i in range(1, len(layers) - 1):\n",
    "            r = 2*np.random.random((layers[i-1] + 1, layers[i] + 1)) -1\n",
    "            self.weights.append(r)\n",
    "        # asigno aleatorios a capa de salida\n",
    "        r = 2*np.random.random( (layers[i] + 1, layers[i+1])) - 1\n",
    "        self.weights.append(r)\n",
    "\n",
    "    def fit(self, X, y, learning_rate=0.2, epochs=100000):\n",
    "        # Agrego columna de unos a las entradas X\n",
    "        # Con esto agregamos la unidad de Bias a la capa de entrada\n",
    "        ones = np.atleast_2d(np.ones(X.shape[0]))\n",
    "        X = np.concatenate((ones.T, X), axis=1)\n",
    "        \n",
    "        for k in range(epochs):\n",
    "            i = np.random.randint(X.shape[0])\n",
    "            a = [X[i]]\n",
    "\n",
    "            for l in range(len(self.weights)):\n",
    "                    dot_value = np.dot(a[l], self.weights[l])\n",
    "                    activation = self.activation(dot_value)\n",
    "                    a.append(activation)\n",
    "            # Calculo la diferencia en la capa de salida y el valor obtenido\n",
    "            error = y[i] - a[-1]\n",
    "            deltas = [error * self.activation_prime(a[-1])]\n",
    "            \n",
    "            # Empezamos en el segundo layer hasta el ultimo\n",
    "            # (Una capa anterior a la de salida)\n",
    "            for l in range(len(a) - 2, 0, -1): \n",
    "                deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_prime(a[l]))\n",
    "            self.deltas.append(deltas)\n",
    "\n",
    "            # invertir\n",
    "            # [level3(output)->level2(hidden)]  => [level2(hidden)->level3(output)]\n",
    "            deltas.reverse()\n",
    "\n",
    "            # backpropagation\n",
    "            # 1. Multiplcar los delta de salida con las activaciones de entrada \n",
    "            #    para obtener el gradiente del peso.\n",
    "            # 2. actualizo el peso restandole un porcentaje del gradiente\n",
    "            for i in range(len(self.weights)):\n",
    "                layer = np.atleast_2d(a[i])\n",
    "                delta = np.atleast_2d(deltas[i])\n",
    "                self.weights[i] += learning_rate * layer.T.dot(delta)\n",
    "\n",
    "            if k % 10000 == 0: print('epochs:', k)\n",
    "\n",
    "    def predict(self, x): \n",
    "        ones = np.atleast_2d(np.ones(x.shape[0]))\n",
    "        a = np.concatenate((np.ones(1).T, np.array(x)), axis=0)\n",
    "        for l in range(0, len(self.weights)):\n",
    "            a = self.activation(np.dot(a, self.weights[l]))\n",
    "        return a\n",
    "\n",
    "    def print_weights(self):\n",
    "        print(\"LISTADO PESOS DE CONEXIONES\")\n",
    "        for i in range(len(self.weights)):\n",
    "            print(self.weights[i])\n",
    "\n",
    "    def get_deltas(self):\n",
    "        return self.deltas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos una Primer Red emulando a la función XOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-25T10:30:58.202079Z",
     "start_time": "2018-07-25T10:30:57.449918Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs: 0\n",
      "Entrdas: [0 0] Salidas: [0.00118339]\n",
      "Entrdas: [0 1] Salidas: [0.97403459]\n",
      "Entrdas: [1 0] Salidas: [0.96119404]\n",
      "Entrdas: [1 1] Salidas: [0.00257987]\n"
     ]
    }
   ],
   "source": [
    "# funcion XOR\n",
    "nn = NeuralNetwork([2,2,1])\n",
    "X = np.array([[0, 0],\n",
    "            [0, 1],\n",
    "            [1, 0],\n",
    "            [1, 1]])\n",
    "y = np.array([0, 1, 1, 0])\n",
    "nn.fit(X, y,epochs=2000)\n",
    "for e in X:\n",
    "    print(\"Entrdas:\",e,\"Salidas:\",nn.predict(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comportamiento de un Coche Robot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crearemos una red neuronal que nos dará los pesos para las conexiones que utilizaremos en un coche robot Arduino"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-25T10:30:58.780875Z",
     "start_time": "2018-07-25T10:30:58.204952Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs: 0\n",
      "epochs: 10000\n",
      "X: [0. 0.] y: [0 1] Network: [-0.00419241  0.99998706]\n",
      "X: [0. 1.] y: [0 1] Network: [0.00213055 0.99997811]\n",
      "X: [ 0. -1.] y: [0 1] Network: [-3.09682297e-04  9.99951487e-01]\n",
      "X: [0.5 1. ] y: [-1  1] Network: [-0.94914109  0.94511784]\n",
      "X: [ 0.5 -1. ] y: [1 1] Network: [0.95643017 0.95122983]\n",
      "X: [1. 1.] y: [ 0 -1] Network: [-0.00427929 -0.95818922]\n",
      "X: [ 1. -1.] y: [ 0 -1] Network: [ 0.00966145 -0.96866856]\n"
     ]
    }
   ],
   "source": [
    "# funcion Coche Evita obstáculos\n",
    "nn = NeuralNetwork([2,3,2],activation ='tanh')\n",
    "X = np.array([[0, 0],   # sin obstaculos\n",
    "              [0, 1],   # sin obstaculos\n",
    "              [0, -1],  # sin obstaculos\n",
    "              [0.5, 1], # obstaculo detectado a derecha\n",
    "              [0.5,-1], # obstaculo a izq\n",
    "              [1,1],    # demasiado cerca a derecha\n",
    "              [1,-1]])  # demasiado cerca a izq\n",
    "\n",
    "y = np.array([[0,1],    # avanzar\n",
    "              [0,1],    # avanzar\n",
    "              [0,1],    # avanzar\n",
    "              [-1,1],   # giro izquierda\n",
    "              [1,1],    # giro derecha\n",
    "              [0,-1],   # retroceder\n",
    "              [0,-1]])  # retroceder\n",
    "nn.fit(X, y, learning_rate=0.03,epochs=15001)\n",
    "\n",
    "index=0\n",
    "for e in X:\n",
    "    print(\"X:\",e,\"y:\",y[index],\"Network:\",nn.predict(e))\n",
    "    index=index+1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-25T10:30:58.790786Z",
     "start_time": "2018-07-25T10:30:58.783641Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LISTADO PESOS DE CONEXIONES\n",
      "[[ 0.0493491  -1.57512575 -1.55094348 -1.21806285]\n",
      " [ 0.15904356  3.2306243   3.02890889 -0.88735754]\n",
      " [ 0.92710662 -0.81186343  0.73500885 -0.05581318]]\n",
      "[[ 0.8537068   0.30089786]\n",
      " [ 1.88818793 -2.09159023]\n",
      " [-1.94124822 -2.65951456]\n",
      " [ 0.10419137 -1.91738651]]\n"
     ]
    }
   ],
   "source": [
    "nn.print_weights()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graficamos la función coste "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos como el gradiente desciende y disminuye el error a medida que pasan las iteraciones de aprendizaje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-25T10:31:40.473536Z",
     "start_time": "2018-07-25T10:31:40.183342Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHcxJREFUeJzt3Xu4XHV97/H3lyBIEUQkFkq4qWkF7AXYB0R8Kq32CBHh8ehBUGy1VETF+6lCqVbxnFqEtkJLFezhiJxIBGsxIhIVOFgrt0QxkkggxARCUMItCYSQ2/f8sVbcs3dmX7Iza9aaPe/X88yz1vqt38x899rZ88m6zG9FZiJJUtPsUHcBkiS1Y0BJkhrJgJIkNZIBJUlqJANKktRIBpQkqZEqC6iIuDwiHomIu0dYHxFxcUQsjoj5EXF4VbVIknpPlXtQXwaOG2X98cD08nEG8IUKa5Ek9ZjKAiozfwA8PkqXk4CvZOE2YI+I2KeqeiRJvWXHGt97X+DBluXlZdvDwztGxBkUe1nsuuuuR7zsZS+b8JvOmzdCMfvC3nsPrt9hBzjssAm/jSRpBPPmzXs0M6eO1a/OgIo2bW3HXcrMy4DLAAYGBnLu3LkTf9N27wqcfnox3RJQu+wC2/E2kqQRRMSy8fSrM6CWA/u1LE8DVtRUC+edV9c7S5LaqfMy89nAn5ZX870CWJWZWx3ekyT1p8r2oCLiKuBYYK+IWA78DfAcgMz8InA9MANYDKwF3llVLZKk3lNZQGXmqWOsT+B9Vb2/JKm3OZKEJKmRDChJUiMZUJKkRjKgJEmNZEBJkhrJgJIkNZIBJUlqJANqBE8/XXcFktTfDChJUiMZUJKkRjKgJEmNZEBJkhrJgJIkNZIBJUlqJANKktRIBpQkqZEMKElSIxlQkqRGMqAkSY1kQEmSGsmAkiQ1kgElSWokA0qS1EgGlCSpkQwoSVIjGVCSpEYyoCRJjWRASZIayYCSJDWSASVJaiQDSpLUSAaUJKmRDKgxLF0Kf/VXkFl3JZLUXwyoMbzpTfDZz8KCBXVXIkn9xYAaw/r1xdQ9KEnqLgNKktRIBpQkqZEqDaiIOC4iFkXE4og4u836/SPi5oj4SUTMj4gZVdYzEVsO7c2fX28dktRvKguoiJgCXAIcDxwCnBoRhwzr9tfA1Zl5GHAK8C9V1TNRq1cX09NOq7cOSeo3Ve5BHQkszswlmbkemAWcNKxPAruX888HVlRYjySph+xY4WvvCzzYsrwcOGpYn08B342I9wO7Aq+tsJ4JefDBsftIkjqvyj2oaNM2/GLtU4EvZ+Y0YAZwZURsVVNEnBERcyNi7sqVKysoVZLUNFUG1HJgv5blaWx9CO904GqAzLwVeC6w1/AXyszLMnMgMwemTp1aUbmSpCapMqDuBKZHxEERsRPFRRCzh/V5AHgNQEQcTBFQ7iJJkqoLqMzcCJwFzAF+TnG13oKIOC8iTiy7fRR4V0T8FLgKeEemYzZIkqq9SILMvB64fljbJ1vmFwLHVFmDJKk3OZKEJKmRDChJUiMZUJKkRjKgJEmNZEBJkhrJgJIkNZIBJUlqJANKktRIBtQ2ePjhuiuQpP5hQG2DVavqrkCS+ocBJUlqJANqGziMrSR1jwG1DQwoSeoeA0qS1EgG1DZwD0qSuseA2gYGlCR1jwElSWokA2oUv/rV0GX3oCSpewyoUbz73UOXjzyynjokqR8ZUKPYsGHo8rp19dQhSf3IgBrFpk11VyBJ/cuAGsWcOXVXIEn9y4CSJDWSASVJaiQDqgarVsGaNXVXIUnNZkBto898ZvtfY489iockaWQG1Db65Cc78zqbN3fmdSRpsjKgJEmNZEBJkhrJgJIkNZIBJUlqJANKktRIBlRDrFwJDz9cdxWS1Bw71l1Av9m4sX37i15UTL3nlCQV3IPqsptuqrsCSeoNBlSXuYckSePjIb4uOvJIWLas7iokqTcYUF2ybBnceWfdVUhS76j0EF9EHBcRiyJicUScPUKfkyNiYUQsiIivVllPnUa6OEKS1F5le1ARMQW4BPgTYDlwZ0TMzsyFLX2mA+cAx2TmExHxoqrqkST1lir3oI4EFmfmksxcD8wCThrW513AJZn5BEBmPlJhPZKkHlJlQO0LPNiyvLxsa/XbwG9HxH9GxG0RcVy7F4qIMyJibkTMXblyZUXldsaiRTB9evHFW0nSxFUZUNGmbfhF1jsC04FjgVOBf42IrW7ll5mXZeZAZg5MnTq144V20oUXwuLFcO21dVciSb2tyoBaDuzXsjwNWNGmzzczc0Nm/gJYRBFYPWvDhmL6iAcrJWm7VBlQdwLTI+KgiNgJOAWYPazPtcAfAUTEXhSH/JZUWFNHnXYa/OmfwsKFg22zy5/wr/+6npokabKoLKAycyNwFjAH+DlwdWYuiIjzIuLEstsc4LGIWAjcDPxlZj5WVU2dNnMmXHklHHooPPlk0dZ6K/fly+upS5Img0q/B5WZ12fmb2fmSzLzf5Vtn8zM2eV8ZuZHMvOQzPzdzJxVZT1VeuaZYrpq1WDbVVeN/px77qmuHknqdY7FV6ODD667AklqLgNqgjZtGrr8+OP11CFJk5UBNUHDA+kP/7CeOiRpsjKgOsQ9KEnqLANKktRIBlSXfP3rdVcgSb3FgOqSs9vebATWru1uHZLUKwyoDlq3bujy+efDLbeM/pxzz4UlPTN2hiR1jwHVQcP3kh57DI49dvTn3HgjvOQllZUkST1rXAEVEVeOp63fXXTRtj/nZz/rfB2SNBmMdw/q0NaF8m65R3S+HEmSCqMGVEScExFrgN+LiNXlYw3wCPDNrlQoSepLowZUZn42M3cDLsjM3cvHbpn5wsw8p0s1SpL60HgP8V0XEbsCRMRpEfEPEXFAhXU1XrS7X7AkqWPGG1BfANZGxO8DHwOWAV+prCpJUt8bb0BtzMwETgIuysyLgN2qK6vZ7rij7gokafIbb0CtiYhzgLcD3y6v4ntOdWU121FHwXXXjb//9ddXV4skTVbjDai3AM8Cf56ZvwT2BS6orKoe8M53jr/v619fXR2SNFmNK6DKUJoJPD8iTgDWZabnoCrwhjdM7Au/kjTZjHckiZOBO4D/DpwM3B4Rb66ysH513XXwoQ/VXYUk1W/HcfY7F/gvmfkIQERMBb4PeBMJSVIlxnsOaoct4VR6bBueK0nSNhvvHtQNETEHuKpcfgvgtWmSpMqMGlAR8VLgNzPzLyPivwGvAgK4leKiCUmSKjHWYbrPA2sAMvMbmfmRzPwwxd7T56suToVMeOihuquQpO4aK6AOzMz5wxszcy5wYCUVaStf/jJMmwa33153JZLUPWMF1HNHWbdLJwvRyH7wg2K6cGG9dUhSN40VUHdGxLuGN0bE6cC8akqSJGnsq/g+BPx7RLyNwUAaAHYC3lhlYSo8+2xxiE+S+s2oAZWZvwJeGRF/BLy8bP52Zt5UeWUC4NJL665Akuoxru9BZebNwM0V16I2nn227gokqR6OBtFwmzbVXYEk1cOAarhbb627AkmqhwHVcJl1VyBJ9TCgesisWXDCCXDPPXVXIknVG+9gsWqA7363mK5bB9//fr21SFLV3INquOuu27rNw36S+kGlARURx0XEoohYHBFnj9LvzRGRETFQZT29qF0YGVCS+kFlARURU4BLgOOBQ4BTI+KQNv12Az4AOBTqOG3eXHcFklS9KvegjgQWZ+aSzFwPzAJOatPvM8DngHUV1tJz1q2DBQvar8uEr32tGOF848bu1iVJ3VJlQO0LPNiyvLxs+7WIOAzYLzPbnGkZ0u+MiJgbEXNXrlzZ+UobaMYMePnL26/bvBnOPLO4R9SaNd2tS5K6pcqAijZtvz57EhE7AP8IfHSsF8rMyzJzIDMHpk6d2sESm+vmUQaW8hyUpH5QZUAtB/ZrWZ4GrGhZ3o1iANr/FxFLgVcAs71QYmyZ8OSTxfyGDfXWIklVqTKg7gSmR8RBEbETcAowe8vKzFyVmXtl5oGZeSBwG3BiebdejaL1IomZM+urQ5KqVFlAZeZG4CxgDvBz4OrMXBAR50XEiVW9bz9oPcT3yCP11SFJVYrssRMaAwMDOXfuxHeyot2ZsR5zxBEwr+V+xj32K5TU5yJiXmaOeTrHkSR6UGs4SdJkZUBNQmeeCSefXHcVkrR9DKhJ4NBDYf78weVLL4VrrqmvHknqBANqEli4ED7wgbqrkKTOMqAmiVtuGV+/O+6AZ56pthZJ6gQDahIZfiPDFSuGLj/0EBx1FPzWb3WvJkmaKANqErniiqHLq1e3X94yCoUkNZkBNYn4fShJk4kBNYmcf/7Q5eGBdcYZ3atFkraXATXJXHvt4PysWTBlymDbD39YT02SNBEOddQHfvd3i+9Jtf7sPfZrlzSJONSRJKmnGVB9wL0lSb3IgOoDCxcOvYeUJPUCA6oPbN4Mf/u3dVchSdvGgOoTn/jE2H3WroVPfxrWr6++HkkaiwHVp5YtK/aqWs9Pffaz8KlPwWWX1VaWJP2aAdWn3vAGOPdc+MUvBtvWri2mzz5bT02S1MqA6lNbxuV79NF665CkkRhQfWrZsmL6/vdvvc7L0iU1gQHV59atG5zvx1E2JDWXAdXn2u0t3XsvrFnT/VokqZUBpa186UvwutfVXYWkfmdA9bnWPajWQ3y33tr9WiSplQHV51oD6sIL66tDkoYzoPrcggV1VyBJ7RlQkqRGMqAkSY1kQEmSGmnHugtQ/davh9tuq7sKSRrKPShx5pnw6lfXXYUkDWVAiZtvrrsCSdqaASVJaiQDSiPatGno8o9+BC99KTz1VD31SOovBpRGtPvuxfSxx4rpxz8O998PP/5xfTVJ6h8GlFi6tH372rVw9dWw117F2Hz331+0Dx8B/ZpriockdZKXmWtUWy6guOsuePjhYn7z5qF9Tj65mHqjQ0mdVOkeVEQcFxGLImJxRJzdZv1HImJhRMyPiBsj4oAq61FnDA8oSapCZQEVEVOAS4DjgUOAUyPikGHdfgIMZObvAV8HPldVPeoc95QkdUOVe1BHAoszc0lmrgdmASe1dsjMmzNzbbl4GzCtwno0AYsXb93mHpSkbqgyoPYFHmxZXl62jeR04DsV1qMJ+P73i+mcOYNt7kFJ6oYqL5KINm1tP9oi4jRgAGg74E5EnAGcAbD//vt3qj5tg29+c3DePShJ3VDlHtRyYL+W5WnAiuGdIuK1wLnAiZn5bLsXyszLMnMgMwemTp1aSbEaP/egJHVDlQF1JzA9Ig6KiJ2AU4DZrR0i4jDgUopweqTCWtRBd94J3/pW3VVImuwqO8SXmRsj4ixgDjAFuDwzF0TEecDczJwNXAA8D7gmIgAeyMwTq6pJnfGpTxXT4XtSjz8Oe+7Z9XIkTVKVflE3M68Hrh/W9smW+ddW+f6qViZEy5nGo46C++6rrx5Jk4tDHWnC/uM/hi63uyRdkibKgNKErV07dh9JmigDSpLUSAaUJiwTrr9+7H6rV8N3v1t9PZImFwNK2+XDHx67z1vfCq97HazY6ltwkjQyA0odteXCiSeegI0bi/mf/7yYPvPM+F7jrW8trgiU1N8MKE1YJtx779C2d7wDNmwovg/1nvds3X/dOnjyydFf96qr4I474NFHO1qupB5jQGnCrryyffv69cX0q18tpq3flTr6aHjBC8b3+mvWTLw2Sb3PgNKEzZq1dVsE3HBDMd/uMvS77hr/63/wgxOrS9LkYECpoyLgzW8e2vbLXxbTGTMG2y66aOzXcrw/qb8ZUOqoBx8cunzbbfD008V86zBIM2e2f/54L6SQNPkZUOqoZ4fdMOXoo7ft+Z/4ROdqkdTbDCjVYtWq9u2PPdbdOiQ1lwGlWtx7L/zkJ1u3R7v7MEvqSwaUanP44UUgte5NGVCStqj0flDSeKxYAddeW9yp9/LLh67bvBl28L9RUl/yT1+1O/nkYgSKSy7Zet2UKcUl6RFwwQVF28aNjjIh9QMDSrW7++7R13/oQ8X0Yx8rpmeeCVOnbn3FoKTJxYBST7nnHvja14p5A0qa3Awo9ZSDDx784u811wyOmC5p8jGg1HMyi+lf/AW85jXt+/zwh8V5q1tv7V5dkjrLgFJP+8EP2rfPmVNMjzlm5OeuXg3f+U7na5LUGQaUJqUtYwJmwllnwUEHFfepavX2txcD2C5d2vXyJI2DAaWet2DB1m2tt/q45JIihLZcXLHF7NmD6yU1jwGlnvfyl2/d9vjjW7e9/e2waVMRXkceOdh+4YVw003V1SdpYgwoTQpbDuk9+igsWwY33ti+36pVxbo77xza3nqxxY9+BA8/XE2dksbPoY40Key/f/EdqZe9bPR+L3zhyOsefBBOPx2+971iecvVgttixYoiAI89Fvbbb9ufL2mQAaVJY6xwGsv++w9dvuEGOO64bXuNffcdnN8ScJs2wcqVsPfe21ef1G88xCeN4Pjj4Yknxtf31lth+fL26/bYA/bZx8OG0rYyoKRR7LknPPBA+3Xr1xeH9J5+Gl75yvaH9O66C556qpgfKcAktWdASWM44IBi1AooAue22+DKK2HnnYtDes973sjPPeywwfnWKwfH41vfgmeeab/umWfgqqvgb/6mGDFj9epte22pF0RO5ExwjQYGBnLu3LkTfr43xFOdxvvnNm8eDAzAu94Fl1229fr3vhe+8IXB5d12M6TUOyJiXmYOjNXPiySkBnryyWJ6//3F9Jprij2wHXaA+fPh298e2n/Nmu7WJ3WDh/ikLoooHrfcUuxNrVsH//mfcNJJxeXpq1YV61/72qL/TTcVwzGdfDIccURxpeEJJ7Q/L/bud289nNPmzXDFFUNH1piozKK2N75xsG3FiqLtM58Z2s9boagTPMQnTSJvfSvMnDm4/A//AB/9aHFn4vHemuS664oLP266Cd72tuK5xxxTDKw7Y0bRZ+bM4r2+8Q1405uKti0fJR/8IFx8cXGe7LnP7dzPpsljvIf43IOSJpGvfnVwLy2iCCcovou1pe1974PTTiv24g44AKZNK4aL2rwZfvxjeMMb4JRTinNfr341vOpVxfO3HHaEIrgAHnposG3evOKKxYsvLpYnutcWAQceOLHnTtSyZRN/7r/9WzGCyWSzYAE8//k1X32amT31OOKII3J7FP/P8+HDR7cee+89vn6HHpr58Y8Pbfv7v8+8//7M1aszN20a+e/69NOL/t/7XubJJ2du2DD+z4Rbbime+5WvbNtnyerVxXMg8/DDt+257TzwQObjjxe1/9M/Za5fv/2vOV633JK5bl3mmWdm/s7vFNv61a8ufrYZMzr/fsDczLE/7z3EJ0k1OPhg2Gkn+OlPR+5z663F2JDTpxeHWpcsgV/9CnbcsdjrffGLi8OoL3pR8XWHJ56A3XeH5zyneGQWF9p86Uvwd39XfP5lwn33FfPTpxfnEVtHQAH4l38prhTdotMxMd5DfJUGVEQcB1wETAH+NTP/btj6nYGvAEcAjwFvycylo72mASVJ9dre2Kj9HFRETAEuAY4HDgFOjYhDhnU7HXgiM18K/CNwflX1SJJ6S5UXSRwJLM7MJZm5HpgFnDSsz0nAFeX814HXRLiPI0lN1q0zQ1V+UXdf4MGW5eXAUSP1ycyNEbEKeCEw5JqYiDgDOKNcfCoiFm1nbXsNf48eYM3V67V6wZq7xZpb7LD9uzYHjKdTlQHVbk9oeO6Opw+ZeRnQZsCXiYmIueM5/tkk1ly9XqsXrLlbrLkeVR7iWw60ju88DVgxUp+I2BF4PtDmZt2SpH5TZUDdCUyPiIMiYifgFGD2sD6zgT8r598M3JS9dt27JKkSlR3iK88pnQXMobjM/PLMXBAR51F8SWs28L+BKyNiMcWe0ylV1TNMxw4XdpE1V6/X6gVr7hZrrkHPfVFXktQfHItPktRIBpQkqZH6KqAi4riIWBQRiyPi7Jpr2S8ibo6In0fEgoj4YNm+Z0R8LyLuK6cvKNsjIi4ua58fEYe3vNaflf3vi4g/G+k9O1j7lIj4SURcVy4fFBG3l+//tfKiGCJi53J5cbn+wJbXOKdsXxQRr6u43j0i4usRcU+5vY9u8naOiA+X/ybujoirIuK5TdzGEXF5RDwSEXe3tHVsu0bEERHxs/I5F0ds35f4R6j3gvLfxfyI+PeI2KNlXdvtN9LnyEi/o07X3LLuf0RERsRe5XLt27jjxjOi7GR4UFyocT/wYmAn4KfAITXWsw9weDm/G3AvxZBQnwPOLtvPBs4v52cA36H47tgrgNvL9j2BJeX0BeX8Cyqu/SPAV4HryuWrgVPK+S8C7ynn3wt8sZw/BfhaOX9Iuf13Bg4qfy9TKqz3CuAvyvmdgD2aup0pvrz+C2CXlm37jiZuY+APgcOBu1vaOrZdgTuAo8vnfAc4voJ6/yuwYzl/fku9bbcfo3yOjPQ76nTNZft+FBegLQP2aso27vjfQ90FdO0HLX4Jc1qWzwHOqbuulnq+CfwJsAjYp2zbB1hUzl8KnNrSf1G5/lTg0pb2If0qqHMacCPwx8B15T/sR1v+yH+9ncs/oKPL+R3LfjF827f2q6De3Sk+8GNYeyO3M4Ojq+xZbrPrgNc1dRsDBzL0A78j27Vcd09L+5B+nap32Lo3AjPL+bbbjxE+R0b7O6iiZoqh4X4fWMpgQDViG3fy0U+H+NoNvbTvCH27qjwscxhwO/CbmfkwQDl9UdltpPq7/XN9HvgYsLlcfiHwZGZuuV9r6/sPGcoK2DKUVTdrfjGwEvg/URyW/NeI2JWGbufMfAi4EHgAeJhim82j2du4Vae2677l/PD2Kv05xV4EY9TVrn20v4OOiogTgYcyc/iNOnphG2+TfgqocQ2r1G0R8Tzg34APZebq0bq2actR2jsuIk4AHsnMeeOoa7R13fxd7EhxiOQLmXkY8DTFoaeR1Fpzec7mJIrDSr8F7EpxR4CR3rsJ23g8trXOrtYfEecCG4GZW5q2sa5u/fv4DeBc4JPtVo9QQyO28UT0U0CNZ+ilroqI51CE08zM/EbZ/KuI2Kdcvw/wSNk+Uv3d/LmOAU6MiKUUo9P/McUe1R5RDFU1/P1HGsqqmzUvB5Zn5u3l8tcpAqup2/m1wC8yc2VmbgC+AbySZm/jVp3arsvL+eHtHVdeNHAC8LYsj3VNoN5HGfl31EkvofjPy0/Lv8NpwI8jYu8J1Ny1bTxhdR9j7NaD4n/SSyh+uVtObh5aYz1BcbPGzw9rv4ChJ5k/V86/nqEnQO8o2/ekOMfygvLxC2DPLtR/LIMXSVzD0JPD7y3n38fQE/hXl/OHMvQE9BKqvUjiP4DfKec/VW7jRm5nihH/FwC/UdZwBfD+pm5jtj4H1bHtSjFc2isYPIE/o4J6jwMWAlOH9Wu7/Rjlc2Sk31Gnax62bimD56AasY07+u+r7gK6+sMWV7ncS3EVzrk11/Iqit3p+cBd5WMGxbHsG4H7yumWf0hBcQPI+4GfAQMtr/XnwOLy8c4u1X8sgwH1YoqrgRaXf6Q7l+3PLZcXl+tf3PL8c8ufZREVXzkE/AEwt9zW15Z/pI3dzsCngXuAu4Eryw/Jxm1j4CqK82QbKP43fnontyswUG6D+4F/ZtiFLh2qdzHF+Zktf4NfHGv7McLnyEi/o07XPGz9UgYDqvZt3OmHQx1Jkhqpn85BSZJ6iAElSWokA0qS1EgGlCSpkQwoSVIjGVBSB0XEpoi4q+XRsVHzI+LAdqNaS5NVZbd8l/rUM5n5B3UXIU0G7kFJXRARSyPi/Ii4o3y8tGw/ICJuLO/fc2NE7F+2/2Z5f6Kflo9Xli81JSK+FMX9or4bEbuU/T8QEQvL15lV048pdZQBJXXWLsMO8b2lZd3qzDyS4hv7ny/b/hn4Smb+HsVApReX7RcDt2Tm71OMHbigbJ8OXJKZhwJPAm8q288GDitf58yqfjipmxxJQuqgiHgqM5/Xpn0p8MeZuaQcJPiXmfnCiHiU4v5JG8r2hzNzr4hYCUzLzGdbXuNA4HuZOb1c/jjwnMz8nxFxA/AUxVBO12bmUxX/qFLl3IOSuidHmB+pTzvPtsxvYvA88uspxmE7ApjXMqq21LMMKKl73tIyvbWc/xHFKOQAbwN+WM7fCLwHICKmRMTuI71oROwA7JeZN1PcTHIPYKu9OKnX+L8sqbN2iYi7WpZvyMwtl5rvHBG3U/zH8NSy7QPA5RHxlxR3/n1n2f5B4LKIOJ1iT+k9FKNatzMF+L8R8XyKEa3/MTOf7NhPJNXEc1BSF5TnoAYy89G6a5F6hYf4JEmN5B6UJKmR3IOSJDWSASVJaiQDSpLUSAaUJKmRDChJUiP9f4ODjwoRrewHAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "deltas = nn.get_deltas()\n",
    "valores=[]\n",
    "index=0\n",
    "for arreglo in deltas:\n",
    "    valores.append(arreglo[1][0] + arreglo[1][1])\n",
    "    index=index+1\n",
    "\n",
    "plt.plot(range(len(valores)), valores, color='b')\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('Cost')\n",
    "plt.xlabel('Epochs')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-07-25T10:25:56.999747Z",
     "start_time": "2018-07-25T10:25:56.975198Z"
    }
   },
   "source": [
    "Lee el artículo completo en www.aprendemachinelearning.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sigeme en Twitter @jbagnato"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}