Amazon Kendra Intelligentes Ranking für Selbstverwalter OpenSearch - Amazon Kendra
So funktioniert das intelligente Such-PluginEinrichtung des intelligenten Such-PluginsInteraktion mit dem intelligenten Such-Plugin OpenSearch Ergebnisse mit Amazon Kendra Ergebnissen vergleichen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Amazon Kendra Intelligentes Ranking für Selbstverwalter OpenSearch

Sie können die semantischen Suchfunktionen nutzen, um die Suchergebnisse Amazon Kendra des selbstverwalteten Open-Source-Suchdienstes OpenSearch, der auf der Apache 2.0-Lizenz basiert, zu verbessern. Das Amazon Kendra Intelligent Ranking-Plugin ordnet die Ergebnisse semantisch neu an mithilfe OpenSearch von. Amazon Kendra Dazu wird die Bedeutung und der Kontext einer Suchabfrage anhand bestimmter Felder, wie z. B. des Hauptteils oder des Titels des Dokuments, aus den OpenSearch Standard-Suchergebnissen verstanden.

Nehmen wir zum Beispiel diese Abfrage: „Haupt-Keynote-Adresse“. Da „Adresse“ mehrere Bedeutungen hat, Amazon Kendra kann die Bedeutung hinter der Anfrage abgeleitet werden, sodass relevante Informationen zurückgegeben werden, die der beabsichtigten Bedeutung entsprechen. In diesem Zusammenhang handelt es sich um eine Grundsatzrede auf einer Konferenz. Ein einfacherer Suchdienst berücksichtigt die Absicht möglicherweise nicht und könnte beispielsweise Ergebnisse für eine Straßenadresse an der Main Street zurückgeben.

Das Intelligent Ranking-Plugin für OpenSearch ist für die OpenSearch (selbstverwaltete) Version 2.4.0 und höher verfügbar. Sie können das Plugin mithilfe eines Schnellstart-Bash-Skripts installieren, um ein neues Docker-Image OpenSearch mit dem mitgelieferten Intelligent Ranking-Plugin zu erstellen. Sehen Sie Einrichtung des intelligenten Such-Plugins — dies ist ein Beispiel für ein Setup, mit dem Sie schnell loslegen können.

So funktioniert das intelligente Such-Plugin

Der Gesamtprozess des Intelligent Ranking-Plugins für OpenSearch (selbst verwaltet) sieht wie folgt aus:

  1. Ein OpenSearch Benutzer gibt eine Abfrage aus und OpenSearch gibt eine Antwort auf die Anfrage oder eine Liste von Dokumenten, die für die Abfrage relevant sind.

  2. Das Intelligent Ranking-Plugin verwendet die Antwort auf die Anfrage und extrahiert Informationen aus den Dokumenten.

  3. Das Intelligent Ranking-Plugin ruft die Rescore-API von Amazon Kendra Intelligent Ranking auf.

  4. Die Rescore API verwendet die extrahierten Informationen aus den Dokumenten und ordnet die Suchergebnisse semantisch neu.

  5. Die Rescore API sendet die neu eingestuften Suchergebnisse zurück an das Plugin. Das Plugin ordnet die Suchergebnisse in der OpenSearch Suchantwort neu an, um das neue semantische Ranking widerzuspiegeln.

Das Intelligent Ranking-Plugin ordnet die Ergebnisse anhand der Felder „Hauptteil“ und „Titel“ neu an. Diese Plugin-Felder können Feldern in Ihrem OpenSearch Index zugeordnet werden, die der Definition des Hauptteils und des Titels eines Dokuments am ehesten entsprechen. Wenn Ihr Index beispielsweise Kapitel eines Buches mit Feldern wie „chapter_heading“ und „chapter_contents“ enthält, können Sie erstere dem „Titel“ und letztere dem „Hauptteil“ zuordnen, um die besten Ergebnisse zu erzielen.

Einrichtung des intelligenten Such-Plugins

Im Folgenden wird beschrieben, wie Sie das Intelligent Ranking-Plugin schnell einrichten OpenSearch (selbst verwalten) können.

Einrichtung OpenSearch (selbst verwaltet) mit dem Intelligent Ranking-Plugin (schnelle Einrichtung)

Wenn Sie bereits ein Docker-Image verwendenopensearch:2.4.0, können Sie dieses Dockerfile verwenden, um mit dem Intelligent Ranking-Plugin ein neues Image von OpenSearch 2.4.0 zu erstellen. Sie fügen einen Container für das neue Bild in Ihre docker-compose.yml-Datei oder opensearch.yml-Datei ein. Sie geben auch Ihre generierte Rescore-Ausführungsplan-ID bei der Erstellung eines Rescore-Ausführungsplans zusammen mit Ihren Regions- und Endpunktinformationen an — siehe Schritt 2 zur Erstellung eines Rescore-Ausführungsplans.

