Utilisation d'un pipeline d' OpenSearch ingestion avec apprentissage automatique et inférence par lots hors ligne - Amazon OpenSearch Service
FonctionnementÀ propos du processeur ml_inferenceConfigurer le processeur ml_inference pour ingérer les demandes de données pour une recherche sémantique

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation d'un pipeline d' OpenSearch ingestion avec apprentissage automatique et inférence par lots hors ligne

Les pipelines OpenSearch Amazon Ingestion (OSI) prennent en charge le traitement d'inférence par lots hors ligne par apprentissage automatique (ML) afin d'enrichir efficacement de gros volumes de données à moindre coût. Utilisez l'inférence par lots hors ligne chaque fois que vous disposez de grands ensembles de données pouvant être traités de manière asynchrone. L'inférence par lots hors ligne fonctionne avec Amazon Bedrock et les SageMaker modèles. Cette fonctionnalité est disponible dans tous les domaines Régions AWS compatibles avec OpenSearch l'ingestion avec OpenSearch Service 2.17+.

Note

Pour le traitement des inférences en temps réel, utilisezConnecteurs Amazon OpenSearch Service ML pour plateformes tierces.

Le traitement d'inférence par lots hors ligne tire parti d'une fonctionnalité OpenSearch appelée ML Commons. ML Commons fournit des algorithmes ML via des appels d'API de transport et REST. Ces appels choisissent les nœuds et les ressources appropriés pour chaque demande de machine learning et surveillent les tâches de machine learning pour garantir la disponibilité. ML Commons vous permet ainsi de tirer parti des algorithmes de ML open source existants et de réduire les efforts nécessaires au développement de nouvelles fonctionnalités de ML. Pour plus d'informations sur ML Commons, voir Machine learning dans la documentation OpenSearch .org.

Fonctionnement

Vous pouvez créer un pipeline d'inférence par lots hors ligne lors de OpenSearch l'ingestion en ajoutant un processeur d'inférence d'apprentissage automatique à un pipeline. Ce processeur permet à votre pipeline de se connecter à des services d'intelligence artificielle, tels que SageMaker l'exécution de tâches d'inférence par lots. Vous pouvez configurer votre processeur pour qu'il se connecte au service d'IA de votre choix via les connecteurs AI (avec support batch_predict) exécutés sur votre domaine cible.

OpenSearch Ingestion utilise le ml_inference processeur avec ML Commons pour créer des tâches d'inférence par lots hors ligne. ML Commons utilise ensuite l'API batch_predict, qui effectue des inférences sur de grands ensembles de données en mode asynchrone hors ligne à l'aide d'un modèle déployé sur des serveurs de modèles externes dans Amazon Bedrock, Amazon, Cohere et OpenAI. SageMaker Le schéma suivant montre un pipeline d' OpenSearch ingestion qui orchestre plusieurs composants pour exécuter ce processus de bout en bout :

Architecture à trois pipelines pour le traitement d'inférence par IA par lots.

Les composants du pipeline fonctionnent comme suit :

Pipeline 1 (préparation et transformation des données) * :

  • Source : Les données sont numérisées à partir de votre source externe prise en charge par OpenSearch Ingestion.

  • Processeurs de données : les données brutes sont traitées et transformées au format approprié pour l'inférence par lots sur le service d'IA intégré.

  • S3 (récepteur) : les données traitées sont stockées dans un compartiment Amazon S3 prêt à servir d'entrée pour exécuter des tâches d'inférence par lots sur le service d'intelligence artificielle intégré.

Pipeline 2 (déclencheur ML batch_inference) :

  • Source : Détection automatisée des événements S3 des nouveaux fichiers créés par la sortie de Pipeline 1.

  • Processeur ML_Inference : processeur qui génère des inférences ML par le biais d'un traitement par lots asynchrone. Il se connecte aux services d'IA via le connecteur AI configuré qui s'exécute sur votre domaine cible.

  • ID de tâche : Chaque travail par lots est associé à un identifiant de tâche dans ml-commons à des fins de suivi et de gestion.

  • OpenSearch ML Commons : ML Commons, qui héberge le modèle de recherche neuronale en temps réel, gère les connecteurs vers les serveurs d'IA distants et sert à l' APIs inférence par lots et à la gestion des tâches.

  • Services d'IA : OpenSearch ML Commons interagit avec des services d'IA tels qu'Amazon Bedrock et Amazon SageMaker pour effectuer des inférences par lots sur les données, produisant ainsi des prédictions ou des informations. Les résultats sont enregistrés de manière asynchrone dans un fichier S3 distinct.

