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.
# Capture des données à partir du point de terminaison en temps réel
**Note**
Pour éviter tout impact sur les requêtes d’inférence, Data Capture cesse de capturer les requêtes à des niveaux élevés d’utilisation du disque. Nous vous recommandons de maintenir l’utilisation du disque en dessous de 75 % pour que la capture des données continue de capturer les requêtes.
Pour capturer des données pour votre point de terminaison en temps réel, vous devez déployer un modèle à l'aide de services d'hébergement basés sur l' SageMaker IA. Cela nécessite que vous créiez un modèle d' SageMaker IA, que vous définissiez une configuration de point de terminaison et que vous créiez un point de terminaison HTTPS.
Les étapes requises pour activer la capture de données sont similaires, que vous utilisiez le SDK Python AWS SDK pour Python (Boto) ou le SDK SageMaker Python. Si vous utilisez le AWS SDK, définissez le [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dictionnaire, ainsi que les champs obligatoires, dans la [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)méthode pour activer la capture de données. Si vous utilisez le SDK SageMaker Python, importez la [DataCaptureConfig](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.data_capture_config.DataCaptureConfig)classe et initialisez une instance à partir de cette classe. Puis, transmettez cet objet au paramètre `DataCaptureConfig` dans la méthode `sagemaker.model.Model.deploy()`.
Pour utiliser les extraits de code suivants, remplacez ceux de l'exemple *italicized placeholder text* de code par vos propres informations.
## Comment activer la capture des données
Spécifiez une configuration de capture de données. Avec cette configuration, vous pouvez capturer la charge utile de la demande et/ou la charge utile de la réponse. L'extrait de code suivant montre comment activer la capture de données à l'aide du SDK AWS SDK pour Python (Boto) et du SDK AI SageMaker Python.
**Note**
Vous n’avez pas besoin d’utiliser Model Monitor pour capturer les données utiles des requêtes ou des réponses.
------
#### [ AWS SDK pour Python (Boto) ]
Configurez les données que vous souhaitez capturer avec le [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dictionnaire lorsque vous créez un point de terminaison à l'aide de `CreateEndpointConfig` cette méthode. Définissez `EnableCapture` sur la valeur booléenne True. En outre, fournissez les paramètres obligatoires suivants :
+ `EndpointConfigName` : le nom de la configuration du point de terminaison. Vous utiliserez ce nom lorsque vous émettrez une requête `CreateEndpoint`.
+ `ProductionVariants` : une liste des modèles que vous souhaitez héberger dans ce point de terminaison. Définissez un type de données de dictionnaire pour chaque modèle.
+ `DataCaptureConfig` : type de données de dictionnaire où vous spécifiez une valeur entière qui correspond au pourcentage initial de données à échantillonner (`InitialSamplingPercentage`), l'URI Amazon S3 où vous voulez que les données capturées soient stockées et une liste d'options de capture (`CaptureOptions`). Spécifiez soit `Input` ou `Output` pour le champ `CaptureMode` dans la liste `CaptureOptions`.
Vous pouvez éventuellement spécifier la manière dont l' SageMaker IA doit encoder les données capturées en transmettant des arguments de paire clé-valeur au dictionnaire. `CaptureContentTypeHeader`
```
# Create an endpoint config name.
endpoint_config_name = ''
# The name of the production variant.
variant_name = ''
# The name of the model that you want to host.
# This is the name that you specified when creating the model.
model_name = ''
instance_type = ''
#instance_type='ml.m5.xlarge' # Example
# Number of instances to launch initially.
initial_instance_count =
# Sampling percentage. Choose an integer value between 0 and 100
initial_sampling_percentage =
# The S3 URI containing the captured data
s3_capture_upload_path = 's3:///'
# Specify either Input, Output, or both
capture_modes = [ "Input", "Output" ]
#capture_mode = [ "Input"] # Example - If you want to capture input only
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": variant_name,
"ModelName": model_name,
"InstanceType": instance_type, # Specify the compute instance type.
"InitialInstanceCount": initial_instance_count # Number of instances to launch initially.
}
],
DataCaptureConfig= {
'EnableCapture': True, # Whether data should be captured or not.
'InitialSamplingPercentage' : initial_sampling_percentage,
'DestinationS3Uri': s3_capture_upload_path,
'CaptureOptions': [{"CaptureMode" : capture_mode} for capture_mode in capture_modes] # Example - Use list comprehension to capture both Input and Output
}
)
```
Pour plus d'informations sur les autres options de configuration des terminaux, consultez l'[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API dans le [guide de référence de l'API Amazon SageMaker AI Service](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html).
------
#### [ SageMaker Python SDK ]
Importez la classe `DataCaptureConfig` du module [sagemaker.model\$1monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). Activez la capture de données en définissant `EnableCapture` sur la valeur booléenne `True`.
Vous pouvez également fournir des arguments pour les paramètres suivants :
+ `SamplingPercentage` : une valeur entière qui correspond au pourcentage de données à échantillonner. Si vous ne fournissez pas de pourcentage d'échantillonnage, SageMaker AI échantillonnera par défaut 20 (20 %) de vos données.
+ `DestinationS3Uri`: l'URI Amazon S3 sera utilisée par l' SageMaker IA pour stocker les données capturées. Si vous n'en fournissez pas, l' SageMaker IA y stockera les données capturées`"s3:/// model-monitor/data-capture"`.
```
from sagemaker.model_monitor import DataCaptureConfig
# Set to True to enable data capture
enable_capture = True
# Optional - Sampling percentage. Choose an integer value between 0 and 100
sampling_percentage =
# sampling_percentage = 30 # Example 30%
# Optional - The S3 URI of stored captured-data location
s3_capture_upload_path = 's3:///'
# Specify either Input, Output or both.
capture_modes = ['REQUEST','RESPONSE'] # In this example, we specify both
# capture_mode = ['REQUEST'] # Example - If you want to only capture input.
# Configuration object passed in when deploying Models to SM endpoints
data_capture_config = DataCaptureConfig(
enable_capture = enable_capture,
sampling_percentage = sampling_percentage, # Optional
destination_s3_uri = s3_capture_upload_path, # Optional
capture_options = ["REQUEST", "RESPONSE"],
)
```
------
## Déployer votre modèle
Déployez votre modèle et créez un point de terminaison HTTPS avec `DataCapture` activée.
------
#### [ AWS SDK pour Python (Boto3) ]
Fournissez la configuration du point de terminaison à SageMaker AI. Le service lance les instances de calcul ML et déploie le ou les modèles tel que spécifié dans la configuration.
Une fois que vous avez votre configuration de modèle et de point de terminaison, utilisez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) pour créer votre point de terminaison. Le nom du point de terminaison doit être unique dans une AWS région de votre AWS compte.
L’exemple suivant crée un point de terminaison à l’aide de la configuration de point de terminaison spécifiée dans la requête. Amazon SageMaker AI utilise le point de terminaison pour provisionner des ressources et déployer des modèles.
```
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name = ''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
```
Pour en savoir plus, consultez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html).
------
#### [ SageMaker Python SDK ]
Définissez un nom pour votre point de terminaison. Cette étape est facultative. Si vous n'en fournissez pas, SageMaker AI créera un nom unique pour vous :
```
from datetime import datetime
endpoint_name = f"DEMO-{datetime.utcnow():%Y-%m-%d-%H%M}"
print("EndpointName =", endpoint_name)
```
Déployez votre modèle sur un point de terminaison HTTPS en temps réel avec la méthode `deploy()` intégrée de l’objet modèle. Indiquez le nom du type d’instance Amazon EC2 sur lequel déployer ce modèle dans le champ `instance_type` ainsi que le nombre initial d’instances sur lesquelles exécuter le point de terminaison dans le champ `initial_instance_count` :
```
initial_instance_count=
# initial_instance_count=1 # Example
instance_type=''
# instance_type='ml.m4.xlarge' # Example
# Uncomment if you did not define this variable in the previous step
#data_capture_config =
model.deploy(
initial_instance_count=initial_instance_count,
instance_type=instance_type,
endpoint_name=endpoint_name,
data_capture_config=data_capture_config
)
```
------
## Affichage des données capturées
Créez un objet prédicteur à partir de la classe [prédictive](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html) du SDK SageMaker Python. Vous utiliserez l'objet renvoyé par la classe `Predictor` pour appeler votre point de terminaison dans une étape ultérieure. Fournissez le nom de votre point de terminaison (défini précédemment comme `endpoint_name`), ainsi que les objets serializer et deserializer pour le sérialiseur et le désérialiseur, respectivement. [Pour plus d'informations sur les types de sérialiseurs, consultez la classe [Serializers](https://sagemaker.readthedocs.io/en/stable/api/inference/serializers.html) dans le SDK AI SageMaker Python.](https://sagemaker.readthedocs.io/en/stable/index.html)
```
from sagemaker.predictor import Predictor
from sagemaker.serializers import
from sagemaker.deserializers import
predictor = Predictor(endpoint_name=endpoint_name,
serializer = ,
deserializer = )
# Example
#from sagemaker.predictor import Predictor
#from sagemaker.serializers import CSVSerializer
#from sagemaker.deserializers import JSONDeserializer
#predictor = Predictor(endpoint_name=endpoint_name,
# serializer=CSVSerializer(),
# deserializer=JSONDeserializer())
```
Dans l’exemple de code de traitement, nous invoquons le point de terminaison avec un échantillon de données de validation que nous avons stocké localement dans un fichier CSV nommé `validation_with_predictions`. Notre échantillon de jeu de validation contient des étiquettes pour chaque entrée.
Les premières lignes de l'instruction with ouvrent d'abord le fichier CSV du jeu de validation, puis séparent chaque ligne du fichier par le caractère virgule `","`, et enfin stockent les deux objets renvoyés dans les variables label et input\$1cols. Pour chaque ligne, l'entrée (`input_cols`) est transmise à la méthode intégrée des objets `Predictor.predict()` de la variable predictor (`predictor`).
Supposons que le modèle renvoie une probabilité. Les probabilités sont comprises entre les valeurs entières de 0 et 1,0. Si la probabilité renvoyée par le modèle est supérieure à 80 % (0,8), nous attribuons à la prédiction une étiquette de valeur entière de 1. Sinon, nous attribuons à la prédiction une étiquette de valeur entière de 0.
```
from time import sleep
validate_dataset = "validation_with_predictions.csv"
# Cut off threshold of 80%
cutoff = 0.8
limit = 200 # Need at least 200 samples to compute standard deviations
i = 0
with open(f"test_data/{validate_dataset}", "w") as validation_file:
validation_file.write("probability,prediction,label\n") # CSV header
with open("test_data/validation.csv", "r") as f:
for row in f:
(label, input_cols) = row.split(",", 1)
probability = float(predictor.predict(input_cols))
prediction = "1" if probability > cutoff else "0"
baseline_file.write(f"{probability},{prediction},{label}\n")
i += 1
if i > limit:
break
print(".", end="", flush=True)
sleep(0.5)
print()
print("Done!")
```
Comme vous avez activé la capture des données aux étapes précédentes, la charge utile des requêtes et réponses et certaines métadonnées supplémentaires sont enregistrées à l'emplacement Amazon S3 que vous avez spécifié dans `DataCaptureConfig`. La livraison des données de capture à Amazon S3 peut prendre quelques minutes.
Affichez les données capturées en répertoriant les fichiers de capture de données stockés dans Amazon S3. Le format du chemin d'accès Amazon S3 est : `s3:///{endpoint-name}/{variant-name}/yyyy/mm/dd/hh/filename.jsonl`.
Il peut y avoir différents fichiers de différentes périodes, organisés en fonction de l’heure de l’invocation. Exécutez la commande suivante pour afficher le contenu d’un seul fichier de capture :
```
print("\n".join(capture_file[-3:-1]))
```
Cela renverra un fichier au format JSON-line spécifique à l' SageMaker IA. Voici un exemple de réponse provenant d’un point de terminaison en temps réel que nous avons appelé en utilisant des données `csv/text` :
```
{"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT",
"data":"69,0,153.7,109,194.0,105,256.1,114,14.1,6,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0\n",
"encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.0254181120544672","encoding":"CSV"}},
"eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"}
{"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT",
"data":"94,23,197.1,125,214.5,136,282.2,103,9.5,5,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1\n",
"encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.07675473392009735","encoding":"CSV"}},
"eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"}
```
Dans l'exemple de traitement, l'objet `capture_file` est un type de liste. Indexez le premier élément de la liste pour afficher une seule requête d'inférence.
```
# The capture_file object is a list. Index the first element to view a single inference request
print(json.dumps(json.loads(capture_file[0]), indent=2))
```
Cela renvoie une réponse semblable à ce qui suit. Les valeurs renvoyées varieront en fonction de la configuration de votre point de terminaison, de votre modèle d' SageMaker IA et des données capturées :
```
{
"captureData": {
"endpointInput": {
"observedContentType": "text/csv", # data MIME type
"mode": "INPUT",
"data": "50,0,188.9,94,203.9,104,151.8,124,11.6,8,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0\n",
"encoding": "CSV"
},
"endpointOutput": {
"observedContentType": "text/csv; charset=character-encoding",
"mode": "OUTPUT",
"data": "0.023190177977085114",
"encoding": "CSV"
}
},
"eventMetadata": {
"eventId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
"inferenceTime": "2022-02-14T17:25:06Z"
},
"eventVersion": "0"
}
```