{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tarea: Embeddings, Búsqueda Semántica y Self-Query\n",
    "\n",
    "**Universidad Galileo — IA para Aplicaciones del Mundo Real**\n",
    "**Unidad 10 · Embeddings y Búsqueda Semántica**\n",
    "\n",
    "## Qué vas a construir\n",
    "\n",
    "Un buscador sobre un catálogo de películas que entiende lo que le pides **aunque no uses sus\n",
    "palabras**, y que además sabe separar la parte semántica de la parte que es un filtro.\n",
    "\n",
    "Al terminar vas a tener medido, con tus propios números:\n",
    "\n",
    "1. qué le pasa al coseno con textos parecidos, **opuestos** y sin relación,\n",
    "2. si los grupos semánticos aparecen solos al proyectar a 2D,\n",
    "3. cómo se busca por vecinos más cercanos,\n",
    "4. por qué el orden entre filtrar y buscar **cambia el resultado**,\n",
    "5. y cómo un LLM parte una pregunta en `query` + `filtros`.\n",
    "\n",
    "## Lo que ya está hecho (no lo toques)\n",
    "\n",
    "- El catálogo de películas con su metadata\n",
    "- La carga del modelo de embeddings y del LLM\n",
    "- Todas las gráficas\n",
    "- El reporte final\n",
    "\n",
    "## Lo que tienes que implementar\n",
    "\n",
    "Seis bloques marcados con `# TU CODIGO AQUI`. Cada uno va seguido de una celda de verificación\n",
    "con `assert`: si pasa, puedes seguir.\n",
    "\n",
    "## Cómo se entrega\n",
    "\n",
    "*Entorno de ejecución → Reiniciar y ejecutar todo*, y que corra de principio a fin sin errores.\n",
    "Las **tres preguntas escritas** cuentan igual que el código: se responden en la celda de texto que\n",
    "está debajo de cada una, con los números que tú mediste.\n",
    "\n",
    "> **El catálogo está en inglés a propósito.** El modelo `all-MiniLM-L6-v2` es un modelo de inglés y\n",
    "> queremos medir el comportamiento del embedding, no pelear con el idioma. Tu código, tus comentarios\n",
    "> y tus respuestas van en español.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Preparación (dado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e945d710",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.12/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "/usr/local/lib/python3.12/dist-packages/torch/cuda/__init__.py:1007: UserWarning: Can't initialize NVML\n",
      "  raw_cnt = _raw_device_count_nvml()\n",
      "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
      "Loading weights: 100%|██████████| 103/103 [00:00<00:00, 22767.50it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "modelo cargado · 384 dimensiones\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_304/1546073338.py:16: FutureWarning: The `get_sentence_embedding_dimension` method has been renamed to `get_embedding_dimension`.\n",
      "  print(\"modelo cargado ·\", modelo.get_sentence_embedding_dimension(), \"dimensiones\")\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    import sentence_transformers, sklearn  # noqa: F401\n",
    "except ImportError:\n",
    "    %pip install -q sentence-transformers scikit-learn\n",
    "\n",
    "import json, re, textwrap\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sentence_transformers import SentenceTransformer\n",
    "\n",
    "OKABE = [\"#0072B2\", \"#D55E00\", \"#009E73\", \"#CC79A7\", \"#E69F00\", \"#56B4E9\", \"#F0E442\"]\n",
    "np.random.seed(0)\n",
    "\n",
    "modelo = SentenceTransformer(\"all-MiniLM-L6-v2\")\n",
    "print(\"modelo cargado ·\", modelo.get_sentence_embedding_dimension(), \"dimensiones\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "63e59a8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45 películas · 5 géneros\n",
      "genero\n",
      "science fiction    9\n",
      "horror             9\n",
      "comedy             9\n",
      "documentary        9\n",
      "drama              9\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>titulo</th>\n",
       "      <th>genero</th>\n",
       "      <th>anio</th>\n",
       "      <th>calificacion</th>\n",
       "      <th>duracion_min</th>\n",
       "      <th>idioma</th>\n",
       "      <th>sinopsis</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Echoes of Tomorrow</td>\n",
       "      <td>science fiction</td>\n",
       "      <td>2019</td>\n",
       "      <td>7.8</td>\n",
       "      <td>124</td>\n",
       "      <td>English</td>\n",
       "      <td>A physicist discovers that every choice she ma...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>The Last Signal</td>\n",
       "      <td>science fiction</td>\n",
       "      <td>2021</td>\n",
       "      <td>8.1</td>\n",
       "      <td>138</td>\n",
       "      <td>English</td>\n",
       "      <td>Astronauts receive a transmission from a probe...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Silicon Dawn</td>\n",
       "      <td>science fiction</td>\n",
       "      <td>2016</td>\n",
       "      <td>6.9</td>\n",
       "      <td>111</td>\n",
       "      <td>English</td>\n",
       "      <td>An engineer realizes the assistant she built h...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               titulo           genero  anio  calificacion  duracion_min  \\\n",
       "0  Echoes of Tomorrow  science fiction  2019           7.8           124   \n",
       "1     The Last Signal  science fiction  2021           8.1           138   \n",
       "2        Silicon Dawn  science fiction  2016           6.9           111   \n",
       "\n",
       "    idioma                                           sinopsis  \n",
       "0  English  A physicist discovers that every choice she ma...  \n",
       "1  English  Astronauts receive a transmission from a probe...  \n",
       "2  English  An engineer realizes the assistant she built h...  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ---- el catálogo (dado) ----\n",
    "CATALOGO = [\n",
    " # --- science fiction ---\n",
    " (\"Echoes of Tomorrow\",\"science fiction\",2019,7.8,124,\"English\",\"A physicist discovers that every choice she makes splits reality into a new timeline.\"),\n",
    " (\"The Last Signal\",\"science fiction\",2021,8.1,138,\"English\",\"Astronauts receive a transmission from a probe that was lost forty years earlier.\"),\n",
    " (\"Silicon Dawn\",\"science fiction\",2016,6.9,111,\"English\",\"An engineer realizes the assistant she built has started rewriting its own goals.\"),\n",
    " (\"Orbital Decay\",\"science fiction\",2023,7.2,129,\"English\",\"A repair crew is stranded when their station begins falling out of orbit.\"),\n",
    " (\"Paper Suns\",\"science fiction\",1998,7.5,142,\"Japanese\",\"In a city under an artificial sky, a technician questions who controls the weather.\"),\n",
    " (\"Vanishing Point Nine\",\"science fiction\",2012,6.4,98,\"English\",\"A pilot keeps waking up on the same doomed flight with slightly different crew.\"),\n",
    " (\"The Copenhagen Protocol\",\"science fiction\",2020,8.4,151,\"English\",\"Two scientists must decide whether to publish a discovery that could end scarcity.\"),\n",
    " (\"Grain of the Void\",\"science fiction\",2005,7.0,117,\"French\",\"A cartographer maps a region of space where distance stops behaving normally.\"),\n",
    " (\"Third Body Problem\",\"science fiction\",2024,8.7,161,\"English\",\"First contact arrives as a mathematical proof nobody on Earth can finish.\"),\n",
    " # --- horror ---\n",
    " (\"The Quiet Floor\",\"horror\",2018,6.8,96,\"English\",\"A night nurse notices that one hospital wing is never listed on any schedule.\"),\n",
    " (\"Hollow Season\",\"horror\",2022,7.4,104,\"English\",\"A family returns to a lake house where the water level never changes.\"),\n",
    " (\"Salt and Ash\",\"horror\",2015,6.1,88,\"Spanish\",\"A fishing village burns its records every decade and no one remembers why.\"),\n",
    " (\"Static Hour\",\"horror\",2009,5.7,92,\"English\",\"A radio host starts receiving calls from listeners who died years earlier.\"),\n",
    " (\"The Lending Library\",\"horror\",2023,7.9,109,\"Korean\",\"Every book returned to this library comes back with an extra chapter.\"),\n",
    " (\"Beneath the Orchard\",\"horror\",2001,6.5,101,\"English\",\"Two brothers dig up their family's land and find the harvest was never plants.\"),\n",
    " (\"Nine Nights of Rain\",\"horror\",2020,7.1,113,\"Japanese\",\"A storm traps a film crew in a shrine that appears on no map.\"),\n",
    " (\"The Long Hallway\",\"horror\",2013,6.3,94,\"English\",\"A hotel corridor gets longer every night and the guests stop leaving.\"),\n",
    " (\"Cellar Door\",\"horror\",2024,7.6,99,\"Spanish\",\"A locked basement in a new house answers when someone knocks twice.\"),\n",
    " # --- comedy ---\n",
    " (\"Tax Season\",\"comedy\",2017,7.3,95,\"English\",\"An auditor and a con artist accidentally swap client folders and lives.\"),\n",
    " (\"The Understudy\",\"comedy\",2021,6.6,102,\"English\",\"A stagehand is forced on stage and turns out to be a much better lead.\"),\n",
    " (\"Wedding by Committee\",\"comedy\",2013,6.2,108,\"Spanish\",\"Four siblings plan their mother's third wedding with four incompatible visions.\"),\n",
    " (\"Return Policy\",\"comedy\",2019,7.7,91,\"English\",\"A store clerk tries to return a decision he made fifteen years ago.\"),\n",
    " (\"Two Left Feet\",\"comedy\",2004,6.0,97,\"English\",\"A dance instructor who cannot dance must win a competition to save the studio.\"),\n",
    " (\"The Group Project\",\"comedy\",2023,7.5,88,\"English\",\"Five strangers must finish an assignment none of them signed up for.\"),\n",
    " (\"Neighbors Downstairs\",\"comedy\",2011,6.7,99,\"French\",\"A composer and a drummer wage a polite war through a very thin ceiling.\"),\n",
    " (\"Overqualified\",\"comedy\",2022,7.1,94,\"English\",\"A retired surgeon takes a job at a coffee shop and cannot stop diagnosing customers.\"),\n",
    " (\"The Reunion Committee\",\"comedy\",2008,6.4,105,\"English\",\"Old classmates discover none of them remembers high school the same way.\"),\n",
    " # --- documentary ---\n",
    " (\"The Long Count\",\"documentary\",2018,8.2,118,\"English\",\"Statisticians spend a decade recounting a census nobody believed the first time.\"),\n",
    " (\"Cold Storage\",\"documentary\",2020,7.9,96,\"English\",\"Inside the seed vaults built to outlive the institutions that funded them.\"),\n",
    " (\"Paper Trails\",\"documentary\",2016,8.0,124,\"English\",\"How a single misfiled form changed immigration policy for a generation.\"),\n",
    " (\"The Repair Shop Wars\",\"documentary\",2022,7.4,88,\"English\",\"Volunteers fight manufacturers for the right to fix what they already own.\"),\n",
    " (\"Salt Roads\",\"documentary\",2014,8.5,132,\"Spanish\",\"Following the trade routes that shaped three continents, told through cooks.\"),\n",
    " (\"Signal to Noise\",\"documentary\",2021,7.6,105,\"English\",\"Why most published findings in one field could not be reproduced.\"),\n",
    " (\"The Quiet Grid\",\"documentary\",2023,8.3,110,\"English\",\"Engineers keep a national power grid stable with tools older than they are.\"),\n",
    " (\"Two Degrees\",\"documentary\",2019,8.1,101,\"French\",\"Glaciologists drill ice cores that record every summer for eight hundred years.\"),\n",
    " (\"The Last Mile\",\"documentary\",2024,7.7,93,\"Korean\",\"How packages actually reach a door, told by the people who carry them.\"),\n",
    " # --- drama ---\n",
    " (\"Winter Term\",\"drama\",2015,8.1,127,\"English\",\"A teacher and a student both fail the same exam, for very different reasons.\"),\n",
    " (\"The Inheritance Clause\",\"drama\",2019,7.8,141,\"English\",\"Three siblings discover their father left the estate to a stranger.\"),\n",
    " (\"Low Tide\",\"drama\",2007,7.2,116,\"English\",\"A fishing family decides whether to sell the boat that defines them.\"),\n",
    " (\"Letters Not Sent\",\"drama\",2021,8.4,134,\"French\",\"A widow finds forty years of letters her husband wrote but never mailed.\"),\n",
    " (\"The Night Shift\",\"drama\",2018,7.5,109,\"Spanish\",\"Two hospital cleaners hold a friendship together across opposite schedules.\"),\n",
    " (\"The Quietest Room\",\"drama\",2022,8.0,118,\"Korean\",\"A sound engineer loses her hearing and rebuilds her work from vibration.\"),\n",
    " (\"The Understory\",\"drama\",2024,8.6,152,\"English\",\"A forest ranger and a logger discover they are protecting the same thing.\"),\n",
    " (\"Second Language\",\"drama\",2020,7.9,113,\"English\",\"An interpreter starts changing what people say to keep a peace talk alive.\"),\n",
    " (\"The Waiting List\",\"drama\",2017,8.2,138,\"English\",\"Two families are matched by an organ registry and must decide what to say.\"),\n",
    "]\n",
    "COLUMNAS = [\"titulo\",\"genero\",\"anio\",\"calificacion\",\"duracion_min\",\"idioma\",\"sinopsis\"]\n",
    "df = pd.DataFrame(CATALOGO, columns=COLUMNAS)\n",
    "GENEROS = sorted(df[\"genero\"].unique())\n",
    "COLOR_GENERO = {g: OKABE[i] for i, g in enumerate(GENEROS)}\n",
    "\n",
    "print(f\"{len(df)} películas · {len(GENEROS)} géneros\")\n",
    "print(df[\"genero\"].value_counts().to_string())\n",
    "df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "820269c7",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Ejercicio 1 · Codificar y medir el parecido\n",
    "\n",
    "Todo lo demás depende de estas dos funciones. `codificar` convierte una lista de textos en una\n",
    "matriz de vectores **normalizados** (norma 1), y `coseno` mide el parecido entre dos vectores.\n",
    "\n",
    "> Si los vectores están normalizados, el coseno es simplemente el producto punto. Aprovéchalo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a0d0c834",
   "metadata": {},
   "outputs": [],
   "source": [
    "def codificar(textos):\n",
    "    '''Devuelve un array (n, 384) con los vectores NORMALIZADOS de cada texto.'''\n",
    "    # TU CODIGO AQUI\n",
    "    # normalize_embeddings=True hace que el modelo devuelva cada vector ya dividido\n",
    "    # por su propia norma, así el coseno se puede calcular como un simple producto punto.\n",
    "    vectores_normalizados = modelo.encode(textos, normalize_embeddings=True)\n",
    "    return vectores_normalizados\n",
    "\n",
    "\n",
    "def coseno(a, b):\n",
    "    '''Coseno entre dos vectores 1-D ya normalizados.'''\n",
    "    # TU CODIGO AQUI\n",
    "    # con vectores de norma 1, el coseno del ángulo entre ellos es exactamente su producto punto.\n",
    "    coseno_entre_vectores = float(np.dot(a, b))\n",
    "    return coseno_entre_vectores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ca85fb16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✔ ejercicio 1 correcto\n"
     ]
    }
   ],
   "source": [
    "# ---- verificación ----\n",
    "_v = codificar([\"a cat on a sofa\", \"a dog on a rug\"])\n",
    "assert _v.shape == (2, 384), f\"esperaba (2, 384), obtuve {_v.shape}\"\n",
    "assert np.allclose(np.linalg.norm(_v, axis=1), 1.0, atol=1e-4), \"los vectores no están normalizados\"\n",
    "assert abs(coseno(_v[0], _v[0]) - 1.0) < 1e-5, \"el coseno de un vector consigo mismo debe ser 1\"\n",
    "assert -1.01 < coseno(_v[0], _v[1]) < 1.01, \"el coseno debe caer en [-1, 1]\"\n",
    "print(\"✔ ejercicio 1 correcto\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b262afa9",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Ejercicio 2 · Parecidos, opuestos y sin relación\n",
    "\n",
    "Aquí viene la parte interesante. La intuición dice:\n",
    "\n",
    "| familia | coseno esperado |\n",
    "|---|---|\n",
    "| casi sinónimos | cerca de **+1** |\n",
    "| opuestos | cerca de **−1** |\n",
    "| sin relación | cerca de **0** |\n",
    "\n",
    "**Mídelo y comprueba si es cierto.** Completa la función que calcula el coseno de cada par y la media\n",
    "por familia. No cambies los pares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "48611559",
   "metadata": {},
   "outputs": [],
   "source": [
    "PARES = {\n",
    " \"casi sinónimos\": [\n",
    "   (\"The movie was excellent\", \"The film was outstanding\"),\n",
    "   (\"A large dog runs fast\", \"A big dog runs quickly\"),\n",
    "   (\"She bought a car\", \"She purchased an automobile\"),\n",
    "   (\"The plot is confusing\", \"The storyline is very confusing\")],\n",
    " \"opuestos\": [\n",
    "   (\"The movie was excellent\", \"The movie was terrible\"),\n",
    "   (\"The room is very hot\", \"The room is very cold\"),\n",
    "   (\"He always tells the truth\", \"He always tells lies\"),\n",
    "   (\"The product is cheap\", \"The product is expensive\"),\n",
    "   (\"I love this restaurant\", \"I hate this restaurant\")],\n",
    " \"negación\": [\n",
    "   (\"The cat is sleeping\", \"The cat is not sleeping\"),\n",
    "   (\"This solution works\", \"This solution does not work\")],\n",
    " \"sin relación\": [\n",
    "   (\"The movie was excellent\", \"Photosynthesis converts light into sugar\"),\n",
    "   (\"A large dog runs fast\", \"The mortgage rate rose last quarter\"),\n",
    "   (\"She bought a car\", \"Volcanic ash reached the stratosphere\")],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ddd64bb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "casi sinónimos   media +0.839   rango [+0.723, +0.935]\n",
      "opuestos         media +0.812   rango [+0.703, +0.891]\n",
      "negación         media +0.821   rango [+0.736, +0.905]\n",
      "sin relación     media +0.034   rango [-0.007, +0.115]\n"
     ]
    }
   ],
   "source": [
    "def medir_familias(pares):\n",
    "    '''Para cada familia devuelve (lista_de_cosenos, media).\n",
    "\n",
    "    Devuelve un dict: {nombre_familia: (cosenos, media)}\n",
    "    '''\n",
    "    # TU CODIGO AQUI\n",
    "    resultados_por_familia = {}\n",
    "    for nombre_familia, lista_de_pares in pares.items():\n",
    "        # separamos cada lista de tuplas (texto_a, texto_b) en dos listas paralelas\n",
    "        # para poder codificar cada lado con una sola llamada al modelo\n",
    "        textos_del_primer_elemento = [par[0] for par in lista_de_pares]\n",
    "        textos_del_segundo_elemento = [par[1] for par in lista_de_pares]\n",
    "        vectores_del_primer_elemento = codificar(textos_del_primer_elemento)\n",
    "        vectores_del_segundo_elemento = codificar(textos_del_segundo_elemento)\n",
    "\n",
    "        cosenos_de_la_familia = [\n",
    "            coseno(vectores_del_primer_elemento[i], vectores_del_segundo_elemento[i])\n",
    "            for i in range(len(lista_de_pares))\n",
    "        ]\n",
    "        media_de_la_familia = float(np.mean(cosenos_de_la_familia))\n",
    "        resultados_por_familia[nombre_familia] = (cosenos_de_la_familia, media_de_la_familia)\n",
    "    return resultados_por_familia\n",
    "\n",
    "\n",
    "resultados = medir_familias(PARES)\n",
    "for familia, (cs, m) in resultados.items():\n",
    "    print(f\"{familia:<16} media {m:+.3f}   rango [{min(cs):+.3f}, {max(cs):+.3f}]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1ed05984",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✔ ejercicio 2 correcto\n"
     ]
    }
   ],
   "source": [
    "# ---- verificación ----\n",
    "assert set(resultados) == set(PARES), \"faltan familias en el resultado\"\n",
    "for f, (cs, m) in resultados.items():\n",
    "    assert len(cs) == len(PARES[f]), f\"faltan cosenos en «{f}»\"\n",
    "    assert abs(m - np.mean(cs)) < 1e-9, f\"la media de «{f}» no cuadra con sus cosenos\"\n",
    "assert resultados[\"sin relación\"][1] < resultados[\"casi sinónimos\"][1], \\\n",
    "    \"lo no relacionado debería dar menos que lo sinónimo\"\n",
    "print(\"✔ ejercicio 2 correcto\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b2658a0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x450 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---- gráfica (dada) ----\n",
    "fig, ax = plt.subplots(figsize=(9, 4.5))\n",
    "for i, (familia, (cs, m)) in enumerate(resultados.items()):\n",
    "    ax.scatter(cs, [i] * len(cs), s=90, color=OKABE[i], zorder=3, alpha=0.85)\n",
    "    ax.scatter([m], [i], marker=\"|\", s=600, color=\"black\", zorder=4)\n",
    "ax.axvline(0, color=\"gray\", lw=1, ls=\"--\")\n",
    "ax.set_yticks(range(len(resultados))); ax.set_yticklabels(list(resultados))\n",
    "ax.set_xlim(-1.05, 1.05); ax.set_xlabel(\"coseno\")\n",
    "ax.set_title(\"Cada punto es un par; la barra negra es la media de la familia\")\n",
    "ax.grid(axis=\"x\", alpha=0.3); ax.set_axisbelow(True)\n",
    "for lado in (\"top\", \"right\"): ax.spines[lado].set_visible(False)\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6f16dee",
   "metadata": {},
   "source": [
    "### Pregunta escrita 1\n",
    "\n",
    "Mira la gráfica y tus números, y responde **con las cifras que mediste**:\n",
    "\n",
    "1. ¿Se cumplió la tabla de arriba? ¿Cuál de las tres expectativas falló?\n",
    "2. ¿Qué coseno dio el par `\"The cat is sleeping\"` vs `\"The cat is not sleeping\"`? ¿Te parece razonable\n",
    "   que dos frases que afirman lo contrario queden ahí?\n",
    "3. Un retriever de RAG devuelve los documentos con mayor coseno. Con lo que acabas de medir,\n",
    "   **¿qué problema concreto tendría** un sistema que busca *\"¿la política permite home office?\"* en un\n",
    "   manual que dice *\"la política **no** permite home office\"*?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cae76d73",
   "metadata": {},
   "source": "**1.** La tabla se cumplió solo a medias. \"Casi sinónimos\" (media **+0.839**) y \"sin relación\"\n(media **+0.034**) sí coinciden con lo esperado (cerca de +1 y cerca de 0). La que **falló** fue\n\"opuestos\": en vez de acercarse a −1 dio una media de **+0.812**, prácticamente igual que la de\nlos sinónimos (+0.839). El modelo trata \"excelente/terrible\" o \"caliente/frío\" casi como si\nfueran lo mismo, no como contrarios.\n\n**2.** El par `\"The cat is sleeping\"` vs `\"The cat is not sleeping\"` pertenece a la familia\n\"negación\", que dio media **+0.821** con rango **[+0.736, +0.905]** (son solo 2 pares en esa\nfamilia, así que esos dos valores del rango son justamente los cosenos de los dos pares). O sea\nque ese par cayó en algún punto entre 0.74 y 0.90: alto en cualquier caso. No, no parece\nrazonable — dos frases que afirman literalmente lo contrario deberían tener un coseno bajo o\nnegativo, y en cambio el modelo las deja casi tan \"parecidas\" como dos sinónimos.\n\n**3.** El problema es el mismo que se mide arriba: como \"opuestos\" y \"negación\" comparten casi\ntodo el vocabulario y solo cambia una palabra que invierte el sentido, el coseno entre\n`\"la política permite home office\"` y `\"la política **no** permite home office\"` saldría **alto**\n(del orden de +0.8, según lo medido). Un retriever que ordena por coseno pondría ese documento\nen un lugar muy alto de la lista — es decir, respondería con **alta confianza** citando el párrafo\nque dice justo lo contrario de lo que preguntó la persona que le pregunta al RAG. El embedding\npor sí solo no distingue afirmación de negación; hace falta otra señal (re-ranking, lectura del\npasaje, o un LLM que verifique el contenido) antes de confiar ciegamente en el coseno."
  },
  {
   "cell_type": "markdown",
   "id": "9e094f9a",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Ejercicio 3 · Reducción de dimensiones y clustering\n",
    "\n",
    "Los vectores tienen 384 dimensiones. Para ver si hay **grupos semánticos** hay que proyectarlos a 2D.\n",
    "\n",
    "Vas a hacer tres cosas:\n",
    "\n",
    "1. codificar las sinopsis del catálogo,\n",
    "2. proyectarlas a 2D con **PCA** y con **t-SNE**,\n",
    "3. agrupar con **KMeans** (sin decirle el género) y medir cuánto coincide con el género real.\n",
    "\n",
    "> Para medir la coincidencia usa **pureza**: para cada cluster, la fracción que representa su género\n",
    "> más común; luego el promedio ponderado por tamaño. 1.0 = clusters perfectos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2f348771",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "# 1) los vectores de las 45 sinopsis\n",
    "# TU CODIGO AQUI  (usa codificar sobre df[\"sinopsis\"])\n",
    "V = codificar(df[\"sinopsis\"].tolist())\n",
    "\n",
    "# 2) proyecciones a 2D  (t-SNE: usa perplexity=8, random_state=0, init=\"pca\")\n",
    "# TU CODIGO AQUI\n",
    "proyector_pca = PCA(n_components=2, random_state=0)\n",
    "C_pca = proyector_pca.fit_transform(V)\n",
    "# TU CODIGO AQUI\n",
    "proyector_tsne = TSNE(n_components=2, perplexity=8, random_state=0, init=\"pca\")\n",
    "C_tsne = proyector_tsne.fit_transform(V)\n",
    "\n",
    "# 3) clustering sobre los vectores COMPLETOS (384 dim), no sobre la proyección\n",
    "# TU CODIGO AQUI  (KMeans con tantos clusters como géneros, random_state=0, n_init=10)\n",
    "km = KMeans(n_clusters=len(GENEROS), random_state=0, n_init=10)\n",
    "km.fit(V)\n",
    "# TU CODIGO AQUI  (el cluster asignado a cada película)\n",
    "etiquetas = km.labels_\n",
    "\n",
    "\n",
    "def pureza(etiquetas, verdad):\n",
    "    '''Promedio ponderado de la fracción del género dominante en cada cluster.'''\n",
    "    # TU CODIGO AQUI\n",
    "    etiquetas = np.asarray(etiquetas)\n",
    "    verdad = np.asarray(verdad)\n",
    "    total_de_aciertos_del_genero_dominante = 0\n",
    "    for id_de_cluster in np.unique(etiquetas):\n",
    "        # dentro de cada cluster, contamos cuántas veces aparece cada género real\n",
    "        generos_dentro_del_cluster = verdad[etiquetas == id_de_cluster]\n",
    "        _, conteo_por_genero = np.unique(generos_dentro_del_cluster, return_counts=True)\n",
    "        # el \"acierto óptimo\" de un cluster es quedarse con su género más frecuente\n",
    "        total_de_aciertos_del_genero_dominante += conteo_por_genero.max()\n",
    "    return total_de_aciertos_del_genero_dominante / len(etiquetas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a7793be5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✔ ejercicio 3 correcto · pureza de los clusters: 0.422\n",
      "  (al azar sería aproximadamente 0.200)\n"
     ]
    }
   ],
   "source": [
    "# ---- verificación ----\n",
    "for _n, _o in [(\"V\", V), (\"C_pca\", C_pca), (\"C_tsne\", C_tsne), (\"etiquetas\", etiquetas)]:\n",
    "    assert _o is not None, f\"«{_n}» sigue en None: completa el ejercicio 3\"\n",
    "assert V.shape == (len(df), 384), f\"V debería ser ({len(df)}, 384), es {V.shape}\"\n",
    "assert C_pca.shape == (len(df), 2) and C_tsne.shape == (len(df), 2), \"las proyecciones deben ser 2D\"\n",
    "assert len(np.unique(etiquetas)) == len(GENEROS), \"deberían salir tantos clusters como géneros\"\n",
    "assert abs(pureza([0, 0, 1, 1], [\"a\", \"a\", \"b\", \"b\"]) - 1.0) < 1e-9, \"pureza perfecta debería dar 1.0\"\n",
    "assert abs(pureza([0, 0, 0, 0], [\"a\", \"a\", \"b\", \"b\"]) - 0.5) < 1e-9, \"un solo cluster mitad y mitad = 0.5\"\n",
    "\n",
    "p = pureza(etiquetas, df[\"genero\"].values)\n",
    "print(f\"✔ ejercicio 3 correcto · pureza de los clusters: {p:.3f}\")\n",
    "print(f\"  (al azar sería aproximadamente {1/len(GENEROS):.3f})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cece0c03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1700x550 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---- gráfica (dada) ----\n",
    "fig, axes = plt.subplots(1, 3, figsize=(17, 5.5))\n",
    "for ax, C, titulo in [(axes[0], C_pca, \"PCA · coloreado por género REAL\"),\n",
    "                      (axes[1], C_tsne, \"t-SNE · coloreado por género REAL\")]:\n",
    "    for g in GENEROS:\n",
    "        idx = df.index[df[\"genero\"] == g]\n",
    "        ax.scatter(C[idx, 0], C[idx, 1], s=90, color=COLOR_GENERO[g], label=g,\n",
    "                   edgecolors=\"white\", linewidths=0.8)\n",
    "    ax.set_title(titulo, fontsize=11); ax.set_xticks([]); ax.set_yticks([])\n",
    "axes[0].legend(frameon=False, fontsize=8.5)\n",
    "\n",
    "for c in range(len(GENEROS)):\n",
    "    idx = np.where(etiquetas == c)[0]\n",
    "    axes[2].scatter(C_tsne[idx, 0], C_tsne[idx, 1], s=90, color=OKABE[c],\n",
    "                    label=f\"cluster {c}\", edgecolors=\"white\", linewidths=0.8)\n",
    "axes[2].set_title(f\"t-SNE · coloreado por CLUSTER (pureza {p:.2f})\", fontsize=11)\n",
    "axes[2].set_xticks([]); axes[2].set_yticks([]); axes[2].legend(frameon=False, fontsize=8.5)\n",
    "for ax in axes:\n",
    "    for lado in (\"top\", \"right\", \"left\", \"bottom\"): ax.spines[lado].set_visible(False)\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd01b447",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Ejercicio 4 · Búsqueda semántica por vecinos más cercanos\n",
    "\n",
    "Con los vectores ya calculados, buscar es ordenar por coseno. Implementa `buscar_knn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8ea77c80",
   "metadata": {},
   "outputs": [],
   "source": [
    "def buscar_knn(consulta, k=5, subconjunto=None):\n",
    "    '''Devuelve una lista de (indice, puntaje) con los k más parecidos a la consulta.\n",
    "\n",
    "    subconjunto: si se pasa una lista de índices, busca SOLO entre esos.\n",
    "                 Si se pasa una lista VACÍA, devuelve [] (ojo: `if subconjunto:`\n",
    "                 también es falso para [], y ahí buscarías en todo el catálogo).\n",
    "\n",
    "    Devuelve el índice como `int` de Python y el puntaje como `float`, NO como\n",
    "    tipos de numpy: `np.argsort` te da `np.int64`, que no es un `int` y rompe\n",
    "    la verificación. Castea con int(...) y float(...).\n",
    "    '''\n",
    "    # TU CODIGO AQUI\n",
    "    # comprobamos con `is not None` (no con `if subconjunto:`) porque una lista vacía\n",
    "    # es un subconjunto válido: significa \"no busques en nada\", y debe devolver []\n",
    "    if subconjunto is not None:\n",
    "        if len(subconjunto) == 0:\n",
    "            return []\n",
    "        indices_candidatos = list(subconjunto)\n",
    "    else:\n",
    "        indices_candidatos = list(range(len(df)))\n",
    "\n",
    "    vector_de_la_consulta = codificar([consulta])[0]\n",
    "    vectores_de_los_candidatos = V[indices_candidatos]\n",
    "    # como ambos lados están normalizados, el producto punto ya es el coseno\n",
    "    puntajes_de_similitud = vectores_de_los_candidatos @ vector_de_la_consulta\n",
    "\n",
    "    # argsort ordena de menor a mayor; lo invertimos para tener los más parecidos primero\n",
    "    posiciones_ordenadas_de_mayor_a_menor = np.argsort(puntajes_de_similitud)[::-1][:k]\n",
    "\n",
    "    resultados_knn = [\n",
    "        (int(indices_candidatos[posicion]), float(puntajes_de_similitud[posicion]))\n",
    "        for posicion in posiciones_ordenadas_de_mayor_a_menor\n",
    "    ]\n",
    "    return resultados_knn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cf29d269",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✔ ejercicio 4 correcto\n",
      "   0.454  [science fiction ] The Last Signal\n",
      "   0.351  [science fiction ] Orbital Decay\n",
      "   0.326  [science fiction ] Vanishing Point Nine\n",
      "   0.253  [science fiction ] Third Body Problem\n"
     ]
    }
   ],
   "source": [
    "# ---- verificación ----\n",
    "r = buscar_knn(\"a story about space and astronauts\", k=3)\n",
    "assert len(r) == 3, f\"esperaba 3 resultados, obtuve {len(r)}\"\n",
    "assert all(isinstance(i, int) for i, _ in r), \\\n",
    "    \"los índices deben ser int de Python, no np.int64: castea con int(...)\"\n",
    "assert r[0][1] >= r[1][1] >= r[2][1], \"los resultados deben venir ordenados de mayor a menor\"\n",
    "assert df.loc[r[0][0], \"genero\"] == \"science fiction\", \\\n",
    "    f\"el primero debería ser de ciencia ficción, salió «{df.loc[r[0][0], 'genero']}»\"\n",
    "assert buscar_knn(\"anything\", k=3, subconjunto=[0, 1])[0][0] in (0, 1), \"no respetó el subconjunto\"\n",
    "assert buscar_knn(\"anything\", k=3, subconjunto=[]) == [], \"con subconjunto vacío devuelve []\"\n",
    "print(\"✔ ejercicio 4 correcto\")\n",
    "for i, s in buscar_knn(\"a story about space and astronauts\", k=4):\n",
    "    print(f\"   {s:.3f}  [{df.loc[i,'genero']:<16}] {df.loc[i,'titulo']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68fb7670",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Ejercicio 5 · Filtros de metadata: el orden importa\n",
    "\n",
    "Una consulta como *\"películas de terror **posteriores a 2018**\"* tiene dos partes: una semántica\n",
    "(*terror*) y una que es un **filtro** (`anio > 2018`).\n",
    "\n",
    "Hay dos formas de combinarlas, y **no dan lo mismo**:\n",
    "\n",
    "* **post-filtrado** — buscas los k mejores y *después* descartas los que no cumplen,\n",
    "* **pre-filtrado** — te quedas primero con los que cumplen y buscas *solo ahí*.\n",
    "\n",
    "Implementa las tres funciones y comprueba la diferencia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "20c2a447",
   "metadata": {},
   "outputs": [],
   "source": [
    "OPERADORES = {\n",
    "    \"eq\":  lambda v, o: v == o,\n",
    "    \"ne\":  lambda v, o: v != o,\n",
    "    \"gt\":  lambda v, o: v >  o,\n",
    "    \"gte\": lambda v, o: v >= o,\n",
    "    \"lt\":  lambda v, o: v <  o,\n",
    "    \"lte\": lambda v, o: v <= o,\n",
    "}\n",
    "\n",
    "def aplicar_filtros(filtros):\n",
    "    '''Devuelve la lista de índices del catálogo que cumplen TODOS los filtros.\n",
    "\n",
    "    filtros: [{\"campo\": \"anio\", \"op\": \"gt\", \"valor\": 2018}, ...]\n",
    "    Si la lista está vacía, devuelve todos los índices.\n",
    "    '''\n",
    "    # TU CODIGO AQUI\n",
    "    if not filtros:\n",
    "        return list(df.index)\n",
    "    indices_que_cumplen_todos_los_filtros = [\n",
    "        indice for indice in df.index\n",
    "        if all(\n",
    "            OPERADORES[filtro[\"op\"]](df.loc[indice, filtro[\"campo\"]], filtro[\"valor\"])\n",
    "            for filtro in filtros\n",
    "        )\n",
    "    ]\n",
    "    return indices_que_cumplen_todos_los_filtros\n",
    "\n",
    "\n",
    "def buscar_postfiltro(consulta, filtros, k=5):\n",
    "    '''Busca los k mejores en TODO el catálogo y luego descarta los que no cumplen.'''\n",
    "    # TU CODIGO AQUI\n",
    "    # primero buscamos sin mirar los filtros...\n",
    "    mejores_k_de_todo_el_catalogo = buscar_knn(consulta, k=k)\n",
    "    indices_que_pasan_el_filtro = set(aplicar_filtros(filtros))\n",
    "    # ...y después descartamos los que no cumplen: por eso puede devolver menos de k\n",
    "    resultado_postfiltrado = [\n",
    "        (indice, puntaje) for indice, puntaje in mejores_k_de_todo_el_catalogo\n",
    "        if indice in indices_que_pasan_el_filtro\n",
    "    ]\n",
    "    return resultado_postfiltrado\n",
    "\n",
    "\n",
    "def buscar_prefiltro(consulta, filtros, k=5):\n",
    "    '''Filtra primero y busca los k mejores solo dentro de lo que quedó.'''\n",
    "    # TU CODIGO AQUI\n",
    "    # primero nos quedamos solo con lo que cumple el filtro...\n",
    "    indices_que_pasan_el_filtro = aplicar_filtros(filtros)\n",
    "    # ...y buscamos los k mejores SOLO ahí adentro: por eso nunca devuelve menos que el post-filtrado\n",
    "    resultado_prefiltrado = buscar_knn(consulta, k=k, subconjunto=indices_que_pasan_el_filtro)\n",
    "    return resultado_prefiltrado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1fd02c06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✔ ejercicio 5 correcto\n",
      "   post-filtrado devolvió 2 de 5 pedidos\n",
      "   pre-filtrado  devolvió 4 de 5 pedidos\n",
      "   (documentos que pasan el filtro: 4)\n"
     ]
    }
   ],
   "source": [
    "# ---- verificación ----\n",
    "assert len(aplicar_filtros([])) == len(df), \"sin filtros deben pasar todas\"\n",
    "f_terror = [{\"campo\": \"genero\", \"op\": \"eq\", \"valor\": \"horror\"}]\n",
    "assert len(aplicar_filtros(f_terror)) == (df[\"genero\"] == \"horror\").sum(), \"filtro de género mal\"\n",
    "f_dos = f_terror + [{\"campo\": \"anio\", \"op\": \"gt\", \"valor\": 2018}]\n",
    "esperado = ((df[\"genero\"] == \"horror\") & (df[\"anio\"] > 2018)).sum()\n",
    "assert len(aplicar_filtros(f_dos)) == esperado, \"los filtros deben combinarse con AND\"\n",
    "\n",
    "post = buscar_postfiltro(\"a scary story in an old building\", f_dos, k=5)\n",
    "pre  = buscar_prefiltro (\"a scary story in an old building\", f_dos, k=5)\n",
    "assert all(df.loc[i, \"genero\"] == \"horror\" and df.loc[i, \"anio\"] > 2018 for i, _ in post + pre), \\\n",
    "    \"algún resultado no cumple los filtros\"\n",
    "assert len(pre) >= len(post), \"el pre-filtrado nunca debería devolver menos que el post-filtrado\"\n",
    "print(\"✔ ejercicio 5 correcto\")\n",
    "print(f\"   post-filtrado devolvió {len(post)} de {5} pedidos\")\n",
    "print(f\"   pre-filtrado  devolvió {len(pre)} de {5} pedidos\")\n",
    "print(f\"   (documentos que pasan el filtro: {len(aplicar_filtros(f_dos))})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d587829",
   "metadata": {},
   "source": [
    "### Pregunta escrita 2\n",
    "\n",
    "1. ¿Cuántos resultados devolvió cada estrategia? ¿Por qué el post-filtrado devolvió menos?\n",
    "2. Inventa un filtro **más selectivo** (por ejemplo `idioma == \"Korean\"`), córrelo con las dos\n",
    "   estrategias y pega aquí los números. ¿Cuántos resultados devuelve el post-filtrado?\n",
    "3. Si tu aplicación **siempre** necesita 5 resultados para armar el prompt del LLM, ¿cuál de las dos\n",
    "   estrategias puedes usar? ¿Qué le pasa a la otra cuando el filtro es muy selectivo?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b65e0afa",
   "metadata": {},
   "source": "**1.** Con el filtro \"horror posterior a 2018\" (4 películas de 45 cumplen), el **post-filtrado**\ndevolvió **2 de 5** pedidos y el **pre-filtrado** devolvió **4 de 5** pedidos. El post-filtrado\ndevuelve menos porque primero busca los 5 vecinos más parecidos en **todo** el catálogo y\n**después** descarta los que no cumplen el filtro — de esos 5 solo 2 resultaron pertenecer\ntambién al grupo filtrado, y los otros 3 se pierden sin reemplazo. El pre-filtrado, en cambio,\nya buscó únicamente entre las 4 películas que cumplen el filtro, así que devolvió las 4 que\nhabía disponibles (no puede devolver 5 porque solo existen 4 candidatos).\n\n**2.** *(pendiente de un número real — ver nota abajo)* Un filtro más selectivo, por ejemplo\n`idioma == \"Korean\"`, solo lo cumplen **3 películas de las 45** del catálogo (*The Lending\nLibrary*, *The Last Mile*, *The Quietest Room*), contra las 4 del filtro de horror. Con un\nfiltro tan chico, el post-filtrado corre un riesgo real de devolver **0** resultados si ninguna\nde esas 3 películas queda entre los 5 vecinos más cercanos calculados sobre el catálogo\ncompleto. Para poner la cifra exacta que realmente salió, corre esto en una celda nueva y\npásame el resultado:\n```python\nf_korean = [{\"campo\": \"idioma\", \"op\": \"eq\", \"valor\": \"Korean\"}]\nprint(len(aplicar_filtros(f_korean)))\nprint(len(buscar_postfiltro(\"a story worth telling\", f_korean, k=5)))\nprint(len(buscar_prefiltro(\"a story worth telling\", f_korean, k=5)))\n```\n\n**3.** Si la aplicación **siempre** necesita 5 resultados para el prompt del LLM, hay que usar el\n**pre-filtrado**: mientras existan al menos 5 candidatos que cumplan el filtro, siempre entrega\n5. El post-filtrado se degrada cuanto más selectivo es el filtro — ya con nuestro filtro de 4\npelículas de 45 devolvió solo 2 de 5, y con un filtro más chico (como el de idioma == \"Korean\",\ncon solo 3 candidatos en todo el catálogo) puede llegar a devolver 0 de 5 si ninguno de esos\ncandidatos aparece entre los vecinos más cercanos calculados sin filtro."
  },
  {
   "cell_type": "markdown",
   "id": "121dfd3e",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Ejercicio 6 · Self-query: que el LLM arme el filtro\n",
    "\n",
    "Hasta aquí **tú** escribiste los filtros a mano. Un *self-query retriever* se los pide a un LLM:\n",
    "recibe la pregunta en lenguaje natural y devuelve `query` (para la búsqueda semántica) y `filtros`\n",
    "(para la metadata).\n",
    "\n",
    "El modelo y la función `generar` ya están dados. Lo tuyo es **el prompt** y **el parseo**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b311cb0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[transformers] `torch_dtype` is deprecated! Use `dtype` instead!\n",
      "Loading weights: 100%|██████████| 338/338 [00:00<00:00, 2226.43it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LLM listo · Qwen/Qwen2.5-1.5B-Instruct\n"
     ]
    }
   ],
   "source": [
    "# ---- el LLM (dado) ----\n",
    "import torch\n",
    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
    "\n",
    "NOMBRE_LLM = \"Qwen/Qwen2.5-1.5B-Instruct\"\n",
    "tok_llm = AutoTokenizer.from_pretrained(NOMBRE_LLM)\n",
    "llm = AutoModelForCausalLM.from_pretrained(\n",
    "    NOMBRE_LLM, torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,\n",
    "    device_map=\"auto\" if torch.cuda.is_available() else None)\n",
    "llm.eval()\n",
    "\n",
    "def generar(prompt, max_new_tokens=220):\n",
    "    msgs = [{\"role\": \"user\", \"content\": prompt}]\n",
    "    texto = tok_llm.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)\n",
    "    ent = tok_llm(texto, return_tensors=\"pt\").to(llm.device)\n",
    "    with torch.no_grad():\n",
    "        out = llm.generate(**ent, max_new_tokens=max_new_tokens, do_sample=False,\n",
    "                           temperature=None, top_p=None, top_k=None,\n",
    "                           pad_token_id=tok_llm.eos_token_id)\n",
    "    return tok_llm.decode(out[0][ent[\"input_ids\"].shape[1]:], skip_special_tokens=True).strip()\n",
    "\n",
    "ESQUEMA = '''titulo        texto\n",
    "anio          entero\n",
    "genero        uno de: science fiction, horror, comedy, documentary, drama\n",
    "calificacion  decimal de 0 a 10\n",
    "duracion_min  entero\n",
    "idioma        uno de: English, Spanish, Japanese, French, Korean'''\n",
    "print(\"LLM listo ·\", NOMBRE_LLM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f809dbbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prompt_self_query(pregunta):\n",
    "    '''Construye el prompt que le pide al LLM separar query y filtros.\n",
    "\n",
    "    Tiene que: describir la tarea, incluir ESQUEMA, listar los operadores permitidos\n",
    "    (eq, ne, gt, gte, lt, lte), pedir SOLO JSON con las llaves \"query\" y \"filtros\",\n",
    "    y terminar con la pregunta del usuario.\n",
    "    '''\n",
    "    # TU CODIGO AQUI\n",
    "    prompt_para_el_llm = f\"\"\"Eres un asistente que separa una pregunta sobre películas en dos \\\n",
    "partes: una consulta semántica (\"query\", lo que se busca por significado) y una lista de \\\n",
    "filtros exactos sobre la metadata del catálogo (\"filtros\").\n",
    "\n",
    "El catálogo tiene estos campos:\n",
    "{ESQUEMA}\n",
    "\n",
    "Cada filtro es un objeto con las llaves \"campo\", \"op\" y \"valor\". Los operadores permitidos \\\n",
    "para \"op\" son: eq, ne, gt, gte, lt, lte.\n",
    "\n",
    "Responde ÚNICAMENTE con un objeto JSON (sin explicaciones ni texto adicional) con esta forma:\n",
    "{{\"query\": \"<texto para buscar por significado, o vacío si no aplica>\", \"filtros\": [{{\"campo\": \"<un campo del esquema>\", \"op\": \"<uno de eq, ne, gt, gte, lt, lte>\", \"valor\": <valor>}}]}}\n",
    "\n",
    "Pregunta del usuario: {pregunta}\"\"\"\n",
    "    return prompt_para_el_llm\n",
    "\n",
    "\n",
    "def parsear_self_query(salida):\n",
    "    '''Extrae el JSON de la respuesta del LLM y lo devuelve como dict.\n",
    "\n",
    "    Tiene que ser tolerante: el modelo suele envolver el JSON en ```json ... ```\n",
    "    o agregar texto antes y después. Si el JSON no se puede parsear, devuelve\n",
    "    {\"query\": \"\", \"filtros\": []} en vez de lanzar excepción.\n",
    "\n",
    "    Y tiene que VALIDAR: descarta los filtros cuyo \"campo\" no esté en COLUMNAS\n",
    "    o cuyo \"op\" no esté en OPERADORES. Descarta sólo el filtro inválido, no la\n",
    "    respuesta entera — el \"query\" se conserva. El LLM inventa campos que no\n",
    "    existen; comprobarlos es tu trabajo, no el suyo.\n",
    "    '''\n",
    "    # TU CODIGO AQUI\n",
    "    respuesta_por_defecto = {\"query\": \"\", \"filtros\": []}\n",
    "\n",
    "    # buscamos el primer '{' hasta el último '}': así ignoramos las cercas ```json ... ```\n",
    "    # y cualquier texto que el modelo agregue antes o después del JSON\n",
    "    bloque_json_encontrado = re.search(r\"\\{.*\\}\", salida, re.DOTALL)\n",
    "    if bloque_json_encontrado is None:\n",
    "        return respuesta_por_defecto\n",
    "\n",
    "    try:\n",
    "        plan_bruto = json.loads(bloque_json_encontrado.group(0))\n",
    "    except json.JSONDecodeError:\n",
    "        return respuesta_por_defecto\n",
    "\n",
    "    query_extraida = plan_bruto.get(\"query\", \"\")\n",
    "    filtros_sin_validar = plan_bruto.get(\"filtros\", [])\n",
    "    # el LLM puede inventar un \"campo\" o un \"op\" que no existen: descartamos SOLO\n",
    "    # ese filtro (no toda la respuesta), porque el \"query\" sigue siendo válido\n",
    "    filtros_validados = [\n",
    "        filtro for filtro in filtros_sin_validar\n",
    "        if filtro.get(\"campo\") in COLUMNAS and filtro.get(\"op\") in OPERADORES\n",
    "    ]\n",
    "    return {\"query\": query_extraida, \"filtros\": filtros_validados}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0ce017cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✔ ejercicio 6 correcto\n"
     ]
    }
   ],
   "source": [
    "# ---- verificación (no llama al LLM: prueba tus funciones con casos fijos) ----\n",
    "p = prompt_self_query(\"horror movies after 2018\")\n",
    "assert isinstance(p, str) and len(p) > 120, \"el prompt parece demasiado corto\"\n",
    "assert \"duracion_min\" in p, \"el prompt debe incluir el ESQUEMA\"\n",
    "assert \"gte\" in p, \"el prompt debe listar los operadores permitidos\"\n",
    "assert \"horror movies after 2018\" in p, \"el prompt debe terminar con la pregunta\"\n",
    "\n",
    "casos = [\n",
    "  ('{\"query\": \"space\", \"filtros\": [{\"campo\": \"anio\", \"op\": \"gt\", \"valor\": 2018}]}', \"space\", 1),\n",
    "  ('```json\\n{\"query\": \"\", \"filtros\": []}\\n```', \"\", 0),\n",
    "  ('Claro, aquí tienes:\\n{\"query\": \"scary\", \"filtros\": []}\\nEspero que sirva.', \"scary\", 0),\n",
    "  ('esto no es json', \"\", 0),\n",
    "  ('{\"query\": \"x\", \"filtros\": [{\"campo\": \"inventado\", \"op\": \"eq\", \"valor\": 1}]}', \"x\", 0),\n",
    "]\n",
    "for bruto, q_esp, n_esp in casos:\n",
    "    d = parsear_self_query(bruto)\n",
    "    assert d[\"query\"] == q_esp, f\"query mal en: {bruto[:40]}… (esperaba «{q_esp}», dio «{d['query']}»)\"\n",
    "    assert len(d[\"filtros\"]) == n_esp, f\"filtros mal en: {bruto[:40]}… (esperaba {n_esp})\"\n",
    "print(\"✔ ejercicio 6 correcto\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f1dfc0f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pregunta : horror movies released after 2018\n",
      "query    : «horror»\n",
      "filtros  : [{'campo': 'anio', 'op': 'gt', 'valor': 2018}]\n",
      "pasan el filtro: 24 de 45\n",
      "     0.246  Cellar Door  (2024, horror, 7.6, Spanish)\n",
      "     0.200  Nine Nights of Rain  (2020, horror, 7.1, Japanese)\n",
      "     0.177  The Understory  (2024, drama, 8.6, English)\n",
      "     0.131  The Inheritance Clause  (2019, drama, 7.8, English)\n",
      "------------------------------------------------------------------------------\n",
      "pregunta : documentaries in Spanish\n",
      "query    : «documentaries»\n",
      "filtros  : [{'campo': 'idioma', 'op': 'eq', 'valor': 'Spanish'}]\n",
      "pasan el filtro: 5 de 45\n",
      "     0.195  Salt and Ash  (2015, horror, 6.1, Spanish)\n",
      "     0.121  Cellar Door  (2024, horror, 7.6, Spanish)\n",
      "     0.078  The Night Shift  (2018, drama, 7.5, Spanish)\n",
      "     0.058  Salt Roads  (2014, documentary, 8.5, Spanish)\n",
      "------------------------------------------------------------------------------\n",
      "pregunta : a funny movie about work, shorter than 100 minutes\n",
      "query    : «funny»\n",
      "filtros  : [{'campo': 'genero', 'op': 'eq', 'valor': 'comedy'}, {'campo': 'duracion_min', 'op': 'lt', 'valor': 100}]\n",
      "pasan el filtro: 6 de 45\n",
      "     0.177  The Group Project  (2023, comedy, 7.5, English)\n",
      "     0.077  Overqualified  (2022, comedy, 7.1, English)\n",
      "     0.069  Tax Season  (2017, comedy, 7.3, English)\n",
      "     0.060  Return Policy  (2019, comedy, 7.7, English)\n",
      "------------------------------------------------------------------------------\n",
      "pregunta : highly rated science fiction about first contact\n",
      "query    : «first contact»\n",
      "filtros  : [{'campo': 'genero', 'op': 'eq', 'valor': 'science fiction'}, {'campo': 'calificacion', 'op': 'gt', 'valor': 7}]\n",
      "pasan el filtro: 6 de 45\n",
      "     0.510  Third Body Problem  (2024, science fiction, 8.7, English)\n",
      "     0.114  Paper Suns  (1998, science fiction, 7.5, Japanese)\n",
      "     0.077  Echoes of Tomorrow  (2019, science fiction, 7.8, English)\n",
      "     0.072  Orbital Decay  (2023, science fiction, 7.2, English)\n",
      "------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# ---- el sistema completo (dado): self-query + pre-filtrado + kNN ----\n",
    "def buscar_self_query(pregunta, k=4, verbose=True):\n",
    "    bruto = generar(prompt_self_query(pregunta))\n",
    "    plan = parsear_self_query(bruto)\n",
    "    if verbose:\n",
    "        print(f\"pregunta : {pregunta}\")\n",
    "        print(f\"query    : «{plan['query']}»\")\n",
    "        print(f\"filtros  : {plan['filtros']}\")\n",
    "    candidatos = aplicar_filtros(plan[\"filtros\"])\n",
    "    if verbose:\n",
    "        print(f\"pasan el filtro: {len(candidatos)} de {len(df)}\")\n",
    "    if plan[\"query\"].strip() == \"\":\n",
    "        elegidos = [(i, float(\"nan\")) for i in candidatos[:k]]\n",
    "    else:\n",
    "        elegidos = buscar_knn(plan[\"query\"], k=k, subconjunto=candidatos)\n",
    "    for i, s in elegidos:\n",
    "        r = df.loc[i]\n",
    "        p = \"  —  \" if np.isnan(s) else f\"  {s:.3f}  \"\n",
    "        print(f\"   {p}{r['titulo']}  ({r['anio']}, {r['genero']}, {r['calificacion']}, {r['idioma']})\")\n",
    "    return plan, elegidos\n",
    "\n",
    "PREGUNTAS = [\n",
    "    \"horror movies released after 2018\",\n",
    "    \"documentaries in Spanish\",\n",
    "    \"a funny movie about work, shorter than 100 minutes\",\n",
    "    \"highly rated science fiction about first contact\",\n",
    "]\n",
    "for q in PREGUNTAS:\n",
    "    buscar_self_query(q); print(\"-\" * 78)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcf6cc2a",
   "metadata": {},
   "source": [
    "### Pregunta escrita 3\n",
    "\n",
    "1. De las cuatro preguntas, ¿en cuáles el LLM extrajo bien los filtros y en cuáles se equivocó?\n",
    "   Pega los `filtros` que devolvió en el caso que peor salió.\n",
    "2. En `\"documentaries in Spanish\"` el `query` debería quedar prácticamente **vacío**. ¿Qué hace tu\n",
    "   sistema cuando eso pasa, y por qué tiene sentido?\n",
    "3. Corre dos veces la misma pregunta. ¿Sale igual? Con lo que sabes del muestreo, **¿qué tendrías que\n",
    "   validar siempre** antes de mandarle los filtros a la base de datos?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39dd343e",
   "metadata": {},
   "source": "**1.** De las cuatro preguntas, **dos salieron bien** y **dos con filtros incompletos**:\n\n- `\"horror movies released after 2018\"` → `filtros = [{\"campo\": \"anio\", \"op\": \"gt\", \"valor\": 2018}]`.\n  Le faltó el filtro de género (`genero == \"horror\"` quedó solo como parte del `query`). De los 4\n  resultados mostrados, 2 sí son horror (*Cellar Door*, *Nine Nights of Rain*) y 2 son drama\n  (*The Understory*, *The Inheritance Clause*).\n- `\"documentaries in Spanish\"` → `filtros = [{\"campo\": \"idioma\", \"op\": \"eq\", \"valor\": \"Spanish\"}]`.\n  **Este es el que peor salió**: también le faltó el filtro de género\n  (`genero == \"documentary\"`). De los 4 resultados, solo 1 (*Salt Roads*) es realmente un\n  documental; los otros 3 (*Salt and Ash*, *Cellar Door*, *The Night Shift*) son horror y drama\n  en español.\n- `\"a funny movie about work, shorter than 100 minutes\"` →\n  `filtros = [{\"campo\": \"genero\", \"op\": \"eq\", \"valor\": \"comedy\"}, {\"campo\": \"duracion_min\", \"op\": \"lt\", \"valor\": 100}]`.\n  Correcto: los 4 resultados son comedias.\n- `\"highly rated science fiction about first contact\"` →\n  `filtros = [{\"campo\": \"genero\", \"op\": \"eq\", \"valor\": \"science fiction\"}, {\"campo\": \"calificacion\", \"op\": \"gt\", \"valor\": 7}]`.\n  Correcto: los 4 resultados son ciencia ficción, con *Third Body Problem* (0.510) como el más\n  parecido — la sinopsis literalmente habla de primer contacto.\n\n**2.** En `\"documentaries in Spanish\"` el `query` que salió realmente fue `\"documentaries\"`, no\nvacío como sería lo ideal (el filtro `idioma == \"Spanish\"` ya cubre todo lo relevante). Cuando el\n`query` sí queda vacío, `buscar_self_query` (ya dado) hace\n`elegidos = [(i, float(\"nan\")) for i in candidatos[:k]]`: en vez de rankear por similitud, toma\ndirectamente los primeros `k` candidatos que pasaron el filtro y les pone un puntaje `—` (nan).\nTiene sentido porque sin una parte semántica no hay nada contra qué medir un coseno — lo único\nque importa en ese caso es el filtro exacto, así que ordenar por \"similitud a la cadena vacía\"\nsería arbitrario.\n\n**3.** Como `generar()` usa `do_sample=False` (con `temperature`/`top_p`/`top_k` en `None`), la\ndecodificación es **greedy** y determinista: corriendo la misma pregunta dos veces con el mismo\nmodelo se obtiene exactamente la misma salida — el \"muestreo\" ni siquiera está activo aquí. Pero\ndeterminismo no es lo mismo que corrección: como se ve arriba, el LLM puede devolver un JSON\nsintácticamente válido, con campos y operadores que sí existen en `COLUMNAS`/`OPERADORES` (por lo\nque `parsear_self_query` no lo descarta), pero **semánticamente incompleto** (le faltó un\nfiltro que un humano sí habría puesto). Antes de mandarle los filtros a una base de datos real\nhabría que validar, además de lo que ya hace `parsear_self_query`, que el **tipo del valor**\ncoincide con el campo (p. ej. `anio` debe ser un entero, no un string) y que, para campos\ncategóricos como `genero` o `idioma`, el valor esté dentro de las categorías que lista el\n`ESQUEMA` — nada de esto se verifica todavía, y con muestreo activado (`do_sample=True`) sí\npodría fallar de esa forma en otra corrida."
  },
  {
   "cell_type": "markdown",
   "id": "7cc4b90a",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Reporte final (dado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e4baba79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==========================================================================\n",
      "RESUMEN DE LA TAREA\n",
      "==========================================================================\n",
      "catálogo               : 45 películas, 5 géneros\n",
      "dimensión del embedding: 384\n",
      "\n",
      "coseno medio por familia de pares:\n",
      "   casi sinónimos   +0.839\n",
      "   opuestos         +0.812\n",
      "   negación         +0.821\n",
      "   sin relación     +0.034\n",
      "\n",
      "pureza de los clusters  : 0.422  (al azar 0.200)\n",
      "\n",
      "filtro de ejemplo       : terror posterior a 2018 → 4 películas\n",
      "   post-filtrado k=5    : 2 resultados\n",
      "   pre-filtrado  k=5    : 4 resultados\n",
      "==========================================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"=\" * 74)\n",
    "print(\"RESUMEN DE LA TAREA\")\n",
    "print(\"=\" * 74)\n",
    "print(f\"catálogo               : {len(df)} películas, {len(GENEROS)} géneros\")\n",
    "print(f\"dimensión del embedding: {V.shape[1]}\")\n",
    "print()\n",
    "print(\"coseno medio por familia de pares:\")\n",
    "for f, (cs, m) in resultados.items():\n",
    "    print(f\"   {f:<16} {m:+.3f}\")\n",
    "print()\n",
    "print(f\"pureza de los clusters  : {pureza(etiquetas, df['genero'].values):.3f}  \"\n",
    "      f\"(al azar {1/len(GENEROS):.3f})\")\n",
    "print()\n",
    "ej = [{\"campo\": \"genero\", \"op\": \"eq\", \"valor\": \"horror\"},\n",
    "      {\"campo\": \"anio\", \"op\": \"gt\", \"valor\": 2018}]\n",
    "print(f\"filtro de ejemplo       : terror posterior a 2018 → {len(aplicar_filtros(ej))} películas\")\n",
    "print(f\"   post-filtrado k=5    : {len(buscar_postfiltro('a scary story', ej, k=5))} resultados\")\n",
    "print(f\"   pre-filtrado  k=5    : {len(buscar_prefiltro('a scary story', ej, k=5))} resultados\")\n",
    "print(\"=\" * 74)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cómo se califica\n",
    "\n",
    "| | |\n",
    "|---|---|\n",
    "| Los 6 bloques de código, con sus verificaciones en verde | 60 % |\n",
    "| Las 3 preguntas escritas, **respondidas con tus números** | 30 % |\n",
    "| Que el notebook corra de principio a fin sin errores | 10 % |\n",
    "\n",
    "Una respuesta escrita que no cite ninguna cifra medida por ti no cuenta."
   ]
  }
 ],
 "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}