Pipeline 3 (ingestion en vrac) :

  • S3 (source) : Les résultats des tâches par lots sont stockés dans S3, qui est la source de ce pipeline.

  • Processeurs de transformation des données : un traitement et une transformation supplémentaires sont appliqués à la sortie d'inférence par lots avant l'ingestion. Cela garantit que les données sont correctement mappées dans l' OpenSearch index.

  • OpenSearch index (Sink) : les résultats traités sont indexés à des OpenSearch fins de stockage, de recherche et d'analyse plus approfondie.

Note

*Le processus décrit par Pipeline 1 est facultatif. Si vous préférez, vous pouvez ignorer ce processus et simplement télécharger vos données préparées dans le récepteur S3 pour créer des tâches par lots.

À propos du processeur ml_inference

OpenSearch L'ingestion utilise une intégration spécialisée entre la source S3 Scan et le processeur d'inférence ML pour le traitement par lots. Le S3 Scan fonctionne en mode métadonnées uniquement pour collecter efficacement les informations des fichiers S3 sans lire le contenu réel du fichier. Le ml_inference processeur utilise le fichier S3 URLs pour se coordonner avec ML Commons pour le traitement par lots. Cette conception optimise le flux de travail d'inférence par lots en minimisant les transferts de données inutiles pendant la phase de numérisation. Vous définissez le ml_inference processeur à l'aide de paramètres. Voici un exemple : 

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:
            # Région AWS 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"

Améliorations des performances d'ingestion à l'aide du processeur ml_inference

Le ml_inference processeur OpenSearch d'ingestion améliore considérablement les performances d'ingestion de données pour les recherches basées sur le ML. Le processeur convient parfaitement aux cas d'utilisation nécessitant des données générées par un modèle d'apprentissage automatique, notamment la recherche sémantique, la recherche multimodale, l'enrichissement de documents et la compréhension des requêtes. Dans le cadre de la recherche sémantique, le processeur peut accélérer d'un ordre de grandeur la création et l'ingestion de vecteurs volumineux et de grande dimension.

La capacité d'inférence par lots hors ligne du processeur offre des avantages distincts par rapport à l'invocation de modèles en temps réel. Alors que le traitement en temps réel nécessite un serveur de modèle dynamique avec des limites de capacité, l'inférence par lots fait évoluer les ressources de calcul de manière dynamique à la demande et traite les données en parallèle. Par exemple, lorsque le pipeline OpenSearch d'ingestion reçoit un milliard de demandes de données sources, il crée 100 fichiers S3 pour la saisie d'inférence par lots ML. Le ml_inference processeur lance ensuite un traitement SageMaker par lots à l'aide de 100 instances ml.m4.xlarge Amazon Elastic Compute Cloud (Amazon EC2), réalisant ainsi la vectorisation d'un milliard de requêtes en 14 heures, une tâche pratiquement impossible à accomplir en mode temps réel.

Configurer le processeur ml_inference pour ingérer les demandes de données pour une recherche sémantique

Les procédures suivantes vous guident dans le processus de configuration et de configuration du ml_inference processeur d' OpenSearch ingestion pour ingérer un milliard de demandes de données à des fins de recherche sémantique à l'aide d'un modèle d'intégration de texte.

Étape 1 : créer des connecteurs et enregistrer des modèles dans OpenSearch

Pour la procédure suivante, utilisez le fichier ML Commons batch_inference_sagemaker_connector_blueprint pour créer un connecteur et un modèle sur Amazon. SageMaker Si vous préférez utiliser des modèles OpenSearch AWS CloudFormation d'intégration, consultez la (Procédure alternative) Étape 1 : Création de connecteurs et de modèles à l'aide d'un modèle AWS CloudFormation d'intégration suite de cette section.

