Note.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Curso de Estadística Computacional con Python\n",
    "\n",
    "![Portada](images/Portada.jpeg)\n",
    "\n",
    "# Tabla de Contenido\n",
    "- [Programación dinámica](#programación-dinámica)\n",
    "    - [Optimzación Fibonnaci](#optimización-de-fibonacci)\n",
    "        - [Optimización Especial](#optimización-especial)\n",
    "        - [Código](#código)\n",
    "    - [Caminos Aleatorios](#caminos-aleatorios)\n",
    "        - [Resultados](#resultado-de-la-simulacion)\n",
    "        - [Código](#códigos-del-borracho)\n",
    "        - [Aporte solo pasos del borracho](#código-para-solo-observar-los-pasos-del-borracho)\n",
    "- [Procesos Estocásticos](#procesos-estocásticos)\n",
    "- [Monte Carlos](#monte-carlos)\n",
    "- [Muestreo e Intervalos de Confianza](#muestro-e-intervalos-de-confianza)\n",
    "- [Datos experimentales](#datos-experimentales)\n",
    "- [Conclusiones](#conclusiones)\n",
    "\n",
    "\n",
    "# Programación dinámica\n",
    "\n",
    "**Programación dinámica:** Se escogió para esconder a patrocinadores gubernamentales el hecho que en realidad estaba haciendo Matemáticas. La frase Programación Dinámica es algo que ningún congresista puede oponerse. **Richard Bellman**\n",
    "\n",
    "**Programación dinámica:**\n",
    "- Subsestructura Óptima: Una solución global óptima se puede encontrar al combinar soluciones óptimas de subproblemas locales.\n",
    "- Problemas empalmados: Una solución óptima que involucra resolver el mismo problema en varias ocasiones.\n",
    "\n",
    "**Memoization:**\n",
    "- La memorización es una técnica para guardar cómputos previos y evitar realizarlos nuevamente.\n",
    "- Normalmente se utiliza un diccionario, donde las consultas se pueden hacer en O(1).\n",
    "- Intercambia tiempo por espacio.\n",
    "\n",
    "> Ventaja de consulta de los Sets y Dict de O(1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimización de Fibonacci\n",
    "\n",
    "$$F_n = F_{n-1} + F_{n-2} \\quad \\forall~n > 2$$\n",
    "\n",
    "![Fibonacci](images/Fibonnaci.png)\n",
    "\n",
    "Pero el algoritmo recursivo es ineficiente, debido a que crece de manera exponencial el tiempo de cómputo.\n",
    "\n",
    "> **Hint:** Para medir tiempo de ejecución desde consola (Mi sistema operativo es Windows usando Git Bash):\n",
    ">```shell\n",
    ">time python src/programacion_dinamica-1.py\n",
    ">```\n",
    "Aprovechando el tiempo de consulta de los diccionarios optimizamos el tiempo de ejecución para calcular un número $n$ de Fibonacci.\n",
    "\n",
    ">**Hint:** Para aumentar el tamaño de recursión y no sea un límite, añadimos la siguiente línea de código:\n",
    ">```python\n",
    ">sys.setrecursionlimit(10002)\n",
    ">```\n",
    "\n",
    "> Sitio Web para observar como funciona ambos algoritmos: [Dynamic Programming (Fibonacci)](https://www.cs.usfca.edu/~galles/visualization/DPFib.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimización Especial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache(maxsize=None)\n",
    "def fib(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    return fib(n-1) + fib(n-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Código \n",
    "[**File**: programacion_dinamica-1.py](src/programacion_dinamica-1.py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number: 1 -> Result: 1\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "from functools import lru_cache\n",
    "\n",
    "def fibonacci_recursivo(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "\n",
    "    return fibonacci_recursivo(n - 1) + fibonacci_recursivo(n - 2)\n",
    "\n",
    "\n",
    "def fibonacci_dinamico(n, memo = {}):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "\n",
    "    try:\n",
    "        return memo[n]\n",
    "    except KeyError:\n",
    "        # Si no esta en el diccionario, lo calculamos y lo guardamos\n",
    "        resultado = fibonacci_dinamico(n - 1, memo) + fibonacci_dinamico(n - 2, memo)\n",
    "        memo[n] = resultado\n",
    "\n",
    "        return resultado\n",
    "\n",
    "@lru_cache(maxsize=None)\n",
    "def fib(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    return fib(n-1) + fib(n-2)\n",
    "\n",
    "sys.setrecursionlimit(10002)\n",
    "n = int(input('Escoge un numero: '))\n",
    "# resultado = fibonacci_recursivo(n)\n",
    "resultado = fib(n)\n",
    "# resultado = fibonacci_dinamico(n)\n",
    "print(f\"Number: {n} -> Result: {resultado}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Caminos Aleatorios\n",
    "\n",
    "> Caminos Aleatorios:\n",
    "> - Es un tipo de simulación que elige aleatoriamente una decisión dentro de un conjunto de decisiones válidas.\n",
    "> - Se utiliza en muchos campos del conocimiento cuando los sistemas no son deterministas e incluyen elementos de aleatoriedad.\n",
    "\n",
    "La idea viene dado por el movimiento browniano, este es el movimiento aleatorio de partículas suspendidas en un fluido (líquido o gas) debido a colisiones con moléculas del medio. Este fenómeno fue observado por Robert Brown en 1827 y es un ejemplo de un proceso estocástico\n",
    "\n",
    "### Entendiendo la aleatoriedad con Python\n",
    "\n",
    "Se dividio en 3 clases:\n",
    "- ¿Qué es un borracho? *Borracho*\n",
    "- ¿Dónde se mueve este borracho? *Campo*\n",
    "- Concepto abstracto a tráves de un objeto: *Coordenada*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Borracho**, toma cambios en alguna de las coordenadas de forma aleatoria. Cada posible paso tiene igual probabilidad de ocurrencia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class Borracho:\n",
    "\n",
    "    def __init__(self, nombre):\n",
    "        self.nombre = nombre\n",
    "\n",
    "\n",
    "class BorrachoTradicional(Borracho):\n",
    "\n",
    "    def __init__(self, nombre):\n",
    "        super().__init__(nombre)\n",
    "\n",
    "    def camina(self):\n",
    "        # Igual probabilidad seleccionar cualquier paso\n",
    "        return random.choice([(0, 1), (0, -1), (1, 0), (-1, 0)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Campo**, muestra (gráfica) los pasos del borracho y limita el área donde se mueve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Campo:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.coordenadas_de_borrachos = {}\n",
    "\n",
    "    def anadir_borracho(self, borracho, coordenada):\n",
    "        \"\"\"\n",
    "        Add Borracho al campo\n",
    "        \"\"\"\n",
    "        self.coordenadas_de_borrachos[borracho] = coordenada\n",
    "\n",
    "    def mover_borracho(self, borracho):\n",
    "        \"\"\"\n",
    "        Mueve el borracho modificando sus coordenadas\n",
    "        \"\"\"\n",
    "        # Genera un paso\n",
    "        delta_x, delta_y = borracho.camina()\n",
    "        # Obtiene las coordenadas del borracho\n",
    "        coordenada_actual = self.coordenadas_de_borrachos[borracho]\n",
    "        # Crea una nueva coordena\n",
    "        nueva_coordenada = coordenada_actual.mover(delta_x, delta_y)\n",
    "        # Modifica la coordena\n",
    "        self.coordenadas_de_borrachos[borracho] = nueva_coordenada\n",
    "\n",
    "    def obtener_coordenada(self, borracho):\n",
    "        \"\"\"\n",
    "        Get Coordenada\n",
    "        \"\"\"\n",
    "        return self.coordenadas_de_borrachos[borracho]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Coordenada**, crea el marco de referencia para el *Borracho* y el *Campo*. Nos permite también calcular la distancia entre una coordena y otra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coordenada:\n",
    "\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def mover(self, delta_x, delta_y):\n",
    "        \"\"\"\n",
    "        Retorna una nueva Coordenada\n",
    "        \"\"\"\n",
    "        return Coordenada(self.x + delta_x, self.y + delta_y)\n",
    "\n",
    "    def distancia(self, otra_coordenada):\n",
    "        \"\"\"\n",
    "        Calcula la distancia Euclidiana\n",
    "        \"\"\"\n",
    "        delta_x = self.x - otra_coordenada.x \n",
    "        delta_y = self.y - otra_coordenada.y \n",
    "\n",
    "        return (delta_x**2 + delta_y**2)**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> La simulación genera $n$ cantidad de pasos del borracho. Siempre que hacemos aleatoriedad ejecutamos $m$ simulaciones para $n$ pasos. Para luego obtener las estadísticas necesarias para proponer los resultados de esas observaciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Librerias a emplear\n",
    "from src.borracho import BorrachoTradicional\n",
    "from src.campo import Campo \n",
    "from src.coordenada import Coordenada \n",
    "\n",
    "# Para graficar\n",
    "from bokeh.plotting import figure, show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def caminata(campo, borracho, pasos):\n",
    "    # Coordinate init\n",
    "    inicio = campo.obtener_coordenada(borracho)\n",
    "\n",
    "    for _ in range(pasos):\n",
    "        # Move borracho\n",
    "        campo.mover_borracho(borracho)\n",
    "\n",
    "    # Return distance between origin and end\n",
    "    return inicio.distancia(campo.obtener_coordenada(borracho))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):\n",
    "    \n",
    "    # Add Borracho\n",
    "    borracho = tipo_de_borracho(nombre='Rigo')\n",
    "    # Crear origen\n",
    "    origen = Coordenada(0, 0)\n",
    "    # Save distance\n",
    "    distancias = []\n",
    "\n",
    "    for _ in range(numero_de_intentos):\n",
    "        # Creo el campo\n",
    "        campo = Campo()\n",
    "        # Ubico el borracho\n",
    "        campo.anadir_borracho(borracho, origen)\n",
    "        # Caminar y devuelve la distancia caminda desde el origen\n",
    "        simulacion_caminata = caminata(campo, borracho, pasos)\n",
    "        # Save\n",
    "        distancias.append(round(simulacion_caminata, 1))\n",
    "\n",
    "    return distancias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def graficar(x, y):\n",
    "    \"\"\"\n",
    "    Plot n vs Distancia media\n",
    "    \"\"\"\n",
    "    grafica = figure(title='Camino aleatorio', x_axis_label='pasos', \n",
    "                     y_axis_label='distancia')\n",
    "    grafica.line(x, y, legend_label='distancia media')\n",
    "\n",
    "    show(grafica)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):\n",
    "\n",
    "    # Save mean distance\n",
    "    distancias_media_por_caminata = []\n",
    "\n",
    "    for pasos in distancias_de_caminata:\n",
    "        distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)\n",
    "        # Media\n",
    "        distancia_media = round(sum(distancias) / len(distancias), 4)\n",
    "        # Maxima\n",
    "        distancia_maxima = max(distancias)\n",
    "        # Minima\n",
    "        distancia_minima = min(distancias)\n",
    "        # Save\n",
    "        distancias_media_por_caminata.append(distancia_media)\n",
    "        print(f'{tipo_de_borracho.__name__} caminata aleatoria de {pasos} pasos')\n",
    "        print(f'Media = {distancia_media}')\n",
    "        print(f'Max = {distancia_maxima}')\n",
    "        print(f'Min = {distancia_minima}')\n",
    "\n",
    "    graficar(distancias_de_caminata, distancias_media_por_caminata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BorrachoTradicional caminata aleatoria de 10 pasos\n",
      "Media = 2.887\n",
      "Max = 7.1\n",
      "Min = 0.0\n",
      "BorrachoTradicional caminata aleatoria de 100 pasos\n",
      "Media = 8.723\n",
      "Max = 21.3\n",
      "Min = 0.0\n",
      "BorrachoTradicional caminata aleatoria de 1000 pasos\n",
      "Media = 29.163\n",
      "Max = 70.7\n",
      "Min = 6.3\n",
      "BorrachoTradicional caminata aleatoria de 10000 pasos\n",
      "Media = 90.969\n",
      "Max = 226.9\n",
      "Min = 15.0\n"
     ]
    }
   ],
   "source": [
    "# Number of steps -> n\n",
    "distancias_de_caminata = [10, 100, 1000, 10000]\n",
    "# Number of Simulations -> m\n",
    "numero_de_intentos = 100\n",
    "\n",
    "main(distancias_de_caminata, numero_de_intentos, BorrachoTradicional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resultado de la Simulacion\n",
    "\n",
    "![Distancias Medias](images/camino_aleatorio.png)\n",
    "\n",
    "### Códigos del Borracho\n",
    "\n",
    "|Name File | Link |\n",
    "|-|-|\n",
    "|Borracho| [Borracho](src/borracho.py) |\n",
    "|Campo| [Campo](src/campo.py) |\n",
    "|Coordenadas | [Coordenadas](src/coordenada.py)|\n",
    "|Simulación | [Simulation](src/camino_aleatorio.py)|\n",
    "\n",
    "### Código para solo observar los pasos del borracho\n",
    "\n",
    "> Nota: Aportado por un estudiante de la comunidad de Platzi. (Angel Armando Martínez Blanco)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from src.borracho import BorrachoTradicional\n",
    "from src.coordenada import Coordenada\n",
    "from src.campo import Campo\n",
    "\n",
    "from bokeh.plotting import figure, show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def graficar(x, y):\n",
    "    figura = figure()\n",
    "    figura.line(x, y)\n",
    "    show(figura)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ejecutar_caminata(campo, borracho, distancia):\n",
    "    x_arreglo = []\n",
    "    y_arreglo = []\n",
    "    x_arreglo.append(campo.obtener_coordenada(borracho).x)\n",
    "    y_arreglo.append(campo.obtener_coordenada(borracho).y)\n",
    "    for _ in range(distancia):\n",
    "        campo.mover_borracho(borracho) #se actualiza las coordenadas del borracho\n",
    "        x_arreglo.append(campo.obtener_coordenada(borracho).x)\n",
    "        y_arreglo.append(campo.obtener_coordenada(borracho).y)\n",
    "    graficar(x_arreglo, y_arreglo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main(distancia, inicio, borracho):\n",
    "    campo = Campo()\n",
    "    campo.anadir_borracho(borracho, inicio) #poner un borracho en origen\n",
    "    ejecutar_caminata(campo, borracho, distancia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "distancia = 100000\n",
    "inicio = Coordenada(0,0)\n",
    "borracho = BorrachoTradicional('Rigo')\n",
    "main(distancia, inicio, borracho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Resultado Caminta Borracho](images/borracho_caminata.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programas Estocásticos\n",
    "\n",
    "- Un programa es determinístico si cuando se corre con el mismo input produce el mismo output.\n",
    "- Los programas determinísticos son muy importantes, pero existen problemas que no pueden resolverse de esa manera.\n",
    "- La programación estocástica permite introducir aleatoriedad a nuestros programas para crear simulaciones que permiten resolver otro tipo de problemas.\n",
    "\n",
    "> Los programas estocásticos se aprovechan de que las distribuciones probabilísticas de un problema se conocen o pueden ser estimadas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probabilidades\n",
    "\n",
    "- La probabilidad es una medida de la certidumbre asociada a un evento o suceso futuro y suele expresarse como un número entre 0 y 1.\n",
    "- Una probabilidad de 0 significa que un suceso jamás sucederá.\n",
    "- Una probabilidad de 1 significa que un suceso está garantizado de suceder en el futuro.\n",
    "- Al hablar de probabilidad preguntamos qué fracción de todos los posibles eventos tiene la propiedad que buscamos.\n",
    "- Por eso es importante poder calcular todas las posibilidades de un evento para entender su probabilidad.\n",
    "- La probabilidad de que un evento suceda y de que no suceda es siempre 1.\n",
    "\n",
    "Ley del Complemento:\n",
    "$$P(A) + P(~A) = 1$$ \n",
    "\n",
    "Ley multiplicativa:\n",
    "$$P(A \\text{y} B) = P(A) * P(B)$$\n",
    "\n",
    "\n",
    "\n",
    "Ley aditiva \n",
    "Mutuamente exclusivos:\n",
    "$$P(A \\text{o} B) = P(A) + P(B)$$\n",
    "No exclusiva:\n",
    "$$P(A \\text{o} B) = P(A) + P(B) - P(A \\text{y} B)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tirar_dado(numero_de_tiros):\n",
    "\n",
    "    secuencia_de_tiros = []\n",
    "\n",
    "    for _ in range(numero_de_tiros):\n",
    "        tiro = random.choice([1, 2, 3, 4, 5, 6])\n",
    "        secuencia_de_tiros.append(tiro)\n",
    "\n",
    "    return secuencia_de_tiros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main(numero_de_tiros, numero_de_intentos):\n",
    "    \n",
    "    tiros = []\n",
    "    for _ in range(numero_de_intentos):\n",
    "        secuencia_de_tiros = tirar_dado(numero_de_tiros)\n",
    "        tiros.append(secuencia_de_tiros)\n",
    "    \n",
    "\n",
    "    tiros_con_1 = 0\n",
    "    for tiro in tiros:\n",
    "        # Para obtener el complemento\n",
    "        # if 1 not in tiro:\n",
    "        if 1 in tiro:\n",
    "            tiros_con_1 += 1\n",
    "\n",
    "    probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos\n",
    "    print(f\"Probabilidad de obtener por lo\" +\n",
    "          f\" menos un 1 en {numero_de_tiros}\" +\n",
    "          f\" tiros = {probabilidad_tiros_con_1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probabilidad de obtener por lo menos un 1 en 1 tiros = 0.147\n"
     ]
    }
   ],
   "source": [
    "numero_de_tiros = int(input('Cuantas tiros del dado: '))\n",
    "numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))\n",
    "\n",
    "main(numero_de_tiros, numero_de_intentos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1615055828898458"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Probabilidad de no obtener un 1\n",
    "(5/6)**10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8384944171101543"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Probabilidad de obtener al menos un 1\n",
    "1 - (5/6)**10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probabilidad de no obtener por lo menos un 1 en 1 tiros = 0.824\n"
     ]
    }
   ],
   "source": [
    "## Ejecutar código directamente\n",
    "%run src/probabilidades.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reto \n",
    "> Obtener la probabilidad de obtener un 12 al tirar 2 dados\n",
    "\n",
    "La posicion más justa es tener todas las posibles combinaciones y de ahi elegir la tirada. Eligiendo una única vez por dados para luego sumar no es muy realista, serían como momentos separados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reto(numero_de_tiros, numero_de_intentos):\n",
    "    \n",
    "    all_valores = [2,3,4,5,6,7,3,4,5,6,7,8,4,\n",
    "                   5,6,7,8,9,5,6,7,8,9,10,6,7,\n",
    "                   8,9,10,11,7,8,9,10,11,12]\n",
    "    \n",
    "    tiros = []\n",
    "    for _ in range(numero_de_intentos):\n",
    "        secuencia_de_tiros = []\n",
    "        for _ in range(numero_de_tiros):\n",
    "            tiro = random.choice(all_valores)\n",
    "            secuencia_de_tiros.append(tiro)\n",
    "\n",
    "        tiros.append(secuencia_de_tiros)\n",
    "\n",
    "    tiros_con_12 = 0\n",
    "    for tiro in tiros:\n",
    "        if 12 in tiro:\n",
    "            tiros_con_12 += 1\n",
    "    \n",
    "   \n",
    "    probabilidad_tiros_con_1 = tiros_con_12 / numero_de_intentos\n",
    "    print(f\"Probabilidad de obtener por lo\" +\n",
    "          f\" menos un 12 en {numero_de_tiros}\" +\n",
    "          f\" tiros = {probabilidad_tiros_con_1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probabilidad de obtener por lo menos un 12 en 10 tiros = 0.24735\n"
     ]
    }
   ],
   "source": [
    "numero_de_tiros = int(input('Cuantas tiros del dado: '))\n",
    "numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))\n",
    "\n",
    "reto(numero_de_tiros, numero_de_intentos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inferencia Estadística\n",
    "\n",
    "- Con las simulaciones podemos calcular las probabilidades de eventos complejos sabiendo las probabilidades de eventos simples.\n",
    "- ¿Qué pasa cuando no sabemos las probabilidades de los eventos simples?\n",
    "- Las técnicas de la Inferencia Estadística nos permiten inferir/concluir las propiedades de una población a partir de una muestra aleatoria.\n",
    "\n",
    "> El principio guía de la Inferencia Estadística es que una muestra aleatoria tiende a exhibir las mismas propiedades que la población de la cual fue extraída. **John Guttag**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Proceso\n",
    "\n",
    "De una **Población** obtenemos unas *muestras* representativas de forma aleatoria de la cual podemos obtener **conclusiones**.\n",
    "\n",
    "- Muestro simplea aleatorio: tomamos de manera aleatoria muestras de las población\n",
    "\n",
    "Esta idea válida proviene de la **Ley de los grandes números** donde en pruebas independientes repetidas con la misma probabilidad *p* de un resultado, la fracción de desviaciones de *p* converge a cero conforme las cantidad de pruebas se acerca al infinito. \n",
    "\n",
    "$$P\\left( \n",
    "    \\lim_{n \\to \\infty} \\bar{X}_n = \\mu\n",
    "\\right) = 1$$\n",
    "\n",
    "### Falacia del apostador\n",
    "\n",
    "- La falacia del apostador señala que después de un evento extremo, ocurrirán eventos menos extremos para nivelar la media.\n",
    "\n",
    "- La regresión a la media señala que después de un evento aleatorio extremo, el siguiente evento probablemente será menos extremo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Media\n",
    "\n",
    "- Es una medida de tendencia central.\n",
    "- Comúnmente es conocida como el promedio.\n",
    "- La media de una población se denota con el símbolo $$\\mu = \\sum_n x_n ~ p(x_n),$$ si la distribución es discreta. La media de una muestra se denota con $$\\bar{x} = \\frac{1}{n} \\sum_{i=1}^n x_i.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def media(X):\n",
    "    return sum(X) / len(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Varianza\n",
    "\n",
    "- La varianza mide qué tan propagados se encuentran un conjunto de valores aleatorios de su media.\n",
    "- Mientras que la media nos da una idea de dónde se encuentran los valores, la varianza nos dice que tan dispersos se encuentran.\n",
    "- La varianza siempre debe entenderse con respecto a la media.\n",
    "\n",
    "$$\\text{VAR}(X) = \\frac{1}{n} \\sum_{i=1}^{n} (x_i - \\mu)^2$$\n",
    "\n",
    "### Desviación estándar\n",
    "- La desviación estándar es la raíz cuadrada de la varianza.\n",
    "- Nos permite entender, también, la propagación y se debe entender siempre relacionado a la media.\n",
    "- La ventaja sobre la varianza es que la desviación estándar está en las mismas unidades que la media.\n",
    "\n",
    "$$\\sigma = \\sqrt{ \\sum_{i=1}^{n} p_i(x_i - \\mu)^2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def varianza(X):\n",
    "    mu = media(X)\n",
    "\n",
    "    acumulador = 0\n",
    "    for x in X:\n",
    "        acumulador += (x - mu)**2\n",
    "\n",
    "    return acumulador / len(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def desviacion_estandar(X):\n",
    "    return math.sqrt(varianza(X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arreglo X: [11, 9, 9, 11, 10, 11, 10, 9, 10, 9, 10, 12, 10, 9, 11, 10, 12, 9, 9, 11]\n",
      "Media = 10.1\n",
      "Varianza = 0.9900000000000002\n",
      "Desviacion estandar = 0.9949874371066201\n"
     ]
    }
   ],
   "source": [
    "X = [random.randint(9, 12) for i in range(20)]\n",
    "mu = media(X)\n",
    "Var = varianza(X)\n",
    "sigma = desviacion_estandar(X)\n",
    "\n",
    "print(f'Arreglo X: {X}')\n",
    "print(f'Media = {mu}')\n",
    "print(f'Varianza = {Var}')\n",
    "print(f'Desviacion estandar = {sigma}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distribución Normal\n",
    "\n",
    "- Es una de las distribuciones más recurrentes en cualquier ámbito.\n",
    "- Se define completamente por su media y su desviación estándar.\n",
    "- Permite calcular intervalos de confianza con la regla empírica.\n",
    "\n",
    "$$f(x) = \\frac{1}{\\sigma \\sqrt{2\\pi}} \\exp\\left(-\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^2\\right)$$\n",
    "\n",
    "### Regla empírica\n",
    "\n",
    "También conocida como la regla 68-95-99.7. Señala cuál es la dispersión de los datos en una distribución normal a uno, dos y tres sigmas. Permite calcular probabilidades con la densidad de la distribución normal. \n",
    "\n",
    "$$\\text{Pr}(\\mu - 1\\sigma \\le X \\le \\mu + 1\\sigma) \\approx 0.6827$$\n",
    "$$\\text{Pr}(\\mu - 2\\sigma \\le X \\le \\mu + 2\\sigma) \\approx 0.9545$$\n",
    "$$\\text{Pr}(\\mu - 3\\sigma \\le X \\le \\mu + 3\\sigma) \\approx 0.9973$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Portada](images/empiric_distr.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monte Carlos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Qué son las Simulaciones de Montecarlo?\n",
    "\n",
    "Permite crear simulaciones para predecir el resultado de un problema, además de convertir problemas determinísticos en problemas estocásticos.\n",
    "\n",
    "Es utilizado en gran diversidad de áreas, desde la ingeniería hasta la biología y el derecho."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Datos\n",
    "PALOS = ['espada', 'corazon', 'rombo', 'trebol']\n",
    "VALORES = ['as', '2', '3', '4', '5', '6', '7', '8', \n",
    "           '9', '10', 'jota', 'reina', 'rey']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crear_baraja():\n",
    "    barajas = []\n",
    "    for palo in PALOS:\n",
    "        for valor in VALORES:\n",
    "            barajas.append((palo, valor))\n",
    "\n",
    "    return barajas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def obtener_mano(barajas, tamano_mano):\n",
    "    \n",
    "    mano = random.sample(barajas, tamano_mano)\n",
    "    \n",
    "    return mano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main(tamano_mano, intentos):\n",
    "    barajas = crear_baraja()\n",
    "\n",
    "    manos = []\n",
    "    for _ in range(intentos):\n",
    "        mano = obtener_mano(barajas, tamano_mano)\n",
    "        manos.append(mano)\n",
    "\n",
    "    pares = 0\n",
    "    for mano in manos:\n",
    "        valores = []\n",
    "        for carta in mano:\n",
    "            ## Save value of the card\n",
    "            valores.append(carta[1])\n",
    "        \n",
    "        ## Count the number of times a value is repeated\n",
    "        counter = dict(collections.Counter(valores))\n",
    "        for val in counter.values():\n",
    "            # Almenos un par\n",
    "            if val == 2:\n",
    "            # Para una tercia\n",
    "            # if val == 3:\n",
    "                pares += 1\n",
    "                break\n",
    "\n",
    "    probabilidad_par = pares / intentos\n",
    "    print(\"La probabilidad de obtener un par en una\" +\n",
    "    # print(\"La probabilidad de obtener una tercia en una\" +\n",
    "          f\" mano de {tamano_mano} barajas es {probabilidad_par}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main_reto(tamano_mano, intentos):\n",
    "    barajas = crear_baraja()\n",
    "\n",
    "    manos = []\n",
    "    for _ in range(intentos):\n",
    "        mano = obtener_mano(barajas, tamano_mano)\n",
    "        manos.append(mano)\n",
    "\n",
    "    valoresNum = {val: i for i, val in enumerate(VALORES, start=1)}\n",
    "    escalera = 0\n",
    "    for mano in manos:\n",
    "        manoNum = [valoresNum[carta[1]] for carta in mano]\n",
    "        valores = sorted(manoNum)  # Obtener y ordenar los valores de la mano\n",
    "        # Comprobar si hay una escalera\n",
    "        if len(valores) == tamano_mano and valores == list(range(valores[0], \n",
    "                                                valores[0] + tamano_mano)):\n",
    "            escalera += 1\n",
    "\n",
    "    probabilidad_escalera = escalera / intentos\n",
    "    print(\"La probabilidad de obtener una escalera en una\" +\n",
    "          f\" mano de {tamano_mano} cartas es {probabilidad_escalera}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La probabilidad de obtener un par en una mano de 5 barajas es 0.489\n"
     ]
    }
   ],
   "source": [
    "tamano_mano = int(input('De cuantas barajas sera la mano: '))\n",
    "intentos = int(input('Cuantos intentos para calcular la probabilidad: '))\n",
    "\n",
    "main(tamano_mano, intentos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La probabilidad de obtener una escalera en una mano de 5 cartas es 0.005\n"
     ]
    }
   ],
   "source": [
    "tamano_mano = int(input('De cuantas barajas sera la mano: '))\n",
    "intentos = int(input('Cuantos intentos para calcular la probabilidad: '))\n",
    "\n",
    "main_reto(tamano_mano, intentos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de PI\n",
    "\n",
    "Calcularemos PI con puntos al azar esparcidos en un plano cartesiano utilizando los scripts de desviación estándar y media que creados anteriormente. Queremos tener un 95% de certeza, entonces para ello realizaremos el cálculo para 1/2 del área de un circulo, optimizando nuestros recursos.\n",
    "\n",
    "$$ \\text{Area Cuadrado} = b \\cdot h$$\n",
    "\n",
    "$$ \\text{Area Circulo} = \\pi \\cdot r^2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math\n",
    "from src.estadisticas import desviacion_estandar, media"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aventar_agujas(numero_de_agujas):\n",
    "    adentro_del_circulo = 0\n",
    "\n",
    "    for _ in range(numero_de_agujas):\n",
    "        x = random.random() * random.choice([-1, 1])\n",
    "        y = random.random() * random.choice([-1, 1])\n",
    "        distancia_desde_el_centro = math.sqrt(x**2 + y**2)\n",
    "\n",
    "        if distancia_desde_el_centro <= 1:\n",
    "            adentro_del_circulo += 1\n",
    "\n",
    "    # La variable adentro_del_circulo representa 1/4 del área del círculo,\n",
    "    # y como solo utilizaremos 1/2 vamos a multiplicarlo por 2.\n",
    "    return (2 * adentro_del_circulo) / numero_de_agujas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimacion(numero_de_agujas, numero_de_intentos):\n",
    "    estimados = []\n",
    "    for _ in range(numero_de_intentos):\n",
    "        estimacion_pi = aventar_agujas(numero_de_agujas)\n",
    "        estimados.append(estimacion_pi)\n",
    "\n",
    "    media_estimados = media(estimados)\n",
    "    sigma = desviacion_estandar(estimados)\n",
    "\n",
    "    # La variable media_estimados tiene los resultados sobre 1/2 del área del\n",
    "    # círculo. Para obtener la estimación de PI completo lo vamos a multiplicar por 2.\n",
    "    print(f\"Est={round(media_estimados, 5) * 2}, \" +\n",
    "          f\"sigma={round(sigma, 5)}, \"  +\n",
    "          f\"agujas={numero_de_agujas}\")\n",
    "\n",
    "    return (media_estimados, sigma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimar_pi(precision, numero_de_intentos):\n",
    "    numero_de_agujas = 1000\n",
    "    sigma = precision\n",
    "\n",
    "    while sigma >= precision / 1.96:\n",
    "        media, sigma = estimacion(numero_de_agujas, numero_de_intentos)\n",
    "        numero_de_agujas *= 2\n",
    "\n",
    "    return media*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Est=3.14336, sigma=0.02608, agujas=1000\n",
      "Est=3.14218, sigma=0.01803, agujas=2000\n",
      "Est=3.14028, sigma=0.01327, agujas=4000\n",
      "Est=3.1414, sigma=0.00933, agujas=8000\n",
      "Est=3.14182, sigma=0.00655, agujas=16000\n",
      "Est=3.14164, sigma=0.00453, agujas=32000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3.1416414999999995"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estimar_pi(0.01, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Muestro e Intervalos de Confianza"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Muestreo \n",
    "\n",
    "Hay ocasiones en la que no tenemos acceso a toda la población que queremos explorar. Uno de los grandes descubrimientos de la estadística es que las muestras aleatorias tienden a mostrar las mismas propiedades de la población objetivo. El tipo de muestreo que hemos hecho hasta ahora es muestreo probabilístico.\n",
    "\n",
    "En un muestreo aleatorio cualquier miembro de la población tiene la misma probabilidad de ser escogido. En un muestreo **estratificado** tomamos en consideración las características de la población para partirla en subgrupos y luego tomamos muestras de cada subgrupo, esto incrementa la probabilidad de que el muestreo sea representativo de la población.\n",
    "\n",
    "## Teorema del límite central\n",
    "\n",
    "Es uno de los teoremas más importantes de la estadística. Establece que muestras aleatorias de cualquier distribución van a tener una distribución normal. Permite entender cualquier distribución como la distribución normal de sus medias y eso nos permite aplicar todo lo que sabemos de distribuciones normales.\n",
    "\n",
    "Mientras más muestras obtengamos, mayor será la similitud con la distribución normal Mientras la muestra sea de mayor tamaño, la desviación estándar será menor.\n",
    "\n",
    "![Sampling_rule](images/samping_rule.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def tirar_dados(n_tiradas):\n",
    "    # Simula la tirada de 2 dados y devuelve las sumas\n",
    "    resultado = [np.random.randint(1, 7) + np.random.randint(1, 7) for _ in range(n_tiradas)]\n",
    "    return resultado\n",
    "\n",
    "def graficar_histograma(data, n_tiradas):\n",
    "    # Crea un histograma de los resultados\n",
    "    plt.hist(data, bins=np.arange(2, 14) - 0.5, density=True, \n",
    "             alpha=0.6, color='g', label='Distribución de Sumas')\n",
    "    \n",
    "    # Graficar la distribución normal\n",
    "    mu = np.mean(data)\n",
    "    sigma = np.std(data)\n",
    "    x = np.linspace(2, 12, 100)\n",
    "    y = (1 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)\n",
    "    plt.plot(x, y, color='red', label='Distribución Normal')\n",
    "\n",
    "    # Personalizar el gráfico\n",
    "    plt.title(f'Histograma de Sumas de {n_tiradas} Tiradas de 2 Dados')\n",
    "    plt.xlabel('Suma')\n",
    "    plt.ylabel('Frecuencia Relativa')\n",
    "    plt.xticks(range(2, 13))\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.show()\n",
    "\n",
    "def main():\n",
    "    n_tiradas = 10000  # Número de tiradas de dados\n",
    "    resultados = tirar_dados(n_tiradas)\n",
    "    graficar_histograma(resultados, n_tiradas)\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datos Experimentales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Cómo trabajar con datos experimentales?\n",
    "\n",
    "Los datos experimentales son aquellos que se generan a través del método científico.\n",
    "\n",
    "- Con el método científico es necesario comenzar con una teoría o hipótesis sobre el resultado al que se quiere llegar.\n",
    "- Basado en la hipótesis se debe crear un experimento para validad o falsear la hipótesis.\n",
    "- Se valida o falsea una hipótesis midiendo la diferencia entre las mediciones experimentales y aquellas mediciones predichas por la hipótesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El método científico y la hipótesis\n",
    "\n",
    "¿Cómo se vinculan la teoría y la experimentación en el método científico? El punto de partida es siempre una hipótesis o teoría, posibilitando la creación de experimentos diseñados objetivamente para su comprobación. En este proceso, es fundamental abordar la experimentación sin prejuicios, buscando la verdad de la hipótesis sin intentar forzar los resultados a favor de nuestras creencias iniciales.\n",
    "\n",
    "### Diseño y ejecución de experimentos\n",
    "\n",
    "¿Cuál es la importancia del diseño y ejecución de experimentos? Una vez formulada la hipótesis, se procede a diseñar un experimento que permita confirmarla o refutarla. La ejecución de dicho experimento proporciona datos que, al compararlos con las predicciones teóricas, nos indican si la teoría se sostiene ante la evidencia empírica o si, por el contrario, debe ser cuestionada o incluso descartada.\n",
    "\n",
    "### Comparación entre teoría y datos experimentales\n",
    "\n",
    "¿Qué sucede cuando se comparan los datos experimentales con las teorías? A lo largo de la historia, muchas teorías han sido confirmadas a través de experimentos, como es el caso de la mecánica cuántica y la teoría general de la relatividad. Sin embargo, el hecho de que estas teorías sean incompatibles entre sí, plantea desafíos significativos e invita a profundizar en el conocimiento y la investigación científica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regresión Lineal\n",
    "\n",
    "La regresión lineal nos permite aproximar una función a un conjunto de datos obtenidos de manera experimental. No necesariamente permite aproximar funciones lineales, sino que sus variantes permiten aproximar cualquier **función polinómica**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.96666667 1.13333333]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])\n",
    "y = np.array([1, 2, 3, 5, 4, 6, 8, 7, 9])\n",
    "\n",
    "coeffs = np.polyfit(x, y, 1)\n",
    "print(coeffs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = coeffs[0]\n",
    "b = coeffs[1]\n",
    "est_y = (m * x) + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGdCAYAAABO2DpVAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQ7tJREFUeJzt3XlcVXXi//HXvZdVhIuoqCgg7oqylC1CZZZljrm0qDDOt22+851pLLeybVIrM2wztRqnZuZrM9+ZwC1catRsUcc2zMA1F9x3XIALKBe49/z+4JfllCl44XAv7+fjcR/XczqX+76S3Def87nnYzEMw0BERETEA6xmBxARERHfoWIhIiIiHqNiISIiIh6jYiEiIiIeo2IhIiIiHqNiISIiIh6jYiEiIiIeo2IhIiIiHuNX30/odrs5cuQIoaGhWCyW+n56ERERqQXDMCgpKSEqKgqr9cLjEvVeLI4cOUJ0dHR9P62IiIh4wMGDB2nXrt0F/3u9F4vQ0FCgOlhYWFh9P72IiIjUgsPhIDo6+tz7+IXUe7H47vRHWFiYioWIiIiXudg0Bk3eFBEREY9RsRARERGPUbEQERERj1GxEBEREY9RsRARERGPUbEQERERj1GxEBEREY9RsRARERGPUbEQERHxFYYBq1dX35ukxsWipKSEcePGERsbS3BwMCkpKaxfv74usomIiEhNrFgB/frBypWmRahxsfjv//5vVq1axf/93/+xefNmbr31Vvr378/hw4frIp+IiIhcqoULz783gcUwLn285OzZs4SGhrJkyRIGDRp0bv+VV17JwIEDef755y/6NRwOB3a7neLiYq0VIiIicjncbpgzB4qKqrdfegkcDrDbYeLE6n3h4fDgg/AzS51fikt9/67RImRVVVW4XC6CgoLO2x8cHMy6det+8jFOpxOn03leMBEREfGAsjKYPBlOnwaL5fvyUFoKkyZVz7WIiIB77oGLrErqKTWqL6GhofTp04epU6dy5MgRXC4X//jHP/jiiy84evToTz4mIyMDu91+7hYdHe2R4CIiIo1eaCjk5kJKSvW2y3X+fUoK5OXVW6mAGp4KAdi9ezcPPPAAa9euxWazccUVV9ClSxc2bNjAt99++6Pjf2rEIjo6WqdCREREPKWionpkoqzs+30hIVBYCP7+HnmKSz0VUuMTLh07dmTNmjWUlpZy8OBBcnJyqKyspEOHDj95fGBgIGFhYefdRERExINycs4vFVC9nZNT71FqPZMjJCSENm3aUFhYyMqVKxk6dKgnc4mIiMilWras+n7YMMjPh+/ek5curfcoNZq8CbBy5UoMw6Br167k5+czceJEunXrxv33318X+URERORihgyBxEQqho/kmMNJTHY2ZGZCbGy9R6lxsSguLubJJ5/k0KFDREREcNdddzFt2jT8PXQOR0RERGooNZV9XZMY89YXFJ6p4F9jrif0l780JUqNi8WIESMYMWJEXWQRERGRGjIMg0XfHGbKki2UVbgIb+JPfkEpyTHNTMlT42IhIiIiDYOjvJI/ZG9h2cYjAFzbIYLXRibRxh5sWiYVCxERES+0YX8hY7NyOVR4FpvVwoRbuvC7vh2xWS2m5lKxEBER8SIut8Gbn+Yz6+NduNwGMRFNmJWWZNqpj/+kYiEiIuIlDhedZXxWHjn7TgNwR3JbnhsaT2hQw/kAhYqFiIiIF/jX5qM8sWgTjvIqmgb6MXVYPHcktzM71o+oWIiIiDRgZyqqeHbpNuZ9fRCApOhwZqclE9O8icnJfpqKhYiISAO15XAxYzJz2XOyDIsFRt/YibH9O+Nvu7wl0OuSioWIiEgD43Yb/HXdXl5auZ1Kl0HrsCBeG5lEn47NzY52USoWIiIiDUhBSTmPzN/Iv3edBGBAfCtevCuB8CYBJie7NCoWIiIiDcSn2wt4dMFGTpVVEORvZfLt8aRfHY3FYu61KWpCxUJERMRk5ZUupi/fzjuf7wOge5swXk9PolNkqLnBakHFQkRExES7jpfwcGYu24+VAPBAahyP3daVIH+byclqR8VCRETEBIZh8M+vDjD1/W04q9y0aBrAy8MT6dc10uxol0XFQkREpJ4VllXw+KJNfLjtOAA3dGnJq8MTaRkaaHKyy6diISIiUo8+332S8fPyOO5w4m+z8Pht3XggNQ6ryYuHeYqKhYiISD2odLl5bdVO5qzZjWFAh5YhzE5Lpmdbu9nRPErFQkREpI7tP1XGmKw8Nh4sAiD96mgm3d6DJgG+9zbse69IRESkAXnvm0NMWryFsgoXYUF+TL8rgV/0amN2rDqjYiEiIlIHHOWVTF68hcV5RwC4Oi6CmSOTiAoPNjlZ3VKxEBER8bBvDhQyNiuXg6fPYrNaGHdzZ37frxM2H5mg+XNULERERDzE5Tb446f5zPx4Fy63QbtmwcxKS+bK2GZmR6s3KhYiIiIecKToLOPm5ZGz9zQAQ5OimDqsJ2FB/iYnq18qFiIiIpdpxZajPL5oM8VnKwkJsPHc0J7ceUVbr1o8zFNULERERGrpTEUVU9/fRmbOQQAS29mZlZZM+xYhJiczj4qFiIhILWw9UsyYzFx2nyjDYoHf9e3IhFu64G+zmh3NVCoWIiIiNeB2G/zvZ3t5acUOKlxuWoUF8tqIJFI6tTA7WoOgYiEiInKJTpQ4eXTBRtbsPAHALT1a8eJdCUSEBJicrOFQsRAREbkEn+4oYOKCjZwsrSDQz8qk23sw6pqYRjlB8+eoWIiIiPwMZ5WL6cu3M/ezfQB0ax3K7PRkurQKNTdYA6ViISIicgH5BSU8nJnHt0cdANyX0p4nBnYjyN9mcrKGS8VCRESqGQasWQN9+0IjH943DIPMnIM89/5WyivdRIQE8MrwBG7q1srsaA1ejT4T43K5mDRpEnFxcQQHB9OxY0emTp2KYRh1lU9EROrLihXQrx+sXGl2ElMVnangwX98w1PZmymvdHN95xasGHu9SsUlqtGIxYsvvsicOXP429/+Rnx8PF9//TX3338/drudMWPG1FVGERGpDwsXfn9/223mZjHJF7tPMX5eHscc5fjbLDw2oBu/vi4OayNYPMxTalQsPv/8c4YOHcqgQYMAaN++PZmZmeTk5NRJOBERqUNuN8yZA0VF1ds/LBZxcdV/Dg+HBx8Eq29f9KnS5WbmRzv54+rdGAbEtQhhdloyvdrZzY7mdWpULFJSUnj77bfZuXMnXbp0YePGjaxbt44ZM2Zc8DFOpxOn03lu2+Fw1D6tiIh4TlkZTJ4Mp09Xz6n4rjyUlsKkSdVzLiIi4J57INR3PwFx4NQZxmTlknewCICRvaOZPLgHIYGahlgbNfpbe+KJJ3A4HHTr1g2bzYbL5WLatGmMGjXqgo/JyMjg2WefveygIiLiYaGhkJsL6enwxRfgclXvd7mqi0ZKCmRl+XSpyM49xKTFWyl1VhEa5EfGnb24PSHK7FhezWLUYOZlVlYWEydO5OWXXyY+Pp68vDzGjRvHjBkzuPfee3/yMT81YhEdHU1xcTFhYWGX/wpEROTyVFRUj0yUlX2/LyQECgvB3zeX/C4pr2Tykq1k5x4GoHdsM2amJdGuWROTkzVcDocDu91+0ffvGo1YTJw4kSeeeIK0tDQAevXqxf79+8nIyLhgsQgMDCQwMLAmTyMiIvUpJ+f8UgHV2zk5kJpqTqY6lHugkLFZeRw4fQarBcbe3IXR/Tri18gXD/OUGv0tnjlzBut/TOCx2Wy43W6PhhIRkXq0bFn1/bBhkJ8PQ4dWby9dalqkuuByG7z5aT53/+kLDpw+Q9vwYOb/tg9j+3dWqfCgGo1YDB48mGnTphETE0N8fDy5ubnMmDGDBx54oK7yiYhIXRsyBBITq+daWCyQnQ2ZmRAba3YyjzlafJbx8/L4cs9pAG5PaMO0O3phD/bNUz1mqtEci5KSEiZNmkR2djYFBQVERUWRnp7O5MmTCQi4tJXdLvUcjYiIiCes2HKMxxdtovhsJU0CbDwzJJ7hV7bT4mE1dKnv3zUqFp6gYiEiIvXhbIWLqR9s492vDgDQq62d2enJxLUIMTmZd6qTyZsiIiLeYNsRB2OycskvKAXgt3078MgtXQnw01yKuqZiISIiPsMwDOZ+to/py7dT4XITGRrIjBFJXNe5hdnRGg0VCxER8QknS508umAjq3ecAKB/90hevCuB5k11yYP6pGIhIiJeb83OEzwyfyMnS50E+Fl5elB3/uvaWE3QNIGKhYiIeC1nlYuXV+zgL+v2AtClVVNeT7+Crq199zLkDZ2KhYiIeKX8glLGZOay7Wj14pb39InlqV90J8jfZnKyxk3FQkREvIphGMxbf5Bnl23jbKWLZk38efnuRPr3aGV2NEHFQkREvEjxmUqezN7EvzYfAyC1U3NmjEiiVViQycnkOyoWIiLiFb7ac4rx8/I4UlyOn9XCxAFd+c31HbBaNUGzIVGxEBGRBq3K5WbWx7t489N83Aa0b96E2enJJLQLNzua/AQVCxERabAOnj7D2KxcvjlQBMDwK9vxzJB4QgL19tVQ6TsjIiIN0pK8wzydvYUSZxWhgX5Mu7MXQxKjzI4lF6FiISIiDUqps4rJS7bw3jeHAbgythkzRyYRHdHE5GRyKVQsRESkwcg7WMTYrFz2nzqD1QIP39SZh2/qhJ9Ni4d5CxULERExndtt8Ke1u5nx4U6q3AZtw4OZmZbEVe0jzI4mNaRiISIipjpWXM6E+Xl8vvsUAIN6teGFO3phb+JvcjKpDRULERExzYdbj/H4ok0Unqkk2N/Gs0PiGd67nRYP82IqFiIiUu/KK108/8E2/vHlAQB6tg1jVloyHVs2NTmZXC4VCxERqVffHnUwJjOXXQWlAPzPDR149NauBPhpgqYvULEQEZF6YRgGf/t8Hy8s305FlZuWoYHMGJHI9Z1bmh1NPEjFQkRE6typUicTF27ik+0FANzULZKX706gedNAk5OJp6lYiIhInfr3rhNMmL+REyVOAvysPDWwG/emtNcETR+lYiEiInWiosrNKx/u4O21ewDoHNmU2enJdG8TZnIyqUsqFiIi4nF7TpQyJiuXLYcdAPzq2hieHtSDIH+bycmkrqlYiIiIxxiGwYKvDzFl6VbOVroIb+LPS3clcGt8a7OjST1RsRAREY8oPlvJU9mb+WDTUQBSOjZnxogkWtuDTE4m9UnFQkRELtv6facZl5XH4aKz+FktTLi1C7+9oSM2qyZoNjYqFiIiUmtVLjevf5LP65/swm1AbPMmzEpLJik63OxoYhIVCxERqZVDhWcYl5XH1/sLAbjzirY8N7QnTQP11tKY6bsvIiI1tmzjEZ7K3kxJeRWhgX48f0dPhia1NTuWNAAqFiIicsnKnFVMWbqVhRsOAXBFTDiz0pKJjmhicrJLZBiwZg307Qu6QFedqNGKL+3bV18p7T9vo0ePrqt8IiLSQGw6VMTtr69j4YZDWC0w5qZOzP9tH+8pFQArVkC/frBypdlJfFaNRizWr1+Py+U6t71lyxZuueUWhg8f7vFgIiLSMLjdBm//ew+vrNxBldsgyh7EayOTuKZDc7Oj1dzChd/f33abuVl8VI2KRcuW569AN336dDp27Ejfvn09GkpERBqGAkc5E+ZvZF3+SQAG9mzN9DsTsDfxNznZJXK7Yc4cKCqq3v5hsYiLq/5zeDg8+CBYtWy7J1gMwzBq88CKigqioqKYMGECTz311AWPczqdOJ3Oc9sOh4Po6GiKi4sJC9P14kVEGqqPth3nsUWbOF1WQbC/jSmDezDyqmjvWjyspATat4fTp6vnVFit4HKBzVZdOgwDIiJg3z4IDTU7bYPmcDiw2+0Xff+udT1bvHgxRUVF3HfffT97XEZGBna7/dwtOjq6tk8pIiL1oLzSxeQlW/jvv3/N6bIKerQJY9nD15F2dYx3lQqoLgu5uZCSUr393en87+5TUiAvT6XCg2o9YjFgwAACAgJYtmzZzx6nEQsREe+x41gJYzJz2XG8BIDfXB/HowO6Eujn5YuHVVRUj0yUlX2/LyQECgvB30tO65jsUkcsavVx0/379/PRRx/x3nvvXfTYwMBAAgMDa/M0IiJSTwzD4B9f7uf5D77FWeWmRdNAXh2RSN8uLS/+YG+Qk3N+qYDq7ZwcSE01J5OPqtWpkLlz5xIZGcmgQYM8nUdEROrZ6bIKfvP3r5m0ZCvOKjc3dm3JinHX+06pAPhudH3YMMjPh6FDq7eXLjUtkq+q8YiF2+1m7ty53Hvvvfj56fpaIiLe7LP8k4yfl0dBiZMAm5UnBnbj/tT23jeX4mKGDIHEREhPr57EmZ0NmZkQG2t2Mp9T4zkWH374IQMGDGDHjh106dKlxk94qedoRESk7lRUuXl11Q7eXrsHw4BOkU2ZnZZMjyj9XJafVmdzLG699VZqOd9TREQagL0nyxiblcumQ8UAjLomhqcH9SA4wMsnaEqDoHMZIiKNhGEYLPrmMJOXbOFMhYvwJv5MvzOB23q2Njua+BAVCxGRRqD4bCVPL97Cso1HALi2QwSvjUyijT3Y5GTia1QsRER83Ib9pxmTmcfhorPYrBYm3NKF3/XtiM3qYxM0pUFQsRAR8VFVLjdvfrqbWR/vxG1ATEQTZqUlkRzTzOxo4sNULEREfNDhorOMy8pl/b5CAO5MbsuzQ+MJDdJVJqVuqViIiPiYDzYd5Yn3NlFSXkXTQD+eH9aTYcltzY4ljYSKhYiIjzhTUcUzS7cy/+tDACRFhzM7LZmY5k1MTiaNiYqFiIgP2HK4mDGZuew5WYbFAqNv7MTY/p3xt9V6EWuRWlGxEBHxYm63wV/X7eWlldupdBm0sQfx2sgkru3Q3Oxo0kipWIiIeKkCRzmPLNjIv3edBGBAfCtevCuB8CYBJieTxkzFQkTEC32y/TiPLtjE6bIKgvytTL49nvSro31v8TDxOioWIiJepLzSxfTl23nn830AdG8TxuvpSXSKDDU3mMj/p2IhIuIldh4vYUxmLtuPlQDwQGocj93WlSB/LR4mDYeKhYhIA2cYBv/46gDPv78NZ5WbFk0DeHl4Iv26RpodTeRHVCxERBqw02UVPL5oE6u2HQfghi4teXV4Ii1DA01OJvLTVCxERBqoz/NPMn5+HscdTgJsVh4f2I37U9pj1eJh0oCpWIiINDCVLjczVu3kT2t2YxjQoWUIs9OS6dnWbnY0kYtSsRARaUD2nSxjbFYuGw8VA5B+dTSTbu9BkwD9uBbvoP9TRUQaAMMweO+bw0xesoWyChf2YH+m39mLgb3amB1NpEZULERETOYor2TS4i0syTsCwNVxEcwcmURUeLDJyURqTsVCRMREG/YXMjYrl0OFZ7FZLYzv35kHb+yETRM0xUupWIiImMDlNvjjp/nM/HgXLrdBu2bBzEpL5srYZmZHE7ksKhYiIvXscNFZxmflkbPvNABDk6KYOqwnYUH+JicTuXwqFiIi9Wj55qM8vmgTjvIqQgJsTB3WkzuS22rxMPEZKhYiIvXgTEUVU9/fRmbOQQASo8OZnZZEbPMQk5OJeJaKhYhIHdtyuJgxWbnsOVGGxQK/69uRCbd0wd9mNTuaiMepWIiI1BG32+B/P9vLSyt2UOFy0yoskNdGJJHSqYXZ0UTqjIqFiEgdKCgp59EFm1i78wQAt/RoxUt3JdAsJMDkZCJ1S8VCRMTDPt1RwMQFGzlZWkGgn5VJt/dg1DUxmqApjYKKhYiIh5RXunhxxXbmfrYPgG6tQ3k9PZnOrULNDSZSj1QsREQulWHAmjXQty/8x+hDfkEJD2fm8e1RBwD3pbTniYHdCPK3mZFUxDQ1npJ8+PBhfvWrX9G8eXOCg4Pp1asXX3/9dV1kExFpWFasgH79YOXKc7sMw+CfX+3n9tfX8e1RBxEhAfzvfb15Zki8SoU0SjUasSgsLCQ1NZV+/fqxfPlyWrZsya5du2jWTJegFZFGYOHC7+9vu43CsgqeeG8TK7ceB+D6zi14dXgikWFBJoYUMVeNisWLL75IdHQ0c+fOPbcvLi7O46FERBoEtxvmzIGiourtHxSLz6N7MaE8hmNGAP42C48N6Mavr4vDqsXDpJGrUbFYunQpAwYMYPjw4axZs4a2bdvy+9//nt/85jcXfIzT6cTpdJ7bdjgctU8rIlKfyspg8mQ4fbp6ToXVSqXVxsykYfzxTAcMi5UORUeZPeEX9OwSZXZakQahRnMs9uzZw5w5c+jcuTMrV67kwQcfZMyYMfztb3+74GMyMjKw2+3nbtHR0ZcdWkSkXoSGQm4upKQAcKBpC4aPepE3rx2OYbEy8lgeyyb2V6kQ+QGLYRjGpR4cEBBA7969+fzzz8/tGzNmDOvXr+eLL774ycf81IhFdHQ0xcXFhIWFXUZ0EZF6UlFB9rVDmNT315QGNiGsvJSMT//MoK+Xg79WJJXGweFwYLfbL/r+XaNTIW3atKFHjx7n7evevTuLFi264GMCAwMJDAysydOIiDQYJeWVTPrzahbf+jAAVx3cysxlr9C25ATk5EBqqskJRRqWGp0KSU1NZceOHeft27lzJ7GxsR4NJSLSEHxzoJBfzP43iw9XYnW7GH9yA5nP3Enbm6pPjbB0qbkBRRqgGo1YjB8/npSUFF544QVGjBhBTk4Ob7/9Nm+//XZd5RMRqXcut8Gc1fm89tEuXG6DtsEWZkWdpfd/T6qexJmdDZmZoF+qRH6kRnMsAN5//32efPJJdu3aRVxcHBMmTPjZT4X8p0s9RyMiYoajxWcZPy+PL/ecBmBwYhTPD+uJPVhzKaRxu9T37xoXi8ulYiEiDdWKLUd5fNFmis9W0iTAxnNDe3LXFW21eJgIdTR5U0TEF52tcPHc+9vIzDkAQEI7O7PSkolrEWJyMhHvo2IhIo3atiMOHs78ht0nygD4bd8OPHJLVwL8aryUkoigYiEijZRhGMz9bB/Tl2+nwuUmMjSQGSOSuK5zC7OjiXg1FQsRaXROlDiZuHAjq3ecAKB/90heujuRiJAAk5OJeD8VCxFpVFbvKODRBZs4WeokwM/K04O681/XxmqCpoiHqFiISKPgrHLx0ood/HXdXgC6tgpldnoyXVuHmpxMxLeoWIiIz8svKGVMZi7bjlavrnxPn1ie+kV3gvxtJicT8T0qFiLiswzDYN76gzy7bBtnK100a+LPy3cn0r9HK7OjifgsFQsR8UlFZyp48r3NLN9yDIDrOrXg1RGJtAoLMjmZiG9TsRARn/PVnlOMm5fH0eJy/KwWJg7oym+u74DVqgmaInVNxUJEfEaly83sj3fx5qf5uA1o37wJs9OTSWgXbnY0kUZDxUJEfMLB02cYk5VL7oEiAIZf2Y5nhsQTEqgfcyL1Sf/iRMTrLck7zNPZWyhxVhEa5Me0O3oxJDHK7FgijZKKhYh4rVJnFZMXb+G93MMAXBnbjJkjk4iOaGJyMpHGS8VCRLxS3sEixmblsv/UGawWePimzjx8Uyf8bFo8TMRMKhYi4lVcboO31u5mxoc7qXIbtA0PZmZaEle1jzA7moigYiEiXuRYcTnj5+XxxZ5TAAzq1YYX7uiFvYm/yclE5DsqFiLiFVZuPcbjizZRdKaSYH8bzw6JZ3jvdlo8TKSBUbEQkQbtbIWL5z/Yxj+/OgBAz7ZhzEpLpmPLpiYnE5GfomIhIg3Wt0cdjMnMZVdBKQD/c0MHHr21KwF+mqAp0lCpWIhIg2MYBn/7fB8vLN9ORZWblqGBzBiRyPWdW5odTUQuQsVCRBqUU6VOJi7cxCfbCwC4qVskL9+dQPOmgSYnE5FLoWIhIg3G2p0neGTBRk6UOAnws/LUwG7cm9JeEzRFvIiKhYiYrqLKzSsf7uDttXsA6BzZlNnpyXRvE2ZyMhGpKRULETHV7hOljM3KZcthBwC/ujaGpwf1IMjfZnIyEakNFQsRMYVhGCz4+hBTlm7lbKWL8Cb+vHRXArfGtzY7mohcBhULEal3xWcqeSp7Mx9sPgpAnw7NeW1kEq3tQSYnE5HLpWIhIvVq/b7TjMvK43DRWfysFibc2oXf3tARm1UTNEV8gYqFiNSLKpeb2Z/k88Ynu3AbENu8CbPSkkmKDjc7moh4kIqFiNS5g6fPMG5eHhv2FwJw5xVteW5oT5oG6keQiK/Rv2qR+mIYsGYN9O0Ljei6DMs2HuGp7M2UlFcRGujH83f0ZGhSW7NjiUgdqdEF95955hksFst5t27dutVVNhHfsmIF9OsHK1eanaRelDqreHTBRh7OzKWkvIrkmHD+NfZ6lQoRH1fjEYv4+Hg++uij77+AnwY9RC7JwoXf3992m7lZ6timQ0WMycxl36kzWC3wUL9OjLm5M342LR4m4utq3Ar8/Pxo3VqfMxe5KLcb5syBoqLq7R8Wi7i46j+Hh8ODD4LVN95w3W6Dt/+9h1dW7qDKbdDGHsTMkUlc06G52dFEpJ7UuFjs2rWLqKgogoKC6NOnDxkZGcTExFzweKfTidPpPLftcDhql1TE25SVweTJcPp09ZyK78pDaSlMmlQ95yIiAu65B0JDzc3qAccd5UyYn8dn+acAGNizNdPvTMDexN/kZCJSn2r0a9I111zDO++8w4oVK5gzZw579+7l+uuvp6Sk5IKPycjIwG63n7tFR0dfdmgRrxAaCrm5kJJSve1ynX+fkgJ5eT5RKj7adpzbZq7ls/xTBPvbmH5nL/446gqVCpFGyGIYhlHbBxcVFREbG8uMGTP49a9//ZPH/NSIRXR0NMXFxYSFaYEhaQQqKqpHJsrKvt8XEgKFheDv3W+85ZUuXvjXt/z9i/0A9GgTxuz0ZDpFNjU5mYh4msPhwG63X/T9+7JmXoaHh9OlSxfy8/MveExgYCCBgYGX8zQi3i0n5/xSAdXbOTmQmmpOJg/YcayEMZm57DhePWL539fFMfG2rgT6afEwkcbssmaMlZaWsnv3btq0aeOpPCK+Z9my6vthwyA/H4YOrd5eutS0SJfDMAz+/sU+Br+xjh3HS2jRNIB37r+Kp2/voVIhIjUbsXj00UcZPHgwsbGxHDlyhClTpmCz2UhPT6+rfCLeb8gQSEyE9PTqSZzZ2ZCZCbGxZiersdNlFTy2cCMffVsAwI1dW/Ly3Ym0DNWopIhUq1GxOHToEOnp6Zw6dYqWLVty3XXX8eWXX9KyZcu6yifi/VJTzz/lYbHAL39pXp5aWrfrJBPm51FQ4iTAZuWJgd24P7U9lkZ0FVERubgaFYusrKy6yiEiDVRFlZtXV+3g7bV7MAzoFNmU2WnJ9IjS5GsR+TFdNlNELmjvyTLGZOay+XAxAL+8JoZJg3oQHKC5FCLy01QsRORHDMNg4YZDTFm6lTMVLuzB/rx4Vy9u66mJ2iLy81QsROQ8xWcreXrxFpZtPALAtR0ieG1kEm3swSYnExFvoGIhIud8ve80Y7PyOFx0FpvVwoRbuvC7vh2xWTVBU0QujYqFiFDlcvPmp7uZ9fFO3AbERDRhVloSyTHNzI4mIl5GxUKkkTtUeIbx8/JYv68QgDuS2/Lc0HhCg7z7cuMiYg4VC5FG7INNR3nivU2UlFfRNNCPqcPiuSO5ndmxRMSLqViINEJlziqeXbaV+V8fAiApOpxZaUnENg8xOZmIeDsVC5FGZsvhYsZk5rLnZBkWC4y+sRNj+3fG33ZZSweJiAAqFiKNhttt8Nd1e3lp5XYqXQatw4J4bWQSfTo2NzuaiPgQFQuRRqDAUc4jCzby710nARgQ34oX70ogvEmAyclExNeoWIj4uE+2H+fRBZs4XVZBkL+VybfHk351tBYPE5E6oWIh4qPKK11MX76ddz7fB0D3NmG8np5Ep8hQc4OJiE9TsRDxQTuPlzAmM5ftx0oAeCA1jsdu60qQvxYPE5G6pWIh4kMMw+AfXx3g+fe34axy0zwkgFeGJ9KvW6TZ0USkkVCxEPERp8sqeHzRJlZtOw7ADV1a8srwBCJDg0xOJiKNiYqFiA/4PP8k4+fncdzhxN9m4fHbuvFAahxWLR4mIvVMxULEi1W63MxYtZM/rdmNYUCHliHMTkumZ1u72dFEpJFSsRDxUvtOljE2K5eNh4oBSL86mkm396BJgP5Zi4h59BNIxMsYhsF73xxm8pItlFW4CAvyY/pdCfyiVxuzo4mIqFiIeBNHeSWTFm9hSd4RAK6Oi2DmyCSiwoNNTiYiUk3FQsRLbNhfyNisXA4VnsVmtTDu5s78vl8nbJqgKSINiIqFSAPnchv88dN8Zn68C5fboF2zYGalJXNlbDOzo4mI/IiKhUgDdqToLOPm5ZGz9zQAQ5OimDqsJ2FB/iYnExH5aSoWIg3U8s1HeXzRJhzlVYQE2HhuaE/uvKKtFg8TkQZNxUKkgTlTUcXU97eRmXMQgMR2dmalJdO+RYjJyURELk7FQqQB2XK4mDFZuew5UYbFAr/r25EJt3TB32Y1O5qIyCVRsRBpANxug//9bC8vrdhBhctNq7BAXhuRREqnFmZHExGpERULEZMVlJTz6IJNrN15AoBberTipbsSaBYSYHIyEZGaU7EQMdGnOwqYuGAjJ0srCPSzMun2Hoy6JkYTNEXEa6lYiJjAWeVi+vLtzP1sHwDdWocyOz2ZLq1CzQ12uQwD1qyBvn1B5UikUbqsGWHTp0/HYrEwbtw4D8UR8X35BSUMe/Pzc6XivpT2LB6d6v2lAmDFCujXD1auNDuJiJik1iMW69ev56233iIhIcGTeUR8lmEYZOYc5Ln3t1Je6SYiJIBXhidwU7dWZkfznIULv7+/7TZzs4iIKWpVLEpLSxk1ahR//vOfef755z2dScTnFJZV8MR7m1i59TgA13duwavDE4kMCzI52WVyu2HOHCgqqt7+YbGIi6v+c3g4PPggWPWRWZHGoFbFYvTo0QwaNIj+/ftftFg4nU6cTue5bYfDUZunFPFaX+w+xfh5eRxzlONvs/DYgG78+ro4rL6weFhZGUyeDKdPV8+p+K48lJbCpEnVcy4iIuCeeyDUB071iMhF1fhXiKysLL755hsyMjIu6fiMjAzsdvu5W3R0dI1DinijSpebl1du55d/+ZJjjnI6tAgh+/ep/OaGDr5RKqC6LOTmQkpK9bbLdf59Sgrk5alUiDQiFsMwjEs9+ODBg/Tu3ZtVq1adm1tx4403kpSUxMyZM3/yMT81YhEdHU1xcTFhYWGXl16kgTpw6gxjsnLJO1gEwMje0Uwe3IOQQB/9IFZFRfXIRFnZ9/tCQqCwEPy1YJqIL3A4HNjt9ou+f9fop9yGDRsoKCjgiiuuOLfP5XKxdu1a3njjDZxOJzab7bzHBAYGEhgYWMP4It4rO/cQkxZvpdRZRViQHxl3JjAooY3ZsepWTs75pQKqt3NyIDXVnEwiYooanQq5+eab2bx5M3l5eeduvXv3ZtSoUeTl5f2oVIg0JiXllYyfl8f4eRspdVZxVftmLB93g++XCoBly6rvhw2D/HwYOrR6e+lS0yKJiDlqNGIRGhpKz549z9sXEhJC8+bNf7RfpDH55kAhY7NyOXj6LFYLjL25C6P7dcSvsSweNmQIJCZCenr1JM7sbMjMhNhYs5OJSD3z0RO+IvXD5Tb405rdzFi1E5fboG14MLPSkujdPsLsaPUrNfX8Ux4WC/zyl+blERHTXHaxWL16tQdiiHifo8VnGT8vjy/3nAZgcGIUzw/riT1YkxVFpPHSiIVILazYcozHF22i+GwlTQJsPDe0J3dd0VaLh4lIo6diIVIDZytcTP1gG+9+dQCAhHZ2ZqUlE9cixORkIiINg4qFyCXadsTBw5nfsPtE9ccqf9u3A4/c0pUAv0YyQVNE5BKoWIhchGEYzP1sH9OXb6fC5SYyNJAZI5K4rnMLs6OJiDQ4KhYiP+NEiZOJCzeyescJAPp3j+SluxOJCAkwOZmISMOkYiFyAWt2nuCR+Rs5Weok0M/K04O686trYzVBU0TkZ6hYiPwHZ5WLl1fs4C/r9gLQtVUos9OT6dpaC2mJiFyMioXID+QXlDImM5dtRx0A3NMnlqd+0Z0gf12uXkTkUqhYiFA9QXPe+oM8u2wbZytdNGviz8t3J9K/Ryuzo4mIeBUVC2n0is5U8OR7m1m+5RgA13VqwasjEmkVFmRyMhER76NiIY3aV3tOMW5eHkeLy/GzWpg4oCu/ub4DVqsmaIqI1IaKhTRKlS43sz/exZuf5uM2IK5FCLPSkkhoF252NBERr6ZiIY3OwdNnGJOVS+6BIgCGX9mOZ4bEExKofw4iIpdLP0mlUVmSd5ins7dQ4qwiNMiPaXf0YkhilNmxRER8hoqFNAqlziomL97Ce7mHAbgythkzRyYRHdHE5GQiIr5FxUJ8Xt7BIsZm5bL/1BmsFnj4ps48fFMn/GxaPExExNNULMRnudwGf1qzm9dW7aTKbdA2PJiZaUlc1T7C7GgiIj5LxUJ80rHicsbPy+OLPacAGNSrDS/c0Qt7E3+Tk4mI+DYVC/E5K7ce4/FFmyg6U0mTABvPDIln+JXttHiYiEg9ULEQn3G2wsXzH2zjn18dAKBn2zBmpyXToWVTk5OJiDQeKhbiE7496mBMZi67CkoB+O0NHXjk1q4E+GmCpohIfVKxEK9mGAbvfL6PjOXbqahy0zI0kBkjErm+c0uzo4mINEoqFuK1TpU6mbhwE59sLwDgpm6RvHx3As2bBpqcTESk8VKxEK+0ducJHlmwkRMlTgL8rPzhF925p0+sJmiKiJhMxUK8SkWVm5dXbufP/94LQOfIpsxOT6Z7mzCTk4mICKhYiBfZfaKUsVm5bDnsAOC/ro3lD4O6E+RvMzmZiIh8R8VCGjzDMJj/9UGeWbqNs5Uuwpv489JdCdwa39rsaCIi8h9ULKRBKz5TyVPZm/lg81EAUjo2Z8aIJFrbg0xOJiIiP0XFQhqsnL2nGZeVy5HicvysFh65tSv/c0MHbFZN0BQRaahULKTBqXK5mf1JPm98sgu3AbHNmzA7LZnE6HCzo4mIyEWoWEjDYRgcXP4p4/YHsWF/IQB3XdGOZ4fG0zRQ/6uKiHiDGl3veM6cOSQkJBAWFkZYWBh9+vRh+fLldZVNGpmlf1/OL1adZMP+QkID/ZiVlsSrIxJVKkREvEiNfmK3a9eO6dOn07lzZwzD4G9/+xtDhw4lNzeX+Pj4usooPq7UWcUzS7ey8FsDAkO4ovIUsx67m+iIJmZHExGRGqpRsRg8ePB529OmTWPOnDl8+eWXKhZSc243G2f+lbEnmrPPCMTqdjP6y/mM3fwBfhEHq48JD4cHHwSrFhMTEfEGtR5jdrlcLFiwgLKyMvr06XPB45xOJ06n89y2w+Go7VOKD3G7Dd7+aDuvHIukyupHlOMEr/1rBtfs3ww2G0yaBIYBERFwzz0QGmp2ZBERuQQ1LhabN2+mT58+lJeX07RpU7Kzs+nRo8cFj8/IyODZZ5+9rJDiW447ypkwP4/P8k+B1Y9fnPiWjHefxV5eveQ5LhdYLJCSAllZKhUiIl7EYhiGUZMHVFRUcODAAYqLi1m4cCF/+ctfWLNmzQXLxU+NWERHR1NcXExYmNZ3aGxWbTvOYws3UnimkmB/G88M6cGIhFZYmjeHsrLvDwwJgcJC8Pc3L6yIiJzjcDiw2+0Xff+ucbH4T/3796djx4689dZbHg0mvqW80sW0D77l/77cD0B8VBiz0pLpFNkU1q2D66//8YPWrYPU1HpOKiIiP+VS378ve0ac2+0+b0RC5D9tP+ZgyBvrzpWK31wfx3u/T6kuFQDLllXfDxsG+fkwdGj19tKl9R9WREQuS43mWDz55JMMHDiQmJgYSkpKePfdd1m9ejUrV66sq3zixQzD4O9f7Gfav76lospNi6aBvDoikb5dWp5/4JAhkJgI6enVcyuysyEzE2JjzQkuIiK1VqNiUVBQwD333MPRo0ex2+0kJCSwcuVKbrnllrrKJ17qVKmTxxZu4uPtBQD069qSl4cn0qJp4I8PTk09/5SHxQK//GU9JRUREU+qUbH461//Wlc5xIes23WSCfPzKChxEmCz8uQvunFfSnssFi0eJiLi63StZPGYiio3r364g7fW7gGgU2RTZqcl0yNKk3RFRBoLFQvxiD0nShmblcfmw8UAjLomhqcH9SA4wGZyMhERqU8qFnJZDMNgwYZDPLN0K2cqXIQ38efFuxIYEN/a7GgiImICFQupteKzlfwhezPvbzoKwLUdInhtZBJt7MEmJxMREbOoWEitfL3vNGOz8jhcdBY/q4UJt3bhtzd0xGbVBE0RkcZMxUJqpMrl5o1P85n98S7cBsRENGF2ejJJ0eFmRxMRkQZAxUIu2aHCM4yfl8f6fYUA3JnclmeHxhMapPU8RESkmoqFXJL3Nx3hyfc2U1JeRdNAP54f1pNhyW3NjiUiIg2MioX8rDJnFc8u28r8rw8BkBQdzuy0ZGKaNzE5mYiINEQqFnJBmw8VMzYrlz0ny7BY4KF+nRhzc2f8bZe9dp2IiPgoFQv5Ebfb4C/r9vDyyh1Uugza2IN4bWQS13ZobnY0ERFp4FQs5DwFjnIeWbCRf+86CcBt8a2ZflcvwpsEmJxMRES8gYqFnPPxt8eZuHATp8sqCPK3MmVwPGlXRWvxMBERuWQqFkJ5pYvpy7fzzuf7AOjRJozZ6cl0imxqbjAREfE6KhaN3M7jJYzJzGX7sRIAfn1dHI/d1pVAPy0eJiIiNadi0UgZhsE/vjrA8+9vw1nlpkXTAF4ZnsiNXSPNjiYiIl5MxaIROl1WweOLNrFq23EA+nZpySvDE2kZGmhyMhER8XYqFo3M5/knGT8/j+MOJwE2K48P7Mb9Ke2xavEwERHxABWLRqLS5ebVD3fy1trdGAZ0bBnC7PRk4qPsZkcTEREfomLRCOw7WcbYrFw2HioGIP3qGCbf3oPgAE3QFBERz1Kx8GGGYbDom8NMWbKFsgoX9mB/XryrF7f1bGN2NBER8VEqFj7KUV7J09lbWLrxCADXxEUwMy2JNvZgk5OJiIgvU7HwQRv2FzI2K5dDhWexWS1MuKULv+vbEZsmaIqISB1TsfAhLrfBm5/mM+vjXbjcBtERwcxOSyY5ppnZ0UREpJFQsfARh4vOMj4rj5x9pwEYlhTF1GE9CQ3yNzmZiIg0JioWPuBfm4/yxKJNOMqraBrox9Rh8dyR3M7sWCIi0gipWHixMxVVPLdsG1nrDwKQGB3O7LQkYpuHmJxMREQaKxULL7XlcDFjsnLZc6IMiwV+f2NHxvXvgr/NanY0ERFpxFQsvIzbbfC/n+3lxRXbqXQZtA4L4rWRSfTp2NzsaCIiIioW3qSgpJxHF2xi7c4TAAyIb8X0OxNoFhJgcjIREZFqKhZe4tMdBUxcsJGTpRUE+VuZfHs86VdHY7Ho2hQiItJw1OiEfEZGBldddRWhoaFERkYybNgwduzYUVfZBCivdPHssq3cP3c9J0sr6Fawl2VJ8MtrYlQqRESkwalRsVizZg2jR4/myy+/ZNWqVVRWVnLrrbdSVlZWV/katV3HS7jjj58z97N9ADxwZheL/z6BzssXmRtMRETkAmp0KmTFihXnbb/zzjtERkayYcMGbrjhBo8Ga8wMw+DdnANMfX8b5ZVumlsqeSXoAP3mTAFXJSxcCHFx1QeHh8ODD4JVnwYRERHzXdYci+Li6mW4IyIiLniM0+nE6XSe23Y4HJfzlD6vsKyCJ97bxMqtxwG44eAmXlnyEpFnir8vD6WlMGkSGAZERMA990BoqImpRUREqtX611y32824ceNITU2lZ8+eFzwuIyMDu91+7hYdHV3bp/R5n+8+ycBZ/2bl1uP42yw8Pag777zwSyITe1Qf4HKdf5+SAnl5KhUiItJgWAzDMGrzwAcffJDly5ezbt062rW78OWjf2rEIjo6muLiYsLCwmrz1D6n0uVm5kc7+ePq3RgGdGgZwuy0ZHq2tVcfUFFRPTLxw7ksISFQWAj+WgtERETqnsPhwG63X/T9u1anQh566CHef/991q5d+7OlAiAwMJDAwMDaPE2jsP9UGWOy8th4sAiA9KujmXR7D5oE/OBbk5NzfqmA6u2cHEhNrb+wIiIiF1GjUyGGYfDQQw+RnZ3NJ598Qtx3EwilVrJzDzFo9jo2HiwiLMiPP466gow7E84vFQDLllXfDxsG+fkwdGj19tKl9ZpXRETkYmo0YjF69GjeffddlixZQmhoKMeOHQPAbrcTHBxcJwF9UUl5JZMWb2Fx3hEAro6LYObIJKLCL/B3OGQIJCZCejpYLJCdDZmZEBtbj6lFREQurkZzLC50Qaa5c+dy3333XdLXuNRzNL7qmwOFjM3K5eDps9isFsbd3Jnf9+uEzaqLXYmISMNVJ3MsajnPUwCX22DO6nxe+2gXLrdBu2bBzEpL5srYZmZHExER8RitFVIPjhSdZfy8PL7aexqAIYlRPH9HT8KC9IkOERHxLSoWdWzFlqM8vmgzxWcrCQmw8dzQntx5RVut8yEiIj5JxaKOnKmoYur735KZcwCAxHZ2ZqUl075FiMnJRERE6o6KRR3YeqSYMZm57D5RhsUCv+vbkfH9uxDgp/U8RETEt6lYeJDbbTD38328uHw7FS43rcICeW1EEimdWpgdTUREpF6oWHjIiRInjy7YyJqdJwDo370VL92dQERIgMnJRERE6o+KhQes3lHAows2crK0gkA/K0/f3oNfXROjCZoiItLoqFhcBmeVi5dW7OCv6/YC0K11KLPTk+nSSquNiohI46RiUUv5BSU8nJnHt0cdANyX0p4nBnYjyN9mcjIRERHzqFjUkGEYZK0/yLPLtlJe6SYiJICX707g5u6tzI4mIiJiOhWLGig6U8ETizazYmv14mvXd27Bq8MTiQwLMjmZiIhIw6BicYm+3HOK8fPyOFpcjr/NwmMDuvHr6+KwavEwERGRc1QsLqLS5WbWR7t4c3U+hgFxLUKYnZZMr3Z2s6OJiIg0OCoWP+PAqTOMnZdL7oEiAEb0bseUwfGEBOqvTURE5KfoHfICluQd5g/ZWyh1VhEa5EfGnb24PSHK7FgiIiINmorFfygpr2TKkq28l3sYgN6xzZiZlkS7Zk1MTiYiItLwqVj8QN7BIsZk5nLg9BmsFhhzc2ce6tcJP5sWDxMREbkUKhaAy23wpzW7eW3VTqrcBm3Dg5mVlkTv9hFmRxMREfEqjb5YHC0+y4R5G/lizykAbk9ow7Q7emEP9jc5mYiIiPdp1MVi5dZjPL5oE0VnKmkSYOPZIfHcfWU7LR4mIiJSS42yWJytcDH1g228+9UBAHq1tTMrLYkOLZuanExERMS7Nbpise2IgzFZueQXlALw2xs68MitXQnw0wRNERGRy9VoioVhGLzz+T4y/rWdCpebyNBAZoxI4rrOLcyOJiIi4jMaRbE4Wepk4oKNfLrjBAD9u0fy4l0JNG8aaHIyERER3+LzxWLNzhM8Mn8jJ0udBPhZeXpQd/7r2lhN0BQREakDPlssnFUuXl6xg7+s2wtAl1ZNmZ2eTLfWYSYnExER8V0+WSx2nyhlTGYuW484ALinTyxP/aI7Qf42k5OJiIj4Np8qFoZhMG/9QZ5dto2zlS6aNfHnpbsTuaVHK7OjiYiINAo+UyyKz1TyZPYm/rX5GACpnZozY0QSrcKCTE4mIiLSePhEsTjuKOeONz/jSHE5flYLjw7oyv9c3wGrVRM0RURE6pNPFIvI0EB6RIURUOlk1n19SIxpZnYkERGRRqnGl5tcu3YtgwcPJioqCovFwuLFi+sgVs1YLBZeaXaC96fdTeK2r8yOIyIi0mjVuFiUlZWRmJjIm2++WRd5ai18ySKaVpyFhQvNjiIiItJo1fhUyMCBAxk4cGBdZKkZtxvmzIGiourt7wrFwoUQF1f95/BwePBBsGodEBERkfpQ53MsnE4nTqfz3LbD4fDMFy4rg8mT4fRpsFi+Lw+lpTBpEhgGRETAPfdAaKhnnlNERER+Vp3/Kp+RkYHdbj93i46O9swXDg2F3FxISanedrnOv09Jgbw8lQoREZF6VOfF4sknn6S4uPjc7eDBg5774jEx8Omn0KTJ+fubNIHVq8FTJUZEREQuSZ2fCgkMDCQwsA5XEc3JqT4t8kNlZdX7U1Pr7nlFRETkR7x/VuOyZdX3w4ZBfj4MHVq9vXSpaZFEREQaqxqPWJSWlpKfn39ue+/eveTl5REREUFMTIxHw12SIUMgMRHS06sncWZnQ2YmxMbWfxYREZFGzmIYhlGTB6xevZp+/fr9aP+9997LO++8c9HHOxwO7HY7xcXFhIVpCXMRERFvcKnv3zUesbjxxhupYRcRERGRRsL751iIiIhIg6FiISIiIh6jYiEiIiIeo2IhIiIiHqNiISIiIh6jYiEiIiIeo2IhIiIiHqNiISIiIh6jYiEiIiIeU+erm/6n767a6XA46vupRUREpJa+e9++2NW3671YlJSUABAdHV3fTy0iIiKXqaSkBLvdfsH/XuNFyC6X2+3myJEjhIaGYrFYPPZ1HQ4H0dHRHDx40GcXN/P116jX5/18/TXq9Xk/X3+Ndfn6DMOgpKSEqKgorNYLz6So9xELq9VKu3bt6uzrh4WF+eT/LD/k669Rr8/7+fpr1Ovzfr7+Guvq9f3cSMV3NHlTREREPEbFQkRERDzGZ4pFYGAgU6ZMITAw0OwodcbXX6Nen/fz9deo1+f9fP01NoTXV++TN0VERMR3+cyIhYiIiJhPxUJEREQ8RsVCREREPEbFQkRERDzGZ4rFm2++Sfv27QkKCuKaa64hJyfH7Eges3btWgYPHkxUVBQWi4XFixebHcljMjIyuOqqqwgNDSUyMpJhw4axY8cOs2N51Jw5c0hISDh3wZo+ffqwfPlys2PVmenTp2OxWBg3bpzZUTzmmWeewWKxnHfr1q2b2bE86vDhw/zqV7+iefPmBAcH06tXL77++muzY3lE+/btf/T9s1gsjB492uxoHuNyuZg0aRJxcXEEBwfTsWNHpk6detF1PeqCTxSLefPmMWHCBKZMmcI333xDYmIiAwYMoKCgwOxoHlFWVkZiYiJvvvmm2VE8bs2aNYwePZovv/ySVatWUVlZya233kpZWZnZ0TymXbt2TJ8+nQ0bNvD1119z0003MXToULZu3Wp2NI9bv349b731FgkJCWZH8bj4+HiOHj167rZu3TqzI3lMYWEhqamp+Pv7s3z5crZt28arr75Ks2bNzI7mEevXrz/ve7dq1SoAhg8fbnIyz3nxxReZM2cOb7zxBt9++y0vvvgiL730Eq+//nr9hzF8wNVXX22MHj363LbL5TKioqKMjIwME1PVDcDIzs42O0adKSgoMABjzZo1ZkepU82aNTP+8pe/mB3Do0pKSozOnTsbq1atMvr27WuMHTvW7EgeM2XKFCMxMdHsGHXm8ccfN6677jqzY9SbsWPHGh07djTcbrfZUTxm0KBBxgMPPHDevjvvvNMYNWpUvWfx+hGLiooKNmzYQP/+/c/ts1qt9O/fny+++MLEZFIbxcXFAERERJicpG64XC6ysrIoKyujT58+ZsfxqNGjRzNo0KDz/i36kl27dhEVFUWHDh0YNWoUBw4cMDuSxyxdupTevXszfPhwIiMjSU5O5s9//rPZsepERUUF//jHP3jggQc8uhCm2VJSUvj444/ZuXMnABs3bmTdunUMHDiw3rPU+yJknnby5ElcLhetWrU6b3+rVq3Yvn27SamkNtxuN+PGjSM1NZWePXuaHcejNm/eTJ8+fSgvL6dp06ZkZ2fTo0cPs2N5TFZWFt988w3r1683O0qduOaaa3jnnXfo2rUrR48e5dlnn+X6669ny5YthIaGmh3vsu3Zs4c5c+YwYcIEnnrqKdavX8+YMWMICAjg3nvvNTueRy1evJiioiLuu+8+s6N41BNPPIHD4aBbt27YbDZcLhfTpk1j1KhR9Z7F64uF+I7Ro0ezZcsWnzp3/Z2uXbuSl5dHcXExCxcu5N5772XNmjU+US4OHjzI2LFjWbVqFUFBQWbHqRM//K0vISGBa665htjYWObPn8+vf/1rE5N5htvtpnfv3rzwwgsAJCcns2XLFv70pz/5XLH461//ysCBA4mKijI7ikfNnz+ff/7zn7z77rvEx8eTl5fHuHHjiIqKqvfvodcXixYtWmCz2Th+/Ph5+48fP07r1q1NSiU19dBDD/H++++zdu1a2rVrZ3YcjwsICKBTp04AXHnllaxfv55Zs2bx1ltvmZzs8m3YsIGCggKuuOKKc/tcLhdr167ljTfewOl0YrPZTEzoeeHh4XTp0oX8/Hyzo3hEmzZtflRyu3fvzqJFi0xKVDf279/PRx99xHvvvWd2FI+bOHEiTzzxBGlpaQD06tWL/fv3k5GRUe/FwuvnWAQEBHDllVfy8ccfn9vndrv5+OOPfe4cti8yDIOHHnqI7OxsPvnkE+Li4syOVC/cbjdOp9PsGB5x8803s3nzZvLy8s7devfuzahRo8jLy/O5UgFQWlrK7t27adOmjdlRPCI1NfVHH/PeuXMnsbGxJiWqG3PnziUyMpJBgwaZHcXjzpw5g9V6/lu6zWbD7XbXexavH7EAmDBhAvfeey+9e/fm6quvZubMmZSVlXH//febHc0jSktLz/vNaO/eveTl5REREUFMTIyJyS7f6NGjeffdd1myZAmhoaEcO3YMALvdTnBwsMnpPOPJJ59k4MCBxMTEUFJSwrvvvsvq1atZuXKl2dE8IjQ09EdzYkJCQmjevLnPzJV59NFHGTx4MLGxsRw5coQpU6Zgs9lIT083O5pHjB8/npSUFF544QVGjBhBTk4Ob7/9Nm+//bbZ0TzG7XYzd+5c7r33Xvz8fOKt7zyDBw9m2rRpxMTEEB8fT25uLjNmzOCBBx6o/zD1/jmUOvL6668bMTExRkBAgHH11VcbX375pdmRPObTTz81gB/d7r33XrOjXbafel2AMXfuXLOjecwDDzxgxMbGGgEBAUbLli2Nm2++2fjwww/NjlWnfO3jpiNHjjTatGljBAQEGG3btjVGjhxp5Ofnmx3Lo5YtW2b07NnTCAwMNLp162a8/fbbZkfyqJUrVxqAsWPHDrOj1AmHw2GMHTvWiImJMYKCgowOHToYf/jDHwyn01nvWbRsuoiIiHiM18+xEBERkYZDxUJEREQ8RsVCREREPEbFQkRERDxGxUJEREQ8RsVCREREPEbFQkRERDxGxUJEREQ8RsVCREREPEbFQkRERDxGxUJEREQ8RsVCREREPOb/AXqDV/Degy5wAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(x, est_y)\n",
    "plt.scatter(x, y, color='red', marker='*')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Atención\n",
    "\n",
    "Este tutorial es basado en el  Curso de Estadística Computacional con Python de Platzi."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "platzi",
   "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.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}