Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Amazon Kendra Clasificación inteligente
Amazon Kendra La clasificación inteligente utiliza las capacidades de búsqueda Amazon Kendra semántica para volver a clasificar de forma inteligente los resultados de un servicio de búsqueda.
**Topics**
+ [Amazon Kendra Clasificación inteligente para autogestión OpenSearch](opensearch-rerank.md)
+ [Clasificación semántica de los resultados de un servicio de búsqueda](search-service-rerank.md)
# Amazon Kendra Clasificación inteligente para autogestión OpenSearch
Puedes aprovechar las capacidades Amazon Kendra de búsqueda semántica que ofrece para mejorar los resultados de búsqueda desde [OpenSearch](https://opensearch.org/docs/latest)el servicio de búsqueda autogestionado de código abierto basado en la licencia Apache 2.0. El complemento Amazon Kendra Intelligent Ranking reclasifica OpenSearch semánticamente los resultados utilizando. Amazon Kendra Para ello, comprende el significado y el contexto de una consulta de búsqueda utilizando campos específicos, como el cuerpo o el título del documento, de los resultados de OpenSearch búsqueda predeterminados.
Tomemos, por ejemplo, esta consulta: “dirección principal de la nota clave”. Dado que «dirección» tiene varios significados, Amazon Kendra puede deducir el significado de la consulta para obtener información relevante alineada con el significado deseado. En este contexto, se trata del discurso de apertura de una conferencia. Un servicio de búsqueda más simple podría no tener en cuenta la intención y arrojar resultados para una dirección postal de Main Street, por ejemplo.
El complemento Intelligent Ranking OpenSearch está disponible para la versión 2.4.0 y versiones posteriores OpenSearch (autogestionables). Puedes instalar el complemento mediante un script Bash de inicio rápido para crear una nueva imagen de Docker OpenSearch con el complemento Intelligent Ranking incluido. Vea [Configuración del complemento de búsqueda inteligente](#setup-opensearch-rerank-plugin): este es un ejemplo de una configuración para ponerse en marcha rápidamente.
## Cómo funciona el complemento de búsqueda inteligente
El proceso general del complemento Intelligent Ranking para OpenSearch (autogestionado) es el siguiente:
1. Un OpenSearch usuario realiza una consulta y OpenSearch proporciona una respuesta a la consulta o una lista de documentos que son relevantes para la consulta.
1. El complemento Intelligent Ranking toma la respuesta a la consulta y extrae la información de los documentos.
1. El complemento Intelligent Ranking realiza una llamada a la API [Rescore](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_Rescore.html) de Amazon Kendra Intelligent Ranking.
1. La API `Rescore` toma la información extraída de los documentos y reclasifica semánticamente los resultados de la búsqueda.
1. La API `Rescore` devuelve los resultados de búsqueda reclasificados al complemento. El complemento reorganiza los resultados de la búsqueda en la respuesta de OpenSearch búsqueda para reflejar la nueva clasificación semántica.
El complemento de clasificación inteligente vuelve a clasificar los resultados utilizando los campos “cuerpo” y “título”. Estos campos del plugin se pueden asignar a los campos del OpenSearch índice que mejor se ajusten a la definición de cuerpo y título de un documento. Por ejemplo, si su índice contiene capítulos de un libro con campos como “chapter\$1heading” y “chapter\$1contents”, puede asignar el primero a “title” y el segundo a “body” para obtener los mejores resultados.
## Configuración del complemento de búsqueda inteligente
A continuación, se describe cómo configurarlo rápidamente OpenSearch (autogestionado) con el complemento Intelligent Ranking.
**Configuración OpenSearch (autogestionada) con el complemento Intelligent Ranking (configuración rápida)**
Si ya utilizas la imagen de Docker`opensearch:2.4.0`, puedes usar este [Dockerfile](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#dockerfile-build-opensearch-example) para crear una nueva imagen de la OpenSearch versión 2.4.0 con el complemento Intelligent Ranking. Incluya un contenedor para la nueva imagen en su archivo [docker-compose.yml](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#docker-compose-opensearch-example) u opensearch.yml. También debe incluir el ID del plan de ejecución de rescate generado al crear un plan de ejecución de rescate, junto con la información sobre la región y el punto de conexión; consulte el paso 2 para crear un plan de ejecución de rescate.
Si anteriormente descargó una versión de la imagen de Docker `opensearch` anterior a la 2.4.0, debe usar la imagen de Docker `opensearch:2.4.0` o una versión posterior y crear una nueva imagen con el complemento Intelligent Ranking incluido.
1. Descargue e instale [Docker Desktop](https://docs.docker.com/get-docker/) para su sistema operativo. Docker Desktop incluye Docker Compose y Docker Engine. Se recomienda comprobar si el ordenador cumple los requisitos del sistema mencionados en los detalles de instalación de Docker.
También puede aumentar los requisitos de uso de memoria en la configuración de su escritorio Docker. Usted es responsable de los requisitos de uso de Docker fuera de los límites de uso disponibles de forma gratuita para los servicios de Docker. Consulte las suscripciones de [Docker](https://docs.docker.com/subscription/).
Compruebe que el estado de Docker Desktop es “en ejecución”.
1. [Aprovisione Amazon Kendra Intelligent Ranking y sus requisitos de capacidad.](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html) Una vez que aprovisione Intelligent Ranking Amazon Kendra , se le cobrará por hora en función de las unidades de capacidad establecidas. Consulte la [información sobre los niveles y precios gratuitos](https://aws.amazon.com/kendra/intelligent-ranking-pricing/).
Utiliza la [CreateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_CreateRescoreExecutionPlan.html)API para aprovisionar el`Rescore API`. Si no necesita más unidades de capacidad que la unidad predeterminada, no añada más unidades y proporcione solo un nombre para su plan de ejecución de rescore. También puede actualizar sus requisitos de capacidad mediante la [UpdateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_UpdateRescoreExecutionPlan.html)API. Para más información, consulte [Clasificación semántica de los resultados de un servicio de búsqueda](https://docs.aws.amazon.com/kendra/latest/dg/search-service-rerank.html).
Si lo desea, puede ir al paso 3 para crear un plan de ejecución de rescore predeterminado al ejecutar el script Bash de inicio rápido.
Anote en el paso 4 el identificador del plan de ejecución de rescore incluido en la respuesta.
------
#### [ 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. Descarga el [script de inicio rápido de Bash](https://github.com/opensearch-project/search-processor/tree/main/helpers) GitHub para tu versión de OpenSearch seleccionando la rama de versión en el menú desplegable de la rama principal.
Este script utiliza imágenes de Docker OpenSearch y OpenSearch paneles de control con la versión que haya seleccionado en el GitHub repositorio del script. Descarga un archivo zip para el complemento Intelligent Ranking y genera un archivo `Dockerfile` para crear una nueva imagen de Docker OpenSearch que incluya el complemento. También crea un archivo [docker-compose.yml](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#docker-compose-opensearch-example) que incluye contenedores para OpenSearch el complemento Intelligent Ranking y los paneles de control. OpenSearch El script agrega el ID del plan de ejecución de rescore, la información de la región y el punto final (usa la región) al archivo docker-compose.yml. A continuación, el script se ejecuta `docker-compose up` para iniciar los contenedores con Intelligent Ranking incluido y los paneles de control. OpenSearch OpenSearch Para detener los contenedores sin quitarlos, ejecute `docker-compose stop`. Para retirar los contenedores, ejecute `docker-compose down`.
1. Abra su terminal y en el directorio del script Bash, ejecute el siguiente comando.
```
bash search_processing_kendra_quickstart.sh -p -r
```
Al ejecutar este comando, proporciona el ID del plan de ejecución de rescore que anotó en el paso 2 al aprovisionar Amazon Kendra Intelligent Ranking, junto con la información de su región. Si lo desea, puede aprovisionar Intelligent Ranking Amazon Kendra mediante la opción `--create-execution-plan`. Esto crea un plan de ejecución para volver a puntuar con un nombre y una capacidad predeterminados.
Para no perder el índice cuando se elimine el contenedor efímero predeterminado, puede hacer que el índice se mantenga durante las ejecuciones proporcionando el nombre del volumen de datos mediante la opción `--volume-name`. Si ha creado un índice anteriormente, puede especificar el volumen en el archivo docker-compose.yml u opensearch.yml. Para dejar sus volúmenes intactos, **no** ejecute`docker-compose down -v`.
El script Bash de inicio rápido configura tus AWS credenciales en el OpenSearch almacén de claves para conectarte a Intelligent Ranking. Amazon Kendra Para proporcionar sus AWS credenciales al script, utilice la `--profile` opción para especificar el perfil. AWS Si no se especifica la `--profile` opción, el script Bash de inicio rápido intentará leer AWS las credenciales (clave de acceso/secreta, token de sesión opcional) de las variables de entorno y, a continuación, del perfil predeterminado. AWS Si no se especifica la `--profile` opción y no se encuentra ninguna credencial, el script no pasará las credenciales al almacén de claves. OpenSearch Si no se especifica ninguna [credencial en el OpenSearch almacén de claves, el complemento sigue comprobando las credenciales en la cadena de proveedores de credenciales predeterminada](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-chain.html), incluidas las credenciales de Amazon ECS contenedor o las credenciales de perfil de instancia entregadas a través del Amazon EC2 servicio de metadatos.
Asegúrese de haber creado un IAM rol con los permisos necesarios para invocar Intelligent Ranking Amazon Kendra . El siguiente es un ejemplo de una IAM política que permite el uso de la `Rescore` API para un plan de ejecución de rescore específico:
### Ejemplo de docker-compose.yml
Un ejemplo de un archivo docker-compose.yml que utiliza OpenSearch 2.4.0 o una versión posterior con el complemento Intelligent Ranking y Dashboards 2.4.0 o una versión 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
```
### Ejemplo de un Dockerfile y creación de una imagen
Un ejemplo de uso de la versión 2.4.0 o posterior con el complemento Intelligent `Dockerfile` Ranking. OpenSearch
```
FROM opensearchproject/opensearch:
RUN /usr/share/opensearch/bin/opensearch-plugin install --batch https://github.com/opensearch-project/search-processor/releases/download//search-processor.zip
```
Creación de una imagen de Docker OpenSearch con el complemento Intelligent Ranking.
```
docker build --tag=
```
## Interactuar con el complemento de búsqueda inteligente
Una vez que lo hayas configurado OpenSearch (autogestionado) con el plugin Intelligent Ranking, podrás interactuar con el plugin mediante comandos curl o bibliotecas OpenSearch cliente. Las credenciales predeterminadas para acceder OpenSearch con el complemento Intelligent Ranking son el nombre de usuario «admin» y la contraseña «admin».
Para aplicar la configuración del complemento Intelligent Ranking a un 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)
```
------
Debe incluir el nombre del campo de texto principal que desea utilizar para volver a clasificar, como un campo de cuerpo del documento o de contenido del documento. También puede incluir otros campos de texto, como el título del documento o el resumen del documento.
Ahora puede realizar cualquier consulta y los resultados se clasifican mediante el complemento 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 eliminar la configuración del complemento Intelligent Ranking de un 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 probar el complemento Intelligent Ranking en una consulta determinada o para probarlo en determinados campos del cuerpo y del 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)
```
------
## Comparar OpenSearch los resultados con Amazon Kendra los resultados
Puede comparar los resultados clasificados side-by-side OpenSearch (autogestionados) con Amazon Kendra los resultados reclasificados. OpenSearch La versión 2.4.0 y posteriores de Dashboards ofrecen side-by-side resultados para que puedas comparar la OpenSearch clasificación de los documentos con la forma en que el plugin clasifica los documentos para una consulta de búsqueda. Amazon Kendra
Antes de poder comparar los resultados OpenSearch clasificados con los Amazon Kendra reclasificados, asegúrate de que tus OpenSearch paneles estén respaldados por un OpenSearch servidor con el complemento Intelligent Ranking. Puede configurarlo utilizando Docker y un script Bash de inicio rápido. Consulte [Configuración del complemento de búsqueda inteligente](#setup-opensearch-rerank-plugin).
A continuación, se describe cómo comparar OpenSearch y Amazon Kendra buscar los resultados en OpenSearch los paneles de control. Para obtener más información, consulte la [documentación de OpenSearch](https://opensearch.org/docs/latest/search-plugins/search-relevance).
**Comparación de los resultados de búsqueda en los paneles OpenSearch**
1. Abre http://localhost:5601 e inicia sesión en OpenSearch Dashboards. Las credenciales predeterminadas son el nombre de usuario “admin” y la contraseña “admin”.
1. Selecciona **Relevancia de búsqueda** en los OpenSearch complementos del menú de navegación.
1. Escriba el texto de búsqueda en la barra de búsqueda.
1. Seleccione su índice para la **consulta 1** e introduzca una consulta en la OpenSearch consulta DSL. Puede usar la variable `%SearchText%` para hacer referencia al texto de búsqueda que ingresó en la barra de búsqueda. Para ver un ejemplo de esta consulta, consulte [OpenSearch la documentación](https://opensearch.org/docs/latest/search-plugins/search-relevance/compare-search-results/#reranking-results-with-amazon-kendra-intelligent-ranking-for-opensearch). Los resultados devueltos para esta consulta son los OpenSearch resultados sin utilizar el complemento Intelligent Ranking.
1. Seleccione el mismo índice para la **consulta 2** e introduzca la misma consulta en la OpenSearch consulta DSL. Además, incluya la extensión `kendra_intelligent_ranking` y especifique la extensión obligatoria `body_field` para clasificarla. También puede especificar el campo de título, pero el campo de cuerpo es obligatorio. Para ver un ejemplo de esta consulta, consulte [OpenSearch la documentación](https://opensearch.org/docs/latest/search-plugins/search-relevance/compare-search-results/#reranking-results-with-amazon-kendra-intelligent-ranking-for-opensearch). Los resultados devueltos para esta consulta son los resultados Amazon Kendra reclasificados mediante el complemento Intelligent Ranking. El complemento clasifica hasta 25 resultados.
1. Seleccione **Buscar** para ver y comparar los resultados.
# Clasificación semántica de los resultados de un servicio de búsqueda
Amazon Kendra Intelligent Ranking utiliza Amazon Kendra las capacidades de búsqueda semántica para volver a clasificar los resultados de un servicio de búsqueda. Para ello, tiene en cuenta el contexto de la consulta de búsqueda, además de toda la información disponible en los documentos del servicio de búsqueda. Amazon Kendra La clasificación inteligente puede mejorar la coincidencia sencilla de palabras clave.
La [CreateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_CreateRescoreExecutionPlan.html)API crea un recurso de clasificación Amazon Kendra inteligente que se utiliza para aprovisionar la API [Rescore](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_Rescore.html). La `Rescore` API reclasifica los resultados de búsqueda de un servicio de búsqueda, por ejemplo [OpenSearch (autogestionado](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html)).
Cuando llama a `CreateRescoreExecutionPlan`, establece las unidades de capacidad necesarias para volver a clasificar los resultados de un servicio de búsqueda. Si no necesita más unidades de capacidad que la unidad única por defecto, no la cambie. Proporcione solo un nombre para su plan de ejecución de rescore. Puede establecer hasta 1000 unidades adicionales. Para obtener información sobre lo que incluye una unidad de capacidad única, consulte [Ajustar la capacidad](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html). Una vez que Amazon Kendra aprovisione Intelligent Ranking, se le cobrará por hora en función de las unidades de capacidad establecidas. Consulte la [información sobre los niveles y precios gratuitos](https://aws.amazon.com/kendra/intelligent-ranking-pricing/).
Cuando llama a `CreateRescoreExecutionPlan`, se genera un identificador del plan de ejecución de rescore que se devuelve en la respuesta. La API `Rescore` usa el ID del plan de ejecución de rescore para volver a clasificar los resultados de un servicio de búsqueda según la capacidad que haya establecido. Incluya el ID del plan de ejecución de rescore en los archivos de configuración de su servicio de búsqueda. [Por ejemplo, si usa OpenSearch (autogestionado), incluye el ID del plan de ejecución de rescore en su archivo docker-compose.yml u opensearch.yml; consulte Clasificación inteligente de los resultados (autoservicio). OpenSearch ](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html)
También se genera un nombre de recurso de Amazon (ARN) en la respuesta cuando se llama a `CreateRescoreExecutionPlan`. Puede usar este ARN para crear una política de permisos en AWS Identity and Access Management (IAM) para restringir el acceso de los usuarios a un ARN específico para un plan de ejecución de rescore específico. Si desea ver un ejemplo de una IAM política que permite usar la `Rescore` API para un plan de ejecución de rescore específico, consulte [Amazon Kendra Intelligent](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html) Ranking for self-management. OpenSearch
A continuación se muestra un ejemplo de cómo crear un plan de ejecución de rescore con unidades de capacidad configuradas en 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.");
}
}
```
------
A continuación se muestra un ejemplo de actualización de un plan de ejecución rescore para establecer las unidades de capacidad en 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.");
}
}
```
------
A continuación se muestra un ejemplo de utilización de la 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());
}
}
```
------