Wenn Sie zuvor eine Version des opensearch Docker-Images heruntergeladen haben, die älter als 2.4.0 ist, müssen Sie das Docker-Image opensearch:2.4.0 oder eine neuere Version verwenden und ein neues Image mit dem mitgelieferten Intelligent Ranking-Plugin erstellen.

  1. Laden Sie Docker Desktop für Ihr Betriebssystem herunter und installieren Sie es. Docker Desktop umfasst Docker Compose und Docker Engine. Es wird empfohlen, dass Sie überprüfen, ob Ihr Computer die in den Docker-Installationsdetails genannten Systemanforderungen erfüllt.

    Sie können Ihre Anforderungen an die Speichernutzung auch in den Einstellungen Ihres Docker-Desktops erhöhen. Sie sind für die Nutzungsanforderungen von Docker außerhalb der frei verfügbaren Nutzungsbeschränkungen für Docker-Dienste verantwortlich. Siehe Docker-Abonnements.

    Überprüfen Sie, ob der Docker Desktop-Status „läuft“ lautet.

  2. Stellen Sie Amazon Kendra Intelligent Ranking und Ihre Kapazitätsanforderungen bereit. Sobald Sie Amazon Kendra Intelligent Ranking bereitgestellt haben, wird Ihnen eine stündliche Abrechnung auf der Grundlage Ihrer festgelegten Kapazitätseinheiten berechnet. Weitere Informationen zum kostenlosen Kontingent und zu den Preisen finden Sie hier.

    Sie verwenden die CreateRescoreExecutionPlanAPI zur Bereitstellung vonRescore API. Wenn Sie nicht mehr Kapazitätseinheiten als die Standardkapazität für eine Einheit benötigen, fügen Sie keine weiteren Einheiten hinzu und geben Sie nur einen Namen für Ihren Rescore-Ausführungsplan an. Sie können Ihre Kapazitätsanforderungen auch mithilfe der UpdateRescoreExecutionPlanAPI aktualisieren. Weitere Informationen finden Sie unter Semantisches Ranking der Ergebnisse eines Suchdienstes.

    Optional können Sie mit Schritt 3 fortfahren, um einen standardmäßigen Rescore-Ausführungsplan zu erstellen, wenn Sie das Schnellstart-Bash-Skript ausführen.

    Notieren Sie sich für Schritt 4 die in der Antwort enthaltene Rescore-Ausführungsplan-ID.

    CLI
    aws kendra-ranking create-rescore-execution-plan \
  --name MyRescoreExecutionPlan \ 
  --capacity-units '{"RescoreCapacityUnits":<integer number of additional capacity units>}'
 
Response:
 
