01_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./imagenes/python_logo.jpeg)\n",
    "# Librería NumPy.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*NumPy*](https://docs.scipy.org/doc/numpy/user/index.html) (*Numerical Python*) es una librería para el cómputo científico. Esta librería contiene muchas funciones matemáticas que permiten realizar operaciones de álgebra lineal, manejar matrices y vectores, generar números pseudo-aleatorios, etc. De forma muy general, el computo científico se basa en operar con arreglos de números; a veces estos arreglos representan matrices y vectores, y las operaciones necesarias son fundamentalmente las del álgebra lineal. En otros casos, como en el análisis de datos, los arreglos de números no necesariamente (o no siempre) son vectores y matrices en estricto sentido matemático. Por ejemplo casi cualquier conjunto de datos puede ser pensado como un arreglo de números. Una imagen es un arreglo bidimensional de números donde cada número representa el brillo de un pixel. Un sonido es un arreglo unidimensional que representa intensidad versus tiempo.\n",
    "\n",
    "*NumPy* no forma parte de la instalación estándar de *Python*, así que debe instalarse por separado. Desde una cónsola o terminal, basta con teclear:\n",
    "\n",
    "```bash\n",
    "pip install numpy\n",
    "```\n",
    "\n",
    "*NumPy* introduce objetos *`array`* que son similares a las listas en *Python*, pero que pueden ser manipulados por numerosas funciones contenidas en la librería. El tamaño de los arrays es **inmutable** y no se permiten elementos vacíos.\n",
    "\n",
    "En definitiva, para el cómputo científico es necesario contar con formas eficientes de almacenar y manipular arreglos de números y *NumPy* ha sido diseñado para esta tarea. El código escrito en *NumPy* suele ser más corto que el código equivalente en *Python* puro. El uso de *loops* es reducido, ya que muchas operaciones se aplican directamente sobre arreglos (*arrays*). Esto se conoce como *vectorizar el código*, internamente los loops siguen estando presentes pero son ejecutados por rutinas optimizadas escritas en lenguajes como _C_ o *Fortran*. Además, *NumPy* provee de muchas funciones matemáticas/científicas listas para usar. Esto reduce la cantidad de código que debemos escribir reduciendo así las posibilidades de cometer errores, y lo más importante, es que las funciones de *NumPy* están escritas usando implementaciones eficientes y confiables.\n",
    "\n",
    "La siguiente *hoja-resumen* condensa los principales comandos de *NumPy* que revisaremos en este *Notebook* y que luego podrá servir para consulta rápida.\n",
    "\n",
    "![](./imagenes/cheat_sheet_numpy.png)\n",
    "\n",
    "Para poder usar *NumPy* debemos importarlo, la forma más común de importar *NumPy* es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arreglos (arrays)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*NumPy* usa una estructura de datos llamada *array* (arreglos). Los arreglos de *NumPy* son similares a las listas de *Python*, pero son más eficientes para realizar tareas numéricas. La eficiencia deriva de las siguientes características:\n",
    "\n",
    "* Las listas de *Python* son muy generales, pudiendo contener objetos de distinto tipo. Además los objetos son asignados dinámicamente; es decir, el tamaño de una lista en *Python* no está predefinido y siempre podemos agregar más y más elementos.\n",
    "\n",
    "* Por el contrario, los arreglos de *NumPy* son **estáticos** y **homogéneos**. El tipo de los objetos se determina cuando el array es creado (de forma automática o por el usuario) lo que permite hacer uso eficiente de la memoria.\n",
    "\n",
    "* Otra razón por la cual los arreglos en *NumPy* son más eficientes que las listas, es que en *Python* todo es un objeto, incluso los números! Por ejemplo en lenguaje *C* un entero es esencialmente un rótulo que conecta un lugar en la memoria de la computadora cuyos bytes se usan para codificar el valor de ese entero. Sin embargo, en *Python* un entero es un objeto más complejo que contiene más información que simplemente el valor del número. Esto da flexibilidad a *Python*, pero el costo es que es más lento que un lenguaje como _C_. Este costo es aún mayor cuando combinamos muchos de estos objetos en un objeto más complejo, por ejemplo cuando combinamos enteros dentro de una lista en *Python*.\n",
    "\n",
    "Otra ventaja de los arreglos de *NumPy* es que se comportan de forma similar a los vectores y matrices usados en matemáticas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creando arreglos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen varias rutinas para crear arreglos de *NumPy* a partir de:\n",
    "\n",
    "* Listas o tuplas de *Python*.\n",
    "* Rangos numéricos.\n",
    "* Números aletorios.\n",
    "* Ceros y unos.\n",
    "* Archivos.\n",
    "\n",
    "### A partir de listas y tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([1, 2, 3, 4 , 5, 6])\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El atributo *`shape`* de los objetos *array* retorna la *forma* de los arreglos; esto es el número de dimensiones y número de elementos del *array* en forma de tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((6,), (3, 3))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape, M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A partir de un rango numérico:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una forma de crear arreglos en *NumPy* desde cero es usando *rangos*. Por ejemplo podemos crear un arreglo conteniendo números igualmente espaciados en el intervalo \\[desde, hasta) usando la función *`arange`*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 10, 2) # desde, hasta(sin incluir), paso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra función para crear rangos es *`linspace`* que devuelve números igualmente espaciados en el intervalo \\[*desde*, *hasta*, *elementos*\\] (es decir incluyendo el *hasta*). Otra diferencia de la función *`linspace`* con *`arange`* es que no se especifica el paso sino la **cantidad total** de números que contendrá el arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1, 10, 5) # desde, hasta, elementos (elementos es opcional)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A partir de números aleatorios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los números aleatorios son usados en muchos problemas científicos. En la práctica las computadoras son capaces solo de generar números *pseudo-aleatorios*; es decir, números que para los fines prácticos *lucen* como números aleatorios.\n",
    "\n",
    "Todas las rutinas para generar números aleatorios viven dentro del módulo *`random`* de *NumPy*. *Python* usa un algortimo llamado [Mersenne Twister](https://en.wikipedia.org/wiki/Mersenne_twister) para generar números pseudo-aleatorios. Este algorítmo es más que suficiente para fines científicos, pero no es útil en el caso que necesitemos números pseudo-aleatorios para usar en *criptografía*.\n",
    "\n",
    "La función mas simple es *`rand`*. Esta función crea un arreglo a partir de una distribución *uniforme* en el intervalo \\[0, 1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.88430927, 0.66596504, 0.99994173, 0.00851365, 0.42786303],\n",
       "       [0.77066912, 0.94805841, 0.78589416, 0.05079134, 0.33327622]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(2, 5)  # arreglo con forma (2, 5)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De forma similar, la función *`randn`* devuelve muestras a partir de la *distribución normal estándar* (media = 0, desviación estándard = 1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.21395335, -1.22334684, -0.94820782,  0.25780658,  0.08921266,\n",
       "        0.12758925, -0.1340775 ,  0.2204907 , -0.61880076, -0.04563472])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(10) # Muestra de 10 elementos de la distribución normal estándar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Más general, la función *`normal`* devuelve una muestra de una *distribución normal* dada una media, una desviación estándar y el tamaño de la muestra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7.99089627, 8.0757311 , 5.37896247, 7.64813094, 3.78056672])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "media   = 5\n",
    "desv    = 2\n",
    "muestra = 5\n",
    "np.random.normal(media, desv, muestra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A partir de ceros y unos:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones *`zeros`* y *`ones`* retornan arreglos de *ceros* y *unos* dados el número de elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5) # Arreglo de 5 elementos cero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(7) # Arreglo de 7 elementos uno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(shape = (2, 3)) # Arreglo de ceros especificando el shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(shape = (3, 3)) # Arreglo de unos especificando el shape."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexado y rebanado de arreglos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los arreglos de *NumPy*, al igual que las listas se pueden *indexar* y se pueden tomar rebanadas (slices). La sintaxis es una generalización de la usada para las listas de *Python*. Una de las diferencias es que podemos indexar de acuerdo a las distintas dimensiones de un arreglo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0]  # El primer elemento de M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0, 1] # El primer elemento de M y obtenemos el segundo elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0][1] # Forma alternativa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1:]  # A partir de la fila 1, todo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:]  # Fila 1, todas las columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]    # Forma equivalente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 8])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:, 1] # Todas las dilas de la columna 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [5, 6],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:, 1:]  # Todas las columnas a partir de la columna 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 8, 9],\n",
       "       [4, 5, 6],\n",
       "       [1, 2, 3]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[::-1]  # Los elementos de M en reversa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es importante acotar que al tomar *rebanadas* (*slices*) *NumPy* NO genera un nuevo arreglo; sino una **vista** (*view*) del arreglo original. Por lo tanto, si a una rebanada le asignamos un número, se lo estaremos asignando al arreglo original, como se puede ver en el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0, 0] = 0\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para crear copias se puede usar la función *`np.copy()`* o el método *`.copy()`* de los objetos *`array`*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones Universales (Ufunc)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*NumPy* provee de varias funciones matemáticas. Esto puede parecer redundante ya que la librería estandard de *Python* ya provee de este tipo de funciones. La **diferencia**, es que la funciones matemáticas de *NumPy* (como otras funciones) pueden ser aplicadas en **un solo paso** a todos los elementos de un arreglo.\n",
    "\n",
    "Por ejemplo, si quisieramos calcular la raíz cuadrada de todos los elementos de una lista de *Python* deberíamos hacer un loop sobre cada elementos de la lista y computar la raíz cuadrada a cada elemento (y posiblemente almacenarlo en otra lista). Con *NumPy* podemos hacer esto mismo en una sola linea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 1.41421356, 1.73205081],\n",
       "       [2.        , 2.23606798, 2.44948974],\n",
       "       [2.64575131, 2.82842712, 3.        ]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciones como *`sqrt`*, que operan sobre arreglos *elemento-a-elemento* se conocen como [***funciones universales***](http://docs.scipy.org/doc/numpy/reference/ufuncs.html) (usualmente abreviadas como *ufunc*).\n",
    "\n",
    "Una de las ventajas de usar *ufuncs* es que permiten escribir código más breve. Otra ventaja es que los cómputos son más rápidos que usando loops de *Python*. Detrás de escena *NumPy* sí realiza un loop, pero este se ejecuta en lenguaje _C_ o *Fortran*, por lo que hay una ganancia considerable en velocidad en comparación con el código en *Python* puro. Además, el código usado por *NumPy* es código que suele estar optimizado gracias a los años de labor de programadores y científicos.\n",
    "\n",
    "Esta forma de omitir loops y escribir operaciones sobre vectores se llama *vectorización*.\n",
    "\n",
    "Veamos otro ejemplo, como sumar todos los elementos de un arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "44"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior la suma se hizo sobre el arreglo \"aplanado\". Hay veces que esto no es lo que queremos, si no que necesitamos sumar sobre alguna de las dimensiones del arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 15, 18])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(M, axis = 0) # Sumariza por columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, 15, 24])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(M, axis = 1) # Sumariza por filas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro elemento que facilita vectorizar código es la capacidad de operar sobre arreglos que no tienen las mismas dimensiones. Esto se llama *broadcasting* y no es más que un conjunto de reglas que permiten aplicar operaciones binarias (suma, multiplicación etc.) a arreglos de distinto tamaño.\n",
    "\n",
    "Consideremos el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "b = np.array([2, 2, 2])\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto no es nada sorprendente, lo que hemos hecho es sumar elemento-a-elemento. Fíjese que el arreglo `b` contiene 3 veces el número 2. Gracias al *broadcasting* es posible obtener el mismo resultado al hacer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto no sólo funciona para arreglos y números, también funciona para dos arreglos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En ambos casos lo que está sucediendo es como si antes de realizar la suma extendieramos una de las partes para que las dimensiones conincidan, por ejemplo repetir 3 veces el número 2 o tres veces el vector b. En realidad tal repetición no se realiza, pero es una forma útil de pensar la operación.\n",
    "\n",
    "Es claro que el *broadcasting* NO puede funcionar para cualquier par de arreglos. La siguiente operación funciona:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1:, :] + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mientras que la siguiente dará un error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,3) (2,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-59-3159866ce791>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,3) (2,) "
     ]
    }
   ],
   "source": [
    "M + b[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El error es claro, *NumPy* no sabe cómo hacer para encajar las dimensiones de estos dos arreglos. Más detalles sobre broadcasting [aquí](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparaciones y máscaras de booleanos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así como es posible sumar un número a un arreglo, también es posible hacer comparaciones *elemento-a-elemento*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M > 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es muy común usar el resultado de tal comparación para obtener valores de un arreglo que cumplan con cierto criterio, como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[M > 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O incluso combinando arreglos, como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 8, 9]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[a == 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Medidas de centralidad y dispersión."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*NumPy* nos permite calcular la media, la mediana y la varianza a partir de arrays de forma muy simple. Por ejemplo para calcular la media podemos usar la función np.mean():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una forma alternativa es usar el método *`.mean()`* de un objeto *array*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones y métodos *`var`* y *`std`* calculan la *varianza* y la *desviación* de un *array*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9166666666666665"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(v) # Varianza de los elementos de v."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9166666666666665"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.var()   # Forma alternativa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.707825127659933"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(v) # Desviación estándar de v."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.707825127659933"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.std()   # Forma alternativa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen otras medidas para caracterizar los datos, llamadas de forma, como son la [*curtosis*](https://es.wikipedia.org/wiki/Curtosis) y el [*sesgo*](https://es.wikipedia.org/wiki/Sesgo_estadístico) (o asimetría estadística).\n",
    "\n",
    "Estás medidas son menos usadas en parte porque su interpretación es menos intuitiva que otras medidas, como la media o la varianza, al punto que la interpretación correcta de estas medidas ha sido objeto de varias discusiones y malos entendidos a los largo de los años. Otra razón para su menor uso es que históricamente gran parte de la estadística se ha basado en el uso de Gausianas (o en asumir que los datos son Gaussianos) para las cuales la curtosis y el sesgo son cero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cuantil."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los *cuantiles* son puntos de corte que dividen al conjunto de datos en grupos de igual tamaño. Existen varios nombres para los cuantiles según la cantidad de divisiones que nos interesen.\n",
    "\n",
    "* Los *cuartiles* son los tres puntos que dividen a la distribución en 4 partes iguales, se corresponden con los cuantiles 0.25, 0.50 y 0.75.\n",
    "* Los *quintiles* dividen a la distribución en cinco partes (corresponden a los cuantiles 0.20, 0.40, 0.60 y 0.80);\n",
    "* Los deciles, que dividen a la distribución en diez partes.\n",
    "* Los percentiles, que dividen a la distribución en cien partes.\n",
    "* La mediana es el percentil 50 o el cuartil 0.5.\n",
    "\n",
    "En *Python* el cálculo de estos estadísticos puede realizarse fácilmente usando funciones predefinidas en *NumPy*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.20943292, 0.43685458, 0.70860723])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.rand(100)\n",
    "np.percentile(x , [25, 50, 75])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Z-score."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El *Z-score* es una cantidad adimensional que expresa el número de desviaciones estándar que un dato está por encima o por debajo de la media. Si el *Z-score* es positivo el dato está por encima de la media, y cuando es negativo está por debajo de la media. Se calcula como:\n",
    "\n",
    "$$z = \\frac{x - \\mu}{\\sigma}$$\n",
    "\n",
    "Donde:\n",
    "\n",
    "$\\mu$ es la media de la población y $\\sigma$ es la desviación estándar de la población.\n",
    "\n",
    "El proceso de restar la media y dividir por la desviación estándar se llama *normalización* o *estandarización*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Error estándar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El *error estándar* es la desviación estándar de alguna medida estimada, por lo general la media (aunque podría ser cualquier otra cantidad).\n",
    "\n",
    "Si tomamos un conjunto de datos y calculamos la media de esos datos y luego tomamos otra muestra y calculamos la media y luego otra y otra, obtendremos que los valores de la media no son siempre los mismos. Si tomamos todas esas medias obtendremos una distribución de medias con una media y desviación estándar, esa desviación estándar será el error estándar de la media. El *error estándar de la media* se suele estimar como:\n",
    "\n",
    "$$\\frac{\\sigma}{\\sqrt{n}}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Donde $\\sigma$ es la desviación estándar de los datos y $n$ es la cantidad de datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La medidas de centralidad y dispersión antes mencionadas son útiles porque resumen en pocos números una gran cantidad de datos. Sin embargo, al sintetizar la información, también pueden ocultarla. Es por ello que siempre es buena idea visualizar la distribución de los datos. En el notebook de [**Matplotlib**](03_matplotlib.ipynb) veremos cómo usar *Python* para graficar y visualizar datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones básicas de Álgebra Lineal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*NumPy* tiene diversas funciones para el cálculo de Álgebra Lineal, agrupadas mayormente en el submódulo *`numpy.linalg`*. A continuación presentamos algunas de las funciones principales del Álgebra Lineal de *NumPy*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(a, b) # Producto escalar de los vectores a y b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a@b # Forma alternativa del producto escalar de los vectores a y b con el operador @."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I = np.identity(3) # Retorna la matriz identidad de 3x3.\n",
    "I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 2., 3.],\n",
       "       [4., 5., 6.],\n",
       "       [7., 8., 9.]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(M, I) # Multiplicación de las matrices M e I."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 2., 3.],\n",
       "       [4., 5., 6.],\n",
       "       [7., 8., 9.]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M@I # Forma alternativa de la multiplicación de las matrices M e I con el operador @."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 4, 7],\n",
       "       [2, 5, 8],\n",
       "       [3, 6, 9]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.T # Matriz transpuesta de M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 5, 9])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diagonal(M) # Retorna la diagonal de la matriz M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 6])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diagonal(M, 1) # Retorna la primera diagonal de M (encima de la diagonal principal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(M) # Retorna la suma de los elementos de la diagonal de M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(M) # Retorna el índice del mayor elemento en M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmin(M, axis = 0) # Retorna los índices de los menores elementos por columna. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.000000000000001"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(M) # Retorna el determinante de M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.        ,  2.        , -1.        ],\n",
       "       [ 2.        , -7.        ,  4.        ],\n",
       "       [-1.        ,  4.66666667, -2.66666667]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(M) # Retorna la matriz inversa de M."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.01506105e-15, -2.00000000e+00,  2.00000000e+00])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.solve(M, b) # Resuelve el sistema lineal de ecuaciones Mx = b."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias adicionales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver operaciones adicionales de *NumPy* podemos consultar los siguientes repositorios:\n",
    "* [Numpy Operations.](https://github.com/tirthajyoti/Machine-Learning-with-Python/blob/master/Pandas%20and%20Numpy/Numpy_operations.ipynb)\n",
    "* [Numpy and Pandas quick basics](https://github.com/tirthajyoti/Machine-Learning-with-Python/blob/master/Pandas%20and%20Numpy/Numpy_Pandas_Quick.ipynb)\n",
    "* [Tools Numpy.](https://github.com/ageron/handson-ml2/blob/master/tools_numpy.ipynb)"
   ]
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}