Recherche du voisin le plus proche (K-nn) dans Amazon Service OpenSearch

Abréviation de son algorithme associé aux k-voisins les plus proches, k-NN pour Amazon OpenSearch Service vous permet de rechercher des points dans un espace vectoriel et de trouver les « voisins les plus proches » pour ces points en fonction de la distance euclidienne ou de la similitude des cosinus. Les cas d'utilisation incluent des recommandations (par exemple, une fonctionnalité « autres chansons que vous pourriez aimer » dans une application musicale), la reconnaissance d'images et la détection des fraudes.

Note

Cette documentation fournit un bref aperçu du plug-in K-nn, ainsi que des limites liées à l'utilisation du plug-in avec un OpenSearch service géré. Pour une documentation complète du plug-in K-nn, y compris des exemples simples et complexes, des références de paramètres et la référence complète de l'API, consultez la OpenSearchdocumentation open source. La documentation open source couvre également le réglage des performances et les paramètres k-NN-specific du cluster.

Prise en main de k-NN

Pour utiliser k-NN, vous devez créer un index avec le paramètre index.knn et ajouter un ou plusieurs champs du type de données knn_vector.

PUT my-index
{
  "settings": {
    "index.knn": true
  },
  "mappings": {
    "properties": {
      "my_vector1": {
        "type": "knn_vector",
        "dimension": 2
      },
      "my_vector2": {
        "type": "knn_vector",
        "dimension": 4
      }
    }
  }
}

Le type de données knn_vector prend en charge une seule liste de 10 000 nombres à virgule flottante maximum, dont le nombre est défini par le paramètre dimension requis. Après avoir créé l'index, ajoutez-y des données.

POST _bulk
{ "index": { "_index": "my-index", "_id": "1" } }
{ "my_vector1": [1.5, 2.5], "price": 12.2 }
{ "index": { "_index": "my-index", "_id": "2" } }
{ "my_vector1": [2.5, 3.5], "price": 7.1 }
{ "index": { "_index": "my-index", "_id": "3" } }
{ "my_vector1": [3.5, 4.5], "price": 12.9 }
{ "index": { "_index": "my-index", "_id": "4" } }
{ "my_vector1": [5.5, 6.5], "price": 1.2 }
{ "index": { "_index": "my-index", "_id": "5" } }
{ "my_vector1": [4.5, 5.5], "price": 3.7 }
{ "index": { "_index": "my-index", "_id": "6" } }
{ "my_vector2": [1.5, 5.5, 4.5, 6.4], "price": 10.3 }
{ "index": { "_index": "my-index", "_id": "7" } }
{ "my_vector2": [2.5, 3.5, 5.6, 6.7], "price": 5.5 }
{ "index": { "_index": "my-index", "_id": "8" } }
{ "my_vector2": [4.5, 5.5, 6.7, 3.7], "price": 4.4 }
{ "index": { "_index": "my-index", "_id": "9" } }
{ "my_vector2": [1.5, 5.5, 4.5, 6.4], "price": 8.9 }

Vous pouvez alors rechercher les données en utilisant le type de requête knn.

GET my-index/_search
{
  "size": 2,
  "query": {
    "knn": {
      "my_vector2": {
        "vector": [2, 3, 5, 6],
        "k": 2
      }
    }
  }
}

Dans ce cas, k est le nombre de voisins que vous voulez que la requête renvoie, mais vous devez également inclure l’option size. Sinon, vous obtenez des résultats k pour chaque partition (et chaque segment) plutôt que des résultats k pour l'ensemble de la requête. k-NN prend en charge une valeur k maximale de 10 000.

Si vous combinez la requête knn avec d'autres clauses, vous pouvez recevoir moins de résultats que k. Dans cet exemple, la clause post_filter réduit le nombre de résultats de 2 à 1.

GET my-index/_search
{
  "size": 2,
  "query": {
    "knn": {
      "my_vector2": {
        "vector": [2, 3, 5, 6],
        "k": 2
      }
    }
  },
  "post_filter": {
    "range": {
      "price": {
        "gte": 6,
        "lte": 10
      }
    }
  }
}

Si vous devez gérer un volume important de requêtes tout en maintenant des performances optimales, vous pouvez utiliser l'_msearchAPI pour créer une recherche groupée avec JSON et envoyer une seule requête pour effectuer plusieurs recherches :

GET _msearch
{ "index": "my-index"}
{ "query": { "knn": {"my_vector2":{"vector": [2, 3, 5, 6],"k":2 }} } }
{ "index": "my-index", "search_type": "dfs_query_then_fetch"}
{ "query": { "knn": {"my_vector1":{"vector": [2, 3],"k":2 }} } }

La vidéo suivante montre comment configurer des recherches vectorielles groupées pour les requêtes K-NN.

Différences, réglage et limitations de k-NN

OpenSearch vous permet de modifier tous les paramètres K-nn à l'aide de l'_cluster/settingsAPI. Sur OpenSearch Service, vous pouvez modifier tous les paramètres sauf knn.memory.circuit_breaker.enabled etknn.circuit_breaker.triggered. Les statistiques k-NN sont incluses en tant que CloudWatch métriques Amazon.

En particulier, vérifiez la KNNGraphMemoryUsage métrique de chaque nœud de données par rapport à la knn.memory.circuit_breaker.limit statistique et à la RAM disponible pour le type d'instance. OpenSearch Le service utilise la moitié de la RAM d'une instance pour le tas Java (jusqu'à une taille de segment de 32 GiB). Par défaut, k-NN utilise jusqu'à 50 % de la moitié restante, de sorte qu'un type d'instance doté de 32 Gio de RAM peut accueillir 8 Gio de graphiques (32 * 0,5 * 0,5). Les performances peuvent baisser si l'utilisation de la mémoire graphique est supérieure à cette valeur.

Vous pouvez migrer un index K-nn créé sur la version 2.x ou ultérieure vers un domaine doté de la version 2.17 UltraWarmou ultérieure ou un stockage à froid sur un domaine.

L'API de suppression du cache et les API d'échauffement pour les indices K-nn sont bloquées pour les indices chauds. Lorsque la première requête est lancée pour l'index, elle télécharge les fichiers graphiques depuis Amazon S3 et charge le graphe en mémoire. De même, lorsque le TTL est expiré pour les graphes, les fichiers sont automatiquement expulsés de la mémoire.