{
    "Id": "<rescore execution plan ID>",
    "Arn": "arn:aws:kendra-ranking:<region>:<account-id>:rescore-execution-plan/<rescore-execution-plan-id>"
}
    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.")

  3. Laden Sie das Schnellstart-Bash-Skript von GitHub für Ihre Version von herunter, OpenSearch indem Sie den Versionszweig aus dem Drop-down-Menü für den Hauptzweig auswählen.

    Dieses Skript verwendet Docker-Images für OpenSearch und OpenSearch Dashboards, die Ihre Version verwenden, die Sie im GitHub Repository für das Skript ausgewählt haben. Es lädt eine ZIP-Datei für das Intelligent Ranking-Plugin herunter und generiert ein, Dockerfile um ein neues Docker-Image zu erstellen OpenSearch , das das Plugin enthält. Außerdem wird eine docker-compose.yml-Datei erstellt, die Container für das Intelligent Ranking-Plugin und OpenSearch Dashboards enthält. OpenSearch Das Skript fügt Ihre Rescore-Ausführungsplan-ID, Regionsinformationen und Endpunkt (verwendet die Region) zur Datei docker-compose.yml hinzu. Das Skript wird dann ausgeführt, docker-compose up um die Container für OpenSearch inklusive Intelligent Ranking und Dashboards zu starten. OpenSearch Führen docker-compose stop Sie den Befehl aus, um die Container zu stoppen, ohne sie zu entfernen. Führen Sie den Befehl aus, um die Container zu entfernendocker-compose down.

  4. Öffnen Sie Ihr Terminal und führen Sie im Verzeichnis des Bash-Skripts den folgenden Befehl aus.

    bash search_processing_kendra_quickstart.sh -p <execution-plan-id> -r <region>

    Wenn Sie diesen Befehl ausführen, geben Sie die Rescore-Ausführungsplan-ID, die Sie in Schritt 2 bei der Bereitstellung von Amazon Kendra Intelligent Ranking notiert haben, zusammen mit Ihren Regionsinformationen an. Optional können Sie Amazon Kendra Intelligent Ranking stattdessen mithilfe der --create-execution-plan Option bereitstellen. Dadurch wird ein Rescore-Ausführungsplan mit einem Standardnamen und einer Standardkapazität erstellt.

    Um Ihren Index nicht zu verlieren, wenn der standardmäßige temporäre Container entfernt wird, können Sie Ihren Index über alle Ausführungen hinweg beibehalten lassen, indem Sie den Namen des Datenvolumes mithilfe der Option angeben. --volume-name Wenn Sie zuvor einen Index erstellt haben, können Sie das Volume in Ihrer Datei docker-compose.yml oder opensearch.yml angeben. Um Ihre Volumes intakt zu lassen, führen Sie das Programm nicht aus. docker-compose down -v

    Das Schnellstart-Bash-Skript konfiguriert Ihre AWS Anmeldeinformationen im OpenSearch Keystore, um eine Verbindung zu Intelligent Ranking herzustellen. Amazon Kendra Um Ihre AWS Anmeldeinformationen für das Skript bereitzustellen, verwenden Sie die --profile Option, um das Profil anzugeben. AWS Wenn die --profile Option nicht angegeben ist, versucht das Schnellstart-Bash-Skript, AWS Anmeldeinformationen (Zugriffs-/Geheimschlüssel, optionales Sitzungstoken) aus Umgebungsvariablen und dann aus dem Standardprofil zu lesen. AWS Wenn die --profile Option nicht angegeben ist und keine Anmeldeinformationen gefunden werden, leitet das Skript keine Anmeldeinformationen an den Keystore weiter. OpenSearch Wenn im OpenSearch Keystore keine Anmeldeinformationen angegeben sind, überprüft das Plugin trotzdem die Anmeldeinformationen in der Standard-Credential-Provider-Kette, einschließlich Amazon ECS Container-Anmeldeinformationen oder Instanzprofil-Anmeldeinformationen, die über den Metadatendienst bereitgestellt werden. Amazon EC2

    Stellen Sie sicher, dass Sie eine IAM Rolle mit den erforderlichen Berechtigungen erstellt haben, um Intelligent Ranking aufzurufen Amazon Kendra . Im Folgenden finden Sie ein Beispiel für eine IAM Richtlinie zur Erteilung der Erlaubnis zur Verwendung der Rescore API für einen bestimmten Rescore-Ausführungsplan:

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "kendra-ranking:Rescore",
            "Resource": "arn:aws:kendra-ranking:${Region}:${Account}:rescore-execution-plan/${RescoreExecutionPlanId}"
        }
    ]
}

Beispiel für docker-compose.yml

Ein Beispiel für eine docker-compose.yml-Datei, die 2.4.0 oder höher mit dem Intelligent Ranking-Plugin und Dashboards OpenSearch 2.4.0 oder höher verwendet. OpenSearch 

version: '3'
networks:
  opensearch-net:
volumes: 
  <volume-name>:
services:
  opensearch-node:
    image: <Docker image tag name of OpenSearch with Intelligent Ranking plugin>
    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.<region>.api.aws
      - kendra_intelligent_ranking.service.region=<region>
      - kendra_intelligent_ranking.service.execution_plan_id=<rescore-execution-plan-id>
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
    ports:
      - 9200:9200
      - 9600:9600
    networks:
      - opensearch-net
  volumes:
    <docker-volume-name>:/usr/share/opensearch/data 
  opensearch-dashboard:
   image: opensearchproject/opensearch-dashboards:<your-version>
   container_name: opensearch-dashboards
   ports:
     - 5601:5601
   environment:
     OPENSEARCH_HOSTS: '["https://opensearch-node:9200"]'
   networks:
     - opensearch-net

Beispiel für ein Dockerfile und das Erstellen eines Images

Ein Beispiel Dockerfile für die Verwendung von OpenSearch 2.4.0 oder höher mit dem Intelligent Ranking-Plugin.

FROM opensearchproject/opensearch:<your-version>
RUN /usr/share/opensearch/bin/opensearch-plugin install --batch  https://github.com/opensearch-project/search-processor/releases/download/<your-version>/search-processor.zip

Erstellen eines Docker-Images für OpenSearch mit dem Intelligent Ranking-Plugin.

docker build --tag=<Docker image tag name of OpenSearch with Intelligent Ranking plugin>

Interaktion mit dem intelligenten Such-Plugin

