diff --git a/Labs/Lab2.ipynb b/Labs/Lab2.ipynb new file mode 100644 index 0000000..6cfe787 --- /dev/null +++ b/Labs/Lab2.ipynb @@ -0,0 +1,1253 @@ +{ + "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": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
titulogeneroaniocalificacionduracion_minidiomasinopsis
0Echoes of Tomorrowscience fiction20197.8124EnglishA physicist discovers that every choice she ma...
1The Last Signalscience fiction20218.1138EnglishAstronauts receive a transmission from a probe...
2Silicon Dawnscience fiction20166.9111EnglishAn engineer realizes the assistant she built h...
\n", + "
" + ], + "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": [ + "
" + ] + }, + "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": [ + "
" + ] + }, + "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\": \"\", \"filtros\": [{{\"campo\": \"\", \"op\": \"\", \"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 +} \ No newline at end of file diff --git a/README.md b/README.md index 7c78a1e..22554f0 100644 --- a/README.md +++ b/README.md @@ -7,3 +7,4 @@ Universidad Galileo — Labs y tareas del curso. | # | Lab | Tema | Enlace | |---|-----|------|--------| | 1 | Selección de Modelos e Hyper-parameter Tuning | Cross-validation, comparación de arquitecturas (scikit-learn, TensorFlow, PyTorch) y tuning con Grid Search, Random Search y Optimización Bayesiana (Optuna) | [Labs/Lab1.ipynb](Labs/Lab1.ipynb) | +| 2 | Embeddings, Búsqueda Semántica y Self-Query | Embeddings con sentence-transformers, similitud coseno, PCA/t-SNE y clustering (KMeans), búsqueda kNN, pre/post-filtrado de metadata, y self-query retriever con un LLM (Qwen2.5) | [Labs/Lab2.ipynb](Labs/Lab2.ipynb) |