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.

Verwenden einer OpenSearch Ingestion-Pipeline mit Offline-Batch-Inferenz für maschinelles Lernen

Amazon OpenSearch Ingestion (OSI) -Pipelines unterstützen die Offline-Batch-Inferenzverarbeitung für maschinelles Lernen (ML), um große Datenmengen effizient und kostengünstig anzureichern. Verwenden Sie Offline-Batch-Inferenz immer dann, wenn Sie über große Datensätze verfügen, die asynchron verarbeitet werden können. Offline-Batch-Inferenz funktioniert mit Amazon Bedrock und SageMaker Modellen. Diese Funktion ist in allen Domains verfügbar AWS-Regionen , die OpenSearch Ingestion mit OpenSearch Service 2.17+ unterstützen.

Die Offline-Batch-Inferenzverarbeitung nutzt eine Funktion OpenSearch namens ML Commons. ML Commons stellt ML-Algorithmen über Transport- und REST-API-Aufrufe bereit. Diese Aufrufe wählen die richtigen Knoten und Ressourcen für jede ML-Anfrage aus und überwachen ML-Aufgaben, um die Verfügbarkeit sicherzustellen. Auf diese Weise können Sie mit ML Commons bestehende Open-Source-ML-Algorithmen nutzen und den Aufwand für die Entwicklung neuer ML-Funktionen reduzieren. Weitere Informationen zu ML Commons finden Sie unter Maschinelles Lernen in der OpenSearch .org-Dokumentation.

Funktionsweise

Sie können eine Offline-Batch-Inferenz-Pipeline bei OpenSearch Ingestion erstellen, indem Sie einer Pipeline einen Inferenzprozessor für maschinelles Lernen hinzufügen. Dieser Prozessor ermöglicht es Ihrer Pipeline, eine Verbindung zu KI-Diensten herzustellen, z. B. SageMaker um Batch-Inferenzjobs auszuführen. Sie können Ihren Prozessor so konfigurieren, dass er über die KI-Konnektoren (mit batch_predict-Unterstützung), die auf Ihrer Zieldomain ausgeführt werden, eine Verbindung zu Ihrem gewünschten KI-Service herstellt.

OpenSearch Ingestion verwendet den ml_inference Prozessor mit ML Commons, um Offline-Batch-Inferenzjobs zu erstellen. ML Commons verwendet dann die batch_predict-API, die Inferenzen für große Datensätze in einem asynchronen Offline-Modus mithilfe eines Modells durchführt, das auf externen Modellservern in Amazon Bedrock, Amazon, Cohere und OpenAI bereitgestellt wird. SageMaker Das folgende Diagramm zeigt eine OpenSearch Ingestion-Pipeline, die mehrere Komponenten orchestriert, um diesen Prozess durchgängig durchzuführen:

Die Pipeline-Komponenten funktionieren wie folgt:

Pipeline 1 (Datenaufbereitung und Transformation) *:

Pipeline 2 (Trigger ML batch_inference):

Pipeline 3 (Massenaufnahme):

Über den ml_inference-Prozessor

OpenSearch Ingestion verwendet eine spezielle Integration zwischen der S3-Scan-Quelle und dem ML-Inferenzprozessor für die Stapelverarbeitung. Der S3-Scan arbeitet nur im Metadatenmodus, um S3-Dateiinformationen effizient zu sammeln, ohne den eigentlichen Dateiinhalt lesen zu müssen. Der ml_inference Prozessor verwendet die S3-Datei URLs , um die Stapelverarbeitung mit ML Commons zu koordinieren. Dieses Design optimiert den Batch-Inferenz-Workflow, indem unnötige Datenübertragungen während der Scanphase minimiert werden. Sie definieren den ml_inference Prozessor mithilfe von Parametern. Ein Beispiel:

