Effectuer une recherche de similarité vectorielle dans Spanner en recherchant les k plus proches voisins

Cette page explique comment effectuer une recherche de similarité vectorielle dans Spanner à l'aide des fonctions de distance cosinus, de distance euclidienne et de produit scalaire pour trouver les voisins les plus proches. Ces informations s'appliquent aux bases de données en dialecte GoogleSQL et en dialecte PostgreSQL. Avant de lire cette page, il est important que vous compreniez les concepts suivants:

  • Distance euclidienne : mesure la distance la plus courte entre deux vecteurs.
  • Distance cosinus : mesure le cosinus de l'angle entre deux vecteurs.
  • Produit scalaire: calcule le cosinus de l'angle multiplié par le produit des grandeurs vectorielles correspondantes. Si vous savez que toutes les représentations vectorielles continues de votre ensemble de données sont normalisées, vous pouvez utiliser DOT_PRODUCT() comme fonction de distance.
  • K-plus proches voisins (KNN) : algorithme de machine learning supervisé utilisé pour résoudre des problèmes de classification ou de régression.

Vous pouvez utiliser des fonctions de distance vectorielle pour effectuer une recherche vectorielle des k plus proches voisins (KNN) pour des cas d'utilisation tels que la recherche de similarité ou la génération augmentée par récupération. Spanner est compatible avec les fonctions COSINE_DISTANCE(), EUCLIDEAN_DISTANCE() et DOT_PRODUCT(), qui fonctionnent sur des représentations vectorielles continues, ce qui vous permet de trouver le KNN de l'embedding d'entrée.

Par exemple, après avoir généré et enregistré vos données opérationnelles Spanner en tant que représentations vectorielles continues, vous pouvez fournir ces représentations vectorielles continues en tant que paramètre d'entrée dans votre requête pour trouver les vecteurs les plus proches dans l'espace N-dimensionnel afin de rechercher des éléments sémantiquement similaires ou associés.

Les trois fonctions de distance acceptent les arguments vector1 et vector2, qui sont de type array<>, et doivent avoir les mêmes dimensions et la même longueur. Pour en savoir plus sur ces fonctions, consultez les pages suivantes:

Examples

Les exemples suivants montrent la recherche KNN, la recherche KNN sur des données partitionnées et l'utilisation d'un indice secondaire avec KNN.

Les exemples utilisent tous EUCLIDEAN_DISTANCE(). Vous pouvez également utiliser COSINE_DISTANCE(). De plus, si tous les représentations vectorielles continues de votre ensemble de données sont normalisées, vous pouvez utiliser DOT_PRODUCT() comme fonction de distance.

Prenons l'exemple d'une table Documents qui contient une colonne (DocEmbedding) d'embeddings de texte précalculés à partir de la colonne d'octets DocContents.

GoogleSQL 

CREATE TABLE Documents (
UserId       INT64 NOT NULL,
DocId        INT64 NOT NULL,
Author       STRING(1024),
DocContents  BYTES,
DocEmbedding ARRAY<FLOAT32>
) PRIMARY KEY (UserId, DocId);

PostgreSQL 

CREATE TABLE Documents (
UserId       bigint NOT NULL,
DocId        bigint NOT NULL,
Author       varchar(1024),
DocContents  bytea,
DocEmbedding float4[],
PRIMARY KEY  (UserId, DocId)
);

En supposant qu'un entraînement d'entrée pour "baseball, mais pas le baseball professionnel" est le tableau [0.3, 0.3, 0.7, 0.7], vous pouvez trouver les cinq premiers documents les plus proches qui correspondent, avec la requête suivante:

GoogleSQL 

SELECT DocId, DocEmbedding FROM Documents
ORDER BY EUCLIDEAN_DISTANCE(DocEmbedding,
ARRAY<FLOAT32>[0.3, 0.3, 0.7, 0.8])
LIMIT 5;

PostgreSQL 

