Rechercher et filtrer avec des embeddings vectoriels

Cette page décrit les différentes manières d'interroger des embeddings vectoriels. Pour obtenir une présentation des recherches de similarité ANN et KNN, consultez Recherches vectorielles.

Rechercher les voisins approximatifs les plus proches (ANN)

Pour effectuer une recherche ANN, utilisez la fonction approx_distance dans une clause SELECT et ORDER BY. Vous devez utiliser une clause LIMIT dans une recherche ANN. Vous pouvez également obtenir la valeur de la distance en plaçant approx_distance dans une liste SELECT.

Utilisez la syntaxe suivante pour les requêtes ANN :

# Ordering by distance
SELECT title
FROM books
ORDER BY approx_distance(embedding, string_to_vector('[1,2,3]'), 'distance_measure=l2_squared')
LIMIT 4;

# Selecting the distance value
SELECT
  approx_distance(
    embedding_name,
    string_to_vector('[1,2,3]'),
    'distance_measure=cosine,num_leaves_to_search=3')
    dist
FROM table
ORDER BY dist
LIMIT limit_value;

La fonction approx_distance utilise les options suivantes :

  • embedding : utilise le nom de la colonne d'embedding vectoriel de la table de base.
  • string_to_vector ou vector_to_string : convertit un vecteur en chaîne et une chaîne en vecteur pour rendre le vecteur lisible.
  • distance_measure : spécifiez la mesure de distance à utiliser pour une recherche de similarité vectorielle. Cette valeur doit correspondre à celle que vous avez définie dans le paramètre distance_measure lors de la création de l'index. Ce paramètre est obligatoire. Les valeurs possibles pour ce paramètre sont les suivantes :
    • COSINE
    • L2_SQUARED
    • DOT_PRODUCT
  • num_leaves_to_search : facultatif. Spécifie le nombre de feuilles à vérifier pour une recherche de similarité vectorielle ANN. Si vous ne spécifiez pas le nombre de feuilles, Cloud SQL utilise une valeur générée en fonction de la taille de la table, du nombre de feuilles dans l'index vectoriel et d'autres facteurs. Vous pouvez consulter cette valeur dans information_schema.innodb_vector_indexes. Nous vous recommandons d'affiner num_leaves_to_search pour obtenir le meilleur équilibre entre la qualité de la recherche et les performances pour votre charge de travail spécifique. Si elle est augmentée, cela a un impact sur les performances, mais améliore le rappel.

L'exemple suivant montre comment utiliser approx_distance pour trouver les K lignes les plus proches à l'aide de la mesure de distance l2_squared et comment ordonner les résultats par distance.

# Ordering by distance
SELECT title
FROM books
ORDER BY approx_distance(embedding, string_to_vector('[1,2,3]'),
                         'distance_measure=l2_squared')
LIMIT 4;

# Selecting the distance value
SELECT
    approx_distance
        (embedding, string_to_vector('[1,2,3]'),
         'distance_measure=l2_squared') dist
FROM table
ORDER BY dist
LIMIT 4;

Filtrer les résultats des requêtes approx_distance

Vous pouvez utiliser la fonction approx_distance avec des conditions WHERE qui filtrent les résultats de la requête avec un prédicat non vectoriel pour effectuer un post-filtrage. La fonction approx_distance est évaluée avant l'application du filtre, ce qui signifie que le nombre de résultats renvoyés est non déterministe.

Par exemple, pour la requête suivante :

SELECT id FROM products WHERE price < 100
ORDER BY approx(embedding, @query_vector,'distance_measure=cosine')
LIMIT 11;

La fonction approx_distance renvoie les 11 voisins les plus proches du vecteur de requête, quel que soit le prix. Dans le filtrage post-traitement, les produits dont le prix est inférieur à 100 sont sélectionnés. Il est possible que tous les voisins les plus proches aient un prix inférieur à 100, ce qui donne 11 résultats pour la requête. Si aucun des voisins les plus proches n'a un prix inférieur à 100, aucune ligne n'est renvoyée.

Si vous pensez que votre filtre dans la condition WHERE est très sélectif, une recherche exacte (KNN) peut être une meilleure option pour garantir qu'un nombre suffisant de lignes est renvoyé.

Vérifier l'état de secours dans les recherches ANN

