1. RedesNeuronales-FordwardPropagation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "65ca39b8-c756-4041-be86-861b4655584f",
   "metadata": {},
   "source": [
    "# Artificial Neural Networks - Forward Propagation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8c7a78b-5670-4d26-9800-8a70d82a134e",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "En este tutorial construiremos una Red Neuronal desde cero y veremos como realizar predicciones usando Forward Propagation. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f38768a9-f44f-4c00-a7e8-445455bed8a1",
   "metadata": {},
   "source": [
    "<h2>Artificial Red Neuronal - Forward Propagation</h2>\n",
    "<h3>Objetivos del Notebook<h3>    \n",
    "<h5> 1. Inicializar la Red</h5>\n",
    "<h5> 2. Computar la sumatoria ponderada en cada nodo. </h5>\n",
    "<h5> 3. Computar el nodo de Activacion</h5>\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d08a45c-bf17-4c10-9293-e467704d29be",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22790a31-0739-4c7c-bb2a-79627d948a8d",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "792df71f-d17e-4cdc-a9c6-e2da121a1b3f",
   "metadata": {},
   "source": [
    "> - ## Intuición Forward Propagation en una Red Neuronal\n",
    "\n",
    "Primeramente veamos como hace predicciones una red Neuronal a traves de Forward Propagation. \n",
    "\n",
    "- Aqui vemos una Red Neuronal que toma 2 inputs, tiene una capa oculta con dos nodos, y una capa de salida output layer con un nodo. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa616642-ec8a-487a-979f-fe24c23cdf7f",
   "metadata": {},
   "source": [
    "<img src=\"http://cocl.us/neural_network_example\" alt=\"Neural Network Example\" width=600px>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58a1d74-5e09-4f06-b9a8-8a0ebdfb8174",
   "metadata": {},
   "source": [
    "- Comenzaremos por inicializar aleatoriamente los pesos y los bias en la Red, Tenemos 6 pesos y 3 bias, uno por cada uno de los nodos en la capa oculta asi como tambien para cada nodo en la capa de salida. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "186e6d2b-cf42-4483-b9ca-12266a6d9452",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "\n",
    "# la funcion `np.around` utiliza un algoritmo rápido pero a veces inexacto para redondear tipos de datos de punto flotante. \n",
    "weights = np.around(np.random.uniform(size=6), decimals=2) #inicializa los pesos\n",
    "biases = np.around(np.random.uniform(size=3), decimals=2) # Inicializa los bias o sesgo\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94877f27-8d67-4c2b-83f7-b2f6742a0eb6",
   "metadata": {},
   "source": [
    "Veamos en un print los pesos y bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e24955c0-c962-4f35-86f4-c5c9f3cff145",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.14 0.45 0.8  0.24 0.75 0.09]\n",
      "[0.15 0.26 0.58]\n"
     ]
    }
   ],
   "source": [
    "print(weights)\n",
    "print(biases)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b35ec595-008f-42b3-bd0a-bc5a23104c85",
   "metadata": {},
   "source": [
    "- Ahora que tenemos los pesos y los bias, definidos para la Red, vamos a computar la salida para inputs dados, $x_1$ and $x_2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7a52c7d8-2aa9-4181-98c7-79387e13cff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1 es 0.5 y x2 es 0.85\n"
     ]
    }
   ],
   "source": [
    "x_1 = 0.5    # Input 1\n",
    "x_2 = 0.85   # Input 2\n",
    "\n",
    "print('x1 es {} y x2 es {}'.format(x_1, x_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "980ba6b5-c421-4cc0-ae94-1439591bc8c0",
   "metadata": {},
   "source": [
    "- Vamos a empezar calculando la sumatoria ponderada de los inputs, $z\\_{1, 1}$, en el primer nodo de la capa oculta. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bc1effe1-f722-43ab-b1bc-28d8eef47120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La sumatoria ponderada de los inputs en el primer nodo en la capa oculta es 0.6025\n"
     ]
    }
   ],
   "source": [
    "z_11 = x_1 * weights[0] + x_2 * weights[1] + biases[0]\n",
    "\n",
    "print('La sumatoria ponderada de los inputs en el primer nodo en la capa oculta es {}'.format(z_11))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a0f434c-873d-4c58-bd53-f71e28cd60ea",
   "metadata": {},
   "source": [
    "- A continuacion, vamos a calcular lo suma ponderada de los inputs, z_1,2, en el segundo nodo de la capa oculta.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "aaad8f49-2eb7-4bff-ada3-56a833241d56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La suma ponderada de los inputs en el segundo nodo en la capa oculta es 0.864\n"
     ]
    }
   ],
   "source": [
    "z_12 = x_1 * weights[2] + x_2 * weights[3] + biases[1]\n",
    "print('La suma ponderada de los inputs en el segundo nodo en la capa oculta es {}'.format(np.around(z_12, decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e47d53a-0787-472e-8ce1-63d21fae963e",
   "metadata": {},
   "source": [
    "- Luego, asumiendo una funcion de activacion sigmoide, calculamos la activacion de el primer nodo, a_1,1, en la capa oculta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b0e15779-68f6-4a96-ab7d-ffeaf99dd814",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La activacion de el primer nodo en la capa oculta es 0.6462\n"
     ]
    }
   ],
   "source": [
    "a_11 = 1.0 / (1.0 + np.exp(-z_11))\n",
    "\n",
    "print('La activacion de el primer nodo en la capa oculta es {}'.format(np.around(a_11, decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e459e097-1cea-41e4-81fb-7d291e2d14f0",
   "metadata": {},
   "source": [
    "- Tambien calcularemos la activacion en el segundo nodo,$a\\_{1, 2}$, en la capa oculta. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c75fb691-0f89-4b6e-bd7c-346b2201ffe8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La activacion de el segundo nodo en la capa oculta es 0.7035\n"
     ]
    }
   ],
   "source": [
    "a_12 = 1.0 / (1.0 + np.exp(-z_12))\n",
    "\n",
    "print('La activacion de el segundo nodo en la capa oculta es {}'.format(np.around(a_12, decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597ccbc-24e6-464c-a6b2-d27d63a03d84",
   "metadata": {},
   "source": [
    "- Ahora estas activaciones nos serviran como entradas de la capa de salida. Asi que, calculamos la suma ponderada de estas inputs a el nodo en la capa oculta. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "dbd986d3-30a0-4404-9eb5-47ae83e3f3d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La suma ponderada de las entradas a el nodo en la capa de salida es 1.128\n"
     ]
    }
   ],
   "source": [
    "z_2 = a_11 * weights[4] + a_12 * weights[5] + biases[2]\n",
    "\n",
    "print('La suma ponderada de las entradas a el nodo en la capa de salida es {}'.format(np.around(z_2, decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9c1e03a-b039-4260-81a0-08cca216f4c8",
   "metadata": {},
   "source": [
    "- Finalmente, calculamos la salida de la Red como la activacion de el nodo en la capa de salida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f1c559e5-a3e7-47ab-8f3b-0f1153459b9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La salida de la Red para x1 = 0.5 and x2 = 0.85 es 0.7555\n"
     ]
    }
   ],
   "source": [
    "a_2 = 1.0 / (1.0 + np.exp(-z_2))\n",
    "\n",
    "print('La salida de la Red para x1 = 0.5 and x2 = 0.85 es {}'.format(np.around(a_2, decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ebd1ca6-d44d-40bd-82d3-2a558f528143",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "\n",
    "- Obviamente, una Red Neuronal para un problema de la vida real esta compuesta de muchas capas ocultas y muchos mas nodos en cada capa. Asi que, no podemos continuar haciendo predicciones usando esta muy ineficiente aproximación calculando la sumatoria ponderada en cada nodo y la activacion de cada nodo manualmente. \n",
    "\n",
    "- En el sentido de codificar una forma automatica de hacer predicciones, vamos a generalizar nuestra Red Neuronal. Una Red Neuronal tomaría **n** inputs, tendria muchas capas ocultas, cada capa oculta tendria **m** nodos, y tendria una capa de salida. La red que codificaremos tendria la siguiente apariencia: \n",
    "\n",
    "<img src=\"http://cocl.us/general_neural_network\" alt=\"Neural Network General\" width=600px>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "850e7eba-a248-44fd-8cd2-94aa4aa1fac0",
   "metadata": {},
   "source": [
    "> - ## Inicializando una Red\n",
    "\n",
    "Comenzamos por formalmente denifir la estructura de la Red."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fcb37103-1a64-4f0e-8f81-14eba1affde6",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2   #Numero de entradas\n",
    "num_hidden_layers = 2    #Numero de capas ocultas\n",
    "m = [2, 2]   #Numero de nodos en cada capa oculta \n",
    "num_nodes_output = 1   #Numero de nodos en la capa de salida"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9c64b81-bb96-4394-ba0b-387b182a6f62",
   "metadata": {},
   "source": [
    "Ahora que definimos la estructura de la Red, vamos a inicializar los Pesos y los Bias en la Red con numero aleatorios. En el sentido de inicializar los pesos y bias con numero aleatorios, necesitaremos importar la libreria **Numpy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "49848b7f-65e2-4b72-8908-3690f03e08c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'layer_1': {'node_1': {'weights': array([0.8 , 0.86]), 'bias': array([0.91])}, 'node_2': {'weights': array([0.57, 0.42]), 'bias': array([0.86])}}, 'layer_2': {'node_1': {'weights': array([0.51, 0.92]), 'bias': array([0.97])}, 'node_2': {'weights': array([0.79, 0.48]), 'bias': array([0.59])}}, 'output': {'node_1': {'weights': array([0.64, 0.26]), 'bias': array([0.99])}}}\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "num_nodes_previous = n    #Numero de nodos en la capa anterior\n",
    "\n",
    "network = {}    #inicializamos la red como un diccionario vacio\n",
    "\n",
    "for layer in range(num_hidden_layers + 1): \n",
    "    \n",
    "    # determine name of layer\n",
    "    if layer == num_hidden_layers:\n",
    "        layer_name = 'output'\n",
    "        num_nodes = num_nodes_output\n",
    "    else:\n",
    "        layer_name = 'layer_{}'.format(layer + 1)\n",
    "        num_nodes = m[layer]\n",
    "    \n",
    "    # initialize weights and biases associated with each node in the current layer\n",
    "    network[layer_name] = {}\n",
    "    for node in range(num_nodes):\n",
    "        node_name = 'node_{}'.format(node+1)\n",
    "        network[layer_name][node_name] = {\n",
    "            'weights': np.around(np.random.uniform(size=num_nodes_previous), decimals=2),\n",
    "            'bias': np.around(np.random.uniform(size=1), decimals=2),\n",
    "        }\n",
    "    \n",
    "    num_nodes_previous = num_nodes\n",
    "    \n",
    "print(network) # print network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ede71a07-dde4-42ad-8b00-a6c9264e18de",
   "metadata": {},
   "source": [
    "- Ahora con el codigo de arriba, somo capaces de inicializar los pesos y los bias de cualquier Red con cualquier numero de capas ocultas y numero de nodos en cada capa. Pero vamos a poner este codigo en una funcion para que asi seamos capaces de ejecutar repetitivamente todo este codigo en el caso de que queramos construir una Red Neuronal. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "239bb866-44c8-4b95-959b-41ce9cb81746",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_network(num_inputs, num_hidden_layers, num_nodes_hidden, num_nodes_output):\n",
    "    \n",
    "    num_nodes_previous = num_inputs # number of nodes in the previous layer\n",
    "\n",
    "    network = {}\n",
    "    \n",
    "    # loop through each layer and randomly initialize the weights and biases associated with each layer\n",
    "    for layer in range(num_hidden_layers + 1):\n",
    "        \n",
    "        if layer == num_hidden_layers:\n",
    "            layer_name = 'output' # name last layer in the network output\n",
    "            num_nodes = num_nodes_output\n",
    "        else:\n",
    "            layer_name = 'layer_{}'.format(layer + 1) # otherwise give the layer a number\n",
    "            num_nodes = num_nodes_hidden[layer] \n",
    "        \n",
    "        # initialize weights and bias for each node\n",
    "        network[layer_name] = {}\n",
    "        for node in range(num_nodes):\n",
    "            node_name = 'node_{}'.format(node+1)\n",
    "            network[layer_name][node_name] = {\n",
    "                'weights': np.around(np.random.uniform(size=num_nodes_previous), decimals=2),\n",
    "                'bias': np.around(np.random.uniform(size=1), decimals=2),\n",
    "            }\n",
    "    \n",
    "        num_nodes_previous = num_nodes\n",
    "\n",
    "    return network # return the network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a04897ec-e1f9-45f5-afa6-c2a052c80a68",
   "metadata": {},
   "source": [
    "#### Ahora vamos a usar la funcion `inicialize_network` para crear una red que: \n",
    "\n",
    "1.  Tome 5 inputs\n",
    "2.  Tenga 3 capas ocultas\n",
    "3.  tenga 3 nodos en la primera capa, 2 nodos en la segunda capa, y 3 nodos en la tercera capa\n",
    "4.  tenga 1 nodo en la capa de salida\n",
    "\n",
    "Llamaremos a la Red **small_network**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "41bda891-6f52-423c-80ae-4bceb0b86e3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "small_network = initialize_network(5, 3, [3, 2, 3], 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49edb32-70da-4939-8580-cc917eaef395",
   "metadata": {},
   "source": [
    "## Calcular la Suma Ponderada en cada nodo\n",
    "\n",
    "La suma ponderada en cada nodo es calculada como el producto punto de las entradas y los pesos + los bias. Asi que vamos a crear una funcion llamada `compute_weighted_sum` que haria eso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5d791563-1d11-45f0-808e-3e210e6f4d50",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_weighted_sum(inputs, weights, bias):\n",
    "    return np.sum(inputs * weights) + bias"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d32ce7f-b816-4fdf-bc12-346dc783f505",
   "metadata": {},
   "source": [
    "- Generamos 5 entradas que puedan alimentar a **small_network**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "44fe674f-0590-4ab7-9b9d-9b2d47e3176a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Las entradas a la Red son [0.15 0.74 0.26 0.53 0.01]\n"
     ]
    }
   ],
   "source": [
    "from random import seed\n",
    "import numpy as np\n",
    "\n",
    "np.random.seed(12)\n",
    "inputs = np.around(np.random.uniform(size=5), decimals=2)\n",
    "\n",
    "print('Las entradas a la Red son {}'.format(inputs))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cce83c4-50a4-4670-8007-c282d7b77c8b",
   "metadata": {},
   "source": [
    "- Usamos la funcion *compute_weighted_sum* para calcular la suma ponderada en el primer nodo de la primera capa oculta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "5cc4a199-5004-4b49-9075-acdc1e0024f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La suma ponderada en el primer nodo de la capa oculta es 1.7668\n"
     ]
    }
   ],
   "source": [
    "node_weights = small_network['layer_1']['node_1']['weights']\n",
    "node_bias = small_network['layer_1']['node_1']['bias']\n",
    "\n",
    "weighted_sum = compute_weighted_sum(inputs, node_weights, node_bias)\n",
    "print('La suma ponderada en el primer nodo de la capa oculta es {}'.format(np.around(weighted_sum[0], decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3c2af20-1b88-4d0a-b671-215fee86abbf",
   "metadata": {},
   "source": [
    "## Calcular el Nodo de Activacion\n",
    "\n",
    "Recordar que la salida de cada nodo es una transformacion simple no-lineal de la suma ponderada. Usamos la funcion de activacion para este mapeo. Usamos la funcion sigmoide como la funcion de activacion aqui. Asi que vamos a definir una funcion que tome la suma ponderada como entrada y retorne la transformacion no-lineal de la entrada usando la funcion Sigmoide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "20781b60-1d01-403d-87ff-813834fe4a58",
   "metadata": {},
   "outputs": [],
   "source": [
    "def node_activation(weighted_sum):\n",
    "    return 1.0 / (1.0 + np.exp(-1 * weighted_sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0584eee-817e-4df8-8ec9-39329c371234",
   "metadata": {},
   "source": [
    "#### Usar la funcion _node_activation_ para calcular la salida del primer nodo en la primera capa oculta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "75a10181-c6e2-4f5e-aa52-64113660fa0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La salida en el primer nodo en la capa oculta es 0.8541\n"
     ]
    }
   ],
   "source": [
    "node_output  = node_activation(compute_weighted_sum(inputs, node_weights, node_bias))\n",
    "print('La salida en el primer nodo en la capa oculta es {}'.format(np.around(node_output[0], decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3ac58c8-0ca7-4581-810b-1c93fd8e606a",
   "metadata": {},
   "source": [
    "## Forward Propagation\n",
    "\n",
    "La pieza final de la construccion de una Red Neuronal que puede realizar predicciones es poner todo junto. Asi que vamos a crear una funcion que aplique las funciones **_compute_weighted_sum_ and _node_activation_** para cada nodo en la Red y propagen todos los datos de forma que las predicciones de las salidas y capa de salida propagen una prediccion por cada nodo en la capa de salida.\n",
    "\n",
    "- La manera en que vamos a relizar esto es a traves de el siguiente procesimiento: \n",
    "\n",
    "1.  Comenzar con una capa de entrada como la entrada a la primera capa oculta.\n",
    "2.  Calcular la suma ponderada en los nodos de la actual capa.\n",
    "3.  calcular la salida de los nodos de las actuales capas.\n",
    "4.  Configurar la salida de la actual capa para ser la entrada a la siguiente capa.\n",
    "5.  Mover a la siguiente capa en la Red.\n",
    "6.  Repetir los pasos 2 - 4 hasta que calculemos la salida de la capa de salida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "795f4d07-94c4-408e-b9cc-60a2e1d5ccdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagate(network, inputs):\n",
    "    \n",
    "    layer_inputs = list(inputs) # start with the input layer as the input to the first hidden layer\n",
    "    \n",
    "    for layer in network:\n",
    "        \n",
    "        layer_data = network[layer]\n",
    "        \n",
    "        layer_outputs = [] \n",
    "        for layer_node in layer_data:\n",
    "        \n",
    "            node_data = layer_data[layer_node]\n",
    "        \n",
    "            # compute the weighted sum and the output of each node at the same time \n",
    "            node_output = node_activation(compute_weighted_sum(layer_inputs, node_data['weights'], node_data['bias']))\n",
    "            layer_outputs.append(np.around(node_output[0], decimals=4))\n",
    "            \n",
    "        if layer != 'output':\n",
    "            print('The outputs of the nodes in hidden layer number {} is {}'.format(layer.split('_')[1], layer_outputs))\n",
    "    \n",
    "        layer_inputs = layer_outputs # set the output of this layer to be the input to next layer\n",
    "\n",
    "    network_predictions = layer_outputs\n",
    "    return network_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a45371cf-3ce7-47ae-934b-1a5322a10cde",
   "metadata": {},
   "source": [
    "#### Usar la funcion _forward_propagate_ para calcular la prediccion de nuestra pequeña red."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f8359f7f-81a0-47d3-82e8-1a6bcd86427c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The outputs of the nodes in hidden layer number 1 is [0.8541, 0.861, 0.772]\n",
      "The outputs of the nodes in hidden layer number 2 is [0.7532, 0.9457]\n",
      "The outputs of the nodes in hidden layer number 3 is [0.6559, 0.7953, 0.8568]\n",
      "The predicted value by the network for the given input is 0.7886\n"
     ]
    }
   ],
   "source": [
    "predictions = forward_propagate(small_network, inputs)\n",
    "print('The predicted value by the network for the given input is {}'.format(np.around(predictions[0], decimals=4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74470ddf-bb38-48cc-91c6-62ffbafe15b1",
   "metadata": {},
   "source": [
    "- De esta manera construimos el codigo para definir una Red Neuronal. \n",
    "\n",
    "Podemos especificar el numero de entradas que una Red Neuronal puede tomar, el numero de capas ocultas como tambien el numero de nodos en cada capa oculta y el numero de nodos en la capa de salida. \n",
    "\n",
    "Primeramente usamos *inicialize_network* para crear nuestra Red Neuronal y definir sus pesos y Bias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "432936ac-35b7-45de-abf9-a3b640c3b53d",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_network = initialize_network(5, 3, [2, 3, 2], 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "969096f5-507c-41b1-baa9-3b0f6cbc5213",
   "metadata": {},
   "source": [
    "Luego, para euna entrada dada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5dd5e39e-9e34-49ee-bb0b-849b5cb93e48",
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = np.around(np.random.uniform(size=5), decimals=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c33526f0-a3e9-4e87-b205-7a5482fcf435",
   "metadata": {},
   "source": [
    "Calculamos las predicciones de la Red:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a77a6e7e-afe3-4a4a-9ede-2d1a994b76ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The outputs of the nodes in hidden layer number 1 is [0.8857, 0.8889]\n",
      "The outputs of the nodes in hidden layer number 2 is [0.7822, 0.6965, 0.7411]\n",
      "The outputs of the nodes in hidden layer number 3 is [0.868, 0.881]\n",
      "The predicted values by the network for the given input are [0.8952, 0.8222, 0.8035]\n"
     ]
    }
   ],
   "source": [
    "predictions = forward_propagate(my_network, inputs)\n",
    "print('The predicted values by the network for the given input are {}'.format(predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23c37892-f79c-4b28-ab74-d87cf39f4b27",
   "metadata": {},
   "source": [
    "- Esto concluye este pequeño tutorial de como funciona una Red Neuronal y como construir una Red Neuronal automatizada, cambiando simplemente las capas de entrada, los nodos de cada capa, capas ocultas y capas de salida. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25e70d51-bb0e-4176-aa0e-fa68e756695a",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}