B - Intro a NumPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "B - Intro a NumPy",
      "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/futurelabmx/cdecmx/blob/main/B%20-%20Intro%20a%20NumPy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OpSHrtcJLQEU"
      },
      "source": [
        "# Introducción a NumPy\n",
        "\n",
        "A lo largo de este cuaderno explicaremos algunos elementos básicos y herramientas con las que cuenta NumPy. Los temas específicos que cubriremos en este cuaderno introductorio son los siguientes:\n",
        "\n",
        "1. Introducción a NumPy\n",
        "2. Atributos, tamaño y forma\n",
        "3. Creación de arreglos\n",
        "4. Indexación y slicing\n",
        "5. Operaciones básicas, broadcasting\n",
        "6. Valores únicos y cuentas\n",
        "7. Matrices en NumPy\n",
        "8. Trasposición, aplanamiento y reversa\n",
        "9. Reshape de matrices\n",
        "10. Módulo random\n",
        "11. Módulo de álgebra lineal\n",
        "12. Conoce SciPy\n",
        "\n",
        "### Planteamiento del problema:\n",
        "\n",
        "El poder manipular datos multidimensionales es generalmente de mucha ayuda, así que utilizaremos algunos de los conceptos previamente mencionados para trabajar con imágenes y descomponerlas en sus diferentes dimensiones (o canales) de color.\n",
        "\n",
        "## ¿Qué es NumPy?\n",
        "\n",
        "<center>\n",
        "    <img width=\"30%\" src=\"https://numpy.org/images/logos/numpy.svg\">\n",
        "</center>\n",
        "\n",
        "**NumPy** es el paquete fundamental para la computación numérica con Python.\n",
        "\n",
        "De acuerdo con Wikipedia: _\"(...) es una biblioteca para el lenguaje de programación Python que da soporte para crear vectores y matrices grandes multidimensionales, junto con una gran colección de funciones matemáticas de alto nivel para operar con ellas.\"_\n",
        "\n",
        "\n",
        "### Objetos en NumPy\n",
        "\n",
        "En NumPy, los objetos con los que trabajamos son arreglos multidimensionales:\n",
        "\n",
        "```\n",
        "                     [1, 2, 3, 4] → [1.0 2.0 3.0 4.0]\n",
        "[[1, 2, 3], [4, 5, 6], [7, 8, 9]] →  [[1.0 2.0 3.0]\n",
        "                                      [4.0 5.0 6.0]\n",
        "                                      [7.0 8.0 9.0]]\n",
        "```\n",
        "\n",
        "### ¿Qué es un _array_?\n",
        "\n",
        "Un arreglo es la formalización de una lista en Python; y un array puede ser indexado por una tupla de enteros no negativos, por booleanos, por otro arreglo o por enteros. El rango de la matriz es el número de dimensiones. La forma de la matriz es una tupla de números enteros que dan el tamaño de la matriz a lo largo de cada dimensión.\n",
        "\n",
        "Una forma en que podemos inicializar matrices NumPy es a partir de listas de Python, utilizando listas anidadas para datos bidimensionales o de mayor dimensión.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lBy00gJgHaQo"
      },
      "source": [
        "import numpy as np # ¡IMPORTANTE!\n",
        "\n",
        "\n",
        "a = np.array([1, 2, 3, 4, 5, 6])\n",
        "print(a)\n",
        "print(type(a))\n",
        "print(a[0])\n",
        "print()\n",
        "\n",
        "b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "print(b)\n",
        "print(type(b))\n",
        "print(b[0])\n",
        "print(type(b[0]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSJW87sPXOAh"
      },
      "source": [
        "## Atributos, tamaño y forma\n",
        "\n",
        "Un arreglo suele ser un contenedor de tamaño fijo de elementos del mismo tipo y tamaño. El número de **dimensiones** y **elementos** se define por su forma. La **forma (shape)** es una tupla de números enteros no negativos que especifican los tamaños de cada dimensión.\n",
        "\n",
        "En NumPy, las dimensiones se denominan **ejes (axes)**.\n",
        "\n",
        "Esto significa que si tenemos un arreglo 2D (una matriz) que se ve así:\n",
        "\n",
        "```python\n",
        "[[0., 0., 0.],\n",
        " [1., 1., 1.]]\n",
        "```\n",
        "\n",
        "Entonces tenemos 2 ejes. El primer eje tiene una longitud de 2 y el segundo eje tiene una longitud de 3. (`shape=(2, 3)`)\n",
        "\n",
        "### ¿Cómo saber la forma y tamaño?\n",
        "\n",
        "- **ndarray.ndim** te dirá el número de ejes o dimensiones de la matriz.\n",
        "- **ndarray.size** te dirá el número total de elementos de la matriz. Este es el producto de los elementos de la forma de la matriz.\n",
        "- **ndarray.shape** te mostrará una tupla de números que indican el número de elementos almacenados a lo largo de cada dimensión de la matriz.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8i5sDqw-XUJP"
      },
      "source": [
        "print(b)\n",
        "print(b.ndim)\n",
        "print(b.size)\n",
        "print(b.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlMAcIGEYIef"
      },
      "source": [
        "## Creación de arreglos\n",
        "\n",
        "Además de crear un array a partir de una secuencia de elementos, puedes crear uno llena de ceros, o llena de unos:\n",
        "\n",
        "```python\n",
        "np.zeros(2)\n",
        "# array([0., 0.])\n",
        "np.ones(2)\n",
        "# array([1., 1.])\n",
        "```\n",
        "\n",
        "#### Ejercicio:\n",
        "\n",
        "- Crea una matriz de ceros de 5x5 e imprímela en pantalla.\n",
        "- ¿Puedes crear una matriz identidad? Una matriz identidad es una matriz cuadrada llena de ceros y con unos en la diagonal. Puedes construirla utilizando un ciclo `for` y haciendo uso de los que conocemos hasta ahora para iterar listas en Python.\n",
        "- Si quieres construir una matriz identidad, también puedes utilizar la función `np.eye()`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RmbbjQIqYT6i"
      },
      "source": [
        "# TODO.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bwPAwu74G3mk"
      },
      "source": [
        "También puedes usar np.linspace() para crear una matriz con valores espaciados linealmente en un intervalo especificado.\n",
        "\n",
        "Para esto nos apoyaremos de una biblioteca que nos permite graficar."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M8LbAUGmG8RV"
      },
      "source": [
        "x = np.linspace(0, 50, 51)\n",
        "print(x)\n",
        "\n",
        "y = np.sin(x)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9RmTn2xEHTxu"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.style.use('seaborn')\n",
        "\n",
        "\n",
        "fig = plt.figure(figsize=(20, 5))\n",
        "plt.plot(x, y)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jLwEXaMvIUag"
      },
      "source": [
        "## Indexación y slicing\n",
        "\n",
        "Podemos indexar y usar slicing matrices NumPy de la misma manera que hacemos con listas de Python.\n",
        "\n",
        "```python\n",
        "data = np.array([1, 2, 3])\n",
        "\n",
        "print(data[1])\n",
        "# 2\n",
        "print(data[0:2])\n",
        "# array([1, 2])\n",
        "print(data[1:])\n",
        "# array([2, 3])\n",
        "print(data[-2:])\n",
        "# array([2, 3])\n",
        "```\n",
        "\n",
        "La principal diferencia es que en lugar de usar múltiples corchetes, usamos comas para acceder a elementos. Exploremos en un ejemplo:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bded7lCiI81o"
      },
      "source": [
        "print(b)\n",
        "print(b[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kV1KnLUxIXcC"
      },
      "source": [
        "## Operaciones básicas, broadcasting\n",
        "\n",
        "Si tuviésemos un par de arrays del misma forma, podríamos operar entre ellos. Consideremos el par de arreglos a continuación:\n",
        "\n",
        "<center>\n",
        "    <img src=\"https://numpy.org/devdocs/_images/np_array_dataones.png\">\n",
        "</center>\n",
        "\n",
        "Podríamos sumarlos:\n",
        "\n",
        "<center>\n",
        "    <img src=\"https://numpy.org/devdocs/_images/np_data_plus_ones.png\">\n",
        "</center>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZVe_biZZ_z2j"
      },
      "source": [
        "data = np.array([1, 2])\n",
        "ones = np.ones(2, dtype=int)\n",
        "print(data + ones)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I2D4JbZY_2bb"
      },
      "source": [
        "\n",
        "Esto en general se preserva para las otras operaciones básicas:\n",
        "\n",
        "<center>\n",
        "    <img src=\"https://numpy.org/devdocs/_images/np_sub_mult_divide.png\">\n",
        "</center>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ri61t6Tb_8T6"
      },
      "source": [
        "print(data - ones)\n",
        "print(data * data)\n",
        "print(data / data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WsluyIZjAFZT"
      },
      "source": [
        "#### ¿Qué sucede si queremos una multiplicación escalar?\n",
        "\n",
        "## Broadcasting\n",
        "\n",
        "<center>\n",
        "    <img src=\"https://numpy.org/devdocs/_images/np_multiply_broadcasting.png\">\n",
        "</center>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KWVlvxGAAXB1"
      },
      "source": [
        "data = np.array([1.0, 2.0])\n",
        "data * 1.6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tsLLRJaSIe8z"
      },
      "source": [
        "## Valores únicos y cuentas\n",
        "\n",
        "Existen algunas funciones propias de los arreglos en NumPy:\n",
        "- **.max()** te dirá el máximo de los elementos del arreglo.\n",
        "- **.min()** te dirá el mínimo de los elementos del arreglo.\n",
        "- **.sum()** te dirá la suma  de los elementos del arreglo.\n",
        "- **.prod()** te dirá el producto de los elementos del arreglo.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPn2pn6SAnGn"
      },
      "source": [
        "A = np.array([\n",
        "    [45, 21,  9, 92],\n",
        "    [76,  2, 12, 35],\n",
        "    [23, 47, 89, 25],\n",
        "    [40, 78, 23,  1]\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pOoMtzsPAqex"
      },
      "source": [
        "Incluso existen funciones que te devuelven estadísticos de tus datos:\n",
        "- **.mean()** te dirá el promedio de los elementos del arreglo.\n",
        "- **.std()** te dirá la desviación estándar de los elementos del arreglo.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A53zvTz3Cha-"
      },
      "source": [
        "B = np.array([45, 21, 9, 92, 76, 2, 12, 35, 23, 47, 89, 25, 40, 78, 23, 1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1yuwUeEbDKC9"
      },
      "source": [
        "En cuanto a querer devolver valores únicos, podemos usar **.uniques()**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "97nXosvRDNZ8"
      },
      "source": [
        "a = np.array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18])\n",
        "unique_values = np.unique(a)\n",
        "print(unique_values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zi0aCgz8str7"
      },
      "source": [
        "Finalmente, no hay que olvidar que podemos utilizar operaciones matemáticas básicas:\n",
        "- **np.sin(x)** te devolverá el seno del vector `x`.\n",
        "- **np.cos(x)** te devolverá el coseno del vector `x`\n",
        "- Etcétera."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OZBPb1Eus1xl"
      },
      "source": [
        "np.cos(B)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8pZnR-8yIimm"
      },
      "source": [
        "## Trasposición, aplanamiento y reversa\n",
        "\n",
        "Es común tener que trasponer matrices. Las matrices NumPy tienen la propiedad **.T** que permite transponer una matriz. De igual manera se puede utilizar **.transpose()**\n",
        "\n",
        "<center>\n",
        "    <img src=\"https://numpy.org/devdocs/_images/np_transposing_reshaping.png\">\n",
        "</center>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7EpMdUEaIZ9A"
      },
      "source": [
        "print(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xZU8i5oRIaTO"
      },
      "source": [
        "En algunas ocasiones resulta útil aplanar una matriz, esto es, convertirla en un arreglo unidimensional. Esto puede lograrse con **.flatten()**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xwwIkx3NIgJm"
      },
      "source": [
        "print(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qQgZOKbEIp1x"
      },
      "source": [
        "Al igual que con las listas en Python, podemos utilizar slicing para revertir un array, sin embargo, NumPy tiene una función propia: **np.flip()**\n",
        "\n",
        "#### ¿Qué sucede si lo utilizamos en matrices?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UgLp-wEFIuzk"
      },
      "source": [
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
        "reversed_arr = np.flip(arr)\n",
        "print('Reversed Array: ', reversed_arr)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BQ4ilZ87IyzA"
      },
      "source": [
        "print(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zE2LrEWCI2D4"
      },
      "source": [
        "### Reshape de matrices\n",
        "\n",
        "**.reshape()** permite cambiar la forma de una matriz sin cambiar los datos. Sólo ten presente que cuando usamos esta función, la matriz que queremos producir debe tener la misma cantidad de elementos que la matriz original.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ktO4FSzI6Vt"
      },
      "source": [
        "print(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h3PJ_8rAIg5o"
      },
      "source": [
        "## Matrices en NumPy\n",
        "\n",
        "Procederemos a explorar un poco con una imagen y sus canales de color.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KHDCUPjMKTZp"
      },
      "source": [
        "import urllib.request\n",
        "\n",
        "\n",
        "image_url = 'https://raw.githubusercontent.com/futurelabmx/cdecmx/gh-pages/assets/images/cdec_python.jpeg'\n",
        "filename = 'image.jgp'\n",
        "urllib.request.urlretrieve(image_url, filename)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bCykkl7sJTf6"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BVKbcMnhJNzQ"
      },
      "source": [
        "# Sección de código libre"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOLl3XB1IkPj"
      },
      "source": [
        "## Módulo random\n",
        "\n",
        "Conoce más del módulo `random` aquí: https://numpy.org/doc/stable/reference/random/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sLJQyPf0JYyY"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LSRnPmH_ImOn"
      },
      "source": [
        "## Módulo de álgebra lineal\n",
        "\n",
        "Conoce más del módulo `linalg` aquí: https://numpy.org/doc/stable/reference/routines.linalg"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a0EhYE0pIobA"
      },
      "source": [
        "## Conoce SciPy\n",
        "\n",
        "Explora SciPy aquí: https://www.scipy.org/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efpB7jYb3hQj"
      },
      "source": [
        "--------\n",
        "\n",
        "> Contenido creado por **Rodolfo Ferro** ([CdeCMx](https://clubesdeciencia.mx/) / [Future Lab](https://futurelab.mx/), 2021). <br>\n",
        "> Contacto: [@rodo_ferro](https://www.instagram.com/rodo_ferro/) & [@rodo_ferro](https://twitter.com/rodo_ferro)"
      ]
    }
  ]
}