laboratorio_2_puente_joaquin_garcia_nelson.py

"""
CC3103 - Procesamiento de Lenguaje Natural
Laboratorio 2: Busqueda semantica con embeddings locales vs busqueda por palabras clave

Autor: Puente, Joaquin
Autor: Garcia, Nelson

Pipeline implementado:
    Corpus de oraciones en espanol
      -> normalizacion (minusculas, sin acentos, sin puntuacion)
      -> tokenizacion + remocion de stopwords
      -> matriz de co-ocurrencia (ventana deslizante)
      -> pesos PPMI
      -> proyeccion aleatoria a D dimensiones  => embeddings de palabra
      -> promedio ponderado por IDF            => embeddings de oracion
      -> ranking top-k por similitud coseno

    En paralelo:
      -> busqueda simple por palabras clave (traslape exacto de terminos)
      -> comparacion cualitativa entre ambos metodos

Objetivos:
- Generar embeddings locales sin depender de modelos preentrenados ni de APIs.
- Rankear documentos con similitud coseno (top-k).
- Implementar una busqueda por palabras clave como linea base.
- Comparar cualitativamente ambos metodos sobre las mismas consultas.

Ejecutar:
    python laboratorio_2_puente_joaquin_garcia_nelson.py

Nota: no se usan librerias externas. Todo corre con la libreria estandar de Python.
"""

from collections import Counter, defaultdict
import math
import random
import re
import unicodedata


# ---------------------------------------------------------------------------
# Configuracion
# ---------------------------------------------------------------------------

DIMENSIONES = 256         # tamano del embedding de palabra
VENTANA = 5               # ventana de co-ocurrencia (palabras a cada lado)
TOP_K = 3                 # cuantos resultados mostrar por consulta
UMBRAL_MINIMO = 0.15      # coseno minimo para considerar que un resultado es relevante
PESO_IDENTIDAD = 1.0      # cuanto pesa la palabra sobre si misma en su vector
SEMILLA = 42              # semilla fija para que la corrida sea reproducible


# ---------------------------------------------------------------------------
# Corpus: 24 oraciones en espanol, agrupadas en 6 temas
# ---------------------------------------------------------------------------

CORPUS = [
    # Tema: inteligencia artificial
    "El modelo de aprendizaje automatico fue entrenado con datos de texto.",
    "Las redes neuronales aprenden patrones a partir de grandes volumenes de datos.",
    "El algoritmo de clasificacion mejoro su precision tras el entrenamiento.",
    "Los datos de entrenamiento deben limpiarse antes de alimentar el modelo.",
    "La inteligencia artificial procesa texto y aprende representaciones vectoriales.",

    # Tema: mascotas
    "El perro corre feliz por el parque cada manana.",
    "Mi gato duerme sobre el sofa durante toda la tarde.",
    "El veterinario reviso a la mascota que llego enferma.",
    "Los cachorros del perro juegan con una pelota en el jardin.",

    # Tema: cocina
    "La receta de sopa lleva verduras frescas y caldo de pollo.",
    "El chef preparo un plato con arroz y pescado a la parrilla.",
    "Hornear pan requiere harina, agua, sal y levadura.",
    "El postre de chocolate se sirve frio despues de la cena.",

    # Tema: clima
    "La lluvia intensa provoco inundaciones en la ciudad costera.",
    "El pronostico anuncia cielo nublado y temperatura baja para manana.",
    "El sol calienta la playa durante el verano seco.",
    "Una tormenta con viento fuerte derribo arboles en el camino.",

    # Tema: deportes
    "El equipo gano el partido de futbol en el ultimo minuto.",
    "La jugadora anoto tres goles durante el segundo tiempo.",
    "El entrenador cambio la tactica del equipo para el torneo.",
    "Los aficionados llenaron el estadio para ver el juego.",

    # Tema: transporte
    "El autobus llego tarde a la estacion por el trafico.",
    "Compre un boleto de avion para viajar hacia la costa.",
    "El automovil electrico consume menos energia en la carretera.",
]