Pour créer des connecteurs et enregistrer des modèles dans OpenSearch

  1. Créez un modèle ML Deep Java Library (DJL) SageMaker pour la transformation par lots. Pour voir d'autres modèles DJL, consultez Semantic_search_with_CFN_Template_for_SageMaker sur : GitHub

    POST https://api.sagemaker.us-east-1.amazonaws.com/CreateModel
{
   "ExecutionRoleArn": "arn:aws:iam::123456789012:role/aos_ml_invoke_sagemaker",
   "ModelName": "DJL-Text-Embedding-Model-imageforjsonlines",
   "PrimaryContainer": { 
      "Environment": { 
         "SERVING_LOAD_MODELS" : "djl://ai.djl.huggingface.pytorch/sentence-transformers/all-MiniLM-L6-v2" 
      },
      "Image": "763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.29.0-cpu-full"
   }
}

  2. Créez un connecteur avec batch_predict comme nouveau action type dans le actions champ :

    POST /_plugins/_ml/connectors/_create
{
  "name": "DJL Sagemaker Connector: all-MiniLM-L6-v2",
  "version": "1",
  "description": "The connector to sagemaker embedding model all-MiniLM-L6-v2",
  "protocol": "aws_sigv4",
  "credential": {
  "roleArn": "arn:aws:iam::111122223333:role/SageMakerRole"
},
  "parameters": {
    "region": "us-east-1",
    "service_name": "sagemaker",
    "DataProcessing": {
      "InputFilter": "$.text",
      "JoinSource": "Input",
      "OutputFilter": "$"
    },
    "MaxConcurrentTransforms": 100,
    "ModelName": "DJL-Text-Embedding-Model-imageforjsonlines",
    "TransformInput": {
      "ContentType": "application/json",
      "DataSource": {
        "S3DataSource": {
          "S3DataType": "S3Prefix",
          "S3Uri": "s3://offlinebatch/msmarcotests/"
        }
      },
      "SplitType": "Line"
    },
    "TransformJobName": "djl-batch-transform-1-billion",
    "TransformOutput": {
      "AssembleWith": "Line",
      "Accept": "application/json",
      "S3OutputPath": "s3://offlinebatch/msmarcotestsoutputs/"
    },
    "TransformResources": {
      "InstanceCount": 100,
      "InstanceType": "ml.m4.xlarge"
    },
    "BatchStrategy": "SingleRecord"
  },
  "actions": [
    {
      "action_type": "predict",
      "method": "POST",
      "headers": {
        "content-type": "application/json"
      },
      "url": "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/OpenSearch-sagemaker-060124023703/invocations",
      "request_body": "${parameters.input}",
      "pre_process_function": "connector.pre_process.default.embedding",
      "post_process_function": "connector.post_process.default.embedding"
    },
    {
      "action_type": "batch_predict",
      "method": "POST",
      "headers": {
        "content-type": "application/json"
      },
      "url": "https://api.sagemaker.us-east-1.amazonaws.com/CreateTransformJob",
      "request_body": """{ "BatchStrategy": "${parameters.BatchStrategy}", "ModelName": "${parameters.ModelName}", "DataProcessing" : ${parameters.DataProcessing}, "MaxConcurrentTransforms": ${parameters.MaxConcurrentTransforms}, "TransformInput": ${parameters.TransformInput}, "TransformJobName" : "${parameters.TransformJobName}", "TransformOutput" : ${parameters.TransformOutput}, "TransformResources" : ${parameters.TransformResources}}"""
    },
    {
      "action_type": "batch_predict_status",
      "method": "GET",
      "headers": {
        "content-type": "application/json"
      },
      "url": "https://api.sagemaker.us-east-1.amazonaws.com/DescribeTransformJob",
      "request_body": """{ "TransformJobName" : "${parameters.TransformJobName}"}"""
    },
    {
      "action_type": "cancel_batch_predict",
      "method": "POST",
      "headers": {
        "content-type": "application/json"
      },
      "url": "https://api.sagemaker.us-east-1.amazonaws.com/StopTransformJob",
      "request_body": """{ "TransformJobName" : "${parameters.TransformJobName}"}"""
    }
  ]
}

  3. Utilisez l'ID de connecteur renvoyé pour enregistrer le SageMaker modèle :

    POST /_plugins/_ml/models/_register
{
    "name": "SageMaker model for batch",
    "function_name": "remote",
    "description": "test model",
    "connector_id": "example123456789-abcde"
}

  4. Appelez le modèle avec le type batch_predict d'action :

    POST /_plugins/_ml/models/teHr3JABBiEvs-eod7sn/_batch_predict
{
  "parameters": {
    "TransformJobName": "SM-offline-batch-transform"
  }
}

    La réponse contient un identifiant de tâche pour le traitement par lots :

    {
 "task_id": "exampleIDabdcefd_1234567",
 "status": "CREATED"
}

  5. Vérifiez l'état du traitement par lots en appelant l'API Get Task à l'aide de l'ID de tâche :

    GET /_plugins/_ml/tasks/exampleIDabdcefd_1234567

    La réponse contient le statut de la tâche :

    {
  "model_id": "nyWbv5EB_tT1A82ZCu-e",
  "task_type": "BATCH_PREDICTION",
  "function_name": "REMOTE",
  "state": "RUNNING",
  "input_type": "REMOTE",
  "worker_node": [
    "WDZnIMcbTrGtnR4Lq9jPDw"
  ],
  "create_time": 1725496527958,
  "last_update_time": 1725496527958,
  "is_async": false,
  "remote_job": {
    "TransformResources": {
      "InstanceCount": 1,
      "InstanceType": "ml.c5.xlarge"
    },
    "ModelName": "DJL-Text-Embedding-Model-imageforjsonlines",
    "TransformOutput": {
      "Accept": "application/json",
      "AssembleWith": "Line",
      "KmsKeyId": "",
      "S3OutputPath": "s3://offlinebatch/output"
    },
    "CreationTime": 1725496531.935,
    "TransformInput": {
      "CompressionType": "None",
      "ContentType": "application/json",
      "DataSource": {
        "S3DataSource": {
          "S3DataType": "S3Prefix",
          "S3Uri": "s3://offlinebatch/sagemaker_djl_batch_input.json"
        }
      },
      "SplitType": "Line"
    },
    "TransformJobArn": "arn:aws:sagemaker:us-east-1:111122223333:transform-job/SM-offline-batch-transform15",
    "TransformJobStatus": "InProgress",
    "BatchStrategy": "SingleRecord",
    "TransformJobName": "SM-offline-batch-transform15",
    "DataProcessing": {
      "InputFilter": "$.content",
      "JoinSource": "Input",
      "OutputFilter": "$"
    }
  }
}

