Cette page explique comment effectuer une recherche vectorielle de similarité Spanner en utilisant la distance de cosinus, la distance euclidienne et le point les fonctions de vecteur de produit pour trouver les K voisins les plus proches. 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 de cosinus: mesure le cosinus de l'angle entre deux vecteurs.
- Produit scalaire: calcule le
cosinus de l'angle multiplié par le produit du vecteur correspondant
grandeurs. Si vous savez que toutes les représentations vectorielles continues
de votre ensemble de données
vous pouvez utiliser
DOT_PRODUCT()
comme fonction de distance. - Voisins les plus proches KNN: un algorithme de machine learning supervisé utilisé pour résoudre les problèmes de régression.
Vous pouvez utiliser des fonctions de distance vectorielle pour effectuer des KNN les plus proches voisins
recherche vectorielle pour des cas d'utilisation tels que la recherche par similarité ou la récupération augmentée
génération. Spanner est compatible avec les COSINE_DISTANCE()
,
Les fonctions EUCLIDEAN_DISTANCE()
et DOT_PRODUCT()
, qui opèrent sur des vecteurs
ce qui vous permet de trouver le KNN de la représentation vectorielle continue d'entrée.
Par exemple, après avoir généré et enregistré votre instance Spanner opérationnelle sous forme de représentations vectorielles continues, vous pouvez ensuite fournissez 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 un espace à N dimensions pour trouver des valeurs sémantiquement similaires ou d'articles associés.
Les trois fonctions de distance utilisent les arguments vector1
et vector2
, qui
sont de type array<>
, doivent avoir les mêmes dimensions et avoir le
de même durée. Pour en savoir plus sur ces fonctions, consultez les pages suivantes:
COSINE_DISTANCE()
dans GoogleSQLEUCLIDEAN_DISTANCE()
dans GoogleSQLDOT_PRODUCT()
dans GoogleSQL- Fonctions mathématiques dans PostgreSQL
(
spanner.cosine_distance()
,spanner.euclidean_distance()
etspanner.dot_product()
) - Choisissez une fonction de distance vectorielle pour mesurer la similarité des représentations vectorielles continues.
Examples
Les exemples suivants illustrent la recherche KNN, la recherche KNN sur des données partitionnées et à l'aide d'un index secondaire avec KNN.
Les exemples utilisent tous EUCLIDEAN_DISTANCE()
. Vous pouvez également utiliser
COSINE_DISTANCE()
En outre, si toutes les représentations vectorielles continues de votre ensemble de données
sont normalisées, vous pouvez utiliser DOT_PRODUCT()
comme fonction de distance.
Exemple 1: recherche KNN
Prenons l'exemple d'une table Documents
comportant une colonne (DocEmbedding
) de données précalculées
des représentations vectorielles continues de texte de la colonne DocContents
octets.
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 primary key,
DocId bigint primary key,
Author varchar(1024),
DocContents bytea,
DocEmbedding float4[]
);
Supposons qu'une représentation vectorielle continue d'entrée pour « baseball, mais pas baseball professionnel »
est le tableau [0.3, 0.3, 0.7, 0.7]
, vous pouvez trouver les cinq documents les plus proches
qui correspondent, par 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
La requête de l'exemple précédent peut être modifiée en ajoutant des conditions à la
WHERE
pour limiter la recherche vectorielle à un sous-ensemble de vos données. Une approche
Cela permet d'effectuer des recherches sur des données partitionnées, telles que les 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 clause WHERE
que vous utilisez ne fait pas partie de la clé primaire de la table,
vous pouvez créer un index secondaire pour accélérer l'opération avec une
analyse d'index 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
Apprenez-en plus sur les fonctions GoogleSQL
COSINE_DISTANCE()
,EUCLIDEAN_DISTANCE()
etDOT_PRODUCT()
.Apprenez-en plus sur les fonctions PostgreSQL
spanner.cosine_distance()
,spanner.euclidean_distance()
etspanner.dot_product()
.Découvrez comment choisir parmi les fonctions de distance vectorielle pour mesurer la similarité des représentations vectorielles continues.