# Las consultas estan redactadas con intencion de Star Wars, pero usando palabras
# que tambien pertenecen al vocabulario cotidiano del corpus. Asi se puede observar
# que hace cada buscador cuando la consulta es ambigua: el usuario pregunta por una
# cosa y el corpus solo puede responder con otra.
CONSULTAS = [
    "el entrenamiento y aprendizaje del padawan",    # 'entrenamiento' jedi vs entrenamiento de modelos
    "el torneo de los cazarrecompensas",             # 'torneo' de caza vs torneo deportivo
    "el jardin del templo jedi",                     # 'jardin' del templo vs jardin de la casa
    "la tormenta de arena en el planeta desertico",  # 'tormenta' de arena vs tormenta meteorologica
    "la mascota del wookiee",                        # 'mascota' criatura vs mascota domestica
    "los caza estelares del escuadron rebelde",      # caso de control: vocabulario desconocido
]


STOPWORDS = {
    "a", "al", "ante", "con", "contra", "de", "del", "desde", "durante", "en",
    "entre", "hacia", "hasta", "para", "por", "segun", "sin", "sobre", "tras",
    "el", "la", "los", "las", "un", "una", "unos", "unas", "lo",
    "y", "e", "o", "u", "ni", "que", "se", "su", "sus", "mi", "mis",
    "es", "son", "fue", "ser", "esta", "estan", "cada", "toda", "todo",
    "muy", "mas", "menos", "ya", "tambien", "pero", "si", "no",
}


# ---------------------------------------------------------------------------
# Normalizacion y tokenizacion
# ---------------------------------------------------------------------------

def quitar_acentos(texto):
    """Convierte 'cafe con leche' y 'café con leche' en la misma cadena."""
    descompuesto = unicodedata.normalize("NFD", texto)
    sin_tildes = "".join(c for c in descompuesto if unicodedata.category(c) != "Mn")
    return unicodedata.normalize("NFC", sin_tildes)


def normalizar(texto):
    """Minusculas, sin acentos y sin caracteres que no sean letras o numeros."""
    texto = quitar_acentos(texto.lower())
    return re.sub(r"[^a-z0-9ñ\s]", " ", texto)


def tokenizar(texto):
    """Devuelve los tokens de contenido: sin stopwords y sin palabras de 1 letra."""
    tokens = re.findall(r"[a-z0-9ñ]+", normalizar(texto))
    return [t for t in tokens if t not in STOPWORDS and len(t) > 1]


# ---------------------------------------------------------------------------
# Paso 1: matriz de co-ocurrencia
# ---------------------------------------------------------------------------

def construir_vocabulario(documentos_tokenizados):
    """Asigna un indice estable a cada palabra distinta del corpus."""
    vocabulario = sorted({token for doc in documentos_tokenizados for token in doc})
    return {palabra: i for i, palabra in enumerate(vocabulario)}


def construir_coocurrencias(documentos_tokenizados, ventana=VENTANA):
    """
    Cuenta cuantas veces cada par de palabras aparece cerca dentro de la misma oracion.

    La intuicion distribucional: dos palabras que aparecen en los mismos contextos
    terminan con vectores parecidos, aunque nunca aparezcan juntas.
    """
    conteos = defaultdict(Counter)
    for tokens in documentos_tokenizados:
        for i, palabra in enumerate(tokens):
            inicio = max(0, i - ventana)
            fin = min(len(tokens), i + ventana + 1)
            for j in range(inicio, fin):
                if j != i:
                    conteos[palabra][tokens[j]] += 1
    return conteos


# ---------------------------------------------------------------------------
# Paso 2: pesos PPMI
# ---------------------------------------------------------------------------

def calcular_ppmi(conteos):
    """
    Positive Pointwise Mutual Information.

        pmi(w, c) = log2( P(w,c) / (P(w) * P(c)) )
        ppmi = max(0, pmi)

    Castiga los pares que solo co-ocurren porque ambas palabras son frecuentes
    y premia los pares que co-ocurren mas de lo que el azar predice.
    """
    total = sum(sum(ctx.values()) for ctx in conteos.values())
    if total == 0:
        return {}

    marginal_fila = {w: sum(ctx.values()) for w, ctx in conteos.items()}
    marginal_col = Counter()
    for ctx in conteos.values():
        marginal_col.update(ctx)

    ppmi = defaultdict(dict)
    for palabra, contextos in conteos.items():
        for contexto, conteo in contextos.items():
            p_conjunta = conteo / total
            p_palabra = marginal_fila[palabra] / total
            p_contexto = marginal_col[contexto] / total
            valor = math.log2(p_conjunta / (p_palabra * p_contexto))
            if valor > 0:
                ppmi[palabra][contexto] = valor
    return ppmi


