Embeddings i cerca vectorial

• Què és un embedding
  • Representació dispersa vs. densa
  • Intuïció geomètrica
• Com s’aprenen els embeddings
  • Objectiu contrastiu
  • Softmax sobre catàleg (skip-gram)
  • LLMs com a productors d’embeddings
• Mètriques de similitud
  • Similitud del cosinus
  • Producte escalar (dot product)
  • Distància L2 (euclidiana)
  • El truc de la normalització
• Cerca aproximada de veïns (ANN)
  • El problema computacional
  • HNSW (Hierarchical Navigable Small World)
  • IVF (Inverted File Index)
  • Quantització de producte (PQ)
  • Comparativa i eines
• Vector stores
  • Eines principals
  • Quan no cal un vector store
• Connexions

Els embeddings i la cerca vectorial són la infraestructura sobre la qual s’assenten els sistemes de recomanació moderns, el RAG i la cerca semàntica. Entendre com funcionen a nivell de fonaments permet prendre decisions informades quan s’integren en sistemes reals.

Què és un embedding

Un embedding és un vector de nombres reals de dimensió fixa que representa un objecte (un text, un usuari, un producte, una imatge) de manera que objectes semànticament semblants queden propers en l’espai vectorial.

Representació dispersa vs. densa

La manera tradicional de representar text era amb vectors dispersos (sparse): un vector de tants components com paraules existeixin al vocabulari, on gairebé tots els valors són zero.

Exemple: si el vocabulari té 50.000 paraules, la paraula “gat” seria:

\[ v_{\text{gat}} = [0, 0, \ldots, 0, 1, 0, \ldots, 0] \quad (\text{50.000 components, un sol 1}) \]

Problemes d’aquesta representació:

• No captura cap relació entre paraules (“gat” i “felí” queden igual de lluny que “gat” i “cotxe”).
• Ocupa molt d’espai, i els càlculs de similitud sobre milions de vectors dispersos son lents.

Un embedding dens representa la mateixa paraula amb un vector de dimensió molt menor (típicament 256–4.096 components) on tots els valors són significatius:

\[ v_{\text{gat}} = [0.23, -0.81, 0.45, \ldots, 0.12] \quad (\text{768 components}) \]

La propietat clau: la geometria del vector captura semàntica. Vectors propers corresponen a objectes amb significat similar.

Intuïció geomètrica

graph LR
    subgraph "Espai d'embeddings (2D simplificat)"
        GAT["gat 🐱"]
        GOS["gos 🐶"]
        FELI["felí 🐈"]
        COTXE["cotxe 🚗"]
        MOTO["moto 🏍️"]
    end
    GAT ---|"proper"| FELI
    GAT ---|"proper"| GOS
    COTXE ---|"proper"| MOTO

“Gat”, “gos” i “felí” seran propers entre ells. “Cotxe” i “moto” seran propers entre ells però lluny dels animals. Aquesta estructura emergeix automàticament de l’entrenament — no cal definir-la a mà.

Com s’aprenen els embeddings

Un model d’embeddings s’entrena per optimitzar un objectiu d’aprenentatge que força vectors de parells semblants a apropar-se i vectors de parells dissemblants a allunyar-se.

Objectiu contrastiu

L’objectiu contrastiu treballa amb trius (anchor, positiu, negatiu): donada una mostra de referència, un exemple similar i un de diferent, l’objectiu és:

\[ \mathcal{L} = \max(0,; d(a, p) - d(a, n) + \text{marge}) \]

On \(d\) és una mètrica de distància, \(a\) és l’anchor, \(p\) el positiu i \(n\) el negatiu. La pèrdua és zero quan el positiu és prou més proper que el negatiu; augmenta quan no ho és.

Com es construeixen els parells positius? Depèn del domini:

Els negatius es solen obtenir per mostreig aleatori del conjunt de dades (in-batch negatives): els altres exemples del mateix batch d’entrenament actuen com a negatius implícits.

Softmax sobre catàleg (skip-gram)

El model word2vec (skip-gram) va popularitzar un objectiu diferent: donada una paraula central, predir les paraules del context. Això és equivalent a maximitzar un softmax sobre tot el vocabulari:

\[ P(\text{context} \mid \text{paraula}) = \frac{e^{v_{\text{context}} \cdot v_{\text{paraula}}}}{\sum_{w} e^{v_w \cdot v_{\text{paraula}}}} \]

La matriu de pesos apreses durant l’entrenament son els embeddings. El mateix principi s’aplica als sistemes de recomanació: substituint “paraules” per “ítems” i “context” per “ítems co-consumits”.

LLMs com a productors d’embeddings

Els LLMs moderns (BERT, sentence-transformers, text-embedding-3) produeixen embeddings com a subproducte del preentrenament. El vector de l’últim token [CLS] o la mitjana dels tokens de sortida es pot usar directament com a representació densa de text. Aquests models lideren els benchmarks de recuperació semàntica (MTEB).

Mètriques de similitud

Un cop tenim dos vectors \(u\) i \(v\), cal mesurar com de similars són. Hi ha tres opcions principals:

Similitud del cosinus

\[ \cos(u, v) = \frac{u \cdot v}{|u| \cdot |v|} \]

Mesura l’angle entre els dos vectors, independentment de la seva magnitud. Val 1 si apunten en la mateixa direcció, 0 si són perpendiculars i -1 si apunten en direccions oposades.

Quan usar-la: cerca semàntica de text, quan la magnitud del vector no té significat (l’important és la direcció).

Producte escalar (dot product)

\[ u \cdot v = \sum_i u_i v_i \]

