{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Los tres métodos que no se ponen de acuerdo\n",
    "\n",
    "32, 203 o 222 filas raras según a quién le preguntes. Y las 21 ventas negativas que resultaron tener una cosa en común.\n",
    "\n",
    "Cuaderno de soluciones del capítulo 6 de **Estadística desde cero**, de Miss Yera.\n",
    "\n",
    "Corre de arriba abajo. Si lo abres en Google Colab no necesitas instalar nada.\n",
    "\n",
    "Capítulo completo: https://missyera.com/guias/estadistica-desde-cero/atipicos/\n",
    "\n",
    "Este es el cuaderno de **soluciones**. Trae el código de cada ejercicio, la\n",
    "explicación de la trampa y la respuesta del quiz. Si vienes del cuaderno de\n",
    "práctica sin haberlo intentado, vuelve 🙂"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un atípico no es un número grande. Es **un número que no pertenece al\n",
    "grupo** 🎯\n",
    "\n",
    "Y esa diferencia, que parece filosófica, decide todo lo que viene. Una venta\n",
    "de 4.000 soles es enorme para una bodega y es martes por la tarde para un\n",
    "mayorista.\n",
    "\n",
    "Vamos a verlo con los tres métodos que se usan, aplicados a las mismas\n",
    "3.000 filas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "URL = 'https://missyera.com/static/datasets/ventas-miss-yera.csv'\n",
    "\n",
    "\n",
    "def carga_limpia(url):\n",
    "    \"\"\"La misma del capítulo 2.\"\"\"\n",
    "    v = pd.read_csv(url).drop_duplicates()\n",
    "    v['ciudad'] = (v['ciudad'].str.strip().str.lower()\n",
    "                   .str.normalize('NFKD')\n",
    "                   .str.encode('ascii', 'ignore').str.decode('utf-8'))\n",
    "    v['monto'] = pd.to_numeric(v['monto'].str.replace(',', '.'))\n",
    "    for col in ['fecha', 'fecha_ultima_compra']:\n",
    "        f = pd.to_datetime(v[col], format='%Y-%m-%d', errors='coerce')\n",
    "        falta = f.isna() & v[col].notna()\n",
    "        f[falta] = pd.to_datetime(v.loc[falta, col], format='%d/%m/%Y',\n",
    "                                  errors='coerce')\n",
    "        v[col] = f\n",
    "    return v\n",
    "\n",
    "\n",
    "v = carga_limpia(URL)\n",
    "m = v['monto']\n",
    "\n",
    "print('filas: %d | de %.2f a %.2f' % (len(m), m.min(), m.max()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y una pregunta que decide medio capítulo: **¿el dato raro de tu archivo es un error o es tu mejor cliente?** Porque se quitan de formas distintas, y uno de los dos no se quita 🎯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Método 1: la puntuación z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El clásico. Cuenta a cuántas desviaciones está cada fila del promedio, y\n",
    "marca las que pasen de 3:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zi=xi−x¯s\n",
    "\n",
    "a cuántas desviaciones del centro está cada dato"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = (m - m.mean()) / m.std()\n",
    "\n",
    "print('a mas de 3 desviaciones: %d filas' % (z.abs() > 3).sum())\n",
    "print('a mas de 2 desviaciones: %d filas' % (z.abs() > 2).sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "32 filas sospechosas de 3.000, un 1,07%. Suena razonable.\n",
    "\n",
    "Antes de seguir, vamos a mirarlas. Esto es lo que casi nadie hace y es lo\n",
    "único que hay que hacer siempre 🔍"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raras = v[z.abs() > 3]\n",
    "print(raras['segmento'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las **32**. Todas 😳\n",
    "\n",
    "Ahí se cae el método entero. La z no encontró ventas raras: encontró\n",
    "**el segmento que vende más caro**. Un mayorista está a más de tres\n",
    "desviaciones del promedio de la empresa porque el promedio de la empresa está\n",
    "lleno de bodegas que venden a 178 soles.\n",
    "\n",
    "Y si le hubieras hecho caso a la receta (\"quita los atípicos y sigue\"),\n",
    "habrías borrado a tus mejores clientes por ser tus mejores clientes 😬\n",
    "\n",
    "Es exactamente el mismo fenómeno de los capítulos 3, 4 y 5: **estamos\n",
    "metiendo cuatro poblaciones en el mismo saco**. Ya nos rompió la media,\n",
    "la dispersión y la forma. Ahora nos rompe la detección de atípicos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Método 2: el rango intercuartílico"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La versión robusta. Marca lo que caiga a más de 1,5 IQR fuera de los\n",
    "cuartiles, que es la regla del diagrama de caja de toda la vida:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q1, q3 = m.quantile(0.25), m.quantile(0.75)\n",
    "iqr = q3 - q1\n",
    "bajo, alto = q1 - 1.5 * iqr, q3 + 1.5 * iqr\n",
    "\n",
    "print('limites: %.2f a %.2f' % (bajo, alto))\n",
    "print('por debajo: %d | por encima: %d | total: %d'\n",
    "      % ((m < bajo).sum(), (m > alto).sum(), ((m < bajo) | (m > alto)).sum()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "203 filas, seis veces más que la z 😵\n",
    "\n",
    "Y mira el reparto: 200 por arriba y 3 por abajo. Ese desequilibrio es la cola\n",
    "derecha del capítulo 5 asomando otra vez."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Método 3: el MAD, el más robusto de todos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La z usa media y desviación, que son justo las dos medidas que los atípicos\n",
    "estropean. Es un poco absurdo si lo piensas: le pides a un dato raro que se\n",
    "delate usando un promedio que él mismo está inflando 🙃\n",
    "\n",
    "El MAD (desviación absoluta mediana) arregla eso usando mediana en los dos\n",
    "sitios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zirob=0,6745(xi−x~)mediana(|x−x~|)\n",
    "\n",
    "lo mismo que la z pero con medianas en los dos sitios, para que los propios atípicos no inflen la vara con la que se les mide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mediana = m.median()\n",
    "mad = (m - mediana).abs().median()\n",
    "z_robusta = 0.6745 * (m - mediana) / mad\n",
    "\n",
    "print('MAD: %.2f' % mad)\n",
    "print('a mas de 3.5 z robustas: %d filas' % (z_robusta.abs() > 3.5).sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "222. Otro número distinto 🤯\n",
    "\n",
    "El 0,6745 es una constante de conversión para que la escala se parezca a la\n",
    "de una desviación estándar normal, y el umbral de 3,5 es la convención que\n",
    "acompaña a este método."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Los tres a la vez"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "por_z = set(v.index[z.abs() > 3])\n",
    "por_iqr = set(v.index[(m < bajo) | (m > alto)])\n",
    "por_mad = set(v.index[z_robusta.abs() > 3.5])\n",
    "\n",
    "print('z: %d | IQR: %d | MAD: %d' % (len(por_z), len(por_iqr), len(por_mad)))\n",
    "print()\n",
    "print('en z y en IQR:   %d' % len(por_z & por_iqr))\n",
    "print('en IQR y en MAD: %d' % len(por_iqr & por_mad))\n",
    "print('en los tres:     %d' % len(por_z & por_iqr & por_mad))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fíjate en el patrón, que es limpísimo: **las 32 de la z están dentro de\n",
    "las 203 del IQR, y casi todas las 203 están dentro de las 222 del MAD**.\n",
    "\n",
    "No es que los métodos se contradigan. Es que son **tres niveles de\n",
    "severidad del mismo criterio**. La z es la más permisiva porque los\n",
    "propios atípicos inflan la desviación que se usa para juzgarlos; el MAD es el\n",
    "más estricto porque no se deja inflar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Método | Usa | Encontró | Cuándo usarlo |\n",
    "|---|---|---|---|\n",
    "| Puntuación z | Media y desviación | 32 | Solo si los datos son acampanados |\n",
    "| 1,5 x IQR | Cuartiles | 203 | El de por defecto, funciona casi siempre |\n",
    "| MAD | Mediana dos veces | 222 | Cuando sospechas que hay muchos atípicos |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ahora hazlo bien: dentro de cada grupo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que había que hacer desde el principio: comparar cada venta contra las de\n",
    "su propio segmento 🏪"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for seg, g in v.groupby('segmento'):\n",
    "    zz = (g['monto'] - g['monto'].mean()) / g['monto'].std()\n",
    "    print('%-11s %3d atipicos de %d' % (seg, (zz.abs() > 3).sum(), len(g)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "21 filas repartidas entre los cuatro segmentos, en vez de 32 concentradas en\n",
    "uno 🙌\n",
    "\n",
    "Y ahora sí son atípicos de verdad: ventas que no se parecen a las de su\n",
    "propio grupo. Mayorista pasa de 32 a 4, que es lo que tenía que pasar.\n",
    "\n",
    "**Regla para llevarte:** antes de buscar atípicos, pregúntate\n",
    "contra qué se está comparando cada fila. Si tus datos tienen grupos con niveles\n",
    "distintos, la detección va por grupo o no vale nada 📌"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Las ventas negativas, y lo que escondían"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Llevan saliendo desde el capítulo 2. Vamos a por ellas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "negativas = v[v['monto'] < 0]\n",
    "\n",
    "print('ventas negativas: %d' % len(negativas))\n",
    "print('suman: %.2f soles' % negativas['monto'].sum())\n",
    "print()\n",
    "print(negativas.groupby('segmento')['monto'].agg(['count', 'mean', 'min']).round(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "21 filas y casi 9.000 soles en negativo. Repartidas por los cuatro\n",
    "segmentos, y con montos proporcionales al tamaño de cada uno.\n",
    "\n",
    "Y ahora la pregunta que lo resolvió todo. ¿Qué tienen en común?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(negativas['compro'].value_counts())\n",
    "print()\n",
    "print('de las 3000 filas, cuantas no compraron:', (v['compro'] == 0).sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Las 21 son ventas que no se cerraron.** Ni una sola\n",
    "excepción 🔎\n",
    "\n",
    "Eso cambia por completo la interpretación. No son devoluciones repartidas al\n",
    "azar: son operaciones que quedaron en negativo *y* no llegaron a\n",
    "concretarse. Lo más probable es que sean anulaciones o notas de crédito que se\n",
    "colaron en la tabla de ventas.\n",
    "\n",
    "Si hubiera sido casualidad, con 21 filas y un 42% de no-compras esperaríamos\n",
    "unas nueve, no veintiuna. Que salgan las 21 no es casualidad, es una regla del\n",
    "sistema que nadie documentó.\n",
    "\n",
    "Y fíjate en lo que acaba de pasar: **buscando datos que estorbaban,\n",
    "encontramos algo del negocio**. Por eso los atípicos se miran antes de\n",
    "borrarlos. Suele haber más información en las 21 filas raras que en las 2.979\n",
    "normales 💎"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El error del capítulo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este lo he cometido yo mil veces. Quiero filtrar por una columna que tiene\n",
    "nulos, así que la limpio antes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esto revienta a propósito.** Se ejecuta dentro de un `try` para que puedas seguir con \"ejecutar todo\" y aun así ver la queja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    v[v['satisfaccion'].dropna() > 4]\n",
    "except Exception as e:\n",
    "    print(f'{type(e).__name__}: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la queja que tiene que salir es esta:\n",
    "\n",
    "```\n",
    "IndexingError: Unalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not match).\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que pasa es que `dropna()` devuelve una serie de 2.769 filas, y\n",
    "estás usándola para filtrar un DataFrame de 3.000. pandas intenta alinearlas por\n",
    "índice, ve que no encajan y se planta.\n",
    "\n",
    "Y menos mal que se planta 🙏 porque la alternativa habría sido rellenar los\n",
    "huecos con algo y devolverte filas que no pediste.\n",
    "\n",
    "La forma correcta es filtrar sobre el original, que trata los nulos como\n",
    "falsos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('satisfaccion mayor que 4:', (v['satisfaccion'] > 4).sum())\n",
    "print('filas con satisfaccion nula:', v['satisfaccion'].isna().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "563 filas, y los 231 nulos quedaron fuera sin drama. Que es lo que querías."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Y ahora, ¿qué hago con ellos?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La pregunta que casi nadie hace. Hay cuatro respuestas y solo una es\n",
    "automática:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Qué haces | Cuándo | En este archivo |\n",
    "|---|---|---|\n",
    "| **Investigar** | Siempre, primero | Las 21 negativas resultaron ser todas no-compras |\n",
    "| **Corregir** | Si es un error de captura demostrable | Un monto con la coma mal puesta |\n",
    "| **Dejar** | Si son reales y te importan | Las ventas de 4.000 soles de Mayorista |\n",
    "| **Capar** | Si estorban al modelo pero existen | Ponerles el valor del percentil 99 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que **nunca** se hace es borrarlos sin mirarlos. Es la\n",
    "diferencia entre limpiar los datos y maquillarlos 💄"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Y dos más, los dos de los cuartiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esto revienta a propósito.** Se ejecuta dentro de un `try` para que puedas seguir con \"ejecutar todo\" y aun así ver la queja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    m.between(bajo, alto, inclusive='si')\n",
    "except Exception as e:\n",
    "    print(f'{type(e).__name__}: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la queja que tiene que salir es esta:\n",
    "\n",
    "```\n",
    "ValueError: Inclusive has to be either string of 'both','left', 'right', or 'neither'.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí el mensaje es de los buenos: te dice las cuatro opciones válidas. Y esas cuatro no son decoración, son la decisión de si el valor que cae justo en el borde entra o no entra, que con atípicos importa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esto revienta a propósito.** Se ejecuta dentro de un `try` para que puedas seguir con \"ejecutar todo\" y aun así ver la queja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    v['monto'].quantile(1.25)\n",
    "except Exception as e:\n",
    "    print(f'{type(e).__name__}: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la queja que tiene que salir es esta:\n",
    "\n",
    "```\n",
    "ValueError: percentiles should all be in the interval [0, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En pandas los cuantiles van de 0 a 1, así que el 25 se escribe 0,25 y el 1,25 no existe. Ojo con esto porque es el gemelo del error de `np.percentile`: **las dos librerías usan escalas distintas para lo mismo** 🚩"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practica 💪"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. ¿Cuánto cambia todo si los quitas?\n",
    "\n",
    "Quita las 32 filas de la puntuación z y mira qué le pasa a\n",
    "la media, a la mediana y a la desviación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sin_ellos = m[z.abs() <= 3]\n",
    "\n",
    "print('           con        sin      cambio')\n",
    "print('media    %8.2f %8.2f %+9.2f' % (m.mean(), sin_ellos.mean(), sin_ellos.mean() - m.mean()))\n",
    "print('mediana  %8.2f %8.2f %+9.2f' % (m.median(), sin_ellos.median(), sin_ellos.median() - m.median()))\n",
    "print('desv.    %8.2f %8.2f %+9.2f' % (m.std(), sin_ellos.std(), sin_ellos.std() - m.std()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "           con        sin      cambio\n",
    "media      803.76   779.52    -24.24\n",
    "mediana    533.63   526.44     -7.19\n",
    "desv.      751.99   702.73    -49.25\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quitar el 1% de las filas mueve la media 24 soles y la mediana 7 🤏\n",
    "\n",
    "Lo cual dice dos cosas. La primera, que la mediana aguanta bastante mejor,\n",
    "como ya sabíamos.\n",
    "\n",
    "La segunda, y más importante: **quitarlos no cambia gran cosa**,\n",
    "así que la decisión de quitarlos o no *no se justifica por el impacto*.\n",
    "Se justifica por si esas filas son reales o no.\n",
    "\n",
    "Y ya sabemos que son reales: son mayoristas comprando como mayoristas. O sea\n",
    "que se quedan 🙅"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Capar en vez de borrar\n",
    "\n",
    "Prueba la alternativa: en vez de quitar las filas\n",
    "extremas, ponles el valor del percentil 1 y del 99."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capado = m.clip(lower=m.quantile(0.01), upper=m.quantile(0.99))\n",
    "\n",
    "print('filas: original %d | capado %d' % (len(m), len(capado)))\n",
    "print('media    %8.2f -> %8.2f' % (m.mean(), capado.mean()))\n",
    "print('desv.    %8.2f -> %8.2f' % (m.std(), capado.std()))\n",
    "print('minimo   %8.2f -> %8.2f' % (m.min(), capado.min()))\n",
    "print('maximo   %8.2f -> %8.2f' % (m.max(), capado.max()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "filas: original 3000 | capado 3000\n",
    "media      803.76 ->   803.43\n",
    "desv.      751.99 ->   732.89\n",
    "minimo   -2497.72 ->    35.64\n",
    "maximo    4236.71 ->  3058.59\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La gracia del capado es que **no pierdes ninguna fila**: siguen\n",
    "siendo 3.000 🎉\n",
    "\n",
    "Eso importa cuando esas filas tienen otras columnas que sí te sirven. Si\n",
    "borras la venta de 4.236 soles, pierdes también su ciudad, su canal y su\n",
    "satisfacción.\n",
    "\n",
    "El precio es que estás inventando datos: esa venta ya no dice 4.236 sino\n",
    "3.058,59. Y el mínimo pasa de -2.497 a +35,64, o sea que las 21 negativas\n",
    "desaparecieron sin que nadie las investigara.\n",
    "\n",
    "Por eso el capado va *después* de investigar, nunca en lugar de. Es\n",
    "una herramienta para que un modelo no se vuelva loco, no para limpiar 🧽"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Los atípicos de una columna que no tiene cola\n",
    "\n",
    "Aplica los tres métodos a `unidades`, que en el\n",
    "capítulo 5 era la más acampanada. ¿Siguen discrepando tanto?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = v['unidades']\n",
    "zu = (u - u.mean()) / u.std()\n",
    "q1u, q3u = u.quantile(0.25), u.quantile(0.75)\n",
    "iqru = q3u - q1u\n",
    "madu = (u - u.median()).abs().median()\n",
    "\n",
    "print('por z:   %d' % (zu.abs() > 3).sum())\n",
    "print('por IQR: %d' % ((u < q1u - 1.5 * iqru) | (u > q3u + 1.5 * iqru)).sum())\n",
    "print('por MAD: %d' % ((0.6745 * (u - u.median()) / madu).abs() > 3.5).sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "por z:   7\n",
    "por IQR: 10\n",
    "por MAD: 0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7, 10 y 0. Comparado con 32, 203 y 222, esto es un acuerdo 🤝\n",
    "\n",
    "Los tres métodos coinciden en que aquí casi no hay nada raro, y el MAD, que\n",
    "era el más estricto con el monto, aquí no marca ni una sola fila.\n",
    "\n",
    "El motivo es el del capítulo 5: `unidades` es acampanada y no\n",
    "tiene cola. Sin cola, los tres criterios acaban dibujando el mismo límite.\n",
    "\n",
    "Aquí está la moraleja que quiero que te lleves: **cuando los métodos\n",
    "discrepan mucho, el problema no son los atípicos, es la forma de la\n",
    "distribución**. Aquellas 32, 203 y 222 no eran tres opiniones sobre unas\n",
    "filas raras: eran tres formas de reaccionar a una cola larga."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Un atípico que no está en ninguna punta\n",
    "\n",
    "Todos los métodos de arriba miran una columna sola. Busca\n",
    "filas raras mirando dos a la vez: ventas con muchas unidades y monto bajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "por_unidad = v['monto'] / v['unidades']\n",
    "\n",
    "print(por_unidad.describe().round(2))\n",
    "print()\n",
    "raras_precio = v[(por_unidad < 5) & (v['monto'] > 0)]\n",
    "print('ventas a menos de 5 soles la unidad: %d' % len(raras_precio))\n",
    "print(raras_precio[['segmento', 'unidades', 'monto']].head(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "count    3000.00\n",
    "mean      121.28\n",
    "std       255.15\n",
    "min      -599.90\n",
    "25%        23.94\n",
    "50%        53.02\n",
    "75%       121.76\n",
    "max      3586.26\n",
    "dtype: float64\n",
    "\n",
    "ventas a menos de 5 soles la unidad: 39\n",
    "    segmento  unidades  monto\n",
    "404   Bodega        13  62.60\n",
    "534   Bodega         9  36.49\n",
    "565   Bodega        13  56.90\n",
    "570   Bodega        24  35.53\n",
    "889   Bodega        21  73.97\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "39 ventas a menos de 5 soles la unidad, y 35 de las 39 son de\n",
    "Bodega 👀\n",
    "\n",
    "Lo interesante es que **ninguna de estas filas es atípica en ninguna de\n",
    "las dos columnas por separado**. Un monto de 53 soles es normalísimo en\n",
    "Bodega. 30 unidades es normalísimo en cualquier sitio. Lo raro es la\n",
    "combinación.\n",
    "\n",
    "Eso se llama atípico multivariante y es el que se escapa siempre, porque nadie\n",
    "mira dos columnas a la vez. Aquí lo cazamos fabricando la razón entre ellas, que\n",
    "es el truco más barato que hay 🪄\n",
    "\n",
    "Y de paso ahí tienes una hipótesis de negocio: hay bodegas comprando a precio\n",
    "de mayorista. Puede ser un descuento mal aplicado o puede ser un revendedor\n",
    "disfrazado de bodega."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Los atípicos por grupo, todos a la vez\n",
    "\n",
    "Escribe algo que marque cada fila como atípica respecto a\n",
    "su propio segmento, y devuelve el DataFrame con esa columna nueva."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def z_dentro_del_grupo(g):\n",
    "    return (g - g.mean()) / g.std()\n",
    "\n",
    "\n",
    "v['z_segmento'] = v.groupby('segmento')['monto'].transform(z_dentro_del_grupo)\n",
    "v['raro'] = v['z_segmento'].abs() > 3\n",
    "\n",
    "print('atipicos por grupo: %d' % v['raro'].sum())\n",
    "print()\n",
    "print(v[v['raro']].groupby('segmento')['monto'].agg(['count', 'min', 'max']).round(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "atipicos por grupo: 21\n",
    "\n",
    "            count      min      max\n",
    "segmento                           \n",
    "Bodega          8  -224.61   415.12\n",
    "Horeca          4  -976.24  1640.51\n",
    "Mayorista       4 -2497.72  4236.71\n",
    "Minimarket      5  -494.70   896.44\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "21 atípicos por grupo. Y hay 21 ventas negativas. Cuando vi los dos\n",
    "números iguales di por hecho que eran las mismas filas, y estuve a punto de\n",
    "escribirlo aquí. Menos mal que lo comprobé 😅"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "negativas = v['monto'] < 0\n",
    "\n",
    "print('atipicos del grupo que son negativos: %d' % (v['raro'] & negativas).sum())\n",
    "print('atipicos del grupo que son positivos: %d' % (v['raro'] & ~negativas).sum())\n",
    "print('negativas que el metodo NO marco:     %d' % (negativas & ~v['raro']).sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "atipicos del grupo que son negativos: 15\n",
    "atipicos del grupo que son positivos: 6\n",
    "negativas que el metodo NO marco:     6\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No eran las mismas. Son 15 negativas más 6 ventas grandes de verdad, y hay 6\n",
    "negativas que el método deja pasar 🙃\n",
    "\n",
    "Las que deja pasar son las negativas chicas, como una de -70 soles en Bodega:\n",
    "dentro de un segmento que vende a 178 de media, eso no llega a tres\n",
    "desviaciones. Y las 6 positivas que sí marca son ventas enormes *para su\n",
    "propio grupo*, como una de 4.236 en Mayorista o una de 415 en Bodega.\n",
    "\n",
    "**Dos totales iguales no son el mismo conjunto.** Esa\n",
    "coincidencia me la creí un minuto, y comprobarla costó tres líneas.\n",
    "\n",
    "Ese `transform` es la pieza clave y vale la pena que te la quedes:\n",
    "calcula algo por grupo y lo devuelve *con la forma de la tabla original*,\n",
    "una fila por fila. Con `apply` tendrías que recomponerlo a mano."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Tu informe de atípicos\n",
    "\n",
    "Junta el capítulo en una función que reciba una columna y\n",
    "un grupo, y te diga qué se encontró antes de decidir nada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def informe(df, columna, grupo):\n",
    "    s = df[columna]\n",
    "    z_global = ((s - s.mean()) / s.std()).abs() > 3\n",
    "    z_grupo = df.groupby(grupo)[columna].transform(\n",
    "        lambda g: ((g - g.mean()) / g.std()).abs()) > 3\n",
    "\n",
    "    print('%s, mirando %s' % (columna, grupo))\n",
    "    print('  atipicos globales: %3d' % z_global.sum())\n",
    "    print('  atipicos por %s: %3d' % (grupo, z_grupo.sum()))\n",
    "    print('  marcados solo por el global: %3d' % (z_global & ~z_grupo).sum())\n",
    "    if (z_global & ~z_grupo).sum() > z_grupo.sum():\n",
    "        print('  AVISO: el metodo global esta marcando grupos enteros')\n",
    "\n",
    "\n",
    "informe(v, 'monto', 'segmento')\n",
    "print()\n",
    "informe(v, 'unidades', 'segmento')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "monto, mirando segmento\n",
    "  atipicos globales:  32\n",
    "  atipicos por segmento:  21\n",
    "  marcados solo por el global:  28\n",
    "  AVISO: el metodo global esta marcando grupos enteros\n",
    "\n",
    "unidades, mirando segmento\n",
    "  atipicos globales:   7\n",
    "  atipicos por segmento:   6\n",
    "  marcados solo por el global:   1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El aviso salta donde tenía que saltar 🚨\n",
    "\n",
    "Y ese \"marcados solo por el global: 28\" es lo demoledor: **de las 32\n",
    "filas que el método global señala, 28 no son raras dentro de su propio\n",
    "segmento**. Solo 4 sobreviven a mirar bien.\n",
    "\n",
    "Con `unidades` el aviso no salta: 7 contra 6, y solo una fila de\n",
    "diferencia. Ahí da casi igual cómo mires, que es lo que pasa cuando no hay\n",
    "grupos de niveles distintos escondidos dentro.\n",
    "\n",
    "Esta función la puedes correr sobre cualquier tabla antes de aplicar ninguna\n",
    "receta de limpieza. Tarda un segundo y te evita borrar a tu mejor cliente 💚"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Atípicos en tres columnas\n",
    "\n",
    "Aplica el criterio del IQR a tres columnas y compara cuántos salen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for col in ['monto', 'unidades', 'descuento']:\n",
    "    s = v[col].dropna()\n",
    "    q1c, q3c = s.quantile(0.25), s.quantile(0.75)\n",
    "    iqrc = q3c - q1c\n",
    "    fuera = ((s < q1c - 1.5 * iqrc) | (s > q3c + 1.5 * iqrc)).sum()\n",
    "    print('%-13s %4d atipicos por IQR, o sea el %.1f%%'\n",
    "          % (col, fuera, fuera / len(s) * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "monto          203 atipicos por IQR, o sea el 6.8%\n",
    "unidades        10 atipicos por IQR, o sea el 0.3%\n",
    "descuento        0 atipicos por IQR, o sea el 0.0%\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El mismo criterio, tres columnas, y de 203 a cero 😮\n",
    "\n",
    "El descuento no tiene **ni uno**, y no porque los datos estén más limpios: es que va de 0 a un tope y no hay forma de salirse. Una columna acotada no puede tener atípicos por este método.\n",
    "\n",
    "Y eso te da una lectura que vale para tu trabajo: si corres el detector sobre veinte columnas y una te da cero, no cantes victoria. Mira primero si esa columna podía tenerlos 🔍"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Mueve el 1,5 y mira qué pasa\n",
    "\n",
    "Prueba el criterio con k igual a 1,5, 2 y 3, y cuenta cuántas filas sobran en cada caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in [1.5, 2.0, 3.0]:\n",
    "    corte = q3 + k * (q3 - q1)\n",
    "    print('con k = %.1f el corte esta en %8.2f y sobran %4d filas'\n",
    "          % (k, corte, (m > corte).sum()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "con k = 1.5 el corte esta en  2292.68 y sobran  200 filas\n",
    "con k = 2.0 el corte esta en  2700.67 y sobran   77 filas\n",
    "con k = 3.0 el corte esta en  3516.67 y sobran    9 filas\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De 200 a 9 moviendo un número que nadie discute 😳\n",
    "\n",
    "Ese 1,5 no sale de ninguna teoría: es una **convención**, y la eligió Tukey porque le funcionaba bien. Cambiarlo a 3 no está mal ni bien, es otra decisión.\n",
    "\n",
    "Y aquí está lo que quiero que te lleves, que es la declaración de este capítulo dicha con números: el número de atípicos no es un hecho de tus datos, es **una consecuencia de lo que elegiste**. Por eso se reporta siempre con el criterio al lado 🚩"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El filtro simétrico que solo cortó de un lado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y ahora la trampa, que es justo lo que pasa cuando limpias atípicos sin mirar de dónde los estás quitando 📉"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La trampa\n",
    "\n",
    "Limpias los atípicos antes de calcular, como manda el manual: fuera todo lo que se aleje más de tres desviaciones. Vuelves a sacar el promedio.\n",
    "\n",
    "```\n",
    "mu, sd = v['monto'].mean(), v['monto'].std()\n",
    "arriba = (v['monto'] > mu + 3 * sd).sum()\n",
    "abajo  = (v['monto'] < mu - 3 * sd).sum()\n",
    "\n",
    "print(arriba, abajo)\n",
    "# 30 2\n",
    "```\n",
    "\n",
    "**Qué está mal**\n",
    "\n",
    "Treinta por arriba y dos por abajo 📉 El filtro que creías simétrico se llevó casi todo de un solo lado.\n",
    "\n",
    "Es lo que pasa al aplicar un criterio hecho para una campana a datos con cola a la derecha: por abajo no hay nada que quitar, porque una venta no puede ser muy negativa, y por arriba hay cola de sobra. La media baja de 803,76 a 777,35, y esa bajada **no es limpieza, es sesgo**.\n",
    "\n",
    "Y el problema no son los 26,41 soles. Es que ahora tienes un número más bajo que el real y la sensación de haber hecho las cosas bien, que es peor.\n",
    "\n",
    "Un atípico no es un dato equivocado: es un dato raro. Antes de quitar ninguno mira **qué son**. Si esas 30 ventas grandes son ventas de verdad, quitarlas es borrar a tus mejores clientes del análisis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprueba que lo tienes\n",
    "\n",
    "La puntuación z marca 32 ventas como atípicas y las 32 son del segmento Mayorista. ¿Qué haces?\n",
    "\n",
    "a) Comparo cada venta contra su propio segmento antes de decidir\n",
    "\n",
    "b) Las quito, porque el método las marcó\n",
    "\n",
    "c) Uso el IQR, que es más robusto\n",
    "\n",
    "d) Las dejo porque son pocas\n",
    "\n",
    "---\n",
    "\n",
    "**La correcta es la a.**\n",
    "\n",
    "*b)* Estarías borrando a tus mejores clientes por ser tus mejores clientes.\n",
    "\n",
    "*c)* El IQR marca 203 y las 32 están dentro. El problema no es el método.\n",
    "\n",
    "*d)* Que sean pocas no dice nada. La pregunta es contra qué se las está comparando.\n",
    "\n",
    "Un atípico no es un número grande: es un número que no pertenece al grupo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lo que te llevas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 🎯 Un atípico no es un número grande, es un número que no pertenece al\n",
    "grupo. Todo depende de contra qué lo compares.\n",
    "\n",
    "- 🔢 Los tres métodos dan 32, 203 y 222 sobre los mismos datos. No se\n",
    "contradicen: son tres niveles de severidad, y la z es la más permisiva porque los\n",
    "atípicos inflan la desviación con la que se les juzga.\n",
    "\n",
    "- 🏪 Los 32 atípicos globales eran los 32 mayoristas más grandes: 28 de ellos\n",
    "no son raros dentro de su propio segmento. Comparando por grupo salen 21\n",
    "repartidos entre los cuatro.\n",
    "\n",
    "- 🧮 Dos totales iguales no son el mismo conjunto. Los 21 atípicos por grupo y\n",
    "las 21 ventas negativas coincidían en el número y compartían solo 15 filas.\n",
    "\n",
    "- 💎 Las 21 negativas tienen las tres en común: ninguna se cerró. Buscando\n",
    "basura encontramos una regla del sistema que nadie había documentado.\n",
    "\n",
    "- 🔀 Los atípicos multivariantes no salen en ninguna punta. 39 ventas a menos\n",
    "de 5 soles la unidad son normales en las dos columnas por separado.\n",
    "\n",
    "- 🚫 Nunca borrar sin mirar. Investigar, corregir, dejar o capar, en ese\n",
    "orden.\n",
    "\n",
    "Y si de todo el capítulo te llevas una sola frase, que sea esta:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un atípico no es un dato equivocado. Es un dato raro, y antes de quitarlo\n",
    "hay que mirar qué es."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y qué hacer al final con los raros (quitarlos, recortarlos o dejarlos) no es\n",
    "una decisión de estadística, es de preprocesamiento, y está contada con sus\n",
    "consecuencias en el\n",
    "[libro de machine learning](https://missyera.com/guias/machine-learning-desde-cero/) 🤖"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Qué viene ahora"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cerramos la parte descriptiva. A partir del capítulo 7 dejamos de describir\n",
    "lo que tenemos y empezamos a afirmar cosas sobre lo que no medimos, que es donde\n",
    "la estadística se pone interesante y peligrosa a la vez. Empezamos por la\n",
    "probabilidad, y solo la que hace falta 🎲"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preguntas frecuentes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué son los outliers?Datos que se salen del grupo. En castellano se les dice valores atípicos, y los dos nombres se usan igual.\n",
    "\n",
    "¿Cómo se detectan los valores atípicos?Con la regla del rango intercuartílico, que marca lo que cae más allá de vez y media el rango por debajo o por encima de los cuartos. Con puntuación z también, y esa se deja engañar por los propios atípicos.\n",
    "\n",
    "¿Se eliminan los outliers?Casi nunca sin mirarlos. Un dato raro puede ser un error de tipeo, que se corrige, o el mejor cliente del año, que hay que dejar. Borrarlos por norma es cómo desaparecen las ventas grandes de un reporte.\n",
    "\n",
    "¿Qué es la puntuación z?A cuántas desviaciones estándar de la media está un dato. Un z de 3 quiere decir tres desviaciones por encima."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Ese era el capítulo 6 de **Estadística desde cero**. El texto completo, con las salidas de cada bloque, está en https://missyera.com/guias/estadistica-desde-cero/atipicos/\n",
    "\n",
    "Que tengas lindo día! 🌸"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}