RAG: leer antes de responder

TF-IDF y similitud coseno

Así se calcula la búsqueda por palabras de la escena. Primero se quitan las palabras muy comunes («de», «la», «que»…) y se recorta cada palabra a su raíz, de forma sencilla («baterías» y «batería» cuentan igual). Con eso, el manual de la lección tiene 228 términos distintos: cada fragmento es un vector de 228 números.

Dados $N$ fragmentos, $c_{t,d}$ es cuántas veces aparece el término $t$ en el fragmento $d$, y $\mathrm{df}(t)$ en cuántos fragmentos aparece. Con las variantes de la lección:

Con $N=25$: «ciclos» aparece en 1 fragmento ($\mathrm{idf}\approx 3.56$) y «garantía» en 6 ($\mathrm{idf}\approx 2.31$); por eso «ciclos» pesa más. Cada vector se normaliza, $\hat{\mathbf d}=\mathbf d/\lVert\mathbf d\rVert$, y la pregunta recibe el mismo tratamiento con los $\mathrm{idf}$ del índice. La similitud coseno queda como un producto punto:

La idea de pesar por rareza es de Karen Spärck Jones (1972): un término que aparece en pocos documentos los distingue mejor.

BM25, la otra puntuación por palabras

BM25 (Robertson y Zaragoza, 2009) puntúa cada fragmento $D$ con una frecuencia que se satura y una corrección por longitud:

con $1.2<k_1<2$ y $0.5<b<0.8$ como valores que, según sus autores, suelen funcionar bien. Es un punto de partida difícil de superar solo con palabras, y muchos sistemas lo combinan con embeddings (búsqueda híbrida).

Embeddings y búsqueda aproximada

Con embeddings (lección 14) el vector tiene unos cientos de números densos y no hace falta que coincidan las palabras: la similitud coseno compara significados. Comparar la pregunta con los $N$ vectores cuesta $O(N\cdot D)$; con millones de fragmentos se usan índices aproximados como HNSW (Malkov y Yashunin), que cambian un poco de exactitud por mucha velocidad. En el artículo que dio nombre a RAG (Lewis et al., 2020), Wikipedia se cortó en trozos de 100 palabras, 21 millones en total, que se indexaron con FAISS y HNSW; al entrenar se recuperaban $k=5$ o $k=10$ por pregunta.

Reordenar

Un recuperador denso (bi-encoder), como DPR (Karpukhin et al., 2020), el que usa RAG, codifica la pregunta y el fragmento por separado, así que los fragmentos se convierten en vectores una sola vez. Un reordenador (cross-encoder) lee la pregunta y el fragmento juntos en una pasada del modelo y devuelve una puntuación: es más fino, pero cuesta una pasada por candidato, así que solo se aplica a los primeros de la lista. Nogueira y Cho (2019) reordenaban con BERT los 1 000 primeros pasajes que traía BM25.

En la lección, las cifras de embeddings y de reordenador se midieron aparte (ver build-dense.py) con dos modelos abiertos: intfloat/multilingual-e5-small (Wang et al., 2024) y cross-encoder/mmarco-mMiniLMv2-L12-H384-v1, entrenado con mMARCO (Bonifacio et al., 2021). El reordenador se aplica a los 5 primeros candidatos.

Cómo se mide la recuperación

Para cada pregunta de prueba se anota el fragmento correcto y su puesto $r_i$ en la lista ordenada ($r_i=0$ si no aparece). Con $Q$ preguntas:

En las 10 preguntas de la escena, con $k=3$: por palabras, 7 de 10; con embeddings, 9 de 10; con embeddings y reordenador, 8 de 10 (en ambos idiomas). Diez preguntas son muy pocas para sacar conclusiones generales: el punto es el método.

Esto mide solo la primera mitad. La segunda, si la respuesta se apoya en lo recuperado, se evalúa con casos de prueba y con revisión humana o con un modelo como juez (lección 34). Ragas (Es et al., 2023) la separa en tres medidas: fidelidad (lo que dice la respuesta se deduce del contexto), pertinencia de la respuesta y pertinencia del contexto.

Actualizar sin reentrenar

En el artículo de RAG se probó cambiar solo el índice: con 82 gobernantes que cambiaron entre 2016 y 2018, el modelo acertó el 70 % con el índice de Wikipedia de 2016 para los de 2016, y el 68 % con el de 2018 para los de 2018; con el índice que no correspondía, solo el 12 % y el 4 %. Para actualizar lo que sabe, se cambian documentos, no pesos.

En código

Un buscador TF-IDF completo, sin librerías. Es la misma receta de la lección, sin recortar las palabras a su raíz:

import math, re
from collections import Counter

STOP = {"la", "el", "de", "los", "a", "en", "tu", "o", "es", "cuanto", "dura"}

def terms(text):
    return [w for w in re.findall(r"[a-z0-9]+", text.lower()) if w not in STOP]

chunks = [
    "la bateria tiene 18 meses de garantia o 500 ciclos de carga",
    "puedes cancelar tu compra durante los 30 dias posteriores a la entrega",
    "el envio es gratis en compras mayores a 1500",
    "carga la bateria a temperatura ambiente",
]

N = len(chunks)
bags = [Counter(terms(c)) for c in chunks]
df = Counter(t for b in bags for t in b)
idf = {t: math.log((N + 1) / (df[t] + 1)) + 1 for t in df}

def vector(bag):
    v = {t: (1 + math.log(c)) * idf[t] for t, c in bag.items() if t in idf}
    norm = math.sqrt(sum(x * x for x in v.values())) or 1.0
    return {t: x / norm for t, x in v.items()}

index = [vector(b) for b in bags]

def search(question, k=2):
    q = vector(Counter(terms(question)))
    scores = [sum(w * d.get(t, 0.0) for t, w in q.items()) for d in index]
    return sorted(enumerate(scores), key=lambda p: -p[1])[:k]

for i, s in search("cuanto dura la garantia de la bateria"):
    print(f"{s:.2f}  {chunks[i]}")
# 0.47  la bateria tiene 18 meses de garantia o 500 ciclos de carga
# 0.27  carga la bateria a temperatura ambiente

Lo que viene

Aquí el modelo solo lee. En la lección 32 puede además usar herramientas: buscar, calcular, escribir. La inyección de instrucciones se retoma en la lección 35, y la evaluación completa de sistemas, en la 34.