As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Amazon Kendra Classificação inteligente para autogestão OpenSearch
Você pode aproveitar os recursos Amazon Kendra de pesquisa semântica do Apache 2.0 para melhorar os resultados de [OpenSearch](https://opensearch.org/docs/latest)pesquisa do serviço de pesquisa autogerenciado de código aberto baseado na Licença Apache 2.0. O plugin Amazon Kendra Intelligent Ranking reclassifica semanticamente os resultados OpenSearch usando. Amazon Kendra Ele faz isso entendendo o significado e o contexto de uma consulta de pesquisa usando campos específicos, como o corpo ou o título do documento, a partir dos resultados de OpenSearch pesquisa padrão.
Veja, por exemplo, esta consulta: “endereço principal da palestra”. Como “endereço” tem vários significados, é Amazon Kendra possível inferir o significado por trás da consulta para retornar informações relevantes alinhadas com o significado pretendido. Nesse contexto, é um discurso de abertura da conferência. Um serviço de pesquisa mais simples pode não levar em conta a intenção e possivelmente retornar resultados para um endereço na Main Street, por exemplo.
O plug-in Intelligent Ranking para OpenSearch está disponível para a versão 2.4.0 OpenSearch (autogerenciada) e posterior. Você pode instalar o plug-in usando um script Bash de início rápido para criar uma nova imagem do Docker OpenSearch com o plug-in Intelligent Ranking incluído. Veja o [Configurando o plug-in de pesquisa inteligente](#setup-opensearch-rerank-plugin). Ele é um exemplo de configuração para você começar a trabalhar rapidamente.
## Como funciona o plug-in de pesquisa inteligente
O processo geral do plugin Intelligent Ranking para OpenSearch (autogerenciado) é o seguinte:
1. Um OpenSearch usuário emite uma consulta e OpenSearch fornece uma resposta à consulta ou uma lista de documentos que são relevantes para a consulta.
1. O plug-in do Intelligent Ranking pega a resposta da consulta e extrai informações dos documentos.
1. O plugin Intelligent Ranking faz uma chamada para a API [Rescore](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_Rescore.html) do Amazon Kendra Intelligent Ranking.
1. A API `Rescore` pega as informações extraídas dos documentos e reclassifica semanticamente os resultados da pesquisa.
1. A API `Rescore` envia os resultados da pesquisa reclassificados de volta ao plug-in. O plug-in reorganiza os resultados da pesquisa na resposta da OpenSearch pesquisa para refletir a nova classificação semântica.
O plugin Intelligent Ranking reclassifica os resultados usando os campos “corpo” e “título”. Esses campos de plug-in podem ser mapeados para campos em seu OpenSearch índice que melhor se ajustem à definição de corpo e título de um documento. Por exemplo, o índice contém capítulos de um livro com campos como “chapter\$1title” e “chapter\$1contents”, mepeie primeiro para “título” e depois o “corpo” para obter os melhores resultados.
## Configurando o plug-in de pesquisa inteligente
A seguir, descrevemos como configurar rapidamente OpenSearch (autogerenciado) com o plug-in Intelligent Ranking.
**Configuração OpenSearch (autogerenciada) com o plug-in Intelligent Ranking (configuração rápida)**
Se você já estiver usando a imagem do Docker`opensearch:2.4.0`, poderá usar esse [Dockerfile](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#dockerfile-build-opensearch-example) para criar uma nova imagem da versão OpenSearch 2.4.0 com o plug-in Intelligent Ranking. Você inclui um contêiner para a nova imagem no arquivo [docker-compose.yml](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#docker-compose-opensearch-example) ou no arquivo opensearch.yml. Você também inclui o ID do plano de execução de repontuação gerado pela criação de um plano de execução de repontuação, junto com as informações da região e do endpoint. Consulte a etapa 2 para criar um plano de execução de repontuação.
Se você já baixou uma versão da imagem do Docker `opensearch` anterior à 2.4.0, você deve usar a imagem do Docker `opensearch:2.4.0` ou posterior e criar uma nova imagem com o plug-in do Intelligent Ranking incluído.
1. Baixe e instale o [Docker Desktop](https://docs.docker.com/get-docker/) para seu sistema operacional. O Docker Desktop inclui o Docker Compose e o Docker Engine. É recomendável verificar se o computador atende aos requisitos de sistema mencionados nos detalhes de instalação do Docker.
Você também pode aumentar os requisitos de uso de memória nas configurações do Docker Desktop. Você é responsável pelos requisitos de uso do Docker fora dos limites de uso disponíveis gratuitamente para os serviços do Docker. Consulte as [assinaturas do Docker](https://docs.docker.com/subscription/).
Verifique se o status do Docker Desktop está “em execução”.
1. Provisione o Amazon Kendra Intelligent Ranking e seus requisitos [de capacidade](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html). Depois de provisionar o Intelligent Ranking do Amazon Kendra , você é cobrado por hora com base nas unidades de capacidade definidas. Veja as [informações sobre o nível gratuito e os preços](https://aws.amazon.com/kendra/intelligent-ranking-pricing/).
Você usa a [CreateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_CreateRescoreExecutionPlan.html)API para provisionar `Rescore API` o. Se não precisar de mais unidades de capacidade do que a unidade padrão, não adicione mais unidades e forneça apenas um nome para o plano de execução de repontuação. Você também pode atualizar seus requisitos de capacidade usando a [UpdateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_UpdateRescoreExecutionPlan.html)API. Para obter mais informações, consulte [Classificação semântica dos resultados de um serviço de pesquisa](https://docs.aws.amazon.com/kendra/latest/dg/search-service-rerank.html).
Opcionalmente, vá para a etapa 3 para criar um plano de execução de repontuação padrão ao executar o script Bash de início rápido.
Para a etapa 4, o ID do plano de execução de repontuação está incluído na resposta.
------
#### [ CLI ]
```
aws kendra-ranking create-rescore-execution-plan \
--name MyRescoreExecutionPlan \
--capacity-units '{"RescoreCapacityUnits":}'
Response:
{
"Id": "",
"Arn": "arn:aws:kendra-ranking:::rescore-execution-plan/"
}
```
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import pprint
import time
kendra_ranking = boto3.client("kendra-ranking")
print("Create a rescore execution plan.")
# Provide a name for the rescore execution plan
name = "MyRescoreExecutionPlan"
# Set your required additional capacity units
# Don't set capacity units if you don't require more than 1 unit given by default
capacity_units = 1
try:
rescore_execution_plan_response = kendra_ranking.create_rescore_execution_plan(
Name = name,
CapacityUnits = {"RescoreCapacityUnits":capacity_units}
)
pprint.pprint(rescore_execution_plan_response)
rescore_execution_plan_id = rescore_execution_plan_response["Id"]
print("Wait for Amazon Kendra to create the rescore execution plan.")
while True:
# Get the details of the rescore execution plan, such as the status
rescore_execution_plan_description = kendra_ranking.describe_rescore_execution_plan(
Id = rescore_execution_plan_id
)
# When status is not CREATING quit.
status = rescore_execution_plan_description["Status"]
print(" Creating rescore execution plan. Status: "+status)
time.sleep(60)
if status != "CREATING":
break
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
1. Baixe o [script Bash de início rápido](https://github.com/opensearch-project/search-processor/tree/main/helpers) GitHub para sua versão do OpenSearch selecionando a ramificação da versão no menu suspenso da ramificação principal.
Esse script usa imagens do Docker OpenSearch e OpenSearch painéis usando a versão que você selecionou no GitHub repositório para o script. Ele baixa um arquivo zip para o plug-in Intelligent Ranking e gera um `Dockerfile` para criar uma nova imagem do Docker OpenSearch que inclua o plug-in. Ele também cria um arquivo [docker-compose.yml](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#docker-compose-opensearch-example) que inclui contêineres OpenSearch com o plug-in e os painéis do Intelligent Ranking. OpenSearch O script adiciona o ID do plano de execução do rescore, as informações da região e o endpoint (usa a região) ao arquivo docker-compose.yml. Em seguida, o script é executado `docker-compose up` para iniciar os contêineres OpenSearch com o Intelligent Ranking incluído e os OpenSearch painéis. Para parar os contêineres sem removê-los, execute `docker-compose stop`. Para remover os contêineres, execute `docker-compose down`.
1. Abra o terminal e, no diretório do script Bash, execute o seguinte comando:
```
bash search_processing_kendra_quickstart.sh -p -r
```
Ao executar esse comando, você fornece o ID do plano de execução de rescore que você anotou na etapa 2 ao provisionar o Amazon Kendra Intelligent Ranking, junto com as informações da sua região. Opcionalmente, você pode provisionar o Intelligent Ranking do Amazon Kendra usando a opção `--create-execution-plan`. Isso cria um plano de execução de repontuação com nome e capacidade padrão.
Para não perder seu índice quando o contêiner temporário padrão for removido, você pode fazer com que seu índice persista em todas as execuções fornecendo o nome do volume de dados usando a opção `--volume-name`. Se você criou um índice anteriormente, pode especificar o volume no arquivo docker-compose.yml ou opensearch.yml. Para deixar os volumes intactos, **não** execute`docker-compose down -v`.
O script Bash de início rápido configura suas AWS credenciais no OpenSearch armazenamento de chaves para se conectar ao Intelligent Ranking. Amazon Kendra Para fornecer suas AWS credenciais ao script, use a `--profile` opção para especificar o AWS perfil. Se a `--profile` opção não for especificada, o script Bash de início rápido tentará ler as AWS credenciais (chave de acesso/secreta, token de sessão opcional) das variáveis de ambiente e, em seguida, do perfil padrão. AWS Se a `--profile` opção não for especificada e nenhuma credencial for encontrada, o script não passará as credenciais para o OpenSearch armazenamento de chaves. Se nenhuma credencial for especificada no OpenSearch repositório de chaves, o plug-in ainda verificará as credenciais na [cadeia de fornecedores de credenciais padrão, incluindo credenciais](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-chain.html) de Amazon ECS contêiner ou credenciais de perfil de instância fornecidas pelo serviço de metadados. Amazon EC2
Certifique-se de ter criado uma IAM função com as permissões necessárias para invocar o Amazon Kendra Intelligent Ranking. Veja a seguir um exemplo de uma IAM política para conceder permissão para usar a `Rescore` API para um plano de execução de rescore específico:
### Exemplo de docker-compose.yml
Um exemplo de um arquivo docker-compose.yml usando OpenSearch 2.4.0 ou posterior com o plug-in Intelligent Ranking e o Dashboards 2.4.0 ou posterior. OpenSearch
```
version: '3'
networks:
opensearch-net:
volumes:
:
services:
opensearch-node:
image:
container_name: opensearch-node
environment:
- cluster.name=opensearch-cluster
- node.name=opensearch-node
- discovery.type=single-node
- kendra_intelligent_ranking.service.endpoint=https://kendra-ranking..api.aws
- kendra_intelligent_ranking.service.region=
- kendra_intelligent_ranking.service.execution_plan_id=
ulimits:
memlock:
soft: -1
hard: -1
nofile:
soft: 65536
hard: 65536
ports:
- 9200:9200
- 9600:9600
networks:
- opensearch-net
volumes:
:/usr/share/opensearch/data
opensearch-dashboard:
image: opensearchproject/opensearch-dashboards:
container_name: opensearch-dashboards
ports:
- 5601:5601
environment:
OPENSEARCH_HOSTS: '["https://opensearch-node:9200"]'
networks:
- opensearch-net
```
### Exemplo de um Dockerfile e construção de uma imagem
Um exemplo de um `Dockerfile` para usar a OpenSearch versão 2.4.0 ou posterior com o plug-in Intelligent Ranking.
```
FROM opensearchproject/opensearch:
RUN /usr/share/opensearch/bin/opensearch-plugin install --batch https://github.com/opensearch-project/search-processor/releases/download//search-processor.zip
```
Construindo uma imagem do Docker OpenSearch com o plug-in Intelligent Ranking.
```
docker build --tag=
```
## Interagindo com o plug-in de pesquisa inteligente
Depois de configurar OpenSearch (autogerenciado) com o plug-in Intelligent Ranking, você pode interagir com o plug-in usando comandos curl ou bibliotecas de OpenSearch clientes. As credenciais padrão para acesso OpenSearch com o plug-in Intelligent Ranking são o nome de usuário 'admin' e a senha 'admin'.
Para aplicar as configurações do plug-in Intelligent Ranking a um OpenSearch índice:
------
#### [ Curl ]
```
curl -XPUT "https://localhost:9200//_settings" -u 'admin:admin' --insecure -H 'Content-Type: application/json' -d'
{
"index": {
"plugin" : {
"searchrelevance" : {
"result_transformer" : {
"kendra_intelligent_ranking": {
"order": 1,
"properties": {
"title_field": "title_field_name_here",
"body_field": "body_field_name_here"
}
}
}
}
}
}
}
'
```
------
#### [ Python ]
```
pip install opensearch-py
from opensearchpy import OpenSearch
host = 'localhost'
port = 9200
auth = ('admin', 'admin')
client = OpenSearch(
hosts = [{'host': host, 'port': port}],
http_compress = True, # enables gzip compression for request bodies
http_auth = auth,
# client_cert = client_cert_path,
# client_key = client_key_path,
use_ssl = True,
verify_certs = False,
ssl_assert_hostname = False,
ssl_show_warn = False,
ca_certs = ca_certs_path
)
setting_body = {
"index": {
"plugin" : {
"searchrelevance" : {
"result_transformer" : {
"kendra_intelligent_ranking": {
"order": 1,
"properties": {
"title_field": "title_field_name_here",
"body_field": "body_field_name_here"
}
}
}
}
}
}
}
response = client.indices.put_settings(index_name, body=setting_body)
```
------
Você deve incluir o nome do campo de texto principal que deseja usar para se reclassificar, como o corpo do documento ou o campo de conteúdo do documento. Você também pode incluir outros campos de texto, como título do documento ou resumo do documento.
Agora você pode emitir qualquer consulta e os resultados são classificados usando o plug-in do Intelligent Ranking.
------
#### [ Curl ]
```
curl -XGET "https://localhost:9200//_search?pretty" -u 'admin:admin' --insecure -H 'Content-Type: application/json' -d'
{
"query" : {
"match" : {
"body_field_name_here": "intelligent systems"
}
}
}
'
```
------
#### [ Python ]
```
from opensearchpy import OpenSearch
host = 'localhost'
port = 9200
auth = ('admin', 'admin')
client = OpenSearch(
hosts = [{'host': host, 'port': port}],
http_compress = True, # enables gzip compression for request bodies
http_auth = auth,
# client_cert = client_cert_path,
# client_key = client_key_path,
use_ssl = True,
verify_certs = False,
ssl_assert_hostname = False,
ssl_show_warn = False,
ca_certs = ca_certs_path
)
query = {
'size': 10,
"query" : {
"match" : {
"body_field_name_here": "intelligent systems"
}
}
}
response = client.search(
body = query,
index = index_name
)
print('\nSearch results:')
print(response)
```
------
Para remover as configurações do plug-in Intelligent Ranking de um OpenSearch índice:
------
#### [ Curl ]
```
curl -XPUT "http://localhost:9200//_settings" -H 'Content-Type: application/json' -d'
{
"index": {
"plugin": {
"searchrelevance": {
"result_transformer": {
"kendra_intelligent_ranking.*": null
}
}
}
}
}
'
```
------
#### [ Python ]
```
from opensearchpy import OpenSearch
host = 'localhost'
port = 9200
auth = ('admin', 'admin')
client = OpenSearch(
hosts = [{'host': host, 'port': port}],
http_compress = True, # enables gzip compression for request bodies
http_auth = auth,
# client_cert = client_cert_path,
# client_key = client_key_path,
use_ssl = True,
verify_certs = False,
ssl_assert_hostname = False,
ssl_show_warn = False,
ca_certs = ca_certs_path
)
setting_body = {
"index": {
"plugin": {
"searchrelevance": {
"result_transformer": {
"kendra_intelligent_ranking.*": null
}
}
}
}
}
response = client.indices.put_settings(index_name, body=setting_body)
```
------
Para testar o plug-in do Intelligent Ranking em uma determinada consulta ou para testar em determinados campos de corpo e título:
------
#### [ Curl ]
```
curl -XGET "https://localhost:9200//_search?pretty" -u 'admin:admin' --insecure -H 'Content-Type: application/json' -d'
{
"query": {
"multi-match": {
"query": "intelligent systems",
"fields": ["body_field_name_here", "title_field_name_here"]
}
},
"size": 25,
"ext": {
"search_configuration": {
"result_transformer": {
"kendra_intelligent_ranking": {
"order": 1,
"properties": {
"title_field": "title_field_name_here",
"body_field": "body_field_name_here"
}
}
}
}
}
}
'
```
------
#### [ Python ]
```
from opensearchpy import OpenSearch
host = 'localhost'
port = 9200
auth = ('admin', 'admin')
client = OpenSearch(
hosts = [{'host': host, 'port': port}],
http_compress = True, # enables gzip compression for request bodies
http_auth = auth,
# client_cert = client_cert_path,
# client_key = client_key_path,
use_ssl = True,
verify_certs = False,
ssl_assert_hostname = False,
ssl_show_warn = False,
ca_certs = ca_certs_path
)
# Index settings null for kendra_intelligent_ranking
query = {
"query": {
"multi_match": {
"query": "intelligent systems",
"fields": ["body_field_name_here", "title_field_name_here"]
}
},
"size": 25,
"ext": {
"search_configuration": {
"result_transformer": {
"kendra_intelligent_ranking": {
"order": 1,
"properties": {
"title_field": "title_field_name_here",
"body_field": "body_field_name_here"
}
}
}
}
}
}
response = client.search(
body = query,
index = index_name
)
print('\nSearch results:')
print(response)
```
------
## Comparando OpenSearch resultados com Amazon Kendra resultados
Você pode comparar os resultados classificados side-by-side OpenSearch (autogerenciados) com Amazon Kendra os resultados reclassificados. OpenSearch A versão 2.4.0 e posterior do Dashboards oferece side-by-side resultados para que você possa comparar como OpenSearch classifica os documentos com a forma como Amazon Kendra o plug-in classifica os documentos para uma consulta de pesquisa.
Antes de comparar os resultados OpenSearch classificados com os resultados Amazon Kendra reclassificados, certifique-se de que seus OpenSearch painéis sejam apoiados por um OpenSearch servidor com o plug-in Intelligent Ranking. Você pode configurar isso usando o Docker e um script Bash de início rápido. Consulte [Configurando o plug-in de pesquisa inteligente](#setup-opensearch-rerank-plugin).
A seguir, descrevemos como comparar OpenSearch e Amazon Kendra pesquisar resultados em OpenSearch painéis. Para obter mais informações, consulte a [documentação da OpenSearch](https://opensearch.org/docs/latest/search-plugins/search-relevance).
**Comparando resultados de pesquisa em OpenSearch painéis**
1. Abra http://localhost:5601 e faça login nos OpenSearch painéis. As credenciais padrão são o nome de usuário e senha “admin”.
1. Selecione **Relevância da pesquisa** nos OpenSearch plug-ins no menu de navegação.
1. Insira o texto de pesquisa na barra de pesquisa.
1. Selecione seu índice para a **Consulta 1** e insira uma OpenSearch consulta na Consulta DSL. Você pode usar a variável `%SearchText%` para se referir ao texto de pesquisa inserido na barra de pesquisa. Para ver um exemplo dessa consulta, consulte a [OpenSearch documentação](https://opensearch.org/docs/latest/search-plugins/search-relevance/compare-search-results/#reranking-results-with-amazon-kendra-intelligent-ranking-for-opensearch). Os resultados retornados para essa consulta são os OpenSearch resultados sem o uso do plug-in Intelligent Ranking.
1. Selecione o mesmo índice para a **Consulta 2** e insira a mesma OpenSearch consulta na Consulta DSL. Além disso, inclua a extensão `kendra_intelligent_ranking` e especifique a obrigatoriedade na qual `body_field` para se classificar. Você também pode especificar o campo do título, mas o campo do corpo é obrigatório. Para ver um exemplo dessa consulta, consulte a [OpenSearch documentação](https://opensearch.org/docs/latest/search-plugins/search-relevance/compare-search-results/#reranking-results-with-amazon-kendra-intelligent-ranking-for-opensearch). Os resultados retornados para essa consulta são os resultados Amazon Kendra reclassificados usando o plug-in Intelligent Ranking. O plugin classifica até 25 resultados.
1. Selecione **Pesquisar** para retornar e comparar os resultados.