(Procédure alternative) Étape 1 : Création de connecteurs et de modèles à l'aide d'un modèle AWS CloudFormation d'intégration

Si vous préférez, vous pouvez AWS CloudFormation créer automatiquement tous les SageMaker connecteurs et modèles Amazon requis pour l'inférence ML. Cette approche simplifie la configuration en utilisant un modèle préconfiguré disponible dans la console Amazon OpenSearch Service. Pour de plus amples informations, veuillez consulter Utilisation AWS CloudFormation pour configurer l'inférence à distance pour la recherche sémantique.

Pour déployer une AWS CloudFormation pile qui crée tous les SageMaker connecteurs et modèles requis

  1. Ouvrez la console Amazon OpenSearch Service.

  2. Dans le volet de navigation, choisissez Intégrations.

  3. Dans le champ de recherche, saisissezSageMaker, puis choisissez Intégration aux modèles d'intégration de texte via Amazon SageMaker.

  4. Choisissez Configurer le domaine, puis sélectionnez Configurer le domaine VPC ou Configurer le domaine public.

  5. Entrez les informations dans les champs du modèle. Pour Activer l'inférence par lots hors ligne, choisissez true pour provisionner les ressources pour le traitement par lots hors ligne.

  6. Choisissez Create pour créer la AWS CloudFormation pile.

  7. Une fois la pile créée, ouvrez l'onglet Outputs dans la AWS CloudFormation console. Localisez le connector_id et le model_id. Vous aurez besoin de ces valeurs ultérieurement lors de la configuration du pipeline.

Étape 2 : Création d'un pipeline d' OpenSearch ingestion pour l'inférence par lots hors ligne du ML

Utilisez l'exemple suivant pour créer un pipeline d' OpenSearch ingestion pour l'inférence par lots hors ligne du ML. Pour plus d'informations sur la création d'un pipeline pour OpenSearch l'ingestion, consultezCréation de pipelines OpenSearch Amazon Ingestion.

Avant de commencer