SELECT DocId, DocEmbedding FROM Documents
ORDER BY spanner.euclidean_distance(DocEmbedding,
'{0.3, 0.3, 0.7, 0.8}'::float4[])
LIMIT 5;

Résultats attendus de cet exemple:

Documents
+---------------------------+-----------------+
| DocId                     | DocEmbedding    |
+---------------------------+-----------------+
| 24                        | [8, ...]        |
+---------------------------+-----------------+
| 25                        | [6, ...]        |
+---------------------------+-----------------+
| 26                        | [3.2, ...]      |
+---------------------------+-----------------+
| 27                        | [38, ...]       |
+---------------------------+-----------------+
| 14229                     | [1.6, ...]      |
+---------------------------+-----------------+

Exemple 2: Recherche KNN sur des données partitionnées

Vous pouvez modifier la requête de l'exemple précédent en ajoutant des conditions à la clause WHERE pour limiter la recherche vectorielle à un sous-ensemble de vos données. Une application courante de cette approche consiste à effectuer une recherche sur des données partitionnées, telles que des lignes appartenant à un UserId spécifique.

GoogleSQL 

SELECT UserId, DocId, DocEmbedding FROM Documents
WHERE UserId=18
ORDER BY EUCLIDEAN_DISTANCE(DocEmbedding,
ARRAY<FLOAT32>[0.3, 0.3, 0.7, 0.8])
LIMIT 5;

PostgreSQL 

SELECT UserId, DocId, DocEmbedding FROM Documents
WHERE UserId=18
ORDER BY spanner.euclidean_distance(DocEmbedding,
'{0.3, 0.3, 0.7, 0.8}'::float4[])
LIMIT 5;

Résultats attendus de cet exemple:

Documents
+-----------+-----------------+-----------------+
| UserId    | DocId           | DocEmbedding    |
+-----------+-----------------+-----------------+
| 18        | 234             | [12, ...]       |
+-----------+-----------------+-----------------+
| 18        | 12              | [1.6, ...]      |
+-----------+-----------------+-----------------+
| 18        | 321             | [22, ...]       |
+-----------+-----------------+-----------------+
| 18        | 432             | [3, ...]        |
+-----------+-----------------+-----------------+

Exemple 3: Recherche KNN sur des plages d'index secondaires

Si le filtre de la clause WHERE que vous utilisez ne fait pas partie de la clé primaire de la table, vous pouvez créer un indice secondaire pour accélérer l'opération à l'aide d'un repérage par indice uniquement.

GoogleSQL 

CREATE INDEX DocsByAuthor
ON Documents(Author)
STORING (DocEmbedding);

SELECT Author, DocId, DocEmbedding FROM Documents
WHERE Author="Mark Twain"
ORDER BY EUCLIDEAN_DISTANCE(DocEmbedding,
   <embeddings for "book about the time traveling American">)
LIMIT 5;

PostgreSQL 

CREATE INDEX DocsByAuthor
ON Documents(Author)
INCLUDE (DocEmbedding);

SELECT Author, DocId, DocEmbedding FROM Documents
WHERE Author="Mark Twain"
ORDER BY spanner.euclidean_distance(DocEmbedding,
   <embeddings for "that book about the time traveling American">)
LIMIT 5;

Résultats attendus de cet exemple:

Documents
+------------+-----------------+-----------------+
| Author     | DocId           | DocEmbedding    |
+------------+-----------------+-----------------+
| Mark Twain | 234             | [12, ...]       |
+------------+-----------------+-----------------+
| Mark Twain | 12              | [1.6, ...]      |
+------------+-----------------+-----------------+
| Mark Twain | 321             | [22, ...]       |
+------------+-----------------+-----------------+
| Mark Twain | 432             | [3, ...]        |
+------------+-----------------+-----------------+
| Mark Twain | 375             | [9, ...]        |
+------------+-----------------+-----------------+

Étape suivante