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\$1.
**Note**
Pour le traitement des inférences en temps réel, utilisez[Connecteurs Amazon OpenSearch Service ML pour plateformes tierces](ml-external-connector.md).
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 le temps de 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](https://docs.opensearch.org/latest/ml-commons-plugin/) dans la documentation OpenSearch .org.
## Comment ça marche
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](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) à 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\$1predict](https://docs.opensearch.org/latest/ml-commons-plugin/api/model-apis/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\$1predict](https://docs.opensearch.org/latest/ml-commons-plugin/api/model-apis/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.\]](http://docs.aws.amazon.com/fr_fr/opensearch-service/latest/developerguide/images/ml_processor.png)
Les composants du pipeline fonctionnent comme suit :
**Pipeline 1 (préparation et transformation des données) \$1 :**
+ 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\$1inference) :**
+ Source : Détection automatisée des événements S3 des nouveaux fichiers créés par la sortie de Pipeline 1.
+ Processeur ML\$1Inference : 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**
\$1Le 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\$1inference
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\$1inference
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\$1inference 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.
**Topics**
+ [Étape 1 : créer des connecteurs et enregistrer des modèles dans OpenSearch](#configure-clients-ml-commons-configuring-create-connectors)
+ [Étape 2 : Création d'un pipeline d' OpenSearch ingestion pour l'inférence par lots hors ligne du ML](#configure-clients-ml-commons-configuring-pipeline)
+ [Étape 3 : Préparez vos données pour l'ingestion](#configure-clients-ml-commons-configuring-data)
+ [Étape 4 : Surveiller le travail d'inférence par lots](#configure-clients-ml-commons-configuring-monitor)
+ [Étape 5 : Lancer la recherche](#configure-clients-ml-commons-configuring-semantic-search)
### Étape 1 : créer des connecteurs et enregistrer des modèles dans OpenSearch
Pour la procédure suivante, utilisez le fichier ML Commons [batch\$1inference\$1sagemaker\$1connector\$1blueprint pour créer](https://github.com/opensearch-project/ml-commons/blob/main/docs/remote_inference_blueprints/batch_inference_sagemaker_connector_blueprint.md) un connecteur et un modèle sur Amazon. SageMaker Si vous préférez utiliser des modèles OpenSearch 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 CloudFormation d'intégration](#configure-clients-ml-commons-configuring-create-connectors-alternative) 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\$1search\$1with\$1CFN\$1Template\$1for\$1SageMaker](https://github.com/opensearch-project/ml-commons/blob/main/docs/tutorials/aws/semantic_search_with_CFN_template_for_Sagemaker.md) 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"
}
}
```
1. 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}"}"""
}
]
}
```
1. 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"
}
```
1. 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"
}
```
1. 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 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 CloudFormation pour configurer l'inférence à distance pour la recherche sémantique](cfn-template.md).
**Pour déployer une CloudFormation pile qui crée tous les SageMaker connecteurs et modèles requis**
1. Ouvrez la console Amazon OpenSearch Service.
1. Dans le volet de navigation, choisissez **Intégrations**.
1. Dans le champ de recherche, saisissez**SageMaker**, puis choisissez **Intégration aux modèles d'intégration de texte via Amazon SageMaker**.
1. Choisissez **Configurer le domaine**, puis sélectionnez **Configurer le domaine VPC ou Configurer le domaine** **public**.
1. 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.
1. Choisissez **Create** pour créer la CloudFormation pile.
1. **Une fois la pile créée, ouvrez l'onglet **Outputs** dans la CloudFormation console. Localisez le **connector\$1id et le model\$1id**.** 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, consultez[Création de pipelines OpenSearch Amazon Ingestion](creating-pipeline.md).
**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.
1. Dans le menu principal, choisissez **Sécurité**, **Rôles**, puis sélectionnez le rôle **ml\$1full\$1access**.
1. Choisissez **Mapped users (Utilisateurs mappés)**, **Manage mapping (Gérer le mappage)**.
1. 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*
1. 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](https://docs.opensearch.org/latest/data-prepper/getting-started/). 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](https://microsoft.github.io/msmarco/Datasets.html), 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\$1djl\$1batch\$1input/. 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](https://docs.opensearch.org/latest/data-prepper/pipelines/configuration/sources/sources/) 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
}
}
]
}
}
```
### Étape 5 : Lancer la recherche
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](https://docs.opensearch.org/latest/vector-search/ai-search/index/).
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_text`entré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
}
}
}
}
```