Pesquisa de K-Nearest Neighbor (k-NN) no Amazon Service OpenSearch

Abreviação do algoritmo associado de k-vizinhos mais próximos, o k-NN for Amazon OpenSearch Service permite pesquisar pontos em um espaço vetorial e encontrar os “vizinhos mais próximos” desses pontos por distância euclidiana ou similaridade de cosseno. Os casos de uso incluem recomendações (por exemplo, um recurso de “outras músicas que você pode gostar” em um aplicativo de música), reconhecimento de imagem e detecção de fraudes.

nota

Esta documentação descreve a compatibilidade de versões entre o OpenSearch Serviço e várias versões do plug-in k-NN, bem como as limitações ao usar o plug-in com o Serviço gerenciado OpenSearch . Para obter uma documentação abrangente do plug-in k-NN, incluindo exemplos simples e complexos, referências de parâmetros e a referência completa da API para o plug-in, consulte a documentação de código OpenSearch aberto. A documentação de código aberto também abrange o ajuste de desempenho e as configurações de cluster específicas do K-NN.

Use as tabelas a seguir para encontrar a versão do plug-in k-NN em execução no seu domínio do Amazon OpenSearch Service. Cada versão do plug-in k-NN corresponde a uma versão OpenSearchou Elasticsearch.

OpenSearch
OpenSearch versão	Versão do plug-in k-NN	Recursos notáveis
2.13	2.13.0.0
2.11	2.11.0.0	Suporte adicionado para ignore_unmapped em consultas k-NN
2.9	2.9.0.0	Implementou vetores de bytes k-NN e filtragem eficiente com o mecanismo Faiss
2.7	2.7.0.0
2,5	2.5.0.0	Estendido SystemIndexPlugin para o índice de sistema do modelo k-NN, adicionou extensões de arquivo específicas do Lucene ao núcleo do HybridFS
2.3	2.3.0.0
1.3	1.3.0.0
1.2	1.2.0.0	Adicionado suporte para a biblioteca Faiss
1.1	1.1.0.0
1,0	1.0.0.0	Renomeação das APIs REST em termpos de compatibilidade com versões anteriores, renomeação do namespace de opendistro para opensearch

Elasticsearch
Versão do Elasticsearch	Versão do plug-in k-NN	Recursos notáveis
7.1	1.3.0.0	Distância euclidiana
7.4	1.4.0.0
7.7	1.8.0.0	Similaridade de cossenos
7.8	1.9.0.0
7.9	1.11.0.0	API de Warmup, pontuação personalizada
7.10	1.13.0.0	Distância de Hamming, distância L1 Norm, desenvolvimento de scripts Painless

Conceitos básicos do k-NN

Para usar o k-NN, é necessário criar um índice com a configuração index.knn e adicionar um ou mais campos do tipo de dados 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
      }
    }
  }
}

O tipo de dados knn_vector oferece suporte a uma única lista de até 10.000 flutuantes, com o número de flutuantes definido pelo parâmetro dimension. Depois de criar o índice, adicione alguns dados a ele.

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 }

Em seguida, você poderá pesquisar os dados usando o tipo de consulta knn.

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

Nesse caso, k é o número de vizinhos a serem retornados pela consulta, mas também é necessário incluir a opção size. Caso contrário, você obterá k resultados para cada fragmento (e cada segmento) em vez de k resultados para toda a consulta. O k-NN oferece suporte a um valor de k máximo de 10.000.

Se você misturar a consulta knn com outras cláusulas, poderá receber menos do que k resultados. Neste exemplo, a cláusula post_filter reduz o número de resultados de 2 para 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
      }
    }
  }
}

Se precisar lidar com um grande volume de consultas e, ao mesmo tempo, manter o desempenho ideal, você pode usar a API _msearch para criar uma pesquisa em massa com JSON e enviar uma única solicitação para realizar várias pesquisas:

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 }} } }

O vídeo a seguir demonstra como configurar pesquisas vetoriais em massa para consultas K-NN.

Diferenças, ajustes e limitações do k-NN

OpenSearch permite que você modifique todas as configurações do k-NN usando a _cluster/settings API. No OpenSearch Serviço, você pode alterar todas as configurações, exceto knn.memory.circuit_breaker.enabled knn.circuit_breaker.triggered e. As estatísticas k-NN são incluídas como métricas da Amazon CloudWatch .

Em particular, verifique a KNNGraphMemoryUsage métrica em cada nó de dados em relação à knn.memory.circuit_breaker.limit estatística e à RAM disponível para o tipo de instância. OpenSearch O serviço usa metade da RAM de uma instância para o heap Java (até um tamanho de heap de 32 GiB). Por padrão, o k-NN usa até 50% da metade restante, portanto, um tipo de instância com 32 GiB de RAM pode acomodar 8 GiB de gráficos (32 * 0,5 * 0,5). A performance poderá ser prejudicada se o uso da memória do gráfico exceder esse valor.

Você não pode migrar um índice k-NN para UltraWarmum armazenamento refrigerado se o índice usar k-NN () aproximado. "index.knn": true Se index.knn estiver definido como false (k-NN exato), ainda é possível mover o índice para outros níveis de armazenamento.