Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Amazon Kendra Classificazione intelligente
Amazon Kendra Intelligent Ranking utilizza funzionalità di ricerca Amazon Kendra semantica per riclassificare in modo intelligente i risultati di un servizio di ricerca.
**Topics**
+ [Amazon Kendra Classificazione intelligente per l'autogestione OpenSearch](opensearch-rerank.md)
+ [Classificazione semantica dei risultati di un servizio di ricerca](search-service-rerank.md)
# Amazon Kendra Classificazione intelligente per l'autogestione OpenSearch
Puoi sfruttare le funzionalità Amazon Kendra di ricerca semantica di cui dispone per migliorare i risultati di ricerca grazie al servizio di [OpenSearch](https://opensearch.org/docs/latest)ricerca open source autogestito basato sulla licenza Apache 2.0. Il plugin Amazon Kendra Intelligent Ranking rielabora semanticamente i risultati utilizzando. OpenSearch Amazon Kendra Lo fa comprendendo il significato e il contesto di una query di ricerca utilizzando campi specifici, come il corpo o il titolo del documento, dai risultati di ricerca predefiniti. OpenSearch
Prendiamo, ad esempio, questa query: «indirizzo principale del keynote». Poiché 'indirizzo' ha diversi significati, Amazon Kendra può dedurre il significato alla base della query per restituire informazioni pertinenti in linea con il significato previsto. In questo contesto, si tratta di un discorso programmatico alla conferenza. Un servizio di ricerca più semplice potrebbe non tenere conto dell'intento e potrebbe restituire risultati per un indirizzo su Main Street, ad esempio.
Il plugin Intelligent Ranking per OpenSearch è disponibile per la versione OpenSearch (autogestita) 2.4.0 e successive. È possibile installare il plug-in utilizzando uno script Bash di avvio rapido per creare una nuova immagine Docker OpenSearch con il plug-in Intelligent Ranking incluso. Vedi[Configurazione del plug-in di ricerca intelligente](#setup-opensearch-rerank-plugin): questo è un esempio di configurazione per renderti operativo rapidamente.
## Come funziona il plugin di ricerca intelligente
Il processo complessivo del plugin Intelligent Ranking for OpenSearch (autogestito) è il seguente:
1. Un OpenSearch utente invia una query e OpenSearch fornisce una risposta alla query o un elenco di documenti pertinenti alla query.
1. Il plugin Intelligent Ranking prende la risposta alla query ed estrae le informazioni dai documenti.
1. Il plug-in Intelligent Ranking effettua una chiamata all'API Rescore di Amazon Kendra Intelligent [Ranking.](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_Rescore.html)
1. L'`Rescore`API prende le informazioni estratte dai documenti e riordina semanticamente i risultati della ricerca.
1. L'`Rescore`API invia i risultati della ricerca riclassificati al plugin. Il plugin riorganizza i risultati della ricerca nella risposta di OpenSearch ricerca per riflettere la nuova classificazione semantica.
Il plugin Intelligent Ranking riclassifica i risultati utilizzando i campi «body» e «title». Questi campi del plug-in possono essere mappati sui campi OpenSearch dell'indice che meglio si adattano alla definizione del corpo e del titolo del documento. Ad esempio, se l'indice contiene capitoli di un libro con campi come «chapter\$1heading» e «chapter\$1contents», puoi mappare il primo a «title» e il secondo a «body» per ottenere i migliori risultati.
## Configurazione del plug-in di ricerca intelligente
Di seguito viene descritto come eseguire una configurazione rapida OpenSearch (autogestita) con il plug-in Intelligent Ranking.
**Configurazione OpenSearch (autogestita) con il plug-in Intelligent Ranking (configurazione rapida)**
Se stai già utilizzando l'immagine Docker`opensearch:2.4.0`, puoi utilizzare questo [Dockerfile](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#dockerfile-build-opensearch-example) per creare una nuova immagine di OpenSearch 2.4.0 con il plug-in Intelligent Ranking. Includi un contenitore per la nuova immagine nel file [docker-compose.yml o nel file opensearch.yml.](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#docker-compose-opensearch-example) Includi anche l'ID del piano di esecuzione di rescore generato dalla creazione di un piano di esecuzione di rescore, insieme alle informazioni sulla regione e sull'endpoint. Vedi il passaggio 2 per creare un piano di esecuzione di rescore.
Se in precedenza hai scaricato una versione dell'immagine `opensearch` Docker precedente alla 2.4.0, devi utilizzare l'immagine Docker `opensearch:2.4.0` o una versione successiva e creare una nuova immagine con il plug-in Intelligent Ranking incluso.
1. Scarica e installa [Docker Desktop](https://docs.docker.com/get-docker/) per il tuo sistema operativo. Docker Desktop include Docker Compose e Docker Engine. Si consiglia di verificare se il computer soddisfa i requisiti di sistema indicati nei dettagli di installazione di Docker.
Puoi anche aumentare i requisiti di utilizzo della memoria all'interno delle impostazioni del tuo Docker Desktop. Sei responsabile dei requisiti di utilizzo di Docker al di fuori dei limiti di utilizzo disponibili gratuitamente per i servizi Docker. Vedi gli abbonamenti [Docker](https://docs.docker.com/subscription/).
Verifica che lo stato di Docker Desktop sia «in esecuzione».
1. Fornisci Amazon Kendra Intelligent Ranking e i tuoi requisiti [di capacità](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html). Una volta effettuato il provisioning di Amazon Kendra Intelligent Ranking, ti verrà addebitato ogni ora in base alle unità di capacità impostate. Consulta le [informazioni sul piano gratuito e sui prezzi](https://aws.amazon.com/kendra/intelligent-ranking-pricing/).
Utilizzi l'[CreateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_CreateRescoreExecutionPlan.html)API per fornire il`Rescore API`. Se non hai bisogno di più unità di capacità rispetto alla singola unità predefinita, non aggiungere altre unità e fornisci solo un nome per il tuo piano di esecuzione di rescore. Puoi anche aggiornare i requisiti di capacità utilizzando l'[UpdateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_UpdateRescoreExecutionPlan.html)API. Per ulteriori informazioni, consulta [Classificazione semantica dei risultati di un servizio di ricerca](https://docs.aws.amazon.com/kendra/latest/dg/search-service-rerank.html).
Facoltativamente, puoi andare al passaggio 3 per creare un piano di esecuzione di rescore predefinito quando esegui lo script Bash di avvio rapido.
Nota per il passaggio 4 l'ID del piano di esecuzione di rescore incluso nella risposta.
------
#### [ 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. Scarica lo [script Bash di avvio rapido](https://github.com/opensearch-project/search-processor/tree/main/helpers) da GitHub per la tua versione di OpenSearch selezionando il ramo della versione dal menu a discesa del ramo principale.
Questo script utilizza immagini Docker OpenSearch e OpenSearch dashboard che utilizzano la versione selezionata nel GitHub repository per lo script. Scarica un file zip per il plug-in Intelligent Ranking e genera un file `Dockerfile` per creare una nuova immagine Docker OpenSearch che includa il plug-in. Crea anche un file [docker-compose.yml](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html#docker-compose-opensearch-example) che include contenitori per il plug-in Intelligent Ranking e OpenSearch le dashboard. OpenSearch Lo script aggiunge l'ID del piano di esecuzione di rescore, le informazioni sulla regione e l'endpoint (utilizza la regione) al file docker-compose.yml. Lo script viene quindi eseguito `docker-compose up` per avviare i contenitori per Intelligent Ranking incluso e Dashboards. OpenSearch OpenSearch Per fermare i contenitori senza rimuoverli, `docker-compose stop` esegui. Per rimuovere i contenitori, esegui`docker-compose down`.
1. Apri il tuo terminale e nella directory dello script Bash, esegui il seguente comando.
```
bash search_processing_kendra_quickstart.sh -p -r
```
Quando esegui questo comando, fornisci l'ID del piano di esecuzione di rescore che hai annotato nel passaggio 2 durante il provisioning di Amazon Kendra Intelligent Ranking, insieme alle informazioni sulla tua regione. Facoltativamente, puoi invece fornire Amazon Kendra Intelligent Ranking utilizzando l'opzione. `--create-execution-plan` Questo crea un piano di esecuzione di rescore con un nome e una capacità predefiniti.
Per non perdere l'indice quando il contenitore temporaneo predefinito viene rimosso, puoi fare in modo che l'indice persista tra le esecuzioni fornendo il nome del volume di dati utilizzando l'opzione. `--volume-name` Se in precedenza hai creato un indice, puoi specificare il volume nel tuo file docker-compose.yml o opensearch.yml. Per lasciare **`docker-compose down -v`intatti** i volumi, non eseguirli.
Lo script Bash di avvio rapido configura AWS le credenziali nel OpenSearch keystore per la connessione a Intelligent Ranking. Amazon Kendra Per fornire le AWS credenziali allo script, utilizzate l'`--profile`opzione per specificare il profilo. AWS Se l'`--profile`opzione non è specificata, lo script Bash di avvio rapido tenta di leggere AWS le credenziali (chiave di accesso/segreta, token di sessione opzionale) dalle variabili di ambiente e quindi dal profilo predefinito. AWS Se l'`--profile`opzione non è specificata e non viene trovata alcuna credenziale, lo script non passerà le credenziali al keystore. OpenSearch Se non viene specificata alcuna credenziale nel OpenSearch keystore, il plug-in controlla comunque le credenziali nella [catena di provider di credenziali di default, incluse le credenziali del Amazon ECS contenitore o le credenziali](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-chain.html) del profilo di istanza fornite tramite il servizio di metadati. Amazon EC2
Assicurati di aver creato un IAM ruolo con le autorizzazioni necessarie per richiamare Intelligent Ranking. Amazon Kendra Di seguito è riportato un esempio di IAM politica per concedere l'autorizzazione all'uso dell'`Rescore`API per uno specifico piano di esecuzione di rescore:
### Esempio di docker-compose.yml
Un esempio di file docker-compose.yml che utilizza OpenSearch 2.4.0 o versione successiva con il plug-in Intelligent Ranking e Dashboards 2.4.0 o versione successiva. 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
```
### Esempio di Dockerfile e creazione di un'immagine
Un esempio di utilizzo della OpenSearch versione 2.4.0 o successiva con il plug-in Intelligent Ranking. `Dockerfile`
```
FROM opensearchproject/opensearch:
RUN /usr/share/opensearch/bin/opensearch-plugin install --batch https://github.com/opensearch-project/search-processor/releases/download//search-processor.zip
```
Creazione di un'immagine Docker per OpenSearch con il plug-in Intelligent Ranking.
```
docker build --tag=
```
## Interazione con il plugin di ricerca intelligente
Dopo aver configurato OpenSearch (gestito autonomamente) il plug-in Intelligent Ranking, puoi interagire con il plug-in utilizzando i comandi curl o le librerie OpenSearch client. Le credenziali predefinite per l'accesso OpenSearch con il plugin Intelligent Ranking sono il nome utente 'admin' e la password 'admin'.
Per applicare le impostazioni del plug-in Intelligent Ranking a un indice: OpenSearch
------
#### [ 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)
```
------
È necessario includere il nome del campo di testo principale che si desidera utilizzare per modificare la classificazione, ad esempio il corpo del documento o il campo del contenuto del documento. Puoi anche includere altri campi di testo, come il titolo del documento o il riepilogo del documento.
Ora puoi emettere qualsiasi query e i risultati vengono classificati utilizzando il plug-in 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)
```
------
Per rimuovere le impostazioni del plug-in Intelligent Ranking per un OpenSearch indice:
------
#### [ 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)
```
------
Per testare il plug-in Intelligent Ranking su una determinata query o su determinati campi del corpo e del titolo:
------
#### [ 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)
```
------
## Confronto OpenSearch dei risultati con Amazon Kendra i risultati
Puoi confrontare side-by-side OpenSearch (autogestiti) i risultati classificati con i risultati Amazon Kendra riclassificati. OpenSearch La versione 2.4.0 e successive di Dashboards offre side-by-side risultati che consentono di confrontare la classificazione dei documenti con quella OpenSearch dei documenti Amazon Kendra oppure il plug-in classifica i documenti per una query di ricerca.
Prima di poter confrontare i risultati OpenSearch classificati con quelli Amazon Kendra riclassificati, assicurati che le OpenSearch dashboard siano supportate da un server con il plug-in Intelligent Ranking. OpenSearch Puoi configurarlo usando Docker e uno script Bash di avvio rapido. Per informazioni, consulta [Configurazione del plug-in di ricerca intelligente](#setup-opensearch-rerank-plugin).
Di seguito viene descritto come confrontare OpenSearch e Amazon Kendra cercare i risultati nelle dashboard. OpenSearch Per ulteriori informazioni, consulta la [Documentazione OpenSearch](https://opensearch.org/docs/latest/search-plugins/search-relevance).
**Confronto dei risultati della ricerca nelle dashboard OpenSearch**
1. Apri http://localhost:5601 e accedi a OpenSearch Dashboards. Le credenziali predefinite sono il nome utente 'admin' e la password 'admin'.
1. Seleziona **Search Relevance** dai OpenSearch plugin nel menu di navigazione.
1. Inserisci il testo da cercare nella barra di ricerca.
1. Seleziona il tuo indice per **Query 1** e inserisci una query in OpenSearch Query DSL. È possibile utilizzare la `%SearchText%` variabile per fare riferimento al testo di ricerca immesso nella barra di ricerca. Per un esempio di questa query, consulta [OpenSearch Documentazione](https://opensearch.org/docs/latest/search-plugins/search-relevance/compare-search-results/#reranking-results-with-amazon-kendra-intelligent-ranking-for-opensearch). I risultati restituiti per questa query sono i OpenSearch risultati senza utilizzare il plug-in Intelligent Ranking.
1. Seleziona lo stesso indice per **Query 2** e inserisci la stessa query in OpenSearch Query DSL. Inoltre, includi l'estensione `kendra_intelligent_ranking` e specifica l'elemento obbligatorio in base al quale `body_field` classificare. Puoi anche specificare il campo del titolo, ma il campo del corpo è obbligatorio. Per un esempio di questa query, vedi [OpenSearch Documentazione](https://opensearch.org/docs/latest/search-plugins/search-relevance/compare-search-results/#reranking-results-with-amazon-kendra-intelligent-ranking-for-opensearch). I risultati restituiti per questa query sono i risultati Amazon Kendra riclassificati utilizzando il plug-in Intelligent Ranking. Il plugin classifica fino a 25 risultati.
1. Seleziona **Cerca** per restituire e confrontare i risultati.
# Classificazione semantica dei risultati di un servizio di ricerca
Amazon Kendra Intelligent Ranking utilizza Amazon Kendra le funzionalità di ricerca semantica per riclassificare i risultati di un servizio di ricerca. Lo fa tenendo conto del contesto della query di ricerca, oltre a tutte le informazioni disponibili dai documenti del servizio di ricerca. Amazon Kendra Intelligent Ranking può migliorare la semplice corrispondenza delle parole chiave.
L'[CreateRescoreExecutionPlan](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_CreateRescoreExecutionPlan.html)API crea una risorsa Amazon Kendra Intelligent Ranking utilizzata per il provisioning dell'API [Rescore.](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Ranking_Rescore.html) L'`Rescore`API riordina i risultati di ricerca di un servizio di ricerca come [OpenSearch (](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html)autogestito).
Quando chiami`CreateRescoreExecutionPlan`, imposti le unità di capacità richieste per riclassificare i risultati di un servizio di ricerca. Se non hai bisogno di più unità di capacità oltre a quella predefinita per la singola unità, non modificare l'impostazione predefinita. Fornisci solo un nome per il tuo piano di esecuzione di rescore. È possibile configurare fino a 1000 unità aggiuntive. Per informazioni su cosa è incluso in una singola unità di capacità, vedere [Regolazione della capacità](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html). Una volta effettuato il provisioning di Amazon Kendra Intelligent Ranking, ti verrà addebitato ogni ora in base alle unità di capacità impostate. Consulta le [informazioni sul piano gratuito e sui prezzi](https://aws.amazon.com/kendra/intelligent-ranking-pricing/).
Un ID del piano di esecuzione di rescore viene generato e restituito nella risposta alla chiamata`CreateRescoreExecutionPlan`. L'`Rescore`API utilizza l'ID del piano di esecuzione di rescore per riclassificare i risultati di un servizio di ricerca utilizzando la capacità impostata. Includi l'ID del piano di esecuzione di rescore nei file di configurazione del tuo servizio di ricerca. [Ad esempio, se utilizzi OpenSearch (gestione automatica), includi l'ID del piano di esecuzione di rescore nel file docker-compose.yml o opensearch.yml. Vedi Risultati di classificazione intelligente (self-service). OpenSearch ](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html)
Nella risposta alla chiamata viene generato anche un Amazon Resource Name (ARN). `CreateRescoreExecutionPlan` È possibile utilizzare questo ARN per creare una politica di autorizzazioni in AWS Identity and Access Management (IAM) per limitare l'accesso degli utenti a un ARN specifico per uno specifico piano di esecuzione di rescore. [Per un esempio di IAM policy per concedere l'autorizzazione all'uso dell'`Rescore`API per uno specifico piano di esecuzione di rescore, vedi Amazon Kendra Intelligent Ranking for self-managed. OpenSearch](https://docs.aws.amazon.com/kendra/latest/dg/opensearch-rerank.html)
Di seguito è riportato un esempio di creazione di un piano di esecuzione di rescore con unità di capacità impostate su 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.");
}
}
```
------
Di seguito è riportato un esempio di aggiornamento di un piano di esecuzione di rescore per impostare le unità di capacità su 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.");
}
}
```
------
Di seguito è riportato un esempio di utilizzo dell'`Rescore`API.
------
#### [ 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());
}
}
```
------