Token Pooling e modelli multi‑vettore per ottimizzare i sistemi RAG aziendali
Introduzione
I sistemi Retrieval‑Augmented Generation (RAG) stanno diventando lo standard per le applicazioni aziendali che richiedono risposte basate su documenti interni. Una delle sfide principali è la gestione della memoria: i modelli LLM hanno limiti di token (es. 8k‑32k) e l'indicizzazione di grandi collezioni può superare rapidamente questi limiti.
Cos'è il Token Pooling
Il token pooling è una tecnica descritta da Hugging Face (blog Token Pooling) che consiste nell'aggregare i token di un documento in un numero fisso di vettori, tipicamente mediante operazioni di media, max‑pool o attention‑based pooling. In pratica, si riduce il numero di token mantenendo una rappresentazione semantica più compatta.
FATTO: il blog riporta che, usando token pooling, è possibile ridurre il conteggio dei token di un documento del 70‑90 % senza una perdita significativa di qualità nei task di retrieval.
Vantaggi per i sistemi RAG
- Efficienza di memoria: meno token da inviare al modello LLM riduce il consumo di VRAM e il tempo di inferenza.
- Velocità di ricerca: gli indici basati su vettori più piccoli sono più rapidi da interrogare.
- Scalabilità: consente di gestire collezioni di documenti di dimensioni maggiori mantenendo i limiti di token del modello.
- Qualità del recupero: il pooling basato su attention preserva le informazioni chiave, migliorando la rilevanza dei risultati rispetto a una semplice truncazione.
Implementazione pratica (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):
# Tokenizza e suddivide in chunk di dimensione gestibile
tokens = tokenizer(text, return_tensors="pt", truncation=False)
input_ids = tokens["input_ids"][0]
# Divide in chunk di max 512 token (esempio)
chunk_size = 512
chunks = [input_ids[i:i+chunk_size] for i in range(0, len(input_ids), chunk_size)]
# Limita il numero di chunk per evitare overflow
if len(chunks) > max_chunks:
# Pooling dei chunk in eccesso (es. media dei rappresentazioni)
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)
Il codice sopra mostra come trasformare un documento arbitrariamente lungo in un unico vettore usando token pooling. Il vettore può poi essere indicizzato con FAISS, Milvus o Elastic Vector Search per il retrieval.
Integrazione con modelli multi‑vettore
I modelli multi‑vettore (es. Dual‑Encoder, ColBERT) producono più rappresentazioni per lo stesso documento (ad es. per frase, paragrafo o entità). Quando si combina il token pooling con questi modelli, si può:
- Applicare pooling a livello di frase e mantenere un set di vettori per documento, migliorando la granularità del recupero.
- Usare un indice 2‑livello: il primo livello contiene i vettori poolati (rapido filtro), il secondo livello contiene i vettori per frase (ranking fine‑grained). Questa architettura riduce il carico computazionale del LLM durante la fase di generazione, poiché il prompt contiene solo i frammenti più rilevanti selezionati dal secondo livello.
Considerazioni operative
- Batch size: per ridurre il tempo di embedding, processare più chunk in batch (es.
torch.nn.utils.rnn.pad_sequence). - Aggiornamento dell'indice: quando i documenti cambiano, rigenera solo i chunk modificati; il pooling consente di ri‑indicare rapidamente.
- Limiti di token del LLM: verifica la lunghezza massima del prompt del modello in uso (es. 8 192 token per LLaMA‑2‑13B) e adatta
max_chunksdi conseguenza. - Validazione della qualità: confronta il recall@k con e senza pooling su un set di query di test per quantificare l'impatto.
Domande per la community
- Quali strategie di token pooling (media, max, attention) avete trovato più efficaci nei vostri progetti RAG?
- Avete sperimentato un indice 2‑livello combinando pooling e modelli multi‑vettore? Quali metriche avete usato per valutare il trade‑off tra velocità e accuratezza?
- Come gestite l'aggiornamento incrementale dell'indice quando i documenti aziendali cambiano frequentemente?