processor:
    - ml_inference:
        # The endpoint URL of your OpenSearch domain
        host: "https://AWS test-offlinebatch-123456789abcdefg.us-west-2.es.amazonaws.com"
        
        # Type of inference operation:
        # - batch_predict: for batch processing
        # - predict: for real-time inference
        action_type: "batch_predict"
        
        # Remote ML model service provider (Amazon Bedrock or SageMaker)
        service_name: "bedrock"
        
        # Unique identifier for the ML model
        model_id: "AWS TestModelID123456789abcde"
        
        # S3 path where batch inference results will be stored
        output_path: "s3://amzn-s3-demo-bucket/"
      
        # Supports ISO_8601 notation strings like PT20.345S or PT15M
        # These settings control how long to keep your inputs in the processor for retry on throttling errors
        retry_time_window: "PT9M"
        
        # AWS configuration settings
        aws:
            # AWS-Region where the Lambda function is deployed
            region: "us-west-2"
            # IAM role ARN for Lambda function execution
            sts_role_arn: "arn:aws::iam::account_id:role/Admin"
        
        # Dead-letter queue settings for storing errors
        dlq:
          s3:
            region: us-west-2
            bucket: batch-inference-dlq
            key_path_prefix: bedrock-dlq
            sts_role_arn: arn:aws:iam::account_id:role/OSI-invoke-ml
            
        # Conditional expression that determines when to trigger the processor
        # In this case, only process when bucket matches "amzn-s3-demo-bucket"
        ml_when: /bucket == "amzn-s3-demo-bucket"

Leistungsverbesserungen bei der Aufnahme mithilfe des ml_inference-Prozessors

Der OpenSearch ml_inference Ingestion-Prozessor verbessert die Datenaufnahmeleistung bei ML-fähiger Suche erheblich. Der Prozessor eignet sich ideal für Anwendungsfälle, in denen modellgenerierte Daten für maschinelles Lernen erforderlich sind, darunter semantische Suche, multimodale Suche, Anreicherung von Dokumenten und Verständnis von Abfragen. Bei der semantischen Suche kann der Prozessor die Erstellung und Aufnahme von großvolumigen, hochdimensionalen Vektoren um eine Größenordnung beschleunigen.

Die Offline-Batch-Inferenzfunktion des Prozessors bietet deutliche Vorteile gegenüber dem Modellaufruf in Echtzeit. Während für die Echtzeitverarbeitung ein Live-Model-Server mit Kapazitätsbeschränkungen erforderlich ist, skaliert Batch-Inferenz die Rechenressourcen dynamisch bei Bedarf und verarbeitet Daten parallel. Wenn die OpenSearch Ingestion-Pipeline beispielsweise eine Milliarde Quelldatenanfragen empfängt, erstellt sie 100 S3-Dateien für die Eingabe von ML-Batch-Inferenzen. Der ml_inference Prozessor initiiert dann einen SageMaker Batch-Job unter Verwendung von 100 ml.m4.xlarge Amazon Elastic Compute Cloud (Amazon EC2) -Instances und schließt die Vektorisierung von einer Milliarde Anfragen innerhalb von 14 Stunden ab — eine Aufgabe, die im Echtzeitmodus praktisch unmöglich zu bewerkstelligen wäre.

Konfigurieren Sie den ml_inference-Prozessor so, dass er Datenanfragen für eine semantische Suche aufnimmt

Die folgenden Verfahren führen Sie durch den Prozess der Einrichtung und Konfiguration des OpenSearch ml_inference Ingestion-Prozessors für die Aufnahme von einer Milliarde Datenanfragen für die semantische Suche mithilfe eines Texteinbettungsmodells.

Schritt 1: Konnektoren erstellen und Modelle registrieren in OpenSearch

Verwenden Sie für das folgende Verfahren den ML Commons batch_inference_sagemaker_connector_blueprint, um einen Konnektor und ein Modell in Amazon zu erstellen. SageMaker Wenn Sie es vorziehen, Integrationsvorlagen zu verwenden, finden Sie weiter unten in diesem Abschnitt weitere Informationen. OpenSearch CloudFormation (Alternatives Verfahren) Schritt 1: Erstellen Sie Konnektoren und Modelle mithilfe einer CloudFormation Integrationsvorlage

(Alternatives Verfahren) Schritt 1: Erstellen Sie Konnektoren und Modelle mithilfe einer CloudFormation Integrationsvorlage

Wenn Sie möchten, können Sie AWS CloudFormation damit automatisch alle erforderlichen SageMaker Amazon-Konnektoren und -Modelle für ML-Inferenz erstellen. Dieser Ansatz vereinfacht die Einrichtung, indem er eine vorkonfigurierte Vorlage verwendet, die in der Amazon OpenSearch Service-Konsole verfügbar ist. Weitere Informationen finden Sie unter Wird verwendet CloudFormation , um Remote-Inferenz für die semantische Suche einzurichten.

Schritt 2: Erstellen Sie eine OpenSearch Ingestion-Pipeline für ML-Offline-Batch-Inferenz

Verwenden Sie das folgende Beispiel, um eine OpenSearch Ingestion-Pipeline für ML-Offline-Batchinferenz zu erstellen. Weitere Informationen zum Erstellen einer Pipeline für OpenSearch Ingestion finden Sie unter. Amazon OpenSearch Ingestion-Pipelines erstellen

