3.Estadistica.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Figures/top_ML.png\" alt=\"Drawing\" style=\"width: 1000px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Estadística "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CONTENIDOS\n",
    "\n",
    "* Introducción a Pandas\n",
    "* Creación de gráficos\n",
    "  \n",
    "Estadística descriptiva y EDA:\n",
    "* Muestra vs Población\n",
    "* Resumen y limpieza de datos\n",
    "* Estadística descriptiva\n",
    "* Probabilidad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Introducción a Pandas\n",
    "\n",
    "Padas es de las librerías más importantes en Python para Data Science!!! Básicamente nos permitirá tener ``Datasets`` abiertos como si se trataran de una hoja de cálculo en el excel, es decir, en forma matricial con dos dimensiones y con columnas e idices indexados.\n",
    "\n",
    "<img src=\"Figures/Pandas.jpg\" alt=\"Drawing\" style=\"width: 800px;\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas sirve para:\n",
    "* Operar en todo el dataset o a una fila o columna (vectores) con alta eficiencia computacional\n",
    "* Ayuda a la limpieza de datos y solucionar datos inexistentes\n",
    "* Acceder a subsets de datos\n",
    "* Añadir o eliminar columnas con nuevas características.\n",
    "* Agrupar datos por características.\n",
    "* Muy eficiente juntando datos de distintas fuentes.\n",
    "* Trabajar con series temporales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.1 Leer datos de un csv\n",
    "\n",
    "La mayoría de las veces cargaremos los archivos a través de un archivo .csv. A continuación podeis ver el código básico que se usará casi siempre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd #importamos Pandas!\n",
    "EV_Data = pd.read_csv('Data/ElectricCarData_Clean.csv')\n",
    "EV_Data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.2 Inspección datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos saber qué dimensiones tiene este DataFrame, podemos mirar su 'forma'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay 103 entradas y 14 características para cada entrada.\n",
    "\n",
    "Puede ser muy útil ver las primeras o últimas entradas del dataset para entender mejor estos datos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos saber el nombre de las columnas o índices, podemos acceder a ellos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.columns[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, para tener un resumen muy bueno, es muy util el metodo ``describe``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.3 Seleccionar datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos trabajar o seleccionar solo con una parte del dataset, podemos usar **[ ]** después del nombre del dataset, e indicar qué columnas se desean seleccionar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data[['Model','TopSpeed_KmH', 'PriceEuro']].head(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si, por el contrario se quiere seleccionar una parte de las filas, se indicará usando *slicing* como en los strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### loc vs iloc\n",
    "\n",
    "Para seleccionar partes más específicas (más de una columna, varias columnas y solo unas filas de éstas,...), se usará la indexación con el loc o iloc. La única diferencia entre los dos, es que el primero se basa en la *etiqueta* de las filas o columnas, mientras que iloc se basa en el *índice* de estas. Con un ejemplo se entiende mejor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.loc[3:5,['Model','TopSpeed_KmH', 'PriceEuro']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.iloc[3:5,1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se debe tener en cuenta que el índice no será siempre un número y puede tratar-se de otro parámetro. Por ejemplo, podemos poner el día como índice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.4 Filtrar datos\n",
    "\n",
    "Otra manera de seleccionar solo una parte del dataset es aplicar *Boolena indexing*, que no es nada más que aplicar un filtro a los datos. Por ejemplo, vamos a seleccionar solo aquellos días en los que la energia máxima ha sido mayor a 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data['PriceEuro'] > 50000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se puede observar ahora tenemos seleccionadas aquellas columnas que cumplen nuestra condición. ¿Y si lo ponemos directamente dentro del dataset cuando seleccionamos solo una part?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data[EV_Data['PriceEuro'] > 50000]\n",
    "\n",
    "# Aquí vemos que ya no salen todos los Vehiculos Eléctricos con Verdadero o Falso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#####################################################################\n",
    "# Ejemplo. ¿Cuáles son los sedans con menos de 3 seg. de aceleración?\n",
    "\n",
    "Sedan_segment = EV_Data[EV_Data['BodyStyle']=='Sedan']\n",
    "Sedan_segment[Sedan_segment['AccelSec'] < 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio\n",
    "\n",
    "Obtener el número de vehículos con RapidCharge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###### Código aquí"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio\n",
    "\n",
    "Obtener un cuadro resumen de los parámetros para los Vehículos Electricos de Tesla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "########################################################################\n",
    "# vuestro codigo aquí!\n",
    "# Paso 1: Filtrar por Tipo de Vehiculo Tesla\n",
    "# Paso 2: Añadir la funcion .describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.5 Funciones básicas interesantes\n",
    "\n",
    "Aquí podeis ver una lista de las funciones más interesantes a mirar en la documentación, con algun ejemplo:\n",
    "\n",
    "| Función   | Quantitativas | Qualitativas|\n",
    "|-----------|---------------|-------------|\n",
    "| count()   |Número de observaciones non-null|  \n",
    "| sum()     |Suma de valores|\n",
    "| mean()    |Media de las observaciones            | \n",
    "| median()  |Mediana de las observaciones             |\n",
    "| min()     |Valor mínimo|\n",
    "| max()     |Valor máximo|\n",
    "| std()     |Desviación standard|\n",
    "| var()     | Varianza|\n",
    "| value_counts()     | Valores unicos en cada columna - tabla de frec|\n",
    "| nunique()          | Número de valores distintos|\n",
    "| isnull()     | Máscara de valores null o Nan|\n",
    "\n",
    "Practicad con alguno de estos parámetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###################################################################################\n",
    "# ¿Cuál es Vehiculo de menor costo del segmento de los Sedans?\n",
    "\n",
    "Sedan_segment = EV_Data[EV_Data['BodyStyle']=='Sedan']\n",
    "Least_Cost = Sedan_segment.PriceEuro.min()\n",
    "\n",
    "Sedan_segment[Sedan_segment['PriceEuro'] == Least_Cost]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##############################################################\n",
    "# vuestro código aquí!\n",
    "\n",
    "# Ejercicio. \n",
    "\n",
    "# Valor total de Vehiculos Tesla (suma de precios)\n",
    "\n",
    "# ¿Cuántos vehiculos hay por cada una de las marcas?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.6 Manipular dataframes\n",
    "\n",
    "Se puede aplicar una función a alguna columna usando el método *apply* y recordando las fuciones lambda!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(EV_Data['PriceEuro'].head())\n",
    "EV_Data['PriceEuro'] = EV_Data['PriceEuro'].apply(lambda x: x * 0.8)\n",
    "EV_Data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **CUIDADO CON SOBREESCRIBIR VARIABLES!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio\n",
    "\n",
    "Crea una columna nueva llamada 'ID Type' con solo el Tipo de Cargador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##############################################################\n",
    "# vuestro código aquí!\n",
    "EV_Data['PlugType'].unique()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.7 Ordenar\n",
    "\n",
    "Si se desea ordenar valores, se puede usar ``sort_values``. Con un ejemplo se entenderá mejor:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data.sort_values(by='PriceEuro', ascending= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio: Mostrar los 5 vehiculos con aceleración mas lenta.\n",
    "###### Código aquí"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.8 Agrupar\n",
    "\n",
    "Por último, una función muy útil es la de agrupar (group_by).\n",
    "\n",
    "Por ejemplo, imagina que quieres agrupar todos los datos por marcas de vehiculos y además contar el numero de elementos por columna especificas.\n",
    "\n",
    "El resultado de esta operación, será otro dataframe con los datos agrupados respeto a una variable. Además también se deberá indicar qué función de *agregación* se desea usar (max, min, mean, count, sum, etc.).\n",
    "\n",
    "Vamos a implementar el ejemplo comentado!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Group_Style = EV_Data[['Brand', 'Segment', 'PlugType']].groupby('Brand').count()\n",
    "Group_Style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Group_Style = EV_Data[['Brand', 'TopSpeed_KmH', 'Range_Km', 'Efficiency_WhKm', 'FastCharge_KmH']].groupby('Brand').max()\n",
    "Group_Style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ejercicio. Obtener el rango y precio minimo de cada BodyStyle.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.9 Merge\n",
    "\n",
    "Muchas veces tendremos la información deseada en distintas bases de datos, archivos o datasets. Pandas nos ofrece la opción de juntar y fusionar datasets con *merge*.\n",
    "\n",
    "Si cargamos otro dataset con información adicional de cada Vehiculo obtenemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "EV_Data = pd.read_csv('Data/ElectricCarData_Clean.csv')  #Data set original\n",
    "EV_Data.head(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EV_Data_MERGE = pd.read_csv('Data/ElectricCarData_MERGE.csv')\n",
    "EV_Data_MERGE.head(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ver como para algunos de los modelos, nos da información adicional, organizada en nuevas columnas. Para saber más sobre estos, ir directamente al repositorio de este dataset e inspeccionar con detalle.\n",
    "\n",
    "De todos modos, si queremos juntar toda la información en un mismo dataset, tendríamos que hacer un merge:\n",
    "\n",
    "<img src=\"Figures/Panda Data Wrangling Cheat Sheet 2.jpeg\" alt=\"Drawing\" style=\"width: 500px;\"/>\n",
    "\n",
    "\n",
    "Donde los modos *how* posibles se refieren a:\n",
    "\n",
    "<img src=\"Figures/merge_options.png\" alt=\"Drawing\" style=\"width: 500px;\"/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "combinado = pd.merge(EV_Data, EV_Data_MERGE, how='left', on='Model')\n",
    "combinado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Qué sucede cuando seleccionamos INNER o OUTER?\n",
    "pd.merge(EV_Data, EV_Data_MERGE, how='inner', on='Model')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Creación de gáficos\n",
    "\n",
    "En Python existen diversas librerías para crear gráficos como Bokeh, altair, Pandas o Matplotlib\n",
    "\n",
    "<img src=\"Figures/four_logos.png\" alt=\"Drawing\" style=\"width: 800px;\"/>\n",
    "\n",
    "En este curso aprenderemos las funciones básicas de matplotlib, ya que las otras librerías siempre estan basadas en esta y nos ayudará a luego saber usarlas también."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.1 Matplotlib.pyplot\n",
    "\n",
    "El módulo que se usa es el pyplot de matplotlib. Toda su documentación se puede encontrar aquí:\n",
    "\n",
    "https://matplotlib.org/api/pyplot_api.html#module-matplotlib.pyplot\n",
    "\n",
    "Vamos a importarla!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las dos instancias más importntes en pyplot son\n",
    "* figure: en matplotlib.figure.Figure, una *figure* ser dónde iran los gráficos. Es el lienzo donde puede haber uno o varios gráficos.\n",
    "* axes: eb matplotlib.axes.Axes, econtramos dode iran los gráficos en sí\n",
    "\n",
    "Vamos a crear un primer gráfico de prueba:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1,2,3,4],[1,4,8,16])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso hemos creado un gráfico usando plot, donde el primer argumento es el eje de las x y el segundo el de las y (deben ser de la smismas dimensiones).\r\n",
    "\r\n",
    "Podemos añadir otra información como título y nombre de los ejes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1,2,3,4],[1,4,8,16])\n",
    "plt.title('Nuestro primer plot!')\n",
    "plt.xlabel('eje X')\n",
    "plt.ylabel('eje Y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.2 Crear ventanas\n",
    "\n",
    "Si se quiere modificar el tamaño del gráfico, es dóde tendremos que usar el término *figure* comentdo anteriormente. Recordamos que *figure* era el lienzo donde poníamos uno o más gráficos. En este caso, solo ponemos uno.\n",
    "\n",
    "Aquí podemos ver como se puede configurar una *figure* con unas medidas predeterminadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20,5))\n",
    "plt.plot([1,2,3,4],[1,4,8,16])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para cada gráfico también se puede determinar el estilo del gráfico con un tercer argumento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1,2,3,4],[1,4,8,16],'r+')\n",
    "plt.show()\n",
    "\n",
    "# https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html\n",
    "\n",
    "# character\tdescription\n",
    "# '.'\tpoint marker\n",
    "# ','\tpixel marker\n",
    "# 'o'\tcircle marker\n",
    "# 'v'\ttriangle_down marker\n",
    "# '^'\ttriangle_up marker\n",
    "# '<'\ttriangle_left marker\n",
    "# '>'\ttriangle_right marker\n",
    "# '1'\ttri_down marker\n",
    "# '2'\ttri_up marker\n",
    "# '3'\ttri_left marker\n",
    "# '4'\ttri_right marker\n",
    "# '8'\toctagon marker\n",
    "# 's'\tsquare marker\n",
    "# 'p'\tpentagon marker\n",
    "# 'P'\tplus (filled) marker\n",
    "# '*'\tstar marker\n",
    "# 'h'\thexagon1 marker\n",
    "# 'H'\thexagon2 marker\n",
    "# '+'\tplus marker\n",
    "# 'x'\tx marker\n",
    "# 'X'\tx (filled) marker\n",
    "# 'D'\tdiamond marker\n",
    "# 'd'\tthin_diamond marker\n",
    "# '|'\tvline marker\n",
    "# '_'\thline marker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y podemos poner más de un gráfico en el mismo plot, indicando en la leyenda que es cada cosa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([1,2,3,4],[1,4,8,16],'g-',label='primero')\n",
    "plt.plot([1,2,3,4],[1,6,12,6],'r-', label='segundo')\n",
    "plt.title('Ahora son dos!')\n",
    "plt.xlabel('eje X')\n",
    "plt.ylabel('eje Y')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3 Subplots\n",
    "\n",
    "Para poner distintos gráficos con distintos ejes se puede usar Subplots. El métdodo `subplot` tiene 3 argumentos: número de filas, número de columnas e índice. Veamos con un ejemplo como se usa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,2))\n",
    "\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot([1,2,3,4],[1,4,9,16],'go')\n",
    "plt.title('Izquierda')\n",
    "plt.xlabel('un eje X')\n",
    "plt.ylabel('un eje Y')\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot([1,2,3,4],[1,6,12,6],'r-')\n",
    "plt.title('Derecha')\n",
    "plt.xlabel('otro eje X')\n",
    "plt.ylabel('otro eje Y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "\n",
    "plt.subplot(2,1,1)\n",
    "plt.plot([1,2,3,4],[1,4,9,16],'go')\n",
    "plt.title('Arriba')\n",
    "plt.xlabel('un eje X')\n",
    "plt.ylabel('un eje Y')\n",
    "\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot([1,2,3,4],[1,6,12,6],'r-')\n",
    "plt.title('Abajo')\n",
    "plt.xlabel('otro eje X')\n",
    "plt.ylabel('otro eje Y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4 Gráfico de barras\n",
    "\n",
    "Para hacer un gráfico de barras en vez de `plot`usaremos `bar`, siguendo una estructura muy parecida.\n",
    "\n",
    "Recordemos el dataset de antes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contadores = londres[['LCLid','energy_max', 'energy_min', 'energy_sum']].groupby('LCLid').mean()\n",
    "contadores.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos hacer una gràfica de barras:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "divisiones=contadores.index[:10]\n",
    "marcas=contadores['energy_max'][:10]\n",
    "\n",
    "plt.figure(figsize=(20,10))\n",
    "plt.bar(divisiones, marcas, color = 'blue')\n",
    "plt.xlabel('contador')\n",
    "plt.ylabel('Energía máxima')\n",
    "plt.xticks(rotation=45, ha='right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O en barras horizontales, usando `barh`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "divisiones=contadores.index[:10]\n",
    "marcas=contadores['energy_max'][:10]\n",
    "\n",
    "plt.figure(figsize=(20,10))\n",
    "plt.barh(divisiones, marcas, color = 'blue')\n",
    "plt.ylabel('Contador')\n",
    "plt.xlabel('Energía máxima')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.5 Histograma\n",
    "\n",
    "Veamos con un ejemplo como hacer un histograma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist([1,5,8,7,4,1,2,4,3,6,5,4,6,3,2,3,6,9,8,5,4,1,6,9,8,7,8,8,8,7,4,7,8,8,9,9,8,7,8,9,6,9,8,7,8,9,6,6,3,2,9,8,1,9,4,1,5,6,5,6,9,6,5,8,5,6,9,6,3,2,1,4,5,8,7,8,9],9)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Generar un histograma de la energía maxima del contador MAC000113\n",
    "\n",
    "#dataset londres filtrando solo un LCLid del MAC000113\n",
    "contador_113 = londres[londres['LCLid']=='MAC000113']\n",
    "\n",
    "#energía màxima de este contador\n",
    "e_max_113= contador_113[['energy_max']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(e_max_113.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e_max_113.hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Muestra vs. Población\n",
    "\n",
    "Siempre que se pueda, será mejor usar la población para responder a nuestras preguntas, pero a veces esto no es posible (no se tienen todos los datos, no todos los clientes tienen un Smart meter, recopilar todos los datos en una misma fuente es difícil, etc). En estos casos usaremos una muestra. \n",
    "\n",
    "¿Qué problema conlleva esto? Veamos un ejemplo, con nuestro dataset de Londres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd #importamos Pandas!\n",
    "londres = pd.read_csv('Data/block_13_diario.csv')\n",
    "londres.head(10)\n",
    "londres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Muestra1 = londres.iloc[1:50,4]\n",
    "Muestra2 = londres.iloc[1345:1854,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Muestra1.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Muestra2.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se puede observar para cada muestra obtenemos métricas o estadísticas distintas. Este error, es el *error de estimación* o el *error muestral* \n",
    "\n",
    "<h4><center>error de estimación = parámetro - estadística</center></h4>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Mean_pob=londres['energy_max'].mean()\n",
    "error1=Mean_pob-Muestra1.mean()\n",
    "error2=Mean_pob-Muestra2.mean()\n",
    "print('Error muestra 1:',error1)\n",
    "print('Error muestra 2:',error2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si lo hacemos para varias muestras, con el mismo número de observaciones de manera aleatória, de manera automática:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "num_observaciones = 50\n",
    "num_muestras = 100\n",
    "lista_mean=[]\n",
    "for muestra in range(num_muestras):\n",
    "    s=londres['energy_max'].sample(num_observaciones,random_state = muestra)\n",
    "    lista_mean.append(s.mean())\n",
    "    \n",
    "plt.scatter(range(1,101),lista_mean)\n",
    "plt.axhline(londres['energy_max'].mean())\n",
    "plt.xlabel('Num de muestra')\n",
    "plt.ylabel('Media aritmética')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Cómo podemos disminuir o solucionar esto? \n",
    "\n",
    "Una manera es, como se ha dicho, intentar acercarnos el máximo a toda la población. Veamos en nuestro ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_observaciones = 50\n",
    "num_muestras = 100\n",
    "listas_mean=[]\n",
    "for num_observaciones in [50,250,500,1000]:\n",
    "    lista_mean=[]\n",
    "    for muestra in range(num_muestras):\n",
    "        s=londres['energy_max'].sample(num_observaciones,random_state = muestra)\n",
    "        lista_mean.append(s.mean())\n",
    "    listas_mean.append(lista_mean)\n",
    "    \n",
    "plt.figure(figsize=(15,8))\n",
    "\n",
    "plt.subplot(2,2,1)\n",
    "plt.scatter(range(1,101),listas_mean[0])\n",
    "plt.axhline(londres['energy_max'].mean())\n",
    "plt.ylim(0.6, 1.1)\n",
    "plt.ylabel('Media aritmética')\n",
    "plt.title('50 observaciones')\n",
    "\n",
    "plt.subplot(2,2,2)\n",
    "plt.scatter(range(1,101),listas_mean[1])\n",
    "plt.axhline(londres['energy_max'].mean())\n",
    "plt.ylim(0.6, 1.1)\n",
    "plt.ylabel('Media aritmética')\n",
    "plt.title('250 observaciones')\n",
    "\n",
    "plt.subplot(2,2,3)\n",
    "plt.scatter(range(1,101),listas_mean[2])\n",
    "plt.axhline(londres['energy_max'].mean())\n",
    "plt.ylim(0.6, 1.1)\n",
    "plt.ylabel('Media aritmética')\n",
    "plt.title('500 observaciones')\n",
    "\n",
    "plt.subplot(2,2,4)\n",
    "plt.scatter(range(1,101),listas_mean[3])\n",
    "plt.axhline(londres['energy_max'].mean())\n",
    "plt.ylim(0.6, 1.1)\n",
    "plt.ylabel('Media aritmética')\n",
    "plt.title('1000 observaciones')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También debemos asegurar que la muestra sea representativa de las diferentes posbles categorias que haya en nuestro dataset. Para eso se puede usar *stratified sampling*\n",
    "\n",
    "\n",
    "<img src=\"Figures/stratified_sampling.jpg\" alt=\"Drawing\" style=\"width: 450px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Limpieza y resumen de datos\n",
    "\n",
    "Pandas nos ofrece varias opciones para obtener un resumen de los datos como el método *describe* visto anteriormente. Además, podemos usar otros métodos como:\n",
    "\n",
    "<img src=\"Figures/pandas_summary.png\" alt=\"Drawing\" style=\"width: 450px;\"/>\n",
    "\n",
    "También son interesantes los métodos *value_counts* i *nunique*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "londres_raw = pd.read_csv('Data/block_13_diario_raw.csv')\n",
    "\n",
    "londres_raw['energy_min'].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio\n",
    "# Calcular la std de la energía mediana del contador MAC000113. R= 0.180486\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ya se ha visto, hay varias opciones para tratar con valores vacíos, pero pandas nos ofrece algunas opciones rápidas e interesantes para ir rápido\n",
    "\n",
    "<img src=\"Figures/missing.png\" alt=\"Drawing\" style=\"width: 450px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Análisis Exploratorio de Datos - Ejemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primero, identificamos los tipos de valores que hay en cada columna. Esto es necesario ya que, como veremos más adelante, columnas numéricas y no numéricas se tratan usando métodos distintos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "londres_raw.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver si hay valores nulos, se puede usar el método .isna(), que devuelve convierte cada casilla en True (si es un NaN) o False (si no lo es), junto con el método .sum() para obtener el número total de NaNs por columna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "londres_raw.isna().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos\n",
    "Vamos a tratar los NA de las distintas columnas con métodos diferentes:\n",
    "* LCLid, energy_std: Copiaremos el valor de arriba.\n",
    "* energy_median, energy_mean: Copiar el valor de abajo\n",
    "* energy_count: Fijaremos el valor \"48\".\n",
    "* energy_sum: Interpolación con method='linear'.\n",
    "* energy_max: Mean de energy_max.\n",
    "* energy_min: Mediana de energy_min."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo: LCLid\n",
    "londres_raw['LCLid']= londres_raw['LCLid'].ffill()\n",
    "\n",
    "# Ejercicio: energy_std\n",
    "\n",
    "\n",
    "# Ejemplo: energy_count\n",
    "londres_raw.fillna({'energy_count':48.0}, inplace=True)\n",
    "\n",
    "# Ejemplo: energy_median\n",
    "londres_raw['energy_median'] = londres_raw['energy_median'].bfill()\n",
    "\n",
    "# Ejercicio: energy_mean\n",
    "\n",
    "\n",
    "# Ejemplo: energy_sum\n",
    "londres_raw['energy_sum'] = londres_raw['energy_sum'].interpolate(method='linear')\n",
    "\n",
    "\n",
    "# Ejemplo: energy_max\n",
    "londres_raw.fillna({'energy_count': londres['energy_max'].mean()}, inplace=True)\n",
    "\n",
    "# Ejercicio: energy_min\n",
    "\n",
    "\n",
    "londres_raw.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Detectar y filtrar los outliers\n",
    "q = londres_raw[\"energy_max\"].quantile(0.99)\n",
    "londres_filt = londres_raw[londres_raw[\"energy_max\"] < q]\n",
    "londres_filt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "londres_filt.reset_index(inplace=True, drop=True)\n",
    "londres_filt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Estadística descriptiva"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Media, mediana y moda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Media\n",
    "\n",
    "Podemos pensar que la media es el centro de gravedad de los datos de una distribución. Veamos un ejemplo y discutamos qué información se puede obtener y como nos puede ayudar o, al revés, desinformar si no se va con cuidado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "\n",
    "poblacion = [0,2,3,3,3,4,13]\n",
    "muestra = random.choices(poblacion, k=4) #Seleccionar aleatoriamente 4 valores de la población\n",
    "\n",
    "poblacion_media = np.mean(poblacion)\n",
    "muestra_media = np.mean(muestra)\n",
    "\n",
    "print('Media poblacion:', poblacion_media)\n",
    "print('Media muestra:', muestra_media)\n",
    "print(muestra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Media Ponderada y Mediana\n",
    "\n",
    "Observemos el dataset *netherlands*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netherlands = pd.read_csv('Data/Electricity_Netherlands/coteq_electricity_2019.csv')\n",
    "netherlands.dropna()\n",
    "netherlands.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se quiere obtener la media del consumo de todo el dataset, se podría calcular como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netherlands[['annual_consume']].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero si observamos bien el *dataset* podemos ver que esta media no es justa. ¿Por qué?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weighted(values, weights):\n",
    "    return sum([a*b for a,b in zip(values, weights)])/sum(weights)\n",
    "\n",
    "weighted(netherlands['annual_consume'], netherlands['num_connections'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos visto como hay veces que computar la media, auque se pueda hacer, no sería correcto. En otras ocasiones, lo que nos pasará es que directamente no podemos calcular la media. Por ejemplo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Edad_clientes = [34,23,54,23,'más de 80',76,34,43,65,57,'más de 80',43,39,49]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, la **mediana** puede ser una buena medida alternativa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra ventaja de la mediana es que no considera de manera equitativa todos los elementos de la distribución, lo que la hace más resistente a cambios en la distribución."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Moda\n",
    "\n",
    "Hemos visto que en ocasiones la media no nos dará la información buscada, o simplemente no se podrá calcular y usaremos la mediana. En otras ocasiones, pero, la moda también nos puede ser de utilidad. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netherlands['city'].head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "netherlands['city'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variabilidad\n",
    "\n",
    "Veamos dos distribuciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "A=[4,4,4,4]\n",
    "B=[0,8,0,8]\n",
    "\n",
    "print('La media de A es:',np.mean(A))\n",
    "print('La media de B es:',np.mean(B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Efectivamente, dos distribuciones muy distintas pueden tener la misma media.\n",
    "\n",
    "Qué otro parámetro nos puede aydar a distinguir las dos distribuciones? Por ejemplo el rango:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rango_A=max(A)-min(A)\n",
    "rango_B=max(B)-min(B)\n",
    "\n",
    "print('El rango de A es:',rango_A)\n",
    "print('El rango de B es:',rango_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero el rango solo considera dos valores, y no es una buena solución:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,21]\n",
    "\n",
    "rango_C=max(C)-min(C)\n",
    "print('La media de C es:',np.mean(C))\n",
    "print('El rango de C es:',rango_C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos que tenemos una distribución con muy poca variabilidad, pero con un rango muy alto. Esto es debido a que solo considera dos valores de la distribución y no toda la distribución."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si consideramos todos los valores podemos calcular:\n",
    "\n",
    "<img src=\"Figures/variabilities.svg\" alt=\"Drawing\" style=\"width: 450px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "$$ Distancia Media = \\frac{1}{n} \\sum_i (x_i - \\mu) $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para evitarlo, usaremos:\n",
    "\n",
    "$$ Varianza = \\frac{1}{n} \\sum_i (x_i - \\mu)^2 $$\n",
    "o también: $$ \\sigma^2 = \\frac{1}{n} \\sum_i (x_i - \\mu)^2 $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El problema de la varianza es que no da un valor que no nos ofrece ningún sentido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "consumos_semana=[0,7,8]\n",
    "\n",
    "print('La varianza es de:', np.var(consumos_semana))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para esto se usa la **desviacón estándar**\n",
    "\n",
    "Desviación estándar $$ \\sigma = \\sqrt (\\frac{1}{n} \\sum_i (x_i - \\mu)^2) $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "consumos=[0,7,8]\n",
    "\n",
    "print('La desviación estandar es de:', np.std(consumos_semana))\n",
    "print('La media es de:', np.mean(consumos_semana))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio\n",
    "\n",
    "Obtener la Varianza, Desviación y Media para las tres distribuciones superiores. ¿Qué valores se obtienen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resolver aquí"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "media = londres['energy_max'].mean()\n",
    "st_dev = londres['energy_max'].std()\n",
    "londres['energy_max'].plot.hist(bins=50)\n",
    "plt.axvline(media, color = 'Black', label = 'Media')\n",
    "plt.axvline(media - st_dev, color = 'Red', label = 'Encima')\n",
    "plt.axvline(media + st_dev, color = 'Violet', label = 'Abajo')\n",
    "plt.legend()\n",
    "print(\"La desviación estandard es:\", st_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué ocurre cuando no podemos trabajar con los datos de toda una población y solo tenemos una muestra?\n",
    "\n",
    "Véamos qué pasa si cogemos varias muestras al azar de nuestra distribución de energía máxima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "media = londres['energy_max'][:3000].mean()\n",
    "st_dev = londres['energy_max'][:3000].std()\n",
    "londres['energy_max'][:3000].plot.hist(bins=50)\n",
    "plt.axvline(media, color = 'Black', label = 'Media')\n",
    "plt.axvline(media - st_dev, color = 'Red', label = 'Encima')\n",
    "plt.axvline(media + st_dev, color = 'Violet', label = 'Abajo')\n",
    "plt.legend()\n",
    "print(\"La desviación estandard es:\", st_dev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "def standard_deviation(array):\n",
    "    reference_point = sum(array) / len(array)\n",
    "    \n",
    "    distances = []\n",
    "    for value in array:\n",
    "        squared_distance = (value - reference_point)**2\n",
    "        distances.append(squared_distance)\n",
    "    \n",
    "    variance = sum(distances) / len(distances)\n",
    "    \n",
    "    return sqrt(variance)\n",
    "\n",
    "std_lista=[]\n",
    "\n",
    "for i in range(3000):\n",
    "    sd=standard_deviation(londres['energy_max'].sample(20, random_state=i))\n",
    "    std_lista.append(sd)\n",
    "\n",
    "plt.hist(std_lista)\n",
    "std_lista = np.array(std_lista)\n",
    "plt.axvline(std_lista.std(), color='Black', label='Desviación Muestra')\n",
    "plt.axvline(st_dev, color = 'Red', label = 'Desviación Población')\n",
    "plt.legend()\n",
    "print(\"La desviación estandard es:\", std_lista.std())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede ver como, en general, las desviaciones estándar siempre son inferiores a la real.\n",
    "\n",
    "<img src=\"Figures/bessel1.svg\" alt=\"Drawing\" style=\"width: 600px;\"/>\n",
    "\n",
    "Conseguir muestras que tengas una varianza parecida es muy difícil.\n",
    "\n",
    "<img src=\"Figures/bessel2.svg\" alt=\"Drawing\" style=\"width: 300px;\"/>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tablas de frecuencia\n",
    "\n",
    "Una tabla de frecuencia nos permite saber cuántas veces aparece cada categoria en una variable. Por suerte Pandas ya nos ofrece herramientas para obtenerla rápidamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frec_counts = londres['LCLid'].value_counts()\n",
    "frec_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿En el caso de trabajar con una variable más continua qué pasaría?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frec_counts = londres['energy_max'].value_counts()\n",
    "frec_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De repente, esta tabla no tiene mucho sentido ni mucha utilidad. Para esto podemos usar el código siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frec_counts = londres['energy_max'].value_counts(bins=5)\n",
    "frec_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para visualizar las tablas de frecuencia podemos usar Matplotlib como antes, o hacer los gráficos directamente desde pandas, que ya nos da esta posibilidad facilitando el trabajo.\n",
    "\n",
    "Así, en el primer caso, tendríamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "londres['LCLid'].value_counts().plot.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y en el segundo caso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "londres['energy_max'].value_counts(bins=5).plot.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparar distribuciones de frecuencia\n",
    "\n",
    "La mejor manera de comparar y evaluar distintas distribuciones de frecuencia es visualizarlas. A continuación hay varios ejemplos:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "londres['energy_max'].plot.kde()\n",
    "londres['energy_min'].plot.kde()\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "londres['energy_max'].hist(histtype='stepfilled', label='Energy Max')\n",
    "londres['energy_min'].hist(histtype='stepfilled', color=sns.desaturate(\"indianred\", .75), label='Energy Min')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejemplo\n",
    "\n",
    "Hacer dos boxplots comparando la energia màxima entre dos contadores con LCLid distintos del dataset *londres* cargado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAC113 = londres.loc[londres['LCLid']=='MAC000113', 'energy_max']\n",
    "MAC5270 = londres.loc[londres['LCLid']=='MAC005270', 'energy_max']\n",
    "data = [MAC113, MAC5270]\n",
    "\n",
    "fig = plt.figure(figsize =(10, 7))\n",
    "# Creating axes instance\n",
    "ax = fig.add_axes([0, 0, 1, 1])\n",
    "# Creating plot\n",
    "bp = ax.boxplot(data)\n",
    "# show plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio**\n",
    "\n",
    "Inspeccionar la carpeta Data de este repositorio y abrir el archivo con los consumos de electricidad de la zona west-land infra en 2019 en un dataset llamado *netherlands* e inspeccionar las primeras filas\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "netherlands = pd.read_csv('Data/Electricity_Netherlands/coteq_electricity_2019.csv')\n",
    "netherlands.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicios** \n",
    "\n",
    "+ ¿Hay missing values? ¿Dónde?\n",
    "+ ¿Cuántos tipos de conexión hay?\n",
    "+ ¿Cuántos pueblos hay en total?\n",
    "+ ¿Qué pueblo tiene más número de conexiones?\n",
    "+ ¿En cuántos casos el zipcode_from es igual al zipcode_to?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Respuesta:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Asimetría\n",
    "\n",
    "En una distribución, también podremos medir la asimetría o el *skewness*:\n",
    "\n",
    "$$ g_1 = \\frac{\\frac{1}{n} \\sum_i (x_i - \\mu)^2 }{\\frac{1}{n} \\sum_i (x_i - \\mu)^3 }$$\n",
    "\n",
    "Otra fórmula que da buenos resultados es *Pearson's median skewness coefficient*:\n",
    "\n",
    "$$ g_p = \\frac{3(\\mu - \\mu_{\\frac{1}{2}})}{\\sigma} $$\n",
    "\n",
    "El skewess muestra:\n",
    "+ Si es negativo es que se extiende más a la izquierda que a la derecha.\n",
    "+ Si es positivo es que se extiende más a la derecha que a la izquierda.\n",
    "\n",
    "En Pandas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "londres['energy_max'].plot.kde()\n",
    "londres['energy_max'].skew()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Probabilidad (opcional - mirar en casa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De todos modos, también podemos calcular la probabilidad sin la necesidad de hacer tantos experimentos:\n",
    "\n",
    "$$ P(E) = \\frac{\\text{Eventos}}{\\text{Posibles eventos}}$$\n",
    "\n",
    "En el caso de un dado:\n",
    "\n",
    "$$ P(\\text{Número par}) = \\frac{3}{6}$$\n",
    "\n",
    "$$ P(\\text{1 o 5}) = \\frac{2}{6}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normas de probabilidad\n",
    "\n",
    "Lo que tendremos normalmente es un *set* de posibles eventos, en el ejemplo del dado:\n",
    "\n",
    "$$ \\Omega = \\text{{1,2,3,4,5,6}}$$\n",
    "\n",
    "Si consideramos tirar dos dados:\n",
    "\n",
    "<img src=\"Figures/pr1m2_sums.png\" alt=\"Drawing\" style=\"width: 600px;\"/>\n",
    "\n",
    "Calular las probabilidades de que entre las dos tirada salga un 6, 2, 7. ¿Qué numero tiene mayor probabilidades de ocurrir?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejercicio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay dos normas básicas para cacular probabilidades combinado dos posibles eventos.\n",
    "\n",
    "$$ P(\\text{A y B}) = P(A)P(B)$$\n",
    "\n",
    "$$ P(\\text{A o B}) = P(A) + P(B) - P(A)P(B)$$\n",
    "\n",
    "O introduciendo una nueva notación:\n",
    "\n",
    "$$ P(A \\cup B) = P(A) + P(B) - P(A \\cap B)$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra norma importante es:\n",
    "    \n",
    "$$ P(A \\cup \\text{no A} ) = P(A) + P(\\text{no A}) = 1$$\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Eventos independientes**\n",
    "\n",
    "Cuando los eventos son independientes es cuando podemos usar la formula\n",
    "\n",
    "$$ P(\\text{A y B}) = P(A)P(B)$$\n",
    "\n",
    "\n",
    "Por ejemplo, la probabilidad de sacar 4 veces una cruz:\n",
    "\n",
    "$$ P(\\text{Cruz 4 veces}) = P(Cruz)P(Cruz)P(Cruz)P(Cruz)$$\n",
    "\n",
    "Pero si los eventos no son independientes no podemos usarla directamente. Por ejemplo\n",
    "\n",
    "$$ P(A) = P(\\text{Número par}) = ??$$\n",
    "\n",
    "$$ P(B) = P(\\text{Número menor a 4}) = ??$$\n",
    "\n",
    "$$ P(A \\cap B) = ?? $$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = {2,4,6}\n",
    "set2 = {1,2,3}\n",
    "set3 = set1.intersection(set2)\n",
    "print(set3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = {2,4,6}\n",
    "set2 = {1,2,3}\n",
    "set3 = set1.union(set2)\n",
    "print(set3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Eventos con y sin reemplazo**\n",
    "\n",
    "También se debe tener en cuenta si hay reemplazo en la muestra. Un ejemplo claro es una baraja de cartas.\n",
    "\n",
    "¿Què probabilidad hay de sacar 4 ases seguidos en una baraja de cartas?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Combinatorias y permutaciones\n",
    "\n",
    "En general para saber cuántas combinaciones e un evento pueden ocurrir, podemos usar la norma de la multiplicación.\n",
    "\n",
    "$$ P(\\text{Pin Móvil = 8424}) = \\frac{1}{10·10·10·10}$$\n",
    "\n",
    "En este caso, ¿había reemplazo?¿Y si no lo hay? \n",
    "\n",
    "A continuación teneis un cuadro resúmen de recordatorio de combinaciones y permutaciones\n",
    "\n",
    "<img src=\"Figures/combinatoria.png\" alt=\"Drawing\" style=\"width: 600px;\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Probabilidad Bayesiana\n",
    "\n",
    "<img src=\"Figures/content_bayes.jpg\" alt=\"Drawing\" style=\"width: 300px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fórmula de Bayes sirve para computar **probabilidades condicionales**, es decir para calcular **probabilidades posteriores** a partir de observaciones\n",
    "\n",
    "$$ P(H | E) = \\frac{P(E | H)P(H)}{P(E)}$$\n",
    "\n",
    "La estadística Bayesiana interpreta las probabilidades como medidas de confianza en un evento, no a partir de la frecuencia en que este evento ocurre a largo plazo.\n",
    "\n",
    "Muchas veces, la formula se interpreta como una **actualización de la creencia** sobre unos datos observados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Bayes Theorem </b> <br>\n",
    "$$ P(A | B) = \\frac{P(B | A)P(A)}{P(B)}$$\n",
    "</div>   \n",
    "\n",
    "\n",
    "Describe la probabilidad condicional entre dos eventos.\n",
    "\n",
    "Es fácilmente demostrable:\n",
    "\n",
    "+ Sabemos que $ P(A \\mbox{ and } B) = P(A)P(B | A) $.\n",
    "+ Tambien tenemos $ P(A \\mbox{ and } B) = P(B)P(A | B)$.\n",
    "+ Juntando, $ P(A)P(B | A) = P(B)P(A | B)$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explicación de la fórmula.\n",
    "\n",
    "La manera más usual de interpretarla es pensadno que $A$ es una hipotesis $H$, y $B$ es una evidencia $E$ que nos puede hacer cambiar nuestra creencia sobre $H$.\n",
    "\n",
    "$$P(H | E) = P(H) \\frac{P(E|H)}{P(E)}$$\n",
    "\n",
    "Con cada nueva prueba o dato podremos actualizar la formula*. \n",
    "\n",
    "\n",
    "+ $P(H | E)$ es conocida como **posterior**.\n",
    "+ $P(H)$ llamada **prior probability** de la hipotesis.\n",
    "+ $P(E | H)$ llamada **likelihood** de la evidencia o datos.\n",
    "+ $P(E)$ normaliza. Si tenemos $n$ hipotesis *mutuamente exclusivas* y *collectivelly exhaustive*, podemos calcular $P(E)$ as:\n",
    "\n",
    "$$ P(E) = P(H_1)P(E|H_1) + \\dots + P(H_n)P(E|H_n)$$\n",
    "\n",
    "\n",
    "En general, $P(H | E), P(H), P(E|H), P(E)$ son funciones!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualización y ejemplo\n",
    "\n",
    "https://www.youtube.com/watch?v=D8VZqxcu0I0\n",
    "\n",
    "https://www.youtube.com/watch?v=R13BD8qKeTg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian Estimation\n",
    "\n",
    "\n",
    "**El problema de los tanques en la II Guerra Mundial**\n",
    "\n",
    "Los tanques alemanes estan enumerados  $1 \\dots N$. Un soldado aliado ve un tanque con el número 60, cuántos tanques tiene Alemania?\n",
    "\n",
    "> *(Fuente: http://greenteapress.com/thinkbayes/html/thinkbayes004.html#toc24)*\n",
    "\n",
    "Sabemos que tendrá 60 o más, pero cuántos más?\n",
    "\n",
    "Aplicando estadística Bayesana, podemos partir el problema en dos partes:\n",
    "\n",
    "+ Qué sabíamos de $N$ antes de los nuevos datos?  **prior** $P(H)$\n",
    "+ Para un valor de $N$, cuál es la *likelihood* de ver un tanque con el número $N$? **likelihood** $P(E|H)$.\n",
    "\n",
    "Como no tenemos información para calcular el **prior** podemos asumir un valor del 1 al 1000 constante\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "hypos = np.array(range(1, 1001))\n",
    "priors = np.array([1.0/len(hypos) for hypo in hypos])\n",
    "\n",
    "with plt.style.context('fivethirtyeight'):\n",
    "    plt.figure(figsize=(10,2))\n",
    "    plt.plot(hypos, priors)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora calculamos la función de **likelihood**, $P(E|H)$. \n",
    "\n",
    "En una hipotética situación con $N$ tanques, qué probabilidad tenemos de ver el número 60?\n",
    "\n",
    "Si asumimos que solo hay un tanque con este número en todo el país y que es igual de fácil de ver cualquiera de los $N$ tanques, tenemos $1/N$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Likelihood(data, hypo):\n",
    "    if hypo < data:\n",
    "        return 0.0\n",
    "    else:\n",
    "        return 1.0/hypo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a calcular ahora!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def Posterior(data, hypos, priors):\n",
    "    posterior = np.array([Likelihood(data, hypo) for hypo in hypos]) * priors\n",
    "    return posterior\n",
    "\n",
    "# After an update, the distribution is no longer normalized, \n",
    "# but because these hypotheses are mutually exclusive and \n",
    "# collectively exhaustive, we can renormalize.\n",
    "\n",
    "def Normalize(d):\n",
    "    total = d.sum()\n",
    "    factor = 1.0 / total\n",
    "    for i in range(len(d)):\n",
    "        d[i] *= factor\n",
    "    return d\n",
    "\n",
    "posterior = Normalize(Posterior(60, hypos, priors))\n",
    "\n",
    "with plt.style.context('fivethirtyeight'):\n",
    "    plt.figure(figsize=(10,2))\n",
    "    plt.ylim([-0.001,0.006])\n",
    "    plt.plot(hypos, posterior)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El valor más probable es 60, pero qué número dirias tu?\n",
    "\n",
    "Si quieres maximizar la probabilidad de acertar el número deberías decir 60, pero en nuestro caso nos puede interesar más decir el valor medio de la distribución de **posteriors**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Meanp(hypos, posterior):\n",
    "    total = 0.0\n",
    "    s = hypos * posterior\n",
    "    return s.mean()*len(hypos)\n",
    "\n",
    "print(int(Meanp(hypos, posterior)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos mejorar nuestras prediciones, necesitamos más datos para actualizar nuestra hipotesis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hypos = range(1, 1001)\n",
    "posterior =  Normalize(Posterior(60, hypos, priors))\n",
    "posterior2 = Normalize(Posterior(30, hypos, posterior))\n",
    "posterior3 = Normalize(Posterior(90, hypos, posterior2))\n",
    "\n",
    "print(int(Meanp(hypos, posterior3)))\n",
    "\n",
    "with plt.style.context('fivethirtyeight'):\n",
    "    plt.figure(figsize=(10,2))\n",
    "    plt.ylim([-0.001,0.025])\n",
    "    plt.plot(hypos, posterior3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Normalize(d):\n",
    "    total = d.sum()\n",
    "    factor = 1.0 / total\n",
    "    for i in range(len(d)):\n",
    "        d[i] *= factor\n",
    "    return d\n",
    "\n",
    "def Likelihood1(datum, hypo):\n",
    "    if hypo < datum:\n",
    "        return 0.0\n",
    "    else:\n",
    "        return 1.0/hypo\n",
    "    \n",
    "def Posterior(datum, hypos, priors, likelihood):\n",
    "    import numpy as np\n",
    "    posterior = np.array([likelihood(datum, hypo) for hypo in hypos]) * priors\n",
    "    return posterior\n",
    "\n",
    "def Posterior_n(data, hypos, priors, likelihood):\n",
    "    p = priors\n",
    "    for d in data:\n",
    "        posterior =  Normalize(Posterior(d, hypos, p, likelihood))\n",
    "        p = posterior\n",
    "    return posterior\n",
    "\n",
    "def Meanp(hypos, posterior):\n",
    "    total = 0.0\n",
    "    s = hypos * posterior\n",
    "    return s.mean()*len(hypos)\n",
    "\n",
    "hypos = np.array(range(1, 1001))\n",
    "priors = np.array([1.0/len(hypos) for hypo in hypos])\n",
    "posteriors = Posterior_n([60,30,90], hypos, priors, Likelihood1)\n",
    "\n",
    "print('Media de la distribución del posterior con 1000 hipotesis: ', \\\n",
    "        int(Meanp(hypos, posteriors)))\n",
    "\n",
    "with plt.style.context('fivethirtyeight'):\n",
    "    plt.figure(figsize=(10,2))\n",
    "    plt.ylim([-0.001,0.025])\n",
    "    plt.plot(hypos, posteriors)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  },
  "widgets": {
   "state": {},
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}