# ---------------------------------------------------------------------------
# Paso 3: embeddings de palabra por proyeccion aleatoria
# ---------------------------------------------------------------------------

def generar_proyecciones(vocabulario, dimensiones=DIMENSIONES, semilla=SEMILLA):
    """
    Asigna a cada palabra un vector aleatorio de +-1/sqrt(D).

    Es el truco de Johnson-Lindenstrauss: proyectar el espacio disperso de
    |V| dimensiones a D dimensiones densas conserva aproximadamente las
    distancias, y evita tener que implementar una SVD a mano.
    """
    rng = random.Random(semilla)
    escala = 1.0 / math.sqrt(dimensiones)
    proyecciones = {}
    for palabra in sorted(vocabulario):
        proyecciones[palabra] = [rng.choice((-escala, escala)) for _ in range(dimensiones)]
    return proyecciones


def normalizar_vector(vector):
    """Lleva el vector a norma 1 para que el coseno sea un simple producto punto."""
    norma = math.sqrt(sum(v * v for v in vector))
    if norma == 0:
        return vector
    return [v / norma for v in vector]


def construir_embeddings_palabra(vocabulario, ppmi, proyecciones, dimensiones=DIMENSIONES):
    """
    Vector de una palabra = su propia proyeccion + la suma de las proyecciones
    de sus contextos, ponderadas por PPMI.

    El termino de identidad garantiza que una palabra siempre se parezca a si
    misma, incluso si casi no tiene contextos en un corpus tan pequeno.
    """
    embeddings = {}
    for palabra in vocabulario:
        vector = [PESO_IDENTIDAD * v for v in proyecciones[palabra]]
        for contexto, peso in ppmi.get(palabra, {}).items():
            proyeccion = proyecciones[contexto]
            for d in range(dimensiones):
                vector[d] += peso * proyeccion[d]
        embeddings[palabra] = normalizar_vector(vector)
    return embeddings


# ---------------------------------------------------------------------------
# Paso 4: embeddings de oracion
# ---------------------------------------------------------------------------

def calcular_idf(documentos_tokenizados):
    """
    IDF suavizado: las palabras que estan en casi todas las oraciones aportan poco.

        idf(t) = log((1 + N) / (1 + df(t))) + 1
    """
    n = len(documentos_tokenizados)
    df = Counter()
    for tokens in documentos_tokenizados:
        df.update(set(tokens))
    return {t: math.log((1 + n) / (1 + df_t)) + 1 for t, df_t in df.items()}


def embedding_de_texto(tokens, embeddings_palabra, idf, dimensiones=DIMENSIONES):
    """
    Promedio de los vectores de palabra ponderado por IDF.

    Devuelve (vector, tokens_conocidos, tokens_desconocidos) porque saber que
    tokens quedaron fuera del vocabulario es clave para interpretar el ranking.
    """
    vector = [0.0] * dimensiones
    conocidos, desconocidos = [], []
    for token in tokens:
        if token in embeddings_palabra:
            conocidos.append(token)
            peso = idf.get(token, 1.0)
            palabra = embeddings_palabra[token]
            for d in range(dimensiones):
                vector[d] += peso * palabra[d]
        else:
            desconocidos.append(token)
    return normalizar_vector(vector), conocidos, desconocidos


def similitud_coseno(a, b):
    """Con vectores ya normalizados, el coseno es el producto punto."""
    return sum(x * y for x, y in zip(a, b))


# ---------------------------------------------------------------------------
# Paso 5: los dos buscadores
# ---------------------------------------------------------------------------

def buscar_semantico(consulta, indice, k=TOP_K):
    """Ranking top-k por similitud coseno entre el embedding de la consulta y los del corpus."""
    tokens = tokenizar(consulta)
    vector, conocidos, desconocidos = embedding_de_texto(
        tokens, indice["embeddings_palabra"], indice["idf"]
    )

    if not conocidos:
        return {"resultados": [], "conocidos": conocidos, "desconocidos": desconocidos}

    puntajes = [
        (i, similitud_coseno(vector, emb))
        for i, emb in enumerate(indice["embeddings_doc"])
    ]
    puntajes.sort(key=lambda par: (-par[1], par[0]))
    resultados = [(i, s) for i, s in puntajes[:k] if s >= UMBRAL_MINIMO]
    return {"resultados": resultados, "conocidos": conocidos, "desconocidos": desconocidos}