Bevor Sie beginnen

Im folgenden Beispiel geben Sie einen IAM-Rollen-ARN für den sts_role_arn Parameter an. Verwenden Sie das folgende Verfahren, um zu überprüfen, ob diese Rolle der Backend-Rolle zugeordnet ist, die Zugriff auf ml-commons in hat. OpenSearch

Beispiel zum Erstellen einer Ingestion-Pipeline für ML-Offline-Batch-Inferenz OpenSearch

version: '2'
extension:
  osis_configuration_metadata:
    builder_type: visual
sagemaker-batch-job-pipeline:
  source:
    s3:
      acknowledgments: true
      delete_s3_objects_on_read: false
      scan:
        buckets:
          - bucket:
              name: name
              data_selection: metadata_only
              filter:
                include_prefix:
                  - sagemaker/sagemaker_djl_batch_input
                exclude_suffix:
                  - .manifest
          - bucket:
              name: name
              data_selection: data_only
              filter:
                include_prefix:
                  - sagemaker/output/
        scheduling:
          interval: PT6M
      aws:
        region: name
      default_bucket_owner: account_ID
      codec:
        ndjson:
          include_empty_objects: false
      compression: none
      workers: '1'
  processor:
    - ml_inference:
        host: "https://search-AWStest-offlinebatch-123456789abcdef.us-west-2.es.amazonaws.com"
        aws_sigv4: true
        action_type: "batch_predict"
        service_name: "sagemaker"
        model_id: "model_ID"
        output_path: "s3://AWStest-offlinebatch/sagemaker/output"
        aws:
          region: "us-west-2"
          sts_role_arn: "arn:aws:iam::account_ID:role/Admin"
        ml_when: /bucket == "AWStest-offlinebatch"
        dlq:
          s3:
            region: us-west-2
            bucket: batch-inference-dlq
            key_path_prefix: bedrock-dlq
            sts_role_arn: arn:aws:iam::account_ID:role/OSI-invoke-ml
    - copy_values:
        entries:
          - from_key: /text
            to_key: chapter
          - from_key: /SageMakerOutput
            to_key: chapter_embedding
          - delete_entries:
            with_keys:
          - text
          - SageMakerOutput
  sink:
    - opensearch:
        hosts: ["https://search-AWStest-offlinebatch-123456789abcdef.us-west-2.es.amazonaws.com"]
        aws:
          serverless: false
          region: us-west-2
        routes:
          - ml-ingest-route
        index_type: custom
        index: test-nlp-index
  routes:
    - ml-ingest-route: /chapter != null and /title != null

Schritt 3: Bereiten Sie Ihre Daten für die Aufnahme vor

Um Ihre Daten für die maschinelle Offline-Batch-Inferenzverarbeitung vorzubereiten, bereiten Sie die Daten entweder selbst mit Ihren eigenen Tools oder Prozessen vor oder verwenden Sie den OpenSearch Data Prepper. Stellen Sie sicher, dass die Daten im richtigen Format organisiert sind, indem Sie entweder eine Pipeline verwenden, um die Daten aus Ihrer Datenquelle zu verarbeiten, oder indem Sie einen Datensatz für maschinelles Lernen erstellen.

Im folgenden Beispiel wird der MS MARCO-Datensatz verwendet, der eine Sammlung von echten Benutzerabfragen für Aufgaben zur Verarbeitung natürlicher Sprache enthält. Der Datensatz ist im JSONL-Format strukturiert, wobei jede Zeile eine Anfrage darstellt, die an das ML-Einbettungsmodell gesendet wird:

{"_id": "1185869", "text": ")what was the immediate impact of the Paris Peace Treaties of 1947?", "metadata": {"world war 2"}}
{"_id": "1185868", "text": "_________ justice is designed to repair the harm to victim, the community and the offender caused by the offender criminal act. question 19 options:", "metadata": {"law"}}
{"_id": "597651", "text": "what is amber", "metadata": {"nothing"}}
{"_id": "403613", "text": "is autoimmune hepatitis a bile acid synthesis disorder", "metadata": {"self immune"}}
...

