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 à sonder 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, elle 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_distance(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-requête, 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. En revanche, 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 vous aider à vous assurer qu'un nombre suffisant de lignes est renvoyé.

Vous pouvez également utiliser le filtrage itératif pour analyser une plus grande partie de l'index de recherche ANN.

Utiliser le filtrage itératif pour améliorer les résultats de recherche ANN

Vous pouvez utiliser le filtrage itératif lorsque les filtres sélectifs de la clause WHERE de votre requête de recherche ANN produisent moins de résultats que le nombre de résultats spécifié dans votre clause LIMIT.

Par exemple, dans la requête suivante, lorsque vous activez le filtrage itératif, la requête analyse une plus grande partie de l'index vectoriel, moins le premier ensemble de résultats filtrés.

EXPLAIN FORMAT=TREE
SELECT * FROM t1 WHERE next_id BETWEEN 15 AND 100
ORDER BY approx_distance(embedding, string_to_vector('[1,2,3]'), 'distance_measure=l2_squared')
LIMIT 10;

EXPLAIN
-> Limit: 10 row(s)  (rows=10)
   -> Vector index loop with iterative filtering
      -> Vector index scan on t1
      -> Filter: (t1.next_id between 15 and 100)
         -> Single-row index lookup on t1 using PRIMARY (id=t1.id)

Vous récupérez plus de voisins à partir de l'index de vecteurs de recherche de manière itérative jusqu'à ce que le maximum configuré (cloudsql_vector_iterative_filtering_max_neighbors) soit atteint. Toutes les correspondances de filtres sont comptabilisées dans LIMIT et supprimées des analyses supplémentaires de l'index vectoriel.

Activer le filtrage itératif

Par défaut, le filtrage itératif est désactivé pour toutes les sessions et instances Cloud SQL.

Pour activer le filtrage itératif pour une session existante, utilisez l'instruction SQL suivante.

SET SESSION cloudsql_vector_iterative_filtering=on;

Vous pouvez également activer le filtrage itératif de manière globale pour toutes les sessions client qui se connectent à l'instance en définissant le flag sur l'instance. Pour définir un indicateur pour une instance, consultez Définir une option de base de données.

Pour en savoir plus sur la définition des variables système au niveau de la session ou au niveau global, consultez Utiliser des variables système dans la documentation MySQL.

Ajuster le filtrage itératif

Pour contrôler le nombre de voisins les plus proches renvoyés pour une requête de recherche ANN avec filtrage itératif activé, vous pouvez utiliser la variable système globale ou de session cloudsql_vector_iterative_filtering_max_neighbors. Vous pouvez utiliser cette configuration pour augmenter le nombre de voisins les plus proches demandés. Toutefois, pour éviter de stocker trop de résultats en mémoire, la valeur maximale de cette variable est 1000.

Pour définir cette variable pour une session, utilisez l'instruction SQL suivante :

SET cloudsql_vector_iterative_filtering_max_neighbors=600;

La valeur par défaut est 500 et le nombre minimal est 10.

Limites

Voici les limites de l'utilisation du filtrage itératif :

  • Non garanti : lorsque vous utilisez le filtrage itératif, Cloud SQL tente de trouver le nombre de résultats spécifié dans la clause LIMIT, mais ne garantit pas que ce nombre sera trouvé. Cela peut se produire si le nombre maximal de voisins (cloudsql_vector_iterative_filtering_max_neighbors) est atteint avant que LIMIT ne soit satisfait, ou s'il n'y a pas assez de lignes correspondant au filtre dans le tableau.

  • Requêtes complexes : le filtrage itératif ne fonctionne que lorsque les prédicats de filtre sont transférés vers le chemin d'accès de la table de base. Il n'est pas compatible avec les filtres appliqués aux tables temporaires, par exemple les tables qui utilisent une clause HAVING. Dans les sous-requêtes, seuls les filtres appliqués à la table de base au sein de la sous-requête elle-même sont pris en compte pour le filtrage itératif.

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 sur la table de base, mais il utilise une mesure de distance différente 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, il est possible que la requête s'exécute plus lentement. 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