def buscar_por_palabras_clave(consulta, indice, k=TOP_K):
    """
    Linea base deliberadamente simple: cuenta cuantos terminos de la consulta
    aparecen literalmente en la oracion, normalizado por el largo de la consulta.

    Sin stemming, sin sinonimos: 'goles' y 'gol' son palabras distintas.
    """
    tokens = tokenizar(consulta)
    if not tokens:
        return {"resultados": [], "terminos": tokens}

    puntajes = []
    for i, doc_tokens in enumerate(indice["docs_tokenizados"]):
        conjunto = set(doc_tokens)
        coincidencias = sum(1 for t in set(tokens) if t in conjunto)
        if coincidencias > 0:
            puntajes.append((i, coincidencias / len(set(tokens))))

    puntajes.sort(key=lambda par: (-par[1], par[0]))
    return {"resultados": puntajes[:k], "terminos": tokens}


def construir_indice(corpus):
    """Arma todo el indice una sola vez: vocabulario, PPMI, embeddings de palabra y de documento."""
    docs_tokenizados = [tokenizar(oracion) for oracion in corpus]
    vocabulario = construir_vocabulario(docs_tokenizados)
    conteos = construir_coocurrencias(docs_tokenizados)
    ppmi = calcular_ppmi(conteos)
    proyecciones = generar_proyecciones(vocabulario)
    embeddings_palabra = construir_embeddings_palabra(vocabulario, ppmi, proyecciones)
    idf = calcular_idf(docs_tokenizados)

    embeddings_doc = [
        embedding_de_texto(tokens, embeddings_palabra, idf)[0]
        for tokens in docs_tokenizados
    ]

    return {
        "corpus": corpus,
        "docs_tokenizados": docs_tokenizados,
        "vocabulario": vocabulario,
        "ppmi": ppmi,
        "embeddings_palabra": embeddings_palabra,
        "embeddings_doc": embeddings_doc,
        "idf": idf,
    }


# ---------------------------------------------------------------------------
# Presentacion
# ---------------------------------------------------------------------------

def titulo(texto):
    print()
    print("=" * 78)
    print(texto)
    print("=" * 78)


def subtitulo(texto):
    print()
    print("-" * 78)
    print(texto)
    print("-" * 78)


def imprimir_resultados(nombre, resultados, corpus):
    print(f"  {nombre}")
    if not resultados:
        print("     (sin resultados)")
        return
    for posicion, (indice_doc, puntaje) in enumerate(resultados, start=1):
        print(f"     {posicion}. [{puntaje:.3f}] doc {indice_doc:>2} | {corpus[indice_doc]}")


def imprimir_resumen_indice(indice):
    titulo("INDICE CONSTRUIDO")
    vocabulario = indice["vocabulario"]
    pares_ppmi = sum(len(v) for v in indice["ppmi"].values())
    print(f"  Oraciones en el corpus       : {len(indice['corpus'])}")
    print(f"  Tokens de contenido totales  : {sum(len(d) for d in indice['docs_tokenizados'])}")
    print(f"  Vocabulario                  : {len(vocabulario)} palabras distintas")
    print(f"  Pares PPMI no nulos          : {pares_ppmi}")
    print(f"  Dimensiones del embedding    : {DIMENSIONES}")
    print(f"  Ventana de co-ocurrencia     : +-{VENTANA}")
    print(f"  Semilla                      : {SEMILLA} (corrida reproducible)")


def imprimir_corpus(corpus):
    titulo("CORPUS")
    for i, oracion in enumerate(corpus):
        print(f"  doc {i:>2} | {oracion}")


def imprimir_vecinos(indice, palabras, k=5):
    """Muestra los vecinos mas cercanos de algunas palabras: sirve para ver si el espacio tiene sentido."""
    titulo("VECINDARIO DE PALABRAS (control de calidad del espacio vectorial)")
    embeddings = indice["embeddings_palabra"]
    for palabra in palabras:
        if palabra not in embeddings:
            print(f"  '{palabra}' no esta en el vocabulario")
            continue
        vector = embeddings[palabra]
        vecinos = [
            (otra, similitud_coseno(vector, emb))
            for otra, emb in embeddings.items()
            if otra != palabra
        ]
        vecinos.sort(key=lambda par: -par[1])
        cercanos = ", ".join(f"{p} ({s:.2f})" for p, s in vecinos[:k])
        print(f"  {palabra:<16} -> {cercanos}")