Dans l'exemple suivant, vous spécifiez un ARN de rôle IAM pour le sts_role_arn paramètre. Utilisez la procédure suivante pour vérifier que ce rôle est mappé au rôle principal qui a accès à ml-commons dans. OpenSearch

  1. Accédez au plugin OpenSearch Dashboards correspondant à votre domaine OpenSearch de service. Vous pouvez trouver le point de terminaison des tableaux de bord sur le tableau de bord de votre domaine sur la console OpenSearch de service.

  2. Dans le menu principal, choisissez Sécurité, Rôles, puis sélectionnez le rôle ml_full_access.

  3. Choisissez Mapped users (Utilisateurs mappés), Manage mapping (Gérer le mappage).

  4. Sous Rôles principaux, entrez l'ARN du rôle Lambda qui a besoin d'une autorisation pour appeler votre domaine. Voici un exemple : arn:aws:iam : ::role/ 111122223333 lambda-role

  5. Sélectionnez Mapper et vérifiez que l'utilisateur ou le rôle s'affiche sous Utilisateurs mappés.

Exemple pour créer un pipeline d' OpenSearch ingestion pour l'inférence par lots hors ligne du ML

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

Étape 3 : Préparez vos données pour l'ingestion

Pour préparer vos données pour le traitement d'inférence par lots hors ligne du ML, préparez les données vous-même à l'aide de vos propres outils ou processus ou utilisez le OpenSearch Data Prepper. Vérifiez que les données sont organisées dans le bon format, soit en utilisant un pipeline pour consommer les données de votre source de données, soit en créant un ensemble de données d'apprentissage automatique.

L'exemple suivant utilise le jeu de données MS MARCO, qui inclut une collection de requêtes utilisateur réelles pour des tâches de traitement du langage naturel. L'ensemble de données est structuré au format JSONL, où chaque ligne représente une demande envoyée au modèle d'intégration ML :

{"_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"}}
...

Pour tester l'utilisation du jeu de données MS MARCO, imaginez un scénario dans lequel vous créez un milliard de demandes d'entrée réparties sur 100 fichiers, contenant chacun 10 millions de requêtes. Les fichiers seraient stockés dans Amazon S3 avec le préfixe s3 ://offlinebatch/sagemaker/sagemaker_djl_batch_input/. Le pipeline OpenSearch d'ingestion analyserait ces 100 fichiers simultanément et lancerait un traitement SageMaker par lots avec 100 travailleurs pour un traitement parallèle, permettant ainsi une vectorisation et une ingestion efficaces du milliard de documents dans lesquels ils se trouvent. OpenSearch

Dans les environnements de production, vous pouvez utiliser un pipeline d' OpenSearch ingestion pour générer des fichiers S3 pour la saisie d'inférence par lots. Le pipeline prend en charge diverses sources de données et fonctionne selon un calendrier de transformation continue des données sources en fichiers S3. Ces fichiers sont ensuite traités automatiquement par les serveurs AI via des tâches par lots planifiées hors ligne, garantissant ainsi un traitement et une ingestion continus des données.

Étape 4 : Surveiller le travail d'inférence par lots

Vous pouvez surveiller les tâches d'inférence par lots à l'aide de la SageMaker console ou du AWS CLI. Vous pouvez également utiliser l'API Get Task pour surveiller les tâches par lots :

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

L'API renvoie une liste des tâches de traitement par lots actives :

{
  "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
        }
      }
    ]
  }
}

Après avoir surveillé le travail d'inférence par lots et confirmé qu'il est terminé, vous pouvez exécuter différents types de recherches basées sur l'IA, notamment sémantiques, hybrides, conversationnelles (avec RAG), neuronales éparses et multimodales. Pour plus d'informations sur les recherches basées sur l'IA prises en charge par le OpenSearch service, consultez la section Recherche par IA.

Pour rechercher des vecteurs bruts, utilisez le type de knn requête, fournissez le vector tableau en entrée et spécifiez le k nombre de résultats renvoyés :

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

Pour exécuter une recherche basée sur l'IA, utilisez le type de neural requête. Spécifiez l'query_textentrée, le modèle model_id d'intégration que vous avez configuré dans le pipeline OpenSearch d'ingestion et le k nombre de résultats renvoyés. Pour exclure les intégrations des résultats de recherche, spécifiez le nom du champ d'intégration dans le paramètre : _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
      }
    }
  }
}