2019_08_24_wild_matrix/matrices_en_la_vida_real.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-GGf1wqnCSSO",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Wild Matrix\n",
    "## Matrices en la vida real\n",
    "\n",
    "**Sebastian Flores**\n",
    "\n",
    "Chief Data Officer | u-planner\n",
    "\n",
    "<img src=\"images/uplanner.png\" alt=\"\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta charla está disponible en github.com/sebastiandres/charlas para libre descarga.\n",
    "\n",
    "Puede verse en línea:\n",
    "\n",
    "* De manera interactiva con binder: [https://bit.ly/2Ub89mU](https://mybinder.org/v2/gh/sebastiandres/charlas/master?filepath=2019_08_24_wild_matrix/matrices_en_la_vida_real.ipynb)\n",
    "\n",
    "* De manera estática en el mismo github: [https://bit.ly/33WmSa2](https://bit.ly/33WmSa2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Data Science?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data science es una ciencia interdisciplinaria, que se apoya en conocimientos de Matemática, Estadística, Informática, entre otros. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Es como ciencia forense, pero en lugar de cadáveres, se investigan datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Es como Jurassic Park, donde se tiene parte del ADN de cada dinosaurio, y para poder completar la información se utilizó otro ADN compatible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Data Science?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"images/jurassic_park.jpg\" alt=\"\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L1gghpmbCSVM",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Algo que aprendí muy tarde\n",
    "\n",
    "Las matrices representan combinaciones lineales. \n",
    "\n",
    "Nada más que eso. \n",
    "\n",
    "Pero eso es **suficientemente** poderoso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Crtx6OD4CSXx",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Combinación lineal de filas\n",
    "Multiplicar un vector por una matriz permite obtener una combinación lineal de las distintas filas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Seleccionar la primera fila\n",
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  1 & 0\n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  a & b\\\\\n",
    "  c & d \n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  a & b \n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Seleccionar la segunda fila\n",
    "\n",
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1\n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  a & b\\\\\n",
    "  c & d \n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  c & d \n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Combinación lineal de filas\n",
    "Multiplicar un vector por una matriz permite obtener una combinación lineal de las distintas filas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Mezclar ambas filas\n",
    "\n",
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  \\alpha & \\beta\n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  a & b\\\\\n",
    "  c & d \n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  \\alpha a + \\beta c & \\alpha b + \\beta d\n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\alpha \\left( \\begin{matrix} \n",
    "   a & b\n",
    "\\end{matrix} \\right) \n",
    "+ \n",
    "\\beta \\left( \\begin{matrix} \n",
    "   c & d\n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Combinación lineal de columnas\n",
    "Multiplicar una matriz por un vector columna (por la derecha) permite obtener una combinación lineal de las columnas de la matriz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Seleccionar la primera columna\n",
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  a & b\\\\\n",
    "  c & d \n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  1 \\\\ 0\n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  a \\\\ c \n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cDUfq9GJKMbt",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Seleccionar la segunda columna\n",
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  a & b\\\\\n",
    "  c & d \n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  0 \\\\ 1\n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  b \\\\ d \n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Combinación lineal de columnas\n",
    "Multiplicar una matriz por un vector columna (por la derecha) permite obtener una combinación lineal de las columnas de la matriz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Combinación de columnas\n",
    "\n",
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  a & b\\\\\n",
    "  c & d \n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  \\alpha \\\\ \\beta\n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  \\alpha a + \\beta b \\\\ \\alpha c + \\beta d\n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\alpha \\left( \\begin{matrix} \n",
    "   a \\\\ c\n",
    "\\end{matrix} \\right) \n",
    "+ \n",
    "\\beta \\left( \\begin{matrix} \n",
    "   b \\\\ d\n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Porqué aprender Algebra Lineal?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Sólo podemos resolver problemas lineales. \n",
    "\n",
    "Todo lo demás es reducir el problema a algo que se parezca o se aproxime a un problema lineal.\n",
    "\n",
    "Desde lo más \"clásico\" (sistemas de ecuaciones, ecuaciones diferenciales ordinarias, ecuaciones diferenciales parciales, etc.) hasta lo más moderno (inteligencia artificial y Machine Learning): **todo depende de matrices y vectores de datos, cada vez de mayor tamaño.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Cómo aprender Algebra Lineal?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"images/saint_curious_george.png\" alt=\"\" align=\"middle\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z_cLNFXnKMhG",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Matrices en u-exam\n",
    "\n",
    "El producto u-exam busca asignar de manera eficiente y sin conflictos las evaluaciones de los estudiantes. Cada estudiante toma varias  asignaturas, y se necesita que en una única semana se agenden las evaluaciones para cada asignatura:\n",
    "* Todos los estudiantes deben tener asignadas todas sus evaluaciones, que deben tener asignado un día, hora, sala y supervisor.\n",
    "* Las evaluaciones de cada estudiante deben repartirse en la semana, y sobre todo, no pueden ocurrir al mismo tiempo. * Para cada asignatura, la evaluación debe quedar en una único día y hora, para todos los estudiantes y en todos los campus, simultáneamente.\n",
    "* Los estudiantes de una misma sección, deben mantenerse reunidos en la evaluación y deben asignarse a una sala disponible de tamaño y características apropiadas.\n",
    "* El día y hora asignado a las evaluaciones deben ser compatibles con la disponibilidad de los supervisores de la evaluación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | notación\n",
    "**Importante:** \n",
    "Una parte crucial del modelamiento de un problema es utilizar una notación apropiada. \n",
    "\n",
    "En nuestro caso hablaremos de:\n",
    "* Estudiantes o alumnos.\n",
    "* Cursos, ramos, materias o asignaturas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | notación\n",
    "\n",
    "- Usar como notación $N_{estudiantes}$ y $N_{asignaturas}$ para los conteos de estudiantes y asignaturas se hará demasiado largo en las fórmulas y sumatorias, aunque haría más legible el código numérico."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Usar la notación $N_e$ y $N_a$ es ambigua, porque la letra \"a\" se usa para alumno y asignatura."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Una convención neutra es utilizar $N_e$ y $N_c$ que es directa de interpretar (ramos/materias no se entiende en otros países)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eWKyW_EuKMjr",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | notación\n",
    "Definamos la matriz $E$ (del inglés \"enrollments\") de dimensiones $N_e$ estudiantes y $N_c$ asignaturas, donde:\n",
    "* El elemento $E_{i,j}$ tiene el valor 1 si el estudiante $i$ está tomando la asignatura $j$.\n",
    "* El elemento $E_{i,j}$ tiene el valor 0 si el estudiante $i$ NO está tomando la asignatura $j$.\n",
    "\n",
    "¿Cuántas filas hay? ¿Cuántas columnas hay?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zWfUmoNmNvQ9",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Por ejemplo, consideremos los siguientes asignaturas:\n",
    "* CORE102: CIVILIZACIÓN CONTEMPORÁNEA II\n",
    "* MAT106: CÁLCULO INTEGRAL\n",
    "* MAT113: ÁLGEBRA LINEAL\n",
    "* FIS101: FÍSICA I\n",
    "* TEI101: TALLER EL ARTE DE LA INGENIERÍA\n",
    "* LID101: LIDERAZGO I\n",
    "* GYM102: EDUCACIÓN FÍSICA II\n",
    "\n",
    "Y consideremos los siguiente alumnos:\n",
    "* Tony Stark\n",
    "* Thor Odinson\n",
    "* Henry Pym\n",
    "* Janet van Dyne\n",
    "* Bruce Banner\n",
    "\n",
    "¿Cuánto vale $N_e$? ¿Cuánto vale $N_c$?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$N_e=5$ estudiantes y $N_c=7$ asignaturas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Supongamos que toman los siguientes cursos:\n",
    "* Tony Stark: MAT106, MAT113, FIS101, LID101\n",
    "* Thor Odinson: CORE102, TE101, LID101, GYM102\n",
    "* Henry Pym: CORE102, MAT106, MAT113, FIS101, TE101, LID101, GYM102\n",
    "* Janet van Dyne: CORE102, MAT106, MAT113, FIS101, TE101, LID101, GYM102\n",
    "* Bruce Banner: CORE102, MAT106, MAT113, FIS101, TE101\n",
    "\n",
    "¿Cómo quedaría la matriz?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "w7dMHhwuNvTD",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "¡Depende de cómo ordenemos los estudiantes y los cursos!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Consideremos el siguiente orden\n",
    "\n",
    "CORE102, MAT106, MAT113, FIS101, TE101, LID101, GYM102:\n",
    "\n",
    "* Tony Stark: \n",
    "    (MAT106, MAT113, FIS101, LID101) -> (0,1,1,1,0,1,0)\n",
    "* Thor Odinson: \n",
    "    (CORE102, TE101, LID101, GYM102) -> (1,0,0,0,1,1,1)\n",
    "* Henry Pym: \n",
    "    (CORE102, MAT106, MAT113, FIS101, TE101, LID101, GYM102) -> (1,1,1,1,1,1,1)\n",
    "* Janet van Dyne: \n",
    "    (CORE102, MAT106, MAT113, FIS101, TE101, LID101, GYM102) -> (1,1,1,1,1,1,1)\n",
    "* Bruce Banner: \n",
    "    (CORE102, MAT106, MAT113, FIS101, TE101) -> (1,1,1,1,1,0,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Obtenemos entonces la siguiente matriz:\n",
    "$$ E = \n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_vKAY0YVU1ZB",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "¿Cómo contar la cantidad de inscripciones por estudiante? \n",
    "\n",
    "¿Cantidad de inscripciones por asignatura? \n",
    "\n",
    "¿Cantidad de inscripciones totales?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam: contando inscripciones por estudiante\n",
    "Para contar las inscripciones por estudiante, necesitamos sumar los elementos de cada fila. Eso es equivalente a ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "¡una multiplicación con un vector por la derecha!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$$ E = \n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  4 \\\\\n",
    "  4 \\\\\n",
    "  7 \\\\\n",
    "  7 \\\\\n",
    "  5 \n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam: contando los estudiantes por curso\n",
    "Para contar la cantidad de estudiante por curso, necesitamos sumar los elementos de cada columna. Eso es equivalente a ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "¡una multiplicación con un vector fila por la izquierda!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$$ E = \n",
    "\\left( \\begin{matrix} \n",
    "  1 &\n",
    "  1 &\n",
    "  1 &\n",
    "  1 &\n",
    "  1 \n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  3 \n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam: contando las inscripciones totales\n",
    "¿Cómo podríamos contar el total de inscripciones?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  1 &\n",
    "  1 &\n",
    "  1 &\n",
    "  1 &\n",
    "  1 \n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  4 &\n",
    "  3 \n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "27\n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam: contando las inscripciones totales\n",
    "\n",
    "Matemáticamente, lo anterior se obtiene por lo siguiente:\n",
    "\n",
    "$$E_{sum} = \\sum_{i=1}^{N_e} \\sum_{j=1}^{N_c} E_{ij} = \\sum_{i=1}^{N_c} 1 \\sum_{j=1}^{N_c} E_{ij} 1$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam: contando los créditos por estudiante\n",
    "¿Cómo podríamos la cantidad de créditos que tomó cada estudiante?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Para contar los créditos por estudiante, necesitamos ponderar los elementos de cada fila. Eso es equivalente a una multiplicación por un vector columna por la derecha."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$$ E = \n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "\\left( \\begin{matrix} \n",
    "  3 \\\\\n",
    "  3 \\\\\n",
    "  3 \\\\\n",
    "  3 \\\\\n",
    "  1 \\\\\n",
    "  1 \\\\\n",
    "  1 \n",
    "\\end{matrix} \\right) \n",
    "= \n",
    "\\left( \\begin{matrix} \n",
    "  10 \\\\\n",
    "  6  \\\\\n",
    "  15 \\\\\n",
    "  15 \\\\\n",
    "  13 \n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Bp0ndP4vNvYg",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¿Qué representa $E^T \\cdot E$?\n",
    "* ¿Cuáles son sus dimensiones?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Como $E$ tiene $N_e$ filas y $N_c$ columnas, $E^T \\cdot E$ debe tener $N_c$ filas y $N_c$ columnas. \n",
    "\n",
    "De alguna manera, esta matriz está relacionando cursos con cursos. Pero ¿cómo?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¿Qué representa $E^T \\cdot E$?\n",
    "* ¿Cómo podemos interpretar $E^T \\cdot E$?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Definamos la matriz $A = E^T \\cdot E$\n",
    "\n",
    "El elemento $A_{i,j}$ está definido como $$A_{i,j} = \\sum_{k=1}^{N_e} (E^T)_{i,k} (E)_{k,j}$$\n",
    "\n",
    "¿Alguna idea?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¿Qué representa $E^T \\cdot E$?\n",
    "$$A_{i,j} = \\sum_{k=1}^{N_e} (E^T)_{i,k} (E)_{k,j} = \\sum_{k=1}^{N_e} E_{k,i} E_{k,j}$$\n",
    "\n",
    "Recordemos que $E_{k,j}$ toma únicamente los valores $0$ y $1$, y por lo tanto, $E_{k,i} E_{k,j}$ sólo es igual a $1$ cuando ambos términos son iguales a $1$, es decir, si el estudiante $k$ está en ambos cursos.\n",
    "\n",
    "La suma sobre todos los elementos de $k$ representa entonces que para cursos $i$ y $j$ fijos, estamos tomando todos los estudiantes y contando (sumando) sólo aquellos que están simultáneamente en $i$ y $j$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "¡La suma anterior dará el total de estudiantes que existen en común entre el curso $i$ y el curso $j$!\n",
    "\n",
    "**Observación**: Lo anterior funciona porque $E$ toma los valores 0 y 1. \n",
    "\n",
    "Si $E_{kj}$ fueran las horas que invierte el estudiante $k$ en el curso $j$, entonces la interpretación no sería correcta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¿Qué representa $E^T \\cdot E$?\n",
    "$$\n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right)^T\n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "=\n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 1 \\\\\n",
    "  1 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 0 & 1 & 1 & 1 \\\\\n",
    "  0 & 1 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 0 \\\\\n",
    "  0 & 1 & 1 & 1 & 0 \n",
    "\\end{matrix} \\right)\n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "=\n",
    "$$\n",
    "$$\n",
    "=\n",
    "\\left( \\begin{matrix} \n",
    "  4 & 3 & 3 & 3 & 4 & 3 & 3 \\\\\n",
    "  3 & 4 & 4 & 4 & 3 & 3 & 2 \\\\\n",
    "  3 & 4 & 4 & 4 & 3 & 3 & 2 \\\\\n",
    "  3 & 4 & 4 & 4 & 3 & 3 & 2 \\\\\n",
    "  4 & 3 & 3 & 3 & 4 & 3 & 3 \\\\\n",
    "  3 & 3 & 3 & 3 & 3 & 4 & 3 \\\\\n",
    "  3 & 2 & 2 & 2 & 3 & 3 & 3\n",
    "\\end{matrix} \\right) \n",
    "$$\n",
    "\n",
    "Por supuesto, la matriz es simétrica.\n",
    "Esta matiz se llama \"matriz de clashing\" o \"matriz de conflicto\" y permite conocer que asignaturas no pueden programarse a la misma hora (y cuales sí pueden programarse de manera simultánea)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Recordemos que la matriz era la siguiente:\n",
    "$$ E = \n",
    "\\left( \\begin{matrix} \n",
    "  0 & 1 & 1 & 1 & 0 & 1 & 0 \\\\\n",
    "  1 & 0 & 0 & 0 & 1 & 1 & 1 \\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 1 & 1\\\\\n",
    "  1 & 1 & 1 & 1 & 1 & 0 & 0\n",
    "\\end{matrix} \\right) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-FcFvlKOQScA",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Qué representa $E \\cdot E^T$?\n",
    "* ¿Dimensiones?\n",
    "* ¿Interpretación?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "De manera completamente análoga, $E \\cdot E^T$ posee dimensiones $N_e$ filas y $N_e$ columnas, y su elemento $i,j$ representa la cantidad de cursos que el estudiante $i$ tiene en común con el estudiante $j$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Cómo hacer esto en el computador?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "E = np.matrix([ [0 , 1 , 1 , 1 , 0 , 1 , 0 ],\n",
    "                [1 , 0 , 0 , 0 , 1 , 1 , 1 ],\n",
    "                [1 , 1 , 1 , 1 , 1 , 1 , 1 ],\n",
    "                [1 , 1 , 1 , 1 , 1 , 1 , 1 ],\n",
    "                [1 , 1 , 1 , 1 , 1 , 0 , 0 ],\n",
    "              ])\n",
    "print(E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Cómo hacer esto en el computador?\n",
    "Multiplicación por vector fila por la izquierda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "vf = np.matrix([1,1,1,1,1])\n",
    "print(vf.shape, E.shape)\n",
    "print(vf * E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Como hacer esto en el computador?\n",
    "Multiplicación por vector columna por la derecha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "vc = np.matrix([1,1,1,1,1,1,1])\n",
    "print(E.shape, vc.shape)\n",
    "print(E * vc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Cómo hacer esto en el computador?\n",
    "Contar el total de inscripciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "vf = np.matrix([1,1,1,1,1])\n",
    "vc = np.matrix([1,1,1,1,1,1,1]).T\n",
    "print(vf.shape, E.shape, vc.shape)\n",
    "print(vf * E * vc )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "¡Ojo! Obtenemos una matriz de 1x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Cómo hacer esto en el computador?\n",
    "Cantidad de estudiantes en común entre distintos cursos, $E^T \\cdot E$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(E.T * E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Cómo hacer esto en el computador?\n",
    "Cantidad de cursos en común entre estudiantes, $E \\cdot E^T$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(E * E.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qY1oOEW9CSv9",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# u-exam | datos reales\n",
    "Consideremos un conjunto de datos real, con las siguientes características:\n",
    "* 4 campus\n",
    "* Aproximadamente 11 mil estudiantes.\n",
    "* Cerca de 900 asignaturas distintas. \n",
    "* ¿Cuántas inscripciones, aproximadamente?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Considerando 5 inscripciones por estudiante, deberían ser cerca de 55 mil inscripciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# u-exam | datos real\n",
    "Carguemos la matriz con datos reales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "c7dQcTkvCS1q",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "E = np.matrix(np.loadtxt(\"E.csv\", delimiter=\";\"))\n",
    "print(E.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(E[:5,:7]) # Mostrando los primeros 5 estudiantes y los primeros 7 cursos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# u-exam | datos real\n",
    "En realidad, no necesitamos que sean \"números flotantes\" (floats) basta con que sean números enteros (ints). Esto nos permitiría incluso ahorrar RAM, pero cuidado, puede traer efectos colaterales si no se maneja con cuidado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E_float = np.matrix(np.loadtxt(\"E.csv\", delimiter=\";\"))\n",
    "E_int = np.matrix(np.loadtxt(\"E.csv\", delimiter=\";\", dtype=np.int8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(E_float.dtype)\n",
    "print(E_int.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(E_float.shape)\n",
    "print(E_int.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(E_float[:1,:1].nbytes)\n",
    "print(E_int[:1,:1].nbytes)\n",
    "print(E_float.nbytes / E_int.nbytes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# u-exam | datos real\n",
    "Volvamos a cargar los datos, considerando elementos de tipo entero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "E = np.matrix(np.loadtxt(\"E.csv\", delimiter=\";\", dtype=int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Tamaño: \", E.shape) # Estudiantes, cursos\n",
    "print(\"Tipo elementos: \", E.dtype) # 64 bits\n",
    "print(\"Tamaño de un elemento: \", E[:1,:1].nbytes) # tamaño de cada elemento\n",
    "print(\"Tamaño matriz (en Mb): \", E.nbytes/(1024*1024)) # tamaño de matriz en la RAM\n",
    "print(\"Algunos elementos:\\n\", E[:5,:7]) # Algunos elementos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | datos real\n",
    "Tratemos de mirar la matriz usando algunas herramientas gráficas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "fig, ax = plt.subplots(figsize=(32,32))\n",
    "ax.matshow(E.T, aspect='equal')\n",
    "plt.box(False)\n",
    "plt.xlabel(\"Estudiante\")\n",
    "plt.ylabel(\"Curso\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | datos real\n",
    "Tratemos de mirar la matriz usando algunas herramientas gráficas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "fig, ax = plt.subplots(figsize=(32,32))\n",
    "ax.matshow(E.T, cmap=plt.cm.Greys, aspect='equal')\n",
    "plt.xlabel(\"Estudiante\")\n",
    "plt.ylabel(\"Curso\")\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | datos real\n",
    "Tratemos de examinar algunos elementos de la matriz usando algunas herramientas gráficas **de manera apropiada**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "fig, ax = plt.subplots(figsize=(32,10))\n",
    "cax = ax.matshow(E[:5,:7], cmap=plt.cm.Greys, aspect='equal')\n",
    "plt.colorbar(cax)\n",
    "plt.xlabel(\"Curso\")\n",
    "plt.ylabel(\"Estudiante\")\n",
    "plt.grid(True)\n",
    "plt.suptitle(\"Algunos elementos de la matriz - Numeración parte en 0\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | inscripciones totales\n",
    "Calculemos la cantidad de inscripciones totales usando varios métodos distintos y midiendo el tiempo que toma realizar la operación. \n",
    "\n",
    "Recordemos que la matriz es de un tamaño mediano, $11,500 * 900$ aproximadamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | inscripciones totales\n",
    "### Versión ingenua:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Version Naive\n",
    "Ne, Nc = E.shape\n",
    "E_sum = 0\n",
    "for i in range(Ne):\n",
    "    for j in range(Nc):\n",
    "        E_sum = E_sum + E[i,j]\n",
    "print(\"Cantidad de inscripciones: \", E_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "El tiempo de ejecución depende del computador usado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | inscripciones totales\n",
    "### Versión matricial:\n",
    "$$E_{sum} = \\sum_{i=1}^{n} \\sum_{j=1}^{n} E_{ij} = \\sum_{i=1}^{n_{c}} 1 \\sum_{i=1}^{n_{e}} E_{ij} 1$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "vector_uno_cursos = np.matrix(np.ones([Nc,1])) \n",
    "vector_uno_estudiantes = np.matrix(np.ones([Ne,1]))\n",
    "E_sum = (vector_uno_estudiantes.T * E) * vector_uno_cursos\n",
    "print(E_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "vector_uno_cursos = np.matrix(np.ones([Nc,1], dtype=int)) \n",
    "vector_uno_estudiantes = np.matrix(np.ones([Ne,1], dtype=int))\n",
    "E_sum = (vector_uno_estudiantes.T * E) * vector_uno_cursos\n",
    "print(E_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Destacan 2 cosas: existe el fenómeno de \"casting\" en el cual el numero real (flotante) toma precedencia sobre el entero, y que el resultado sigue siendo una matriz (de 1 fila por 1 columna)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | inscripciones totales\n",
    "### Versión con funciones nativas:\n",
    "Usar la función suma ya implementada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Versión nativa - matricial\n",
    "E_sum = E.sum()\n",
    "print(\"Cantidad de inscripciones: \", E_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | inscripciones totales\n",
    "\n",
    "Resultado: \n",
    "\n",
    "Puede existir una diferencia de hasta 1000 veces en el tiempo de ejecución de un conteo tan sencillo como la suma de los elementos de una matriz. \n",
    "\n",
    "Seguir el principio **KISS: Keep It Simple, Stupid!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | Estudiantes en común entre asignaturas\n",
    "### Versión ingenua"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Versión Naive : Toma demasiado tiempo!\n",
    "Ne, Nc = E.shape\n",
    "ETE_v1 = np.zeros([Nc, Nc])\n",
    "for i in range(Nc):\n",
    "    print(\"Fila %d de %d. Porcentaje de las filas completado: %.2f\" %(i+1, Nc, 100.*(i+1)/Nc))\n",
    "    if i==5:\n",
    "        break\n",
    "    for j in range(Nc):\n",
    "        for k in range(Ne):\n",
    "            ETE_v1[i,j] = ETE_v1[i,j] + E[k,i]*E[k,j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(ETE_v1[:5,:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | Estudiantes en común entre asignaturas\n",
    "### Versión ingenua\n",
    "\n",
    "La versión ingenua es **demasiado** lenta. Consideremos calcularla solo para los primeros $10$ cursos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Versión Naive : Toma demasiado tiempo!\n",
    "N_aux = 10\n",
    "ETE_v2 = np.zeros([N_aux, N_aux])\n",
    "for i in range(N_aux):\n",
    "    print(\"Fila %d de %d. Porcentaje de las filas completado: %.2f\" %(i+1, N_aux, 100.*(i+1)/N_aux))\n",
    "    for j in range(N_aux):\n",
    "        for k in range(Ne):\n",
    "            ETE_v2[i,j] = ETE_v1[i,j] + E[k,i]*E[k,j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(ETE_v2[:5,:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | Estudiantes en común entre asignaturas\n",
    "### Versión ingenua\n",
    "\n",
    "¿Cuánto tiempo hubiera sido necesario?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Para una matriz de $10$ por $10$ $=$ $100$ combinaciones de cursos necesitamos aproximadamente 2 segundos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Para una matriz de $919$ cursos por $919$ cursos existen $844,561$ combinaciones y necesitamos 2.2 * 844,561 / 100 segundos, es decir, ¡más de 4 horas!."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(919 * 919)\n",
    "t = 2.0\n",
    "print(t * 919 * 919 / 100 / 3600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | Estudiantes en común entre asignaturas\n",
    "### Versión matricial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "E.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Versión matricial (nativa)\n",
    "ETE_v3 = E.T * E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(ETE_v3[:5,:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Podemos calcular todas el resultado para todos los cursos mediante multiplicación matricial en menos de 90 segundos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | Estudiantes en común entre asignaturas\n",
    "### Versión matricial\n",
    "Veamos el resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def plot_matrix(A):\n",
    "    fig, ax = plt.subplots(figsize=(12,12))\n",
    "    A_aux = A.astype(float)\n",
    "    masked_matrix = np.ma.array(A_aux, mask=(A_aux==0))\n",
    "    cmap = plt.cm.Reds\n",
    "    cmap.set_bad(color='white')\n",
    "    cax = ax.matshow(masked_matrix, cmap=cmap, aspect='equal', interpolation='none')\n",
    "    plt.colorbar(cax)\n",
    "    plt.box(False)\n",
    "    plt.grid(True)\n",
    "    plt.xlabel(\"Curso\", fontsize=10)\n",
    "    plt.ylabel(\"Curso\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "plot_matrix(ETE_v3[:,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## u-exam | ¿Porqué hacemos esto?\n",
    "\n",
    "Para asignar las evaluaciones de manera compatible, es necesario:\n",
    "* Asignar primero las evaluaciones que son más difíciles, que son aquellas que tienen mayor cantidad de alumnos y tienen la mayor duración ($E^T E$).\n",
    "* Para los cursos seleccionados, es necesario obtener los estudiantes en común, y buscar separar las fechas de sus evaluaciones para esos estudiantes lo más posible verificando que no coincidan con asignaciones previas ($E E^T$).\n",
    "\n",
    "Acá sólo hemos considerado la matriz de estudiantes y cursos, pero también es necesario:\n",
    "* Considerar las secciones a las que perteneccen los estudiantes, y asignar cada sección en un horario a una sala de capacidad compatible y de tipo de sala apropiado.\n",
    "* Considerar que el horario de la evaluación debe ser compatible con la disponibilidad de los supervisores que cuidarán la evaluación.\n",
    "\n",
    "Las otras características también son representadas mediante matrices sobre las cuales las operaciones de álgebra lineal permiten obtener soluciones en un tiempo acotado a pesar de la dificultad del problema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Resumen y conclusiones\n",
    "\n",
    "* Algebra lineal y matrices son **muy** importantes.\n",
    "* Uso de librerías y operaciones nativas resulta crucial para rapidez numérica.\n",
    "* Interpretación y modelamiento son más interesantes y más complejos que operatoria a ciegas."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "collapsed_sections": [],
   "name": "Matrices en la vida real.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.7.1"
  },
  "livereveal": {
   "autolaunch": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}