8-9-10 - Qué es y cómo se utiliza Numpy-Arrays en Numpy-Operaciones aritméticas en Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Curso de Machine Learning Aplicado con Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Machine-Learning](assets/Machine-Learning.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qué es y cómo se utiliza Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![numpycheatsheet](assets/numpycheatsheet.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Datos importantes:\n",
    "\n",
    "* Numpy es una librería muy importante para el ecosistema de Python ya que es la base de todos los cálculos científicos y muchas de las librerías de Machine Learning.\n",
    "* Scikit-Learn con sus modelos, cuando retorna un resultado, en general lo retorna en un formato Numpy.\n",
    "* La API de Numpy tiene muchas similitudes con Pandas.\n",
    "* Numpy reemplaza de forma más eficiente lo que podría ser un tipo lista. En las listas podemos tener conjuntos de elementos numéricos. Sin embargo las listas no logran manejar datos de dos dimensiones.\n",
    "* Las listas no poseen métodos que son prácticos para hacer aritmética.\n",
    "* Es importante saber que otros lenguajes de programación poseen librerías altamente optimizadas para hacer cálculos numéricos con vectores de datos. Numpy es esa librería para el lenguaje de programación de Python.\n",
    "* np.linspace es una función que permite crear un array de una dimensión de números entre 0 y 1.\n",
    "* Los array a diferencia de otros objetos en Python están fuertemente tipificados. Esta tipificación fuerte es necesaria porque es una de las cosas que permite que esta librería sea más rápida que ocupar listas, por ejemplo.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Porque Numpy?\n",
    "\n",
    "* `list` no tiene buen manejo para los indices cuando se trabaja con listas de datos de más de dos dimensiones.\n",
    "* `list` no posee metodos de algebra lineal, ni de transformaciones de datos.\n",
    "* En otros lenguajes encontramos estructuras de datos altamente optimizadas para poder hacer operaciones algebraicas sobre arrays.\n",
    "\n",
    "###### Por sobre Numpy se erige todo un ecosistema de librerias muy utiles que iremos viendo en el recorrido de este curso.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crear Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La version de numpy es 1.13.1\n"
     ]
    }
   ],
   "source": [
    "#Importar la librería\n",
    "import numpy as np\n",
    "print(\"La version de numpy es {}\".format(np.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Como crear arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = np.array([1,2,3])                 # con una lista\n",
    "type(a1)\n",
    "# Le entregamos una lista y el nos retorna un numpyarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "a2 = np.arange(10)       \n",
    "print(type(a2))\n",
    "print(a2)\n",
    "# np.arange es un metodo similar al range del tipo lista2 = np.arange(10)\n",
    "# np.arange es un metodo similar al range del tipo list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a3 =  np.zeros((2,3))   \n",
    "# crear un lista de dos dimensiones, pre-rellenada con zeros\n",
    "a4 =  np.ones((2,3))    \n",
    "# crear un lista de dos dimensiones, pre-rellenada con unos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array de ceros\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array de unos\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import display\n",
    "print(\"array de ceros\")\n",
    "display(a3);\n",
    "print(\"array de unos\")\n",
    "display(a4)\n",
    "# De esta forma tambien podemos ver que tipo de objeto es"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`np.linspace(a,b,n)` es una función que permite crear arrays de una dimensión, de largo n, y que contienen puntos entre a y b, distanciados de forma regular. La distancia entre cada punto sera de $(b−a)/(n−1).$ **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "linspace\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a5 = np.linspace(0,1,11)\n",
    "print(\"linspace\")\n",
    "display(a5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dtypes\n",
    "a5.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dimensión de un Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1.shape \n",
    "# Con esto podemos saber las dimensiones de nuestro array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(a3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a1D = np.array([1,2,3])\n",
    "a2D = np.array([[1,2,3]])\n",
    "display(a1D.shape)\n",
    "display(a2D.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Son los dos arrays iguales?\n",
    "np.array_equal(a1D,a2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Redimensionando(Reshaping) para que sean iguales\n",
    "new_dims = (1,a1D.shape[0])\n",
    "a = a1D.reshape(new_dims)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_equal(a,a2D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Acceso a elementos y Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  0,  3],\n",
       "       [ 4,  3,  5],\n",
       "       [ 6, 10, -1]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1,0,3],[4,3,5],[6,10,-1]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2,1]\n",
    "# Mirando que contiene en esa posicion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a un elemento de un array de dimensión n, la síntaxis es \n",
    "\n",
    "**array[i1,i2,i3,...iN].**\n",
    "\n",
    "En este curso y frecuentemente en ML trabajaremos con arrays de dimensión 1 o dimensión 2, por lo que:\n",
    "\n",
    "* Para un array de 1D: **a[index]**\n",
    "\n",
    "* Para un array de 2D: **a[index1,index2]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  0.,  1.]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "b = np.eye(3)\n",
    "display(a);display(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:5]\n",
    "#Los 5 primeros elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  0.,  1.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  1.])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0:3,2] \n",
    "#Extraemos toda la segunda columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  1.])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[2,0:3]\n",
    "#Extraemos la tercera fila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  0.,  1.]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[:,:]\n",
    "# No entrega todo el array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones sobre arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a      \t=\t [0 1 2 3]\n",
      "a + 5  \t=\t [5 6 7 8]\n",
      "a - 5  \t=\t [-5 -4 -3 -2]\n",
      "a * 2  \t=\t [0 2 4 6]\n",
      "a / 2  \t=\t [ 0.   0.5  1.   1.5]\n",
      "a // 2 \t=\t [0 0 1 1]\n",
      "-a     \t=\t [ 0 -1 -2 -3]\n",
      "a ** 2 \t=\t [0 1 4 9]\n",
      "a % 2  \t=\t [0 1 0 1]\n"
     ]
    }
   ],
   "source": [
    "# Aritmetica\n",
    "a = np.arange(4)\n",
    "\n",
    "print(\"a      \\t=\\t\", a)\n",
    "print(\"a + 5  \\t=\\t\", a + 5)  #suma a cada elemento 5\n",
    "print(\"a - 5  \\t=\\t\", a - 5)  #resta a cada elemento 5\n",
    "print(\"a * 2  \\t=\\t\", a * 2)  #multiplica a cada elemento 2\n",
    "print(\"a / 2  \\t=\\t\", a / 2)  #divide a cada elemento 2 con punto flotante\n",
    "print(\"a // 2 \\t=\\t\", a // 2) #divide a cada elemento 2 sin punto flotante\n",
    "print(\"-a     \\t=\\t\", -a)     #volver negativo el vector \n",
    "print(\"a ** 2 \\t=\\t\", a ** 2) #Exponer cada elemento, elevarlo a 2\n",
    "print(\"a % 2  \\t=\\t\", a % 2)  #Si es par o impar con modulo,(0=par,1=impar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones con respecto a otro vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2 4 6]\n",
      "[0 1 4 9]\n"
     ]
    }
   ],
   "source": [
    "print(a+a) #suma el vector con el mismo\n",
    "print(a*a) #multiplica el vector con el mismo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operator | ufunc | \n",
    ":---: | :--- |\n",
    "`+` | *np.add*\n",
    "`-` | *np.subtract*\n",
    "`*` | *np.multiply*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.        ,   2.71828183,   7.3890561 ,  20.08553692])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.69314718,  1.09861229,  1.38629436])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  1.        ,  1.41421356,  1.73205081])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False], dtype=bool)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Otras ufuncs interesantes\n",
    "a = np.arange(4)\n",
    "b = np.arange(1,5)\n",
    "\n",
    "display(np.exp(a))         # exponencial\n",
    "display(np.log(b))         # logaritmo natural\n",
    "display(np.sqrt(a))        # raiz cuadrada\n",
    "display(np.greater(a,b))   # superior o igual punto a punto item contra item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rendimiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Las ufuncs corren a velocidad de código compilado C.\n",
    "De poder utilizarse se deberían preferir a el uso de for loops.\n",
    "Un código Numpy solo con funciones nativas, sin bucles, se le llama código \"vectorizado\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "253 ms ± 3.21 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "a = np.arange(1000000)\n",
    "b = np.zeros(1000000)\n",
    "i = 0\n",
    "for el in a:\n",
    "    b[i] = el+el\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.29 ms ± 40.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "a = np.arange(1000000)\n",
    "a+a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Con esto hemos medido el perfomance de un for loop contra las funciones compiladas en c de numpy y mientras en el for gasta 3.21 milisegundos por loop en numpy gasta 40.3 microsegundos por loop ¡Algo absolutamente abrumador!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estadística y aleatoridad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Estadística\n",
    "a = np.arange(10)\n",
    "\n",
    "display(np.mean(a))           # promedio\n",
    "display(np.median(a))         # mediana    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6000000000000001"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "np.percentile(a,40)                  # percentil\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.29060088,  0.26802952,  0.09905195,  0.21687608,  0.01838974,\n",
       "        0.70813897,  0.72302612,  0.82054207,  0.72057702,  0.54433689])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random(10) # Aleatoridad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}