Token Pooling y modelos multi‑vector para optimizar sistemas RAG empresariales
Traducido automáticamente del italiano. Leer el original
Introducción
Los sistemas Retrieval‑Augmented Generation (RAG) se están convirtiendo en el estándar para aplicaciones empresariales que requieren respuestas basadas en documentos internos. Uno de los principales desafíos es la gestión de la memoria: los modelos LLM tienen límites de tokens (p. ej. 8k‑32k) y la indexación de grandes colecciones puede superar rápidamente estos límites.
Qué es el Token Pooling
El token pooling es una técnica descrita por Hugging Face (blog Token Pooling) que consiste en agregar los tokens de un documento en un número fijo de vectores, típicamente mediante operaciones de media, max‑pool o attention‑based pooling. En la práctica, se reduce el número de tokens manteniendo una representación semántica más compacta.
HECHO: el blog indica que, usando token pooling, es posible reducir el conteo de tokens de un documento en un 70‑90 % sin una pérdida significativa de calidad en tareas de retrieval.
Ventajas para los sistemas RAG
- Eficiencia de memoria: menos tokens que enviar al modelo LLM reducen el consumo de VRAM y el tiempo de inferencia.
- Velocidad de búsqueda: los índices basados en vectores más pequeños son más rápidos de consultar.
- Escalabilidad: permite gestionar colecciones de documentos de mayor tamaño manteniendo los límites de tokens del modelo.
- Calidad de la recuperación: el pooling basado en attention preserva la información clave, mejorando la relevancia de los resultados frente a una simple truncación.
Implementación práctica (Python)
from transformers import AutoTokenizer, AutoModel
import torch
model_name = "sentence-transformers/all-MiniLM-L6-v2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)
def token_pooling(text, pool_type="mean", max_chunks=16):
# Tokeniza y divide en chunks de tamaño manejable
tokens = tokenizer(text, return_tensors="pt", truncation=False)
input_ids = tokens["input_ids"][0]
# Divide en chunks de máx. 512 tokens (ejemplo)
chunk_size = 512
chunks = [input_ids[i:i+chunk_size] for i in range(0, len(input_ids), chunk_size)]
# Limita el número de chunks para evitar overflow
if len(chunks) > max_chunks:
# Pooling de los chunks en exceso (p. ej. media de las representaciones)
chunks = chunks[:max_chunks]
embeddings = []
for chunk in chunks:
with torch.no_grad():
out = model(chunk.unsqueeze(0))[0] # (1, seq_len, hidden)
if pool_type == "mean":
emb = out.mean(dim=1) # (1, hidden)
elif pool_type == "max":
emb, _ = out.max(dim=1)
else:
raise ValueError("pool_type must be 'mean' or 'max'")
embeddings.append(emb.squeeze())
stacked = torch.stack(embeddings)
pool_type == :
final_emb = stacked.mean(dim=)
:
final_emb, _ = stacked.(dim=)
final_emb.numpy()
text =
vector = token_pooling(text, pool_type=)
(vector.shape)
El código anterior muestra cómo transformar un documento arbitrariamente largo en un único vector usando token pooling. El vector puede luego indexarse con FAISS, Milvus o Elastic Vector Search para el retrieval.
Integración con modelos multi‑vector
Los modelos multi‑vector (p. ej. Dual‑Encoder, ColBERT) producen más representaciones para el mismo documento (por ejemplo, por frase, párrafo o entidad). Al combinar el token pooling con estos modelos, se puede:
- Aplicar pooling a nivel de frase y mantener un conjunto de vectores por documento, mejorando la granularidad de la recuperación.
- Usar un índice de 2 niveles: el primer nivel contiene los vectores poolados (filtro rápido), el segundo nivel contiene los vectores por frase (ranking fine‑grained). Esta arquitectura reduce la carga computacional del LLM durante la fase de generación, ya que el prompt contiene solo los fragmentos más relevantes seleccionados por el segundo nivel.
Consideraciones operativas
- Batch size: para reducir el tiempo de embedding, procesar más chunks en batch (p. ej.
torch.nn.utils.rnn.pad_sequence). - Actualización del índice: cuando los documentos cambian, regenera solo los chunks modificados; el pooling permite re‑indexar rápidamente.
- Límites de tokens del LLM: verifica la longitud máxima del prompt del modelo en uso (p. ej. 8 192 tokens para LLaMA‑2‑13B) y adapta
max_chunksen consecuencia. - Validación de la calidad: compara el recall@k con y sin pooling en un conjunto de consultas de prueba para cuantificar el impacto.
Preguntas para la comunidad
- ¿Qué estrategias de token pooling (media, max, attention) han encontrado más efectivas en sus proyectos RAG?
- ¿Han experimentado un índice de 2 niveles combinando pooling y modelos multi‑vector? ¿Qué métricas han usado para evaluar el trade‑off entre velocidad y precisión?
- ¿Cómo gestionan la actualización incremental del índice cuando los documentos empresariales cambian con frecuencia?