def comparar_consulta(consulta, indice, k=TOP_K):
    """Corre ambos buscadores sobre la misma consulta y devuelve metricas para el resumen final."""
    semantico = buscar_semantico(consulta, indice, k)
    palabras = buscar_por_palabras_clave(consulta, indice, k)

    subtitulo(f"CONSULTA: {consulta!r}")
    print(f"  Tokens de la consulta   : {palabras['terminos']}")
    if semantico["desconocidos"]:
        print(f"  Fuera del vocabulario   : {semantico['desconocidos']}")
    print()

    imprimir_resultados(f"Semantica (coseno, top-{k}):", semantico["resultados"], indice["corpus"])
    print()
    imprimir_resultados(f"Palabras clave (top-{k}):", palabras["resultados"], indice["corpus"])

    ids_sem = {i for i, _ in semantico["resultados"]}
    ids_kw = {i for i, _ in palabras["resultados"]}
    union = ids_sem | ids_kw
    traslape = len(ids_sem & ids_kw) / len(union) if union else 0.0

    print()
    print(f"  Documentos en comun     : {sorted(ids_sem & ids_kw) or 'ninguno'}")
    print(f"  Traslape (Jaccard)      : {traslape:.2f}")
    print(f"  Observacion             : {observacion(semantico, palabras, ids_sem, ids_kw)}")

    return {
        "consulta": consulta,
        "n_sem": len(ids_sem),
        "n_kw": len(ids_kw),
        "traslape": traslape,
    }


def observacion(semantico, palabras, ids_sem, ids_kw):
    """Genera el comentario cualitativo de cada consulta a partir de lo que realmente paso."""
    if not semantico["conocidos"]:
        return ("ningun termino de la consulta esta en el vocabulario: la busqueda "
                "semantica no puede representar la consulta y ambos metodos fallan")
    if not ids_kw:
        return ("la busqueda literal no encontro nada; la semantica si recupera "
                "oraciones del tema correcto")
    if ids_sem == ids_kw:
        orden_sem = [i for i, _ in semantico["resultados"]]
        orden_kw = [i for i, _ in palabras["resultados"]]
        if orden_sem != orden_kw:
            return ("ambos recuperan el mismo conjunto, pero en distinto orden: la "
                    "busqueda literal empata documentos que la semantica si separa")
        return ("ambos metodos coinciden: la consulta usa las mismas palabras "
                "exactas del documento, donde la busqueda literal ya es suficiente")
    solo_sem = sorted(ids_sem - ids_kw)
    if solo_sem:
        return (f"la semantica agrega los documentos {solo_sem}, que ninguna palabra "
                "de la consulta menciona literalmente (revisar si el tema coincide)")
    return "la busqueda literal recupera documentos que la semantica ordena mas abajo"