Dans certains cas, une recherche ANN est remplacée par une recherche KNN. En voici quelques exemples :

  • Il n'y a pas d'index vectoriel sur la table de base.
  • Il existe un index vectoriel dans la table de base, mais il utilise une mesure de distance différente de celle du paramètre distance_measure dans les options de recherche approx_distance.
  • L'index vectoriel est corrompu ou invisible pour la transaction actuelle.
  • La valeur LIMIT spécifiée est supérieure à 10 000.
  • Aucune LIMIT n'est spécifiée.
  • La requête actuelle implique plusieurs appels approx_distance sur la même table de base.
  • L'optimiseur estime qu'il est plus efficace d'utiliser KNN.

Dans tous ces cas, un avertissement est envoyé au client pour lui indiquer qu'une recherche exacte a été effectuée et pourquoi.

Utilisez la commande suivante dans le client mysql pour afficher l'état du basculement :

SHOW global status LIKE '%cloudsql_vector_knn_fallback%';

Si vous souhaitez utiliser ANN et que le système revient à KNN, l'exécution de la requête peut être plus lente. Vous devez identifier la raison de cette régression et déterminer si vous devez apporter des modifications pour que le réseau ANN soit utilisé à la place.

Exemple : Créer un index vectoriel et exécuter une requête ANN

L'exemple de tutoriel suivant décrit la procédure à suivre pour créer un index vectoriel et exécuter une requête ANN dans Cloud SQL.

  1. Générer des embeddings vectoriels Vous pouvez créer des embeddings vectoriels manuellement ou utiliser l'API d'embedding de texte de votre choix. Pour obtenir un exemple utilisant Vertex AI, consultez Générer des embeddings vectoriels basés sur des données de ligne.

  2. Créez une table dans Cloud SQL contenant une colonne d'embeddings vectoriels à trois dimensions.

    CREATE TABLE books(
id INTEGER PRIMARY KEY AUTO_INCREMENT, title VARCHAR(60), embedding VECTOR(3) USING VARBINARY);

  3. Insérez un embedding vectoriel dans la colonne.

    INSERT INTO books VALUES ((1, 'book title', string_to_vector('[1,2,3]')));

  4. Effectuez un commit sur les modifications :

    commit;

  5. Créez l'index vectoriel à l'aide de la fonction L2_squared pour mesurer la distance.

    CREATE
  VECTOR INDEX vectorIndex
ON dbname.books(embeddings)
USING SCANN QUANTIZER = SQ8 DISTANCE_MEASURE = l2_squared;

  6. Utilisez la syntaxe suivante pour effectuer une recherche ANN avec un LIMIT de quatre résultats de recherche :

    SELECT title
FROM books
ORDER BY approx_distance(embedding, string_to_vector('[1,2,3]'), 'distance_measure=l2_squared')
LIMIT 4;

SELECT approx_distance(embedding, string_to_vector('[1,2,3]'), 'distance_measure=cosine') dist
FROM books
ORDER BY dist
LIMIT 4;

Recherche des k plus proches voisins (KNN)

Pour effectuer une recherche des k plus proches voisins, utilisez la fonction vector_distance avec une option de mesure de distance et une fonction de conversion de vecteur (string_to_vector ou vector_to_string) dans une instruction SELECT. Utilisez la syntaxe suivante :

SELECT vector_distance(string_to_vector('[1,2,3]'),
                      string_to_vector('[1,2,3]'),
                      'Distance_Measure=dot_product');

Remplacez les valeurs [1,2,3] par les valeurs d'intégration de vos données.

L'exemple suivant montre comment utiliser cette requête avec la fonction cosine_distance et la fonction de conversion de vecteur string_to_vector.

SELECT id,cosine_distance(embedding, string_to_vector('[1,2,3]')) dist
FROM books
ORDER BY distance
LIMIT 10;

Obtenir la distance de cosinus dans une requête KNN

Utilisez la fonction cosine_distance de Cloud SQL pour calculer la distance à l'aide du cosinus.

SELECT cosine_distance(embedding, string_to_vector('[3,1,2]')) AS distance FROM books WHERE id = 10;

Obtenir la distance de produit scalaire dans une requête KNN

Utilisez la fonction dot_product de Cloud SQL pour calculer la distance à l'aide du produit scalaire.

SELECT dot_product(embedding, string_to_vector('[3,1,2]')) AS distance FROM books WHERE id = 10;

Obtenir la distance L2 au carré dans une requête KNN

Utilisez la fonction l2_squared_distance de Cloud SQL pour calculer la distance à l'aide de la norme L2 au carré.

SELECT
  l2_squared_distance(embedding, string_to_vector('[3,1,2]'))
    AS distance
FROM books
WHERE id = 10;

Étapes suivantes