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
Amazon Kendra O Intelligent Ranking usa recursos de pesquisa Amazon Kendra semântica para reclassificar de forma inteligente os resultados de um serviço de pesquisa.
**Topics**
+ [Amazon Kendra Classificação inteligente para autogestão OpenSearch](opensearch-rerank.md)
+ [Classificando semanticamente os resultados de um serviço de pesquisa](search-service-rerank.md)
# 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.
# Classificando semanticamente os resultados de um serviço de pesquisa
Amazon Kendra O Intelligent Ranking usa Amazon Kendra os recursos de pesquisa semântica para reclassificar os resultados de um serviço de pesquisa. Ele faz isso levando em consideração o contexto da consulta de pesquisa, além de todas as informações disponíveis nos documentos do serviço de pesquisa. Amazon Kendra A classificação inteligente pode melhorar a correspondência simples de palavras-chave.
A [CreateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_CreateRescoreExecutionPlan.html)API cria um recurso de classificação Amazon Kendra inteligente usado para provisionar a API [Rescore](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_Rescore.html). A `Rescore` API reclassifica os resultados da pesquisa de um serviço de pesquisa, como [OpenSearch (autogerenciado)](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html).
Ao chamar `CreateRescoreExecutionPlan`, você define as unidades de capacidade necessárias para reclassificar os resultados de um serviço de pesquisa. Se você não precisar de mais unidades de capacidade além do padrão de unidade única, não altere o padrão. Forneça somente um nome para seu plano de execução de repontuação. É possível configurar até 1000 unidades extras. Para obter informações sobre o que está incluído em uma única unidade de capacidade, consulte [Ajustando a capacidade](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html). Depois de provisionar o Amazon Kendra Intelligent Ranking, 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/).
Um ID do plano de execução de repontuação é gerado e retornado na resposta quando você chama `CreateRescoreExecutionPlan`. A API `Rescore` usa o ID do plano de execução de repontuação para reclassificar os resultados de um serviço de pesquisa usando a capacidade definida. Você inclui o ID do plano de execução de repontuação nos arquivos de configuração do serviço de pesquisa. [Por exemplo, se você usa OpenSearch (autogerenciado), inclui o ID do plano de execução de rescore em seu arquivo docker-compose.yml ou opensearch.yml — consulte Resultados de classificação inteligente (autoatendimento). OpenSearch ](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html)
Um nome do recurso da Amazon (ARN) também é gerado na resposta ao chamar `CreateRescoreExecutionPlan`. Você pode usar esse ARN para criar uma política de permissões em AWS Identity and Access Management (IAM) para restringir o acesso do usuário a um ARN específico para um plano de execução de rescore específico. Para ver um exemplo de IAM política para conceder permissão para usar a `Rescore` API para um plano de execução de rescore específico, consulte [Classificação Amazon Kendra inteligente para OpenSearch autogerenciamento](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html).
Veja a seguir um exemplo de criação de um plano de execução de repontuação com unidades de capacidade definidas como 1.
------
#### [ CLI ]
```
aws kendra-ranking create-rescore-execution-plan \
--name MyRescoreExecutionPlan \
--capacity-units '{"RescoreCapacityUnits":1}'
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.")
```
------
#### [ Java ]
```
import java.util.concurrent.TimeUnit;
import software.amazon.awssdk.services.kendraranking.KendraRankingClient;
import software.amazon.awssdk.services.kendraranking.model.CapacityUnitsConfiguration;
import software.amazon.awssdk.services.kendraranking.model.CreateRescoreExecutionPlanRequest;
import software.amazon.awssdk.services.kendraranking.model.CreateRescoreExecutionPlanResponse;
import software.amazon.awssdk.services.kendraranking.model.DescribeRescoreExecutionPlanRequest;
import software.amazon.awssdk.services.kendraranking.model.DescribeRescoreExecutionPlanResponse;
import software.amazon.awssdk.services.kendraranking.model.RescoreExecutionPlanStatus;
public class CreateRescoreExecutionPlanExample {
public static void main(String[] args) throws InterruptedException {
String rescoreExecutionPlanName = "MyRescoreExecutionPlan";
int capacityUnits = 1;
KendraRankingClient kendraRankingClient = KendraRankingClient.builder().build();
System.out.println(String.format("Creating a rescore execution plan named %s", rescoreExecutionPlanName));
CreateRescoreExecutionPlanResponse createResponse = kendraRankingClient.createRescoreExecutionPlan(
CreateRescoreExecutionPlanRequest.builder()
.name(rescoreExecutionPlanName)
.capacityUnits(
CapacityUnitsConfiguration.builder()
.rescoreCapacityUnits(capacityUnits)
.build()
)
.build()
);
String rescoreExecutionPlanId = createResponse.id();
System.out.println(String.format("Waiting for rescore execution plan with id %s to finish creating.", rescoreExecutionPlanId));
while (true) {
DescribeRescoreExecutionPlanResponse describeResponse = kendraRankingClient.describeRescoreExecutionPlan(
DescribeRescoreExecutionPlanRequest.builder()
.id(rescoreExecutionPlanId)
.build()
);
RescoreExecutionPlanStatus rescoreExecutionPlanStatus = describeResponse.status();
if (rescoreExecutionPlanStatus != RescoreExecutionPlanStatus.CREATING) {
break;
}
TimeUnit.SECONDS.sleep(60);
}
System.out.println("Rescore execution plan creation is complete.");
}
}
```
------
Veja a seguir um exemplo de atualização de um plano de execução de repontuação para definir unidades de capacidade como 2.
------
#### [ CLI ]
```
aws kendra-ranking update-rescore-execution-plan \
--id \
--capacity-units '{"RescoreCapacityUnits":2}'
```
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import pprint
import time
kendra_ranking = boto3.client("kendra-ranking")
print("Update a rescore execution plan.")
# Provide the ID of the rescore execution plan
id =
# Re-set your required additional capacity units
capacity_units = 2
try:
kendra_ranking.update_rescore_execution_plan(
Id = id,
CapacityUnits = {"RescoreCapacityUnits":capacity_units}
)
print("Wait for Amazon Kendra to update 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 = id
)
# When status is not UPDATING quit.
status = rescore_execution_plan_description["Status"]
print(" Updating rescore execution plan. Status: "+status)
time.sleep(60)
if status != "UPDATING":
break
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
#### [ Java ]
```
import java.util.concurrent.TimeUnit;
import software.amazon.awssdk.services.kendraranking.KendraRankingClient;
import software.amazon.awssdk.services.kendraranking.model.CapacityUnitsConfiguration;
import software.amazon.awssdk.services.kendraranking.model.DescribeRescoreExecutionPlanRequest;
import software.amazon.awssdk.services.kendraranking.model.DescribeRescoreExecutionPlanResponse;
import software.amazon.awssdk.services.kendraranking.model.RescoreExecutionPlanStatus;
import software.amazon.awssdk.services.kendraranking.model.UpdateRescoreExecutionPlanRequest;
import software.amazon.awssdk.services.kendraranking.model.UpdateRescoreExecutionPlanResponse;
public class UpdateRescoreExecutionPlanExample {
public static void main(String[] args) throws InterruptedException {
String rescoreExecutionPlanId = ;
int newCapacityUnits = 2;
KendraRankingClient kendraRankingClient = KendraRankingClient.builder().build();
System.out.println(String.format("Updating a rescore execution plan named %s", rescoreExecutionPlanId));
UpdateRescoreExecutionPlanResponse updateResponse = kendraRankingClient.updateRescoreExecutionPlan(
UpdateRescoreExecutionPlanRequest.builder()
.id(rescoreExecutionPlanId)
.capacityUnits(
CapacityUnitsConfiguration.builder()
.rescoreCapacityUnits(newCapacityUnits)
.build()
)
.build()
);
System.out.println(String.format("Waiting for rescore execution plan with id %s to finish updating.", rescoreExecutionPlanId));
while (true) {
DescribeRescoreExecutionPlanResponse describeResponse = kendraRankingClient.describeRescoreExecutionPlan(
DescribeRescoreExecutionPlanRequest.builder()
.id(rescoreExecutionPlanId)
.build()
);
RescoreExecutionPlanStatus rescoreExecutionPlanStatus = describeResponse.status();
if (rescoreExecutionPlanStatus != RescoreExecutionPlanStatus.UPDATING) {
break;
}
TimeUnit.SECONDS.sleep(60);
}
System.out.println("Rescore execution plan update is complete.");
}
}
```
------
Veja a seguir um exemplo de uso da API `Rescore`.
------
#### [ CLI ]
```
aws kendra-ranking rescore \
--rescore-execution-plan-id \
--search-query "intelligent systems" \
--documents "[{\"Id\": \"DocId1\",\"Title\": \"Smart systems\", \"Body\": \"intelligent systems in everyday life\",\"OriginalScore\": 2.0}, {\"Id\": \"DocId2\",\"Title\": \"Smarter systems\", \"Body\": \"living with intelligent systems\",\"OriginalScore\": 1.0}]"
```
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import pprint
kendra_ranking = boto3.client("kendra-ranking")
print("Use the Rescore API.")
# Provide the ID of the rescore execution plan
id =
# The search query from the search service
query = "intelligent systems"
# The list of documents for Intelligent Ranking to rescore
document_list = [
{"Id": "DocId1", "Title": "Smart systems", "Body": "intelligent systems in everyday life", "OriginalScore": 2.0},
{"Id": "DocId2", "Title": "Smarter systems", "Body": "living with intelligent systems", "OriginalScore": 1.0}
]
try:
rescore_response = kendra_ranking.rescore(
rescore_execution_plan_id = id,
search_query = query,
documents = document_list
)
print(rescore_response["RescoreId"])
print(rescore_resposne["ResultItems"])
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
#### [ Java ]
```
import java.util.ArrayList;
import java.util.List;
import software.amazon.awssdk.services.kendraranking.KendraRankingClient;
import software.amazon.awssdk.services.kendraranking.model.RescoreRequest;
import software.amazon.awssdk.services.kendraranking.model.RescoreResponse;
import software.amazon.awssdk.services.kendraranking.model.Document;
public class RescoreExample {
public static void main(String[] args) {
String rescoreExecutionPlanId = ;
String query = "intelligent systems";
List documentList = new ArrayList<>();
documentList.add(
Document.builder()
.id("DocId1")
.originalScore(2.0F)
.body("intelligent systems in everyday life")
.title("Smart systems")
.build()
);
documentList.add(
Document.builder()
.id("DocId2")
.originalScore(1.0F)
.body("living with intelligent systems")
.title("Smarter systems")
.build()
);
KendraRankingClient kendraRankingClient = KendraRankingClient.builder().build();
RescoreResponse rescoreResponse = kendraRankingClient.rescore(
RescoreRequest.builder()
.rescoreExecutionPlanId(rescoreExecutionPlanId)
.searchQuery(query)
.documents(documentList)
.build()
);
System.out.println(rescoreResponse.rescoreId());
System.out.println(rescoreResponse.resultItems());
}
}
```
------