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 décrit la compatibilité des versions entre le OpenSearch Service et les différentes versions du plug-in K-nn, ainsi que les limitations 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 pour le plugin, consultez la OpenSearch documentation open source. La documentation open source couvre également le réglage des performances et les paramètres de cluster spécifiques à K-NN.

Utilisez les tableaux suivants pour trouver la version du plug-in K-nn exécutée sur votre domaine Amazon OpenSearch Service. Chaque version du plugin K-nn correspond à une version OpenSearchou à une version d'Elasticsearch.

OpenSearch
OpenSearch version	Version du plug-in k-NN	Fonctions notables
2,13	2.13.0.0
2.11	2.11.0.0	Ajout du support pour les ignore_unmapped requêtes in K-nn
2.9	2.9.0.0	Vecteurs d'octets K-nn implémentés et filtrage efficace avec le moteur Faiss
2.7	2.7.0.0
2,5	2.5.0.0	Extension SystemIndexPlugin pour l'index du système du modèle K-nn, ajout d'extensions de fichiers spécifiques à Lucene au noyau d'HybridFS
2.3	2.3.0.0
1.3	1.3.0.0
1.2	1.2.0.0	Ajout de la prise en charge de la bibliothèque Faiss
1.1	1.1.0.0
1.0	1.0.0.0	Renommé les API REST tout en prenant en charge la compatibilité ascendante, renommé l'espace de noms de opendistro à opensearch

Elasticsearch
Version d'Elasticsearch	Version du plug-in k-NN	Fonctions notables
7.1	1.3.0.0	Distance euclidienne
7.4	1.4.0.0
7.7	1.8.0.0	Similarité cosinus
7.8	1.9.0.0
7,9	1,1,0.0	API de préparation, notation personnalisée
7,10	1,13,0.0	Distance de Hamming, distance de norme L1, scripting indolore

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.

Vérifiez notamment 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 ne pouvez pas migrer un index k-NN vers un stockage à UltraWarmfroid si l'index utilise approximativement k-NN ()"index.knn": true. Si index.knn est réglé sur false (k-NN exact), vous pouvez toujours déplacer l'index vers d'autres niveaux de stockage.