Combina angle i magnitud. Vectors llargs (alta norma) obtenen puntuacions més altes fins i tot si l’angle no és millor. Introdueix un biaix de popularitat: ítems representats amb vectors de gran norma tendeixen a aparecer més.

Quan usar-lo: sistemes de recomanació, on la magnitud pot capturar la popularitat o rellevància global d’un ítem.

Distància L2 (euclidiana)

\[ d(u, v) = |u - v| = \sqrt{\sum_i (u_i - v_i)^2} \]

La distància espacial directa entre dos punts.

Quan usar-la: features d’imatges, quan l’espai vectorial és calibrat i la distància absoluta té significat.

El truc de la normalització

Si normalitzem tots els vectors a norma unitària (\(|v| = 1\)), la similitud del cosinus i el producte escalar produeixen el mateix resultat:

\[ \cos(u, v) = u \cdot v \quad \text{si } |u| = |v| = 1 \]

Normalitzar prèviament permet usar el producte escalar (molt eficient en GPU) en lloc de calcular cosinus explícitament. La majoria de models moderns produeixen vectors ja normalitzats.

Cerca aproximada de veïns (ANN)

El problema computacional

Amb un catàleg d’1 milió de vectors de dimensió 768, trobar els 10 més similars a una consulta requereix calcular 1 milió de productes escalars. En un servei que rep milers de consultes per segon, el cost és prohibitiu.

La cerca exacta de veïns no escala. La solució és acceptar una petita pèrdua de precisió a canvi d’una reducció dràstica de latència: la cerca aproximada de veïns (ANN).

HNSW (Hierarchical Navigable Small World)

HNSW construeix un graf multicapa on els vectors s’interconnecten per proximitat. Les capes superiors contenen pocs nodes i connexions llargues (navegació ràpida); les capes inferiors contenen tots els nodes i connexions curtes (refinament precís).

graph TD
    subgraph "Capa 2 (navegació global)"
        A2["A"] --- C2["C"]
        C2 --- F2["F"]
    end
    subgraph "Capa 1"
        A1["A"] --- B1["B"]
        B1 --- C1["C"]
        C1 --- E1["E"]
        E1 --- F1["F"]
    end
    subgraph "Capa 0 (tots els nodes)"
        A0["A"] --- B0["B"]
        B0 --- C0["C"]
        C0 --- D0["D"]
        D0 --- E0["E"]
        E0 --- F0["F"]
    end

Cerca: entrar per la capa superior, navegar cap al node més proper a la consulta, baixar a la capa inferior, refinar. El cost és \(O(\log n)\) en lloc de \(O(n)\).

Avantatges: recall molt alt, latència molt baixa. Inconvenient: memòria elevada (el graf ocupa el doble que els vectors).

IVF (Inverted File Index)

IVF divideix l’espai en \(k\) clústers (via k-means). Cada vector s’assigna al seu centroide. En el moment de la cerca, només s’exploren els \(n_{\text{probe}}\) clústers més propers a la consulta.

Avantatge: molt menor consum de memòria que HNSW. Inconvenient: si el vector de consulta queda a la frontera entre dos clústers, els veritables veïns poden estar en un clúster no explorat (recall menor).

Quantització de producte (PQ)

PQ comprimeix cada vector dividint-lo en \(m\) subvectors i aproximant cadascun amb el centroide del seu clúster. Un vector de 768 dimensions pot quedar comprimit a pocs bytes.

Avantatge: reducció dramàtica de memòria (10–50x). Inconvenient: pèrdua de qualitat del recall.

En la pràctica, IVF i PQ es combinen (IVFPQ): IVF redueix el nombre de candidats, PQ redueix la memòria dels vectors emmagatzemats.

Comparativa i eines

FAISS (Meta): biblioteca de referència per a CPU i GPU. Implementa HNSW, IVF, PQ i combinacions. Baix nivell, molt configurable.

ScaNN (Google): optimitzat específicament per maximitzar recall@k. Usant internament quantització asimètrica, supera FAISS en benchmarks de recall a latència equivalent.

hnswlib: implementació lleugera de HNSW, adequada per a prototips o serveis amb pocs milions de vectors.

Vector stores

Les biblioteques ANN (FAISS, ScaNN) operen sobre índexs en memòria: no persisteixen entre reinicis, no filtren per metadades, no gestionen múltiples col·leccions. Els vector stores afegeixen una capa de gestió sobre l’índex ANN:

• Persistència: l’índex es guarda a disc i es carrega automàticament.
• Filtratge per metadades: cerca els vectors més similars a la consulta entre els que compleixen una condició (per exemple, idioma = "ca" o data > 2024-01-01).
• Cerca híbrida: combina similitud vectorial (semàntica) amb BM25 (lexical), millorant la precisió per a consultes amb termes exactes.
• Multi-tenancy: col·leccions aïllades per a clients o contextos diferents.

Eines principals

Quan no cal un vector store

Si el catàleg té menys de ~10.000 vectors, la cerca exacta amb producte escalar en memòria (via NumPy o PyTorch) és suficient i elimina una dependència d’infraestructura:

# Cerca exacta per a catàlegs petits
scores = query_vector @ item_matrix.T  # shape: (n_items,)
top_k = scores.argsort()[-10:][::-1]

Per a volums superiors, un vector store justifica la complexitat addicional.

Connexions

Aquests conceptes apareixen aplicats en altres parts dels materials:

• Patrons de programació amb LLMs — cobreix la selecció pràctica de models d’embeddings, estratègies de chunking, cerca híbrida i l’ús de Chroma en pipelines RAG.
• Sistemes de recomanació — l’arquitectura two-tower usa embeddings apresos per a usuaris i ítems; la fase de retrieval s’implementa amb ANN sobre els vectors d’ítems precomputats.