Tutorial_Numpy_2022_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tutorial_Numpy_2022-1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Javcm/Intro-a-Deep-Learning-UNAM-FC/blob/main/Tutorial_Numpy_2022_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7y4zCwlrpjey"
      },
      "source": [
        "<img src = \"https://drive.google.com/uc?id=17atj9OubRtxp1m0gVTwAGORykjvdxWA0\" align = \"center\" >"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HLGXEww0poe5"
      },
      "source": [
        "<font color = 'BlackCyan' size = 8>\n",
        "Tutorial Numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AmUIJ_6sprNI"
      },
      "source": [
        "<font size=4>\n",
        "En este Notebook se aborda el uso de la paquetería Numpy y su aplicación en diversas áreas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ez4J-jmSpt_n"
      },
      "source": [
        "<font size = 5, color = \"blue\">\n",
        "1.- ¿Por qué Numpy?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V2_gud2jpw1Q"
      },
      "source": [
        "<font size=4>\n",
        "Numpy es una biblioteca que se ha vuelto esencial para el cómputo científico al utilizar el lenguaje de programación Python.\n",
        "Destaca como una de las bibliotecas más recurrentes y útilies debido a que permite realizar operaciones con mayor sencillez y eficiencia."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QfrWlNdHp0Vr"
      },
      "source": [
        "## <font size=4> Cualquier cosa que quieras saber de esta biblioteca en el futuro lo puedes encontrar [aquí](https://numpy.org/doc/stable/)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1HjXn5DGp6cM"
      },
      "source": [
        "<font size = 5, color = \"blue\">\n",
        "2.- Ventajas de utilizar Numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zWLLB-UMp9Sg"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Comparemos la biblioteca **math** y **numpy** al definir la función Sigmoide, la cual es una función muy utilizada en Deep Learning. En particular observemos la forma en que operan **math.exp()** y **np.exp()**:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GTvMI4-GqAIk"
      },
      "source": [
        "<font size = 4>\n",
        "Recordando que: \n",
        "$sigmoid(x) = \\frac{1}{1+e^{-x}}$ "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xETnuUZ6peZj"
      },
      "source": [
        "<img src = \"https://drive.google.com/uc?id=1NdvUhSr_AGYmQ1XByZUcfq87d36wvKi_\" align = \"center\" >"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "00EAOp85pXVv"
      },
      "source": [
        "#Definimos la función utilizando la biblioteca math:\n",
        "\n",
        "import math\n",
        "\n",
        "def sigmoide_math(x):\n",
        "    '''\n",
        "    Input: elemento del tipo int o float\n",
        "    output: elemento del tipo int o float\n",
        "    '''\n",
        "    return 1/(1 + math.exp(-x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8E0JjY0aqpM8"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Las entradas de la función sigmoide suelen ser vectores, en este caso probaremos con enteros, flotantes y vectores:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z6DZG4NypeK3",
        "outputId": "05155f76-f439-4fd3-e44b-7faf0d1079f5"
      },
      "source": [
        "#Calculamos el valor de sigmoide para x = 1 como entero y flotante:\n",
        "\n",
        "x = 1 #int(1)\n",
        "y = 1. #float(1)\n",
        "\n",
        "print(\"x es del tipo {} y sigmoide(x) tiene el valor {:.5f}\\n y es del tipo {} y sigmoide(y) tiene el valor {:.5f}.\"\\\n",
        "      .format( type(x), sigmoide_math(x), type(y), sigmoide_math(y) ) )\n",
        "\n",
        "\n",
        "#print(\"database es una {} con {} elements and shape {}.\".format(type(database), len(database), database.shape))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x es del tipo <class 'int'> y sigmoide(x) tiene el valor 0.73106\n",
            " y es del tipo <class 'float'> y sigmoide(y) tiene el valor 0.73106.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HCMF8DMxrYHf"
      },
      "source": [
        "<font size = 4>\n",
        "    \n",
        "Observamos que no hay diferencia."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PRUSHPlMra_Q"
      },
      "source": [
        "<font size = 4>\n",
        "    \n",
        "Ahora bien, si intentamos calcular el valor de **sigmoide_math()** de X = [1,2,3], obtenemos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "id": "A6E95UBvHgxs",
        "outputId": "3805ee33-cd09-4baa-82c6-253b525a8f44"
      },
      "source": [
        "X = [1,2,3]\n",
        "\n",
        "sigmoide_math(X)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-9-ed79bd136242>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0msigmoide_math\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-7-5490dbfdc055>\u001b[0m in \u001b[0;36msigmoide_math\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0moutput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0melemento\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mtipo\u001b[0m \u001b[0mint\u001b[0m \u001b[0mo\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m     '''\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: bad operand type for unary -: 'list'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GxQ3OQ2CH4dJ"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Este error se debe a que **math** funciona con variables del tipo entero y flotante."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q4WS7rEXpfBi"
      },
      "source": [
        "#Importamos Numpy\n",
        "\n",
        "import numpy as np  #pip install numpy\n",
        "                    #conda install numpy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yErtEFtOspVo"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Probemos utilizando **np.exp()** para los tres tipos de variable: entero, flotante, vector(arreglo):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nse5i8IDstDP"
      },
      "source": [
        "np.exp?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tQJLfFEgsPZ5"
      },
      "source": [
        "#Definimos la función sigmoid utilizando Numpy:\n",
        "\n",
        "def sigmoid_np(x):\n",
        "    \"\"\"\n",
        "    Input: Vector X del tipo arreglo de numpy\n",
        "    Output: Arreglo de numpy\n",
        "    \"\"\"\n",
        "    return 1/(1 + np.exp(-x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 253
        },
        "id": "gaWoOzjNItfm",
        "outputId": "9ab4c12f-33ed-48c7-90a2-80e9085702c5"
      },
      "source": [
        "sigmoid_np(X) #X = [1,2,3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-c702a33cfbac>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msigmoid_np\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#X = [1,2,3]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-14-4b41dc121ad6>\u001b[0m in \u001b[0;36msigmoid_np\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mOutput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mArreglo\u001b[0m \u001b[0mde\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \"\"\"\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: bad operand type for unary -: 'list'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nUVCN8sQJL-P",
        "outputId": "2c0efa02-fea3-4797-c9f4-63a1502f8017"
      },
      "source": [
        "#Numpy no puede calcular la exponencial de una lista, debemos convertir esa lista\n",
        "#en un arreglo de Numpy.\n",
        "\n",
        "X = np.array([1,2,3])\n",
        "\n",
        "print(X, type(X))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3] <class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s7Uk0TV8s3Ks",
        "outputId": "ec69c3c4-fdec-4314-8332-09155ea3a42a"
      },
      "source": [
        "#Evaluamos con x, y, X:\n",
        "\n",
        "print(\"'x' es del tipo {} y sigmoide(x) tiene el valor {:.5f}. \\n\\n 'y' es del tipo {} y sigmoide(y) tiene el valor {:.5f}.\\\n",
        " \\n\\n 'X' es del tipo {} y sigmoid de X tiene el valor de {}.\"\\\n",
        "      .format(type(x), sigmoid_np(x),type(y), sigmoid_np(y), type(X), sigmoid_np(X)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'x' es del tipo <class 'int'> y sigmoide(x) tiene el valor 0.73106. \n",
            "\n",
            " 'y' es del tipo <class 'float'> y sigmoide(y) tiene el valor 0.73106. \n",
            "\n",
            " 'X' es del tipo <class 'numpy.ndarray'> y sigmoid de X tiene el valor de [0.73105858 0.88079708 0.95257413].\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XRknjCkhuTNu"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Lo que ocurre es que **Numpy** calcula la exponencial de cada una de las entradas del vector 'X' y regresa np.exp(X) como un vector de la misma forma que 'X'.\n",
        "    \n",
        "<font color = \"red\">    \n",
        "\n",
        "$$ \\text{For } x \\in \\mathbb{R}^n \\text{,     } sigmoid(x) = sigmoid\\begin{pmatrix}\n",
        "    x_1  \\\\\n",
        "    x_2  \\\\\n",
        "    ...  \\\\\n",
        "    x_n  \\\\\n",
        "\\end{pmatrix} = \\begin{pmatrix}\n",
        "    \\frac{1}{1+e^{-x_1}}  \\\\\n",
        "    \\frac{1}{1+e^{-x_2}}  \\\\\n",
        "    ...  \\\\\n",
        "    \\frac{1}{1+e^{-x_n}}  \\\\\n",
        "\\end{pmatrix}\\tag{1} $$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ZhP98RGw9S5"
      },
      "source": [
        "<font size = 5, color = \"blue\">\n",
        "3.- Gradiente de la Función Sigmoide"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N57fdnlXxAPx"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Como se verá más adelante, para optimizar una función de pérdida se requiere calcular el gradiente de funciones al hacer retropropagación (Gradient Descent). En este sentido, calculemos el **gradiente** de la función **sigmoide** el cual se determina mediante la ecuación (recordando que  $sigmoid(x) = \\frac{1}{1+e^{-x}}$ )\n",
        "\n",
        " $$ sigmoid\\_gradient (x) = \\sigma '(x) = \\sigma (x) (1 - \\sigma (x)) \\tag {2} $$\n",
        "    \n",
        "Puedes comprobar que la ecuación es correcta diferenciando respecto a la variable de la función."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TOFAASjbs-QZ"
      },
      "source": [
        "# EJERCICIO \n",
        "\n",
        "# Implementa la función sigmoid_gradient(x) \n",
        "\n",
        "\n",
        "\n",
        "def sigmoid_gradient(x):\n",
        "    \"\"\"\n",
        "    Input: x, un entero, flotante o arreglo de numpy.\n",
        "    output: gradiente de sigmoid(x), flotante.\n",
        "    \"\"\"\n",
        "    # código \n",
        "    \n",
        "    sig_grad = \n",
        "    \n",
        "    return sig_grad"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LAD6AGP9tJSd",
        "outputId": "2094da6e-f3a1-4b2f-961d-b91410e45ba0"
      },
      "source": [
        "#Probamos con el arreglo X definido previamente\n",
        "\n",
        "sigmoid_gradient(X)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.19661193, 0.10499359, 0.04517666])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "acYFg1RvzOcu"
      },
      "source": [
        "<font size = 5, color = \"blue\">\n",
        "4.- Array Reshape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuxYOVnozR4t"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Veamos el funcionamiento de dos atributos muy utilizados en el tratamiento de datos con Numpy: **np.shape()** y **np.reshape()**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rm11-WD0zWSP"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "1.- **np.shape()** se utiliza para saber las dimensiones de un arreglo de numpy. Esto se puede interpretar como las dimensiones de una matriz.\n",
        "    \n",
        "2.- **np.reshape()** se utiliza para cambiar las dimensiones del arreglo (matriz) de numpy."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WIOi4oS-zdxK"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Estas funciones son muy frecuentes al implementar redes neuronales convolucionales. Esto ya que se suele modelar a las imágenes como un arreglo de pixeles a los cuales les corresponde un valor entre 0 y 255 para cada uno de los colores rojo, verde y azul (RGB). Formando un arreglo de 3 dimensiones ($largo$, $ancho$, $profundo$)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NQfASL3mztfp"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Este arreglo se reordena como un vector de 1 dimensión: ($largo$$*$$ancho$$*$$profundo$) al introducirlo al modelo de la red neuronal. En inglés a este vector se le denomina 'flatten'."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DaObWAaqz1Mc"
      },
      "source": [
        "<img src = \"https://drive.google.com/uc?id=1chF7upglVNOFlR5x7jNEt4nkSWdb5jAc\" align = \"center\" >"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TAaLvMDo0IMb"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Implementemos la función **np.reshape** reordenando un arreglo de la forma (3,3,2) en un arreglo de la forma (18,1):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VUQkxrMlzG_T"
      },
      "source": [
        "#Definimos la función Reshape:\n",
        "\n",
        "def image2vector(image):\n",
        "    \"\"\"\n",
        "    Input:\n",
        "    imagen -- arreglo de numpy de la forma (longitud, anchura, profundidad)\n",
        "    \n",
        "    Returns:\n",
        "    v -- vector de la forma (longitud*anchura*profundidad, 1)\n",
        "    \"\"\"\n",
        "    \n",
        "    v = image.reshape( (image.shape[0]*image.shape[1]*image.shape[2]), 1)\n",
        "    \n",
        "    return v"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ltr_iOfl0WpW"
      },
      "source": [
        "<font size=3> Puedes aprender más del atributo **np.reshape()** en el siguiente [enlace](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WJSCYvTD0Ow8",
        "outputId": "1bf0fbb4-ef30-49bb-f884-f4d31c689608"
      },
      "source": [
        "#Definimos un arreglo de prueba y comprobamos:\n",
        "\n",
        "image = np.array([[[ 0.67826139,  0.29380381],\n",
        "                   [ 0.90714982,  0.52835647],\n",
        "                   [ 0.4215251 ,  0.45017551]],\n",
        "\n",
        "                  [[ 0.92814219,  0.96677647],\n",
        "                   [ 0.85304703,  0.52351845],\n",
        "                   [ 0.19981397,  0.27417313]],\n",
        "\n",
        "                  [[ 0.60659855,  0.00533165],\n",
        "                   [ 0.10820313,  0.49978937],\n",
        "                   [ 0.34144279,  0.94630077]] \n",
        "                  ])\n",
        "\n",
        "image.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3, 3, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LRbbahdq0fUF",
        "outputId": "2d551e1f-3112-4ee8-fea3-9eb947f5c1ba"
      },
      "source": [
        "image_flatten = image2vector(image)\n",
        "image_flatten.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(18, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VoFytrHv1DJg",
        "outputId": "5062a0df-c956-4416-d8eb-fc851d26cadb"
      },
      "source": [
        "image_flatten"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.67826139],\n",
              "       [0.29380381],\n",
              "       [0.90714982],\n",
              "       [0.52835647],\n",
              "       [0.4215251 ],\n",
              "       [0.45017551],\n",
              "       [0.92814219],\n",
              "       [0.96677647],\n",
              "       [0.85304703],\n",
              "       [0.52351845],\n",
              "       [0.19981397],\n",
              "       [0.27417313],\n",
              "       [0.60659855],\n",
              "       [0.00533165],\n",
              "       [0.10820313],\n",
              "       [0.49978937],\n",
              "       [0.34144279],\n",
              "       [0.94630077]])"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_ocxbVf9rml"
      },
      "source": [
        "<font size = 5, color = \"blue\">\n",
        "5.- Broadcast y normalización"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EOxuFzEQ9u_r"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Un proceso fundamental en algoritmos de Deep learning es la normalización de los datos con lo que se entrenará una red neuronal.\n",
        "Por ejemplo, es posible normalizar una matriz o arreglo a partir de normalizar cada uno de sus renglones o filas.\n",
        "Esto es, dada la matriz $$x:\n",
        "\\begin{bmatrix}\n",
        "    0 & 3 & 4 \\\\\n",
        "    2 & 6 & 4 \\\\\n",
        "\\end{bmatrix}\\tag{1}$$ entonces $$\\| x\\| = \\begin{bmatrix}\n",
        "    5 \\\\\n",
        "    \\sqrt{56} \\\\\n",
        "\\end{bmatrix}\\tag{2} $$ y        $$ x\\_normalized = \\frac{x}{\\| x\\|} = \\begin{bmatrix}\n",
        "    0 & \\frac{3}{5} & \\frac{4}{5} \\\\\n",
        "    \\frac{2}{\\sqrt{56}} & \\frac{6}{\\sqrt{56}} & \\frac{4}{\\sqrt{56}} \\\\\n",
        "\\end{bmatrix}\\tag{3}$$\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oMNE_tMxBlgg"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Implementemos una función que nos permita llevar acabo la operación, haremos uso del atributo de numpy **np.linalg.norm(x)**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oGunSvCY1GiM"
      },
      "source": [
        "#Función que normaliza cada renglón de un arreglo:\n",
        "\n",
        "def normalizeRows(x):\n",
        "    \"\"\"\n",
        "    Input:\n",
        "    x -- Un arreglo de numpy de la forma (n, m)\n",
        "    \n",
        "    Output:\n",
        "    x -- El arreglo x con cada uno de sus renglones normalizado.\n",
        "    \"\"\"\n",
        "    x_norm = np.linalg.norm(x, axis = 1, keepdims = True)\n",
        "    \n",
        "    \n",
        "    # Broadcast\n",
        "    x = x / x_norm\n",
        "\n",
        "    return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1H_awYIm_qxo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "48e1425a-ced4-476a-ca1c-ac6ee0122890"
      },
      "source": [
        "#Probamos la función:\n",
        "\n",
        "x = np.array([\n",
        "    [0, 3, 4],\n",
        "    [1, 6, 4]])\n",
        "x.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ArdYOTwzCQLP",
        "outputId": "0875b2a6-d9ff-4e28-9f5d-d21246547734"
      },
      "source": [
        "x_normalizada = normalizeRows(x)\n",
        "x_normalizada"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.        , 0.6       , 0.8       ],\n",
              "       [0.13736056, 0.82416338, 0.54944226]])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjCdt4UlCc3Z"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Observemos con detenimento la operación $x/x_{norm}$.\n",
        "\n",
        "Cada uno de estos arreglos tiene las siguientes dimensiones."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dD_lGcxGCWwG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "48e97d09-b67d-4ede-8aa4-110ce505cc69"
      },
      "source": [
        "#Definimos x_norm:\n",
        "x_norm = np.linalg.norm(x, axis = 1, keepdims = True)\n",
        "print(x_norm)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[5.        ]\n",
            " [7.28010989]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ace2-tA1VG8S",
        "outputId": "8e539fc1-31e2-4a6c-c159-6b01b0d428dc"
      },
      "source": [
        "#Definimos x/x_norm\n",
        "x_rowunit = x/x_norm\n",
        "print(x_rowunit)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.         0.6        0.8       ]\n",
            " [0.13736056 0.82416338 0.54944226]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "10c08e1rVh4z",
        "outputId": "85ea5031-8e4a-47aa-af1d-b7644356c26f"
      },
      "source": [
        "x + x_norm"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 5.        ,  8.        ,  9.        ],\n",
              "       [ 8.28010989, 13.28010989, 11.28010989]])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nOY1PPTsCgIZ",
        "outputId": "4994ff46-042e-4113-919a-72aa73c2485d"
      },
      "source": [
        "print(\"El arreglo x tiene dimensión {}, mientras que el arreglo x_norm tiene dimensión {}.\\n\\nPero el arreglo x/x_norm tiene dimensiones {}. Es decir las mismas que x.\" \\\n",
        "      .format(x.shape,x_norm.shape, x_rowunit.shape)) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El arreglo x tiene dimensión (2, 3), mientras que el arreglo x_norm tiene dimensión (2, 1).\n",
            "\n",
            "Pero el arreglo x/x_norm tiene dimensiones (2, 3). Es decir las mismas que x.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j5wfc-jhGO4r",
        "outputId": "5e72da29-cb0c-4312-9163-06d80820071f"
      },
      "source": [
        "#Definimos el vector x más la adición de un escalar:\n",
        "\n",
        "x_escalar = x + 5\n",
        "\n",
        "print(\"El arreglo x tiene dimensión {}, mientras que el arreglo x_escalar tiene dimensión {}\".format(x.shape,x_escalar.shape)) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "El arreglo x tiene dimensión (2, 3), mientras que el arreglo x_escalar tiene dimensión (2, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3HGXJiIlIUwj"
      },
      "source": [
        "<font size = 4> Observemos quién es **x_escalar**\n",
        "\n",
        "## ¿Qué pueden argumentar? "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s54CNpPTHMgI",
        "outputId": "6e396236-c470-403c-d497-c66e4493fe2d"
      },
      "source": [
        "print(x.shape)\n",
        "\n",
        "print(x)\n",
        "print(\"\\n\")\n",
        "\n",
        "print(x_escalar.shape)\n",
        "print(x_escalar)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(2, 3)\n",
            "[[0 3 4]\n",
            " [1 6 4]]\n",
            "\n",
            "\n",
            "(2, 3)\n",
            "[[ 5  8  9]\n",
            " [ 6 11  9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oFg6JsX4IjGr",
        "outputId": "d648345b-48f5-416b-99d3-aa3fce8b860a"
      },
      "source": [
        "x_s = np.array([5 , 5, 5])\n",
        "x_ss = x_s[np.newaxis, :]\n",
        "x_ss.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XrfoXVf3Khap",
        "outputId": "11f5d90f-155a-489b-cb0e-7fa792caaa15"
      },
      "source": [
        "x + x_ss"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 5,  8,  9],\n",
              "       [ 6, 11,  9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E-x3bE_ILGfA"
      },
      "source": [
        "<font size=4> Puedes entender mejor el Broadcasting [aquí](https://numpy.org/doc/stable/user/basics.broadcasting.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HnzAh5FZLNlV"
      },
      "source": [
        "<font size = 4>\n",
        "\n",
        "Como un ejercicio extra de broadcasting implementemos la función **Softmax**, esta se define como:\n",
        "    \n",
        "    \n",
        "- $ \\text{Sea } x \\in \\mathbb{R}^{1\\times n} \\text{,       } softmax(x) = softmax(\\begin{bmatrix}\n",
        "    x_1  &&\n",
        "    x_2 &&\n",
        "    ...  &&\n",
        "    x_n  \n",
        "\\end{bmatrix}) = \\begin{bmatrix}\n",
        "     \\frac{e^{x_1}}{\\sum_{j}e^{x_j}}  &&\n",
        "    \\frac{e^{x_2}}{\\sum_{j}e^{x_j}}  &&\n",
        "    ...  &&\n",
        "    \\frac{e^{x_n}}{\\sum_{j}e^{x_j}} \n",
        "\\end{bmatrix} $ \n",
        "\n",
        "- $\\text{Para un arreglo } x \\in \\mathbb{R}^{m \\times n} \\text{,  $x_{ij}$ asigna al elemento en el $i^{th}$ renglon y $j^{th}$ columna de $x$, entonces tenemos: }$  $$softmax(x) = softmax\\begin{bmatrix}\n",
        "    x_{11} & x_{12} & x_{13} & \\dots  & x_{1n} \\\\\n",
        "    x_{21} & x_{22} & x_{23} & \\dots  & x_{2n} \\\\\n",
        "    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
        "    x_{m1} & x_{m2} & x_{m3} & \\dots  & x_{mn}\n",
        "\\end{bmatrix} = \\begin{bmatrix}\n",
        "    \\frac{e^{x_{11}}}{\\sum_{j}e^{x_{1j}}} & \\frac{e^{x_{12}}}{\\sum_{j}e^{x_{1j}}} & \\frac{e^{x_{13}}}{\\sum_{j}e^{x_{1j}}} & \\dots  & \\frac{e^{x_{1n}}}{\\sum_{j}e^{x_{1j}}} \\\\\n",
        "    \\frac{e^{x_{21}}}{\\sum_{j}e^{x_{2j}}} & \\frac{e^{x_{22}}}{\\sum_{j}e^{x_{2j}}} & \\frac{e^{x_{23}}}{\\sum_{j}e^{x_{2j}}} & \\dots  & \\frac{e^{x_{2n}}}{\\sum_{j}e^{x_{2j}}} \\\\\n",
        "    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
        "    \\frac{e^{x_{m1}}}{\\sum_{j}e^{x_{mj}}} & \\frac{e^{x_{m2}}}{\\sum_{j}e^{x_{mj}}} & \\frac{e^{x_{m3}}}{\\sum_{j}e^{x_{mj}}} & \\dots  & \\frac{e^{x_{mn}}}{\\sum_{j}e^{x_{mj}}}\n",
        "\\end{bmatrix} = \\begin{pmatrix}\n",
        "    softmax\\text{(first row of x)}  \\\\\n",
        "    softmax\\text{(second row of x)} \\\\\n",
        "    ...  \\\\\n",
        "    softmax\\text{(last row of x)} \\\\\n",
        "\\end{pmatrix} $$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F090ulNxKnSh"
      },
      "source": [
        "# EJERCICIO: Implementa la función softmax descrita previamente\n",
        "\n",
        "### HINT visita el link: https://numpy.org/doc/stable/reference/generated/numpy.sum.html\n",
        "\n",
        "#Función Softmax:\n",
        "\n",
        "def softmax(x):\n",
        "    \"\"\"\n",
        "    Input:\n",
        "    x -- Un arreglo con dimensiones (n,m)\n",
        "    \n",
        "    Output:\n",
        "    s -- Un arreglo igual a la función softmax de x con dimensiones (n,m)\n",
        "    \"\"\"\n",
        "   \n",
        "   \n",
        "   #Broadcast\n",
        "    s = \n",
        "    return s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CuA8qxM1XBRE",
        "outputId": "9d7b5386-0c2d-4a5b-917a-20c36112a80d"
      },
      "source": [
        "#Calculamos la función softmax de un arreglo:\n",
        "\n",
        "x = np.array([[9, 2, 5, 0, 0], [7, 5, 0, 0 ,0]])\n",
        "\n",
        "print(\"x es un arreglo de dimensiones {} y softmax(x) es un arreglo con dimensiones {}. \\n\\nPor su parte softmax(x) tiene los valores: \\n\\n{}\"\\\n",
        "     .format(x.shape, softmax(x).shape, softmax(x)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x es un arreglo de dimensiones (2, 5) y softmax(x) es un arreglo con dimensiones (2, 5). \n",
            "\n",
            "Por su parte softmax(x) tiene los valores: \n",
            "\n",
            "[[9.80897665e-01 8.94462891e-04 1.79657674e-02 1.21052389e-04\n",
            "  1.21052389e-04]\n",
            " [8.78679856e-01 1.18916387e-01 8.01252314e-04 8.01252314e-04\n",
            "  8.01252314e-04]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cAWx8PHMXCSl"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pf36G_iNLZ_l",
        "outputId": "311eb028-dbce-4a22-d5fc-791a7b58c980"
      },
      "source": [
        "#Calculamos la función softmax de un arreglo:\n",
        "\n",
        "x = np.array([[9, 2, 5, 0, 0], [7, 5, 0, 0 ,0]])\n",
        "\n",
        "print(\"x es un arreglo de dimensiones {} y softmax(x) es un arreglo con dimensiones {}. \\n\\nPor su parte softmax(x) tiene los valores: \\n\\n{}\"\\\n",
        "     .format(x.shape, softmax(x).shape, softmax(x)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x es un arreglo de dimensiones (2, 5) y softmax(x) es un arreglo con dimensiones (2, 5). \n",
            "\n",
            "Por su parte softmax(x) tiene los valores: \n",
            "\n",
            "[[9.80897665e-01 8.94462891e-04 1.79657674e-02 1.21052389e-04\n",
            "  1.21052389e-04]\n",
            " [8.78679856e-01 1.18916387e-01 8.01252314e-04 8.01252314e-04\n",
            "  8.01252314e-04]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "COZ054vVLr5L"
      },
      "source": [
        "<font size = 5, color = \"blue\">\n",
        "6.- Vectorización"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rP80SXSOL_45"
      },
      "source": [
        "<font size=4>\n",
        "    \n",
        "Como se ha mencionado, en deep learning se manejan conjuntos de datos muy grandes. De manera que una función no computacionalmente óptima puede convertirse en un gran cuello de botella en el algoritmo y puede dar como resultado un modelo que demore años en ejecutarse. Para asegurarse de que el código sea computacionalmente eficiente se utiliza la vectorización. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9oDpd5NULcpF",
        "outputId": "1931db31-324a-47da-8674-5a334f05158c"
      },
      "source": [
        "import time  #Biblioteca utilizada para contar el tiempo de ejecución.\n",
        "\n",
        "x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]\n",
        "x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]\n",
        "\n",
        "\n",
        "\n",
        "#Implementación del producto punto clásico entre vectores\n",
        "\n",
        "tic = time.process_time()\n",
        "dot = 0\n",
        "for i in range(len(x1)):\n",
        "    dot += x1[i]*x2[i]\n",
        "toc = time.process_time()\n",
        "print (\"Producto punto = \" + str(dot) + \"\\n ----- Tiempo de cálculo = \" + str(1000*(toc - tic)) + \"ms\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Producto punto = 278\n",
            " ----- Tiempo de cálculo = 0.11801999999860868ms\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xfrRc8sRMKOh"
      },
      "source": [
        "<font size=4>\n",
        "    \n",
        "Comparemos con las mismas operaciones utilizando la vectorización de Numpy:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8wysd0oPMGv_",
        "outputId": "3572dbf2-689d-408e-d402-94625c7a8282"
      },
      "source": [
        "x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]\n",
        "x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]\n",
        "\n",
        "#Producto punto entre vectores de numpy\n",
        "\n",
        "tic = time.process_time()\n",
        "dot = np.dot(x1,x2)\n",
        "toc = time.process_time()\n",
        "print (\"Producto punto = \" + str(dot) + \"\\n ----- Tiempo de cálculo = \" + str(1000*(toc - tic)) + \"ms\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Producto punto = 278\n",
            " ----- Tiempo de cálculo = 0.07276999999916711ms\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "riJUggTAM_p7"
      },
      "source": [
        "VECTORIZACIÓN ~ técnicas que perminten \"quitar\"  bucles explícitos en el código "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SQ1hIvOOMOSa"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}