Stellen Sie sich zum Testen mit dem MS MARCO-Datensatz ein Szenario vor, in dem Sie eine Milliarde Eingabeanforderungen erstellen, die auf 100 Dateien verteilt sind und jeweils 10 Millionen Anfragen enthalten. Die Dateien würden in Amazon S3 mit dem Präfix s3://offlinebatch/sagemaker/sagemaker_djl_batch_input/ gespeichert. Die OpenSearch Ingestion-Pipeline würde diese 100 Dateien gleichzeitig scannen und einen SageMaker Batch-Job mit 100 Mitarbeitern zur parallel Verarbeitung initiieren, was eine effiziente Vektorisierung und Aufnahme der eine Milliarde Dokumente ermöglicht. OpenSearch

In Produktionsumgebungen können Sie eine OpenSearch Ingestion-Pipeline verwenden, um S3-Dateien für die Batch-Inferenzeingabe zu generieren. Die Pipeline unterstützt verschiedene Datenquellen und arbeitet nach einem Zeitplan, um Quelldaten kontinuierlich in S3-Dateien umzuwandeln. Diese Dateien werden dann automatisch von KI-Servern im Rahmen von geplanten Offline-Batch-Jobs verarbeitet, wodurch eine kontinuierliche Datenverarbeitung und -aufnahme gewährleistet wird.

Schritt 4: Überwachen Sie den Batch-Inferenzjob

Sie können die Batch-Inferenzjobs mit der SageMaker Konsole oder dem überwachen. AWS CLI Sie können auch die Get Task API verwenden, um Batch-Jobs zu überwachen:

GET /_plugins/_ml/tasks/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "state": "RUNNING"
          }
        }
      ]
    }
  },
  "_source": ["model_id", "state", "task_type", "create_time", "last_update_time"]
}

Die API gibt eine Liste der aktiven Batch-Job-Aufgaben zurück:

{
  "took": 2,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 3,
      "relation": "eq"
    },
    "max_score": 0.0,
    "hits": [
      {
        "_index": ".plugins-ml-task",
        "_id": "nyWbv5EB_tT1A82ZCu-e",
        "_score": 0.0,
        "_source": {
          "model_id": "nyWbv5EB_tT1A82ZCu-e",
          "state": "RUNNING",
          "task_type": "BATCH_PREDICTION",
          "create_time": 1725496527958,
          "last_update_time": 1725496527958
        }
      },
      {
        "_index": ".plugins-ml-task",
        "_id": "miKbv5EB_tT1A82ZCu-f",
        "_score": 0.0,
        "_source": {
          "model_id": "miKbv5EB_tT1A82ZCu-f",
          "state": "RUNNING",
          "task_type": "BATCH_PREDICTION",
          "create_time": 1725496528123,
          "last_update_time": 1725496528123
        }
      },
      {
        "_index": ".plugins-ml-task",
        "_id": "kiLbv5EB_tT1A82ZCu-g",
        "_score": 0.0,
        "_source": {
          "model_id": "kiLbv5EB_tT1A82ZCu-g",
          "state": "RUNNING",
          "task_type": "BATCH_PREDICTION",
          "create_time": 1725496529456,
          "last_update_time": 1725496529456
        }
      }
    ]
  }
}

Schritt 5: Suche ausführen

Nachdem Sie den Batch-Inferenzjob überwacht und bestätigt haben, dass er abgeschlossen ist, können Sie verschiedene Arten von KI-Suchen ausführen, darunter semantische, hybride, dialogorientierte (mit RAG), neuronale, spärliche und multimodale Suchen. Weitere Informationen zu KI-Suchen, die von OpenSearch Service unterstützt werden, finden Sie unter KI-Suche.

Verwenden Sie zur Suche nach Rohvektoren den knn Abfragetyp, geben Sie das vector Array als Eingabe an und geben Sie die k Anzahl der zurückgegebenen Ergebnisse an:

GET /my-raw-vector-index/_search
{
  "query": {
    "knn": {
      "my_vector": {
        "vector": [0.1, 0.2, 0.3],
        "k": 2
      }
    }
  }
}

Verwenden Sie den neural Abfragetyp, um eine KI-gestützte Suche auszuführen. Geben Sie die query_text Eingabe, die model_id des Einbettungsmodells, das Sie in der OpenSearch Ingestion-Pipeline konfiguriert haben, und die k Anzahl der zurückgegebenen Ergebnisse an. Um Einbettungen aus den Suchergebnissen auszuschließen, geben Sie den Namen des Einbettungsfeldes im Parameter an: _source.excludes

GET /my-ai-search-index/_search
{
  "_source": {
    "excludes": [
      "output_embedding"
    ]
  },
  "query": {
    "neural": {
      "output_embedding": {
        "query_text": "What is AI search?",
        "model_id": "mBGzipQB2gmRjlv_dOoB",
        "k": 2
      }
    }
  }
}