Sobald Sie das Intelligent Ranking-Plugin eingerichtet OpenSearch (selbst verwaltet) haben, können Sie mithilfe von Curl-Befehlen oder OpenSearch Client-Bibliotheken mit dem Plugin interagieren. Die Standardanmeldedaten für den Zugriff OpenSearch mit dem Intelligent Ranking-Plugin sind der Benutzername „admin“ und das Passwort „admin“.

So wenden Sie die Plugin-Einstellungen für Intelligent Ranking auf einen Index an OpenSearch :

Curl
curl -XPUT "https://localhost:9200/<your-docs-index>/_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)

Sie müssen den Namen des Haupttextfeldes angeben, das Sie für die Rangfolge verwenden möchten, z. B. den Hauptteil eines Dokuments oder ein Feld mit dem Dokumentinhalt. Sie können auch andere Textfelder wie den Dokumenttitel oder die Dokumentzusammenfassung einbeziehen.

Jetzt können Sie jede beliebige Abfrage stellen und die Ergebnisse werden mit dem Intelligent Ranking-Plugin eingestuft.

Curl
curl -XGET "https://localhost:9200/<your-docs-index>/_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)

Um die Plugin-Einstellungen für Intelligent Ranking für einen OpenSearch Index zu entfernen:

Curl
curl -XPUT "http://localhost:9200/<your-docs-index>/_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)

Um das Intelligent Ranking-Plugin mit einer bestimmten Abfrage oder mit bestimmten Text- und Titelfeldern zu testen:

Curl
curl -XGET "https://localhost:9200/<your-docs-index>/_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)

OpenSearch Ergebnisse mit Amazon Kendra Ergebnissen vergleichen

Sie können side-by-side OpenSearch (selbst verwaltete) Rangfolge mit Ergebnissen mit neu eingestuften Ergebnissen vergleichen. Amazon Kendra OpenSearch Die Dashboard-Version 2.4.0 und höher bietet side-by-side Ergebnisse, sodass Sie die Rangfolge von Dokumenten mit der OpenSearch Rangfolge von Amazon Kendra Dokumenten für eine Suchabfrage vergleichen können.

Bevor Sie OpenSearch Rangergebnisse mit Ergebnissen vergleichen können, die Amazon Kendra neu eingestuft wurden, stellen Sie sicher, dass Ihre OpenSearch Dashboards von einem OpenSearch Server mit dem Intelligent Ranking-Plugin unterstützt werden. Sie können dies mit Docker und einem Schnellstart-Bash-Skript einrichten. Siehe Einrichtung des intelligenten Such-Plugins.

Im Folgenden wird beschrieben, wie Sie Ergebnisse in OpenSearch OpenSearch Dashboards vergleichen und Amazon Kendra suchen. Weitere Informationen finden Sie in der OpenSearchDokumentation.

Suchergebnisse in OpenSearch Dashboards vergleichen

  1. Öffnen Sie http://localhost:5601 und melden Sie sich bei OpenSearch Dashboards an. Die Standardanmeldedaten sind der Benutzername „admin“ und das Passwort „admin“.

  2. Wählen Sie in den OpenSearch Plugins im Navigationsmenü die Option Suchrelevanz aus.

  3. Geben Sie den Suchtext in die Suchleiste ein.

  4. Wählen Sie Ihren Index für Abfrage 1 aus und geben Sie eine Abfrage in die OpenSearch Query DSL ein. Sie können die %SearchText% Variable verwenden, um auf den Suchtext zu verweisen, den Sie in die Suchleiste eingegeben haben. Ein Beispiel für diese Abfrage finden Sie in der OpenSearch Dokumentation. Die für diese Abfrage zurückgegebenen Ergebnisse sind die OpenSearch Ergebnisse ohne Verwendung des Intelligent Ranking-Plug-ins.

  5. Wählen Sie denselben Index für Abfrage 2 aus und geben Sie dieselbe Abfrage in die OpenSearch Query-DSL ein. Geben Sie außerdem die Erweiterung mit an kendra_intelligent_ranking und geben Sie die obligatorische Erweiterung an, body_field nach der die Rangfolge erfolgen soll. Sie können auch das Titelfeld angeben, aber das Textfeld ist ein Pflichtfeld. Ein Beispiel für diese Abfrage finden Sie in der OpenSearch Dokumentation. Bei den für diese Abfrage zurückgegebenen Ergebnissen handelt es sich um Ergebnisse, die mit dem Intelligent Ranking-Plugin Amazon Kendra neu eingestuft wurden. Das Plugin bewertet bis zu 25 Ergebnisse.

  6. Wählen Sie Suchen, um die Ergebnisse zurückzugeben und zu vergleichen.