def imprimir_comparacion_final(metricas):
    titulo("COMPARACION CUALITATIVA ENTRE AMBOS METODOS")

    print()
    print(f"  {'Consulta':<32} {'#Sem':>5} {'#Clave':>7} {'Traslape':>9}")
    print("  " + "-" * 56)
    for m in metricas:
        consulta = m["consulta"][:30]
        print(f"  {consulta:<32} {m['n_sem']:>5} {m['n_kw']:>7} {m['traslape']:>9.2f}")

    promedio = sum(m["traslape"] for m in metricas) / len(metricas)
    print(f"\n  Traslape promedio entre ambos rankings: {promedio:.2f}")

    print("""
  El experimento: consultas ambiguas fuera de dominio
  ---------------------------------------------------
  Ninguna de las consultas habla realmente de lo que contiene el corpus. El
  usuario pregunta por Star Wars y el corpus solo sabe de mascotas, cocina,
  clima, deportes, transporte e inteligencia artificial. Cada consulta se
  apoya en una palabra ambigua ('entrenamiento', 'torneo', 'jardin',
  'tormenta', 'mascota') que existe en ambos mundos. Esto vuelve visible que
  ninguno de los dos buscadores entiende la intencion: los dos devuelven la
  lectura cotidiana de la palabra, y ninguno es capaz de responder 'no tengo
  nada sobre este tema'.

  Donde gana la busqueda semantica
  --------------------------------
  - Extiende el resultado al resto del tema. En 'el torneo de los
    cazarrecompensas' la busqueda literal solo devuelve el doc 19, mientras
    que la semantica agrega el doc 17 ('el equipo gano el partido de futbol'),
    que no comparte ninguna palabra con la consulta. El puente lo hace
    'equipo', que co-ocurre con 'torneo' en el doc 19 y con 'futbol' en el
    doc 17. Lo mismo en 'el jardin del templo jedi', que alcanza el doc 5
    ('el perro corre feliz por el parque') partiendo solo de 'jardin'.
  - Devuelve un ranking graduado, no un conjunto plano de coincidencias. En
    'el entrenamiento y aprendizaje del padawan' la busqueda literal empata
    los tres documentos en 0.333, sin poder decir cual es mejor; la semantica
    los ordena 0.814 / 0.725 / 0.523 y deja arriba el que mas se parece.
  - Aguanta mejor el vocabulario desconocido. En 'la tormenta de arena en el
    planeta desertico', 3 de los 4 terminos de contenido estan fuera del
    vocabulario y aun asi recupera el doc 16 con 0.944, porque el unico
    termino conocido arrastra todo su contexto. La busqueda literal encuentra
    el mismo documento pero con 0.250, un puntaje que no la distingue de una
    coincidencia debil.

  Donde gana la busqueda por palabras clave
  -----------------------------------------
  - Es exacta y explicable: se ve de inmediato por que aparecio un documento.
    La semantica solo entrega un numero entre 0 y 1 que hay que interpretar.
  - No inventa relaciones. En 'la mascota del wookiee' la semantica cuela el
    doc 21 ('el autobus llego tarde a la estacion') con 0.316, porque el verbo
    'llego' aparece tanto ahi como en el doc 7. Es un falso positivo por una
    palabra de poco contenido que sirvio de puente, algo que la busqueda
    literal, al no propagar nada, nunca comete.
  - No requiere construir ningun modelo: no hay matriz de co-ocurrencia, ni
    PPMI, ni proyeccion, ni umbral que calibrar.

  Limitaciones observadas en esta implementacion
  ----------------------------------------------
  - El corpus tiene 24 oraciones. La hipotesis distribucional necesita mucho
    mas texto: aqui buena parte de la senal proviene del tema compartido
    dentro de cada oracion, no de un conocimiento general del idioma. Por eso
    los aciertos semanticos vienen con puntajes bajos (0.24 - 0.28) y hubo que
    poner un umbral minimo para filtrar ruido de la proyeccion aleatoria.
  - Las palabras fuera del vocabulario no tienen vector. En 'los caza
    estelares del escuadron rebelde' los cuatro terminos son desconocidos y la
    busqueda semantica queda tan ciega como la literal. Un modelo preentrenado
    con subpalabras no tendria ese problema.
  - Ninguno de los dos metodos hace stemming ni lematizacion, ni desambigua
    sentidos: 'tormenta de arena' y 'tormenta con viento' se tratan como la
    misma cosa.

  Conclusion
  ----------
  Los metodos son complementarios, no sustitutos. La busqueda literal es la
  linea base correcta cuando el usuario ya conoce el vocabulario del corpus;
  la semantica cubre el caso en que lo describe con otras palabras, a cambio
  de un riesgo de falsos positivos. Pero estas consultas muestran el limite
  comun a los dos: sin una nocion de dominio, un buscador siempre contesta
  algo. Un sistema real combina recuperacion literal para precision y
  vectorial para cobertura, y agrega un umbral de rechazo para poder admitir
  que la respuesta no esta en el corpus.
""")


# ---------------------------------------------------------------------------
# Programa principal
# ---------------------------------------------------------------------------

def main():
    titulo("LABORATORIO 2 - BUSQUEDA SEMANTICA VS BUSQUEDA POR PALABRAS CLAVE")
    print("  Embeddings locales: co-ocurrencia -> PPMI -> proyeccion aleatoria")
    print("  Sin librerias externas ni modelos preentrenados.")

    imprimir_corpus(CORPUS)

    indice = construir_indice(CORPUS)
    imprimir_resumen_indice(indice)
    imprimir_vecinos(indice, ["gato", "datos", "equipo", "lluvia", "pollo"])

    titulo(f"CONSULTAS DE PRUEBA ({len(CONSULTAS)})")
    metricas = [comparar_consulta(consulta, indice) for consulta in CONSULTAS]

    imprimir_comparacion_final(metricas)


if __name__ == "__main__":
    main()