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.
# Configurer un Job de traitement SageMaker Clarify
Pour analyser vos données et modèles afin de détecter les biais et l'explicabilité à l'aide de SageMaker Clarify, vous devez configurer une tâche de traitement SageMaker Clarify. Ce guide vous montre comment spécifier le nom du jeu de données en entrée, le nom du fichier de configuration d'analyse et l'emplacement de sortie pour une tâche de traitement. Pour configurer le conteneur de traitement, les entrées de tâches, les sorties, les ressources et les autres paramètres, vous avez deux options. Vous pouvez soit utiliser l'`CreateProcessingJob`API SageMaker AI, soit utiliser l'API SageMaker `SageMaker ClarifyProcessor` AI Python SDK,
Pour plus d'informations sur les paramètres communs à toutes les tâches de traitement, consultez [Amazon SageMaker API Reference](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html?icmpid=docs_sagemaker_lp).
## Configuration d'une tâche de traitement SageMaker Clarify à l'aide de l' SageMaker API
Les instructions suivantes montrent comment fournir chaque partie de la configuration spécifique de SageMaker Clarify à l'aide de l'`CreateProcessingJob`API.
1. Entrez l'identifiant de recherche uniforme (URI) d'une image de conteneur SageMaker Clarify dans le `AppSpecification` paramètre, comme indiqué dans l'exemple de code suivant.
```
{
"ImageUri": "the-clarify-container-image-uri"
}
```
**Note**
L'URI doit identifier une image de conteneur SageMaker Clarify prédéfinie. `ContainerEntrypoint`et ne `ContainerArguments` sont pas pris en charge. Pour plus d'informations sur les images de conteneurs SageMaker Clarify, consultez[Conteneurs SageMaker Clarify préfabriqués](clarify-processing-job-configure-container.md).
1. Spécifiez à la fois la configuration de votre analyse et les paramètres de votre jeu de données en entrée dans le paramètre `ProcessingInputs`.
1. Spécifiez l'emplacement du fichier de configuration d'analyse JSON, qui inclut les paramètres d'analyse des biais et d'analyse d'explicabilité. Le paramètre `InputName` de l’objet `ProcessingInput` doit être **analysis\$1config** tel qu’illustré dans l’exemple de code suivant.
```
{
"InputName": "analysis_config",
"S3Input": {
"S3Uri": "s3://your-bucket/analysis_config.json",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/config"
}
}
```
Pour plus d’informations sur le schéma du fichier de configuration d’analyse, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
1. Spécifiez l’emplacement du jeu de données d’entrée. Le paramètre `InputName` de l'objet `ProcessingInput` doit être `dataset`. Ce paramètre est facultatif si vous avez fourni le "dataset\$1uri" dans le fichier de configuration d'analyse. Les valeurs suivantes sont requises dans la configuration `S3Input`.
1. `S3Uri` peut être un objet Amazon S3 ou un préfixe S3.
1. `S3InputMode` doit être de type **File**.
1. `S3CompressionType` doit être de type `None` (valeur par défaut).
1. `S3DataDistributionType` doit être de type `FullyReplicated` (valeur par défaut).
1. `S3DataType` peut avoir la valeur `S3Prefix` ou `ManifestFile`. Pour être utilisé`ManifestFile`, le `S3Uri` paramètre doit spécifier l'emplacement d'un fichier manifeste qui suit le schéma de la section de référence de l' SageMaker API [S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri). Ce fichier manifeste doit répertorier les objets S3 contenant les données d'entrée pour la tâche.
Le code suivant montre un exemple de configuration d'entrée.
```
{
"InputName": "dataset",
"S3Input": {
"S3Uri": "s3://your-bucket/your-dataset.csv",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/data"
}
}
```
1. Spécifiez la configuration pour la sortie de la tâche de traitement dans le paramètre `ProcessingOutputConfig`. Un seul objet `ProcessingOutput` est requis dans la configuration `Outputs`. Les conditions suivantes sont requises dans la configuration de sortie :
1. `OutputName` doit avoir pour valeur **analysis\$1result**.
1. `S3Uri` doit être un préfixe S3 de l'emplacement de sortie.
1. `S3UploadMode` doit être défini sur **EndOfJob**.
Le code suivant montre un exemple de configuration de sortie.
```
{
"Outputs": [{
"OutputName": "analysis_result",
"S3Output": {
"S3Uri": "s3://your-bucket/result/",
"S3UploadMode": "EndOfJob",
"LocalPath": "/opt/ml/processing/output"
}
}]
}
```
1. Spécifiez la configuration `ClusterConfig` pour les ressources que vous utilisez dans votre tâche de traitement dans le paramètre `ProcessingResources`. Les paramètres suivants sont nécessaires à l'intérieur de l'objet `ClusterConfig`.
1. `InstanceCount` indique le nombre d'instances de calcul dans le cluster qui exécute la tâche de traitement. Spécifiez une valeur supérieure à `1` pour activer le traitement distribué.
1. `InstanceType` fait référence aux ressources qui exécutent votre tâche de traitement. L'analyse SageMaker AI SHAP étant gourmande en ressources informatiques, l'utilisation d'un type d'instance optimisé pour le calcul devrait améliorer le temps d'exécution de l'analyse. La tâche de traitement SageMaker Clarify n'utilise pas GPUs.
Le code suivant montre un exemple de configuration de ressource.
```
{
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 20
}
}
```
1. Spécifiez la configuration du réseau que vous utilisez dans votre tâche de traitement au sein de l'objet `NetworkConfig`. Les valeurs suivantes sont requises dans la configuration.
1. `EnableNetworkIsolation`doit être défini sur `False` (par défaut) afin que SageMaker Clarify puisse invoquer un point de terminaison, si nécessaire, pour les prédictions.
1. Si le modèle ou le point de terminaison que vous avez fourni à la tâche SageMaker Clarify se trouve dans un Amazon Virtual Private Cloud (Amazon VPC), la tâche SageMaker Clarify doit également se trouver dans le même VPC. Spécifiez le VPC à l'aide de. [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_VpcConfig.html) En outre, le VPC doit disposer de points de terminaison vers un compartiment Amazon S3, un service AI et SageMaker un service SageMaker AI Runtime.
Si le traitement distribué est activé, vous devez également autoriser la communication entre les différentes instances d’une même tâche de traitement. Configurez une règle pour votre groupe de sécurité qui autorise les connexions entrantes entre les membres du même groupe de sécurité. Pour de plus amples informations, veuillez consulter [Donnez à Amazon SageMaker Clarify Jobs l'accès aux ressources de votre Amazon VPC](clarify-vpc.md).
Le code suivant montre un exemple de configuration réseau.
```
{
"EnableNetworkIsolation": False,
"VpcConfig": {
...
}
}
```
1. Définissez la durée maximale d'exécution de la tâche à l'aide du paramètre `StoppingCondition`. La durée maximale d'exécution d'une tâche SageMaker Clarify est de `7` jours ou de `604800` secondes. Si la tâche ne peut pas être terminée dans ce délai, elle sera arrêtée et aucun résultat d'analyse ne sera fourni. Par exemple, la configuration suivante limite la durée maximale d'exécution de la tâche à 3 600 secondes.
```
{
"MaxRuntimeInSeconds": 3600
}
```
1. Spécifiez un rôle IAM pour le paramètre `RoleArn`. Le rôle doit entretenir une relation de confiance avec Amazon SageMaker AI. Il peut être utilisé pour effectuer les opérations SageMaker d'API répertoriées dans le tableau suivant. Nous vous recommandons d'utiliser la politique gérée Amazon SageMaker AIFull Access, qui accorde un accès complet à l' SageMaker IA. Pour plus d’informations sur cette politique, consultez [AWS politique gérée : AmazonSageMakerFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonSageMakerFullAccess). Si vous avez des préoccupations concernant l’octroi d’un accès complet, les autorisations minimales requises varient selon que vous fournissez un modèle ou un nom de point de terminaison. L'utilisation d'un nom de point de terminaison permet d'accorder moins d'autorisations à l' SageMaker IA.
Le tableau suivant contient les opérations d'API utilisées par la tâche de traitement SageMaker Clarify. Un **X** sous **Nom du modèle** et **Nom du point de terminaison** indique l'opération d'API qui est requise pour chaque entrée.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/clarify-processing-job-configure-parameters.html)
Pour plus d’informations sur les autorisations requises, consultez [Autorisations d'API Amazon SageMaker AI : référence sur les actions, les autorisations et les ressources](api-permissions-reference.md).
Pour plus d'informations sur le transfert de rôles à SageMaker l'IA, consultez[Transmission de rôles](sagemaker-roles.md#sagemaker-roles-pass-role).
Une fois que vous avez défini les éléments individuels de la configuration de la tâche de traitement, combinez-les pour configurer la tâche.
## Configuration d'une tâche de traitement SageMaker Clarify à l'aide du AWS SDK pour Python
L'exemple de code suivant montre comment lancer une tâche de traitement SageMaker Clarify à l'aide du [AWS SDK pour Python](https://aws.amazon.com/sdk-for-python/).
```
sagemaker_client.create_processing_job(
ProcessingJobName="your-clarify-job-name",
AppSpecification={
"ImageUri": "the-clarify-container-image-uri",
},
ProcessingInputs=[{
"InputName": "analysis_config",
"S3Input": {
"S3Uri": "s3://your-bucket/analysis_config.json",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/config",
},
}, {
"InputName": "dataset",
"S3Input": {
"S3Uri": "s3://your-bucket/your-dataset.csv",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/data",
},
},
],
ProcessingOutputConfig={
"Outputs": [{
"OutputName": "analysis_result",
"S3Output": {
"S3Uri": "s3://your-bucket/result/",
"S3UploadMode": "EndOfJob",
"LocalPath": "/opt/ml/processing/output",
},
}],
},
ProcessingResources={
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 20,
},
},
NetworkConfig={
"EnableNetworkIsolation": False,
"VpcConfig": {
...
},
},
StoppingCondition={
"MaxRuntimeInSeconds": 3600,
},
RoleArn="arn:aws:iam:::role/service-role/AmazonSageMaker-ExecutionRole",
)
```
Pour un exemple de bloc-notes contenant des instructions pour exécuter une tâche de traitement SageMaker Clarify à l'aide du AWS SDK pour Python, voir [Équité et explicabilité avec SageMaker Clarify à l'aide du AWS SDK](http://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_boto3.ipynb) pour Python. Tout compartiment S3 utilisé dans le bloc-notes doit se trouver dans la même AWS région que l'instance du bloc-notes qui y accède.
## Configuration d'une tâche de traitement SageMaker Clarify à l'aide du SDK SageMaker Python
Vous pouvez également configurer une tâche de traitement SageMaker Clarify [SageMaker ClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor)à l'aide de l'API du SDK SageMaker Python. Pour de plus amples informations, veuillez consulter [Exécutez des tâches de traitement SageMaker Clarify pour l'analyse des biais et l'explicabilité](clarify-processing-job-run.md).
**Topics**
+ [
# Conteneurs SageMaker Clarify préfabriqués
](clarify-processing-job-configure-container.md)
+ [
# Fichiers de configuration d’analyse
](clarify-processing-job-configure-analysis.md)
+ [
# Guide de compatibilité des formats de données
](clarify-processing-job-data-format.md)
# Conteneurs SageMaker Clarify préfabriqués
Amazon SageMaker AI fournit des images de conteneur SageMaker Clarify prédéfinies qui incluent les bibliothèques et autres dépendances nécessaires pour calculer les mesures de biais et les attributions de fonctionnalités à des fins d'explication. Ces images sont capables d'exécuter des [tâches de traitement SageMaker ](processing-job.md) Clarify sur votre compte.
Les images URIs des conteneurs se présentent sous la forme suivante :
```
.dkr.ecr..amazonaws.com/sagemaker-clarify-processing:1.0
```
Par exemple :
```
111122223333.dkr.ecr.us-east-1.amazonaws.com/sagemaker-clarify-processing:1.0
```
Le tableau suivant répertorie les adresses par Région AWS.
Images Docker pour SageMaker clarifier les tâches de traitement
| Région | Adresse de l’image |
| --- | --- |
| USA Est (Virginie du Nord) | 205585389593.dkr. ecr.us-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| USA Est (Ohio) | 211330385671.dkr. ecr.us-east-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| USA Ouest (Californie du Nord) | 740489534195.dkr. ecr.us-west-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| USA Ouest (Oregon) | 306415355426.dkr. ecr.us-west-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Hong Kong) | 098760798382.dkr. ecr.ap-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Mumbai) | 452307495513.dkr. ecr.ap-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Jakarta) | 705930551576.dkr. ecr.ap-southeast-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Tokyo) | 377024640650.dkr. ecr.ap-northeast-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Séoul) | 263625296855.dkr. ecr.ap-northeast-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Osaka) | 912233562940.dkr. ecr.ap-northeast-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Singapour) | 834264404009.dkr. ecr.ap-southeast-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asie-Pacifique (Sydney) | 007051062584.dkr. ecr.ap-southeast-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Canada (Centre) | 675030665977.dkr. ecr.ca-central-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Francfort) | 017069133835.dkr. ecr.eu-central-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Zurich) | 730335477804.dkr. ecr.eu-central-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Irlande) | 131013547314.dkr. ecr.eu-west-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Londres) | 440796970383.dkr. ecr.eu-west-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Paris) | 341593696636.dkr. ecr.eu-west-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Stockholm) | 763603941244.dkr. ecr.eu-north-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Middle East (Bahrain) | 835444307964.dkr. ecr.me-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Amérique du Sud (São Paulo) | 520018980103.dkr. ecr.sa-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Afrique (Le Cap) | 811711786498.dkr. ecr.af-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Milan) | 638885417683.dkr. ecr.eu-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Chine (Pékin) | 122526803553.dkr. ecr.cn-north-1.amazonaws.com .cn/:1.0 sagemaker-clarify-processing |
| Chine (Ningxia) | 122578899357.dkr. ecr.cn-northwest-1.amazonaws.com .cn/:1.0 sagemaker-clarify-processing |
# Fichiers de configuration d’analyse
Pour analyser vos données et modèles afin de déterminer s'ils sont explicables et biaisés à l'aide de SageMaker Clarify, vous devez configurer une tâche de traitement. Une partie de la configuration de cette tâche de traitement inclut la configuration d’un fichier d’analyse. Ce fichier d’analyse spécifie les paramètres de l’analyse des biais et de l’explicabilité. Consultez [Configurer un Job de traitement SageMaker Clarify](clarify-processing-job-configure-parameters.md) pour savoir comment configurer une tâche de traitement et un fichier d’analyse.
Ce guide décrit le schéma et les paramètres de ce fichier de configuration d’analyse. Ce guide inclut également des exemples de fichiers de configuration d’analyse pour le calcul des indicateurs de biais pour un jeu de données tabulaire et la génération d’explications pour les problèmes liés au traitement du langage naturel (NLP), à la vision par ordinateur et aux séries temporelles (TS).
Vous pouvez créer le fichier de configuration d'analyse ou utiliser le [SDK SageMaker Python](https://sagemaker.readthedocs.io/) pour en générer un pour vous avec l'[SageMaker ClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor)API. L'affichage du contenu du fichier peut être utile pour comprendre la configuration sous-jacente utilisée par la tâche SageMaker Clarify.
**Topics**
+ [
## Schéma du fichier de configuration d'analyse
](#clarify-processing-job-configure-schema)
+ [
## Exemples de fichiers de configuration d’analyse
](#clarify-processing-job-configure-analysis-examples)
## Schéma du fichier de configuration d'analyse
La section suivante décrit le schéma du fichier de configuration d'analyse, y compris les exigences et les descriptions des paramètres.
### Exigences liées au fichier de configuration d'analyse
La tâche de traitement SageMaker Clarify s'attend à ce que le fichier de configuration d'analyse soit structuré selon les exigences suivantes :
+ Le nom de l'entrée de traitement doit être `analysis_config.`
+ Le fichier de configuration d'analyse est au format JSON et codé en UTF-8.
+ Le fichier de configuration d'analyse est un objet Amazon S3.
Vous pouvez spécifier des paramètres supplémentaires dans le fichier de configuration d'analyse. La section suivante propose différentes options permettant d'adapter la tâche de traitement SageMaker Clarify à votre cas d'utilisation et aux types d'analyse souhaités.
### Paramètres des fichiers de configuration d'analyse
Dans le fichier de configuration JSON, vous pouvez spécifier les paramètres suivants.
+ **version** : (facultatif) chaîne de version du schéma du fichier de configuration d'analyse. Si aucune version n'est fournie, SageMaker Clarify utilise la dernière version prise en charge. Actuellement, la seule version prise en charge est `1.0`.
+ **dataset\$1type** : format du jeu de données. Le format du jeu de données en entrée peut avoir l'une des valeurs suivantes :
+ Tabulaire
+ `text/csv` pour CSV
+ `application/jsonlines`pour le [format dense des lignes SageMaker AI JSON](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines)
+ `application/json` pour JSON
+ `application/x-parquet` pour Apache Parquet
+ `application/x-image` pour activer l’explicabilité pour les problèmes de vision par ordinateur
+ Explications du modèle de prévision de séries temporelles
+ `application/json` pour JSON
+ **dataset\$1uri** : (facultatif) identifiant de ressource uniforme (URI) du jeu de données principal. Si vous fournissez un préfixe d'URI S3, la tâche de traitement SageMaker Clarify collecte de manière récursive tous les fichiers S3 situés sous le préfixe. Vous pouvez fournir un préfixe d'URI S3 ou un URI S3 vers un fichier manifeste d'image pour les problèmes de vision par ordinateur. Si `dataset_uri` est fourni, il a priorité sur l’entrée de la tâche de traitement du jeu de données. Quel que soit le type de format, à l'exception des cas d'utilisation d'images et de séries chronologiques, la tâche de traitement SageMaker Clarify charge le jeu de données en entrée dans un bloc de données tabulaire, en tant que jeu de données **tabulaire**. Ce format permet à l' SageMaker IA de manipuler et d'analyser facilement le jeu de données d'entrée.
+ **headers** : (facultatif)
+ **Tabular :** tableau de chaînes contenant les noms de colonnes d’un jeu de données tabulaire. Si aucune valeur n'est fournie`headers`, la tâche de traitement SageMaker Clarify lit les en-têtes de l'ensemble de données. Si le jeu de données ne comporte pas d’en-têtes, la tâche de traitement Clarify génère automatiquement des noms d’espaces réservés sur la base d’un indice de colonne basé sur zéro. Par exemple, les noms des espaces réservés pour les première et deuxième colonnes seront **column\$10**, **column\$11**, etc.
**Note**
Par convention, if `dataset_type` a pour valeur `application/jsonlines` ou `application/json`, alors `headers` doit contenir les noms suivants dans l’ordre :
noms des caractéristiques
nom de l’étiquette (si `label` est spécifié)
nom de l’étiquette prédite (si `predicted_label` est spécifié)
Un exemple de `headers` pour un type de jeu de données `application/jsonlines` si `label` est spécifié est : `["feature1","feature2","feature3","target_label"]`.
+ **Série temporelle :** liste des noms de colonnes du jeu de données. Si ces données ne sont pas fournies, Clarify génère des en-têtes à utiliser en interne. Pour les cas d’explicabilité d’une série temporelle, fournissez les en-têtes dans l’ordre suivant :
1. identifiant de l’élément
1. timestamp
1. série temporelle cible
1. toutes les colonnes des séries temporelles associées
1. toutes les colonnes de covariables statiques
+ **label** : (facultatif) chaîne ou index entier basé sur zéro. S'il est fourni, `label` est utilisé pour localiser l'étiquette de vérité terrain, également connue sous le nom d'étiquette observée ou d'attribut cible dans un jeu de données tabulaire. L'étiquette de vérité terrain est utilisée pour calculer les métriques de biais. La valeur pour `label` est spécifiée en fonction de la valeur du paramètre `dataset_type`, comme suit.
+ Si `dataset_type` a pour valeur **text/csv**, `label` peut être spécifié comme l'un ou l'autre des éléments suivants :
+ Un nom de colonne valide
+ Un index compris dans la plage des colonnes du jeu de données
+ Si `dataset_type` a pour valeur **application/parquet**, `label` doit être un nom de colonne valide.
+ Si tel `dataset_type` est **application/jsonlines** le cas, `label` il doit s'agir [JMESPath](https://jmespath.org/)d'une expression écrite pour extraire l'étiquette de vérité fondamentale de l'ensemble de données. Par convention, si `headers` est spécifié, il doit contenir le nom de l'étiquette.
+ Si tel `dataset_type` est **application/json** le cas, `label` il doit s'agir [JMESPath](https://jmespath.org/)d'une expression écrite pour extraire l'étiquette de vérité fondamentale pour chaque enregistrement de l'ensemble de données. Cette JMESPath expression doit produire une liste d'étiquettes où le i the label est en corrélation avec le i de l'enregistrement.
+ **predicted\$1label** : (facultatif) chaîne ou index entier basé sur zéro. S'il est fourni, `predicted_label` est utilisé pour localiser la colonne contenant l'étiquette prédite dans un jeu de données tabulaire. L'étiquette prédite est utilisée pour calculer les **métriques de biais** de post-entraînement. Le paramètre `predicted_label` est facultatif si le jeu de données n'inclut pas l'étiquette prédite. Si des étiquettes prédites sont requises pour le calcul, la tâche de traitement SageMaker Clarify obtiendra des prédictions à partir du modèle.
La valeur pour `predicted_label` est spécifiée en fonction de la valeur du paramètre `dataset_type`, comme suit :
+ Si `dataset_type` a pour valeur **text/csv**, `predicted_label` peut être spécifié comme l'un ou l'autre des éléments suivants :
+ Nom de colonne valide. Si `predicted_label_dataset_uri` est spécifié mais que `predicted_label` n'est pas fourni, le nom d'étiquette prédite par défaut est "predicted\$1label".
+ Index compris dans la plage des colonnes du jeu de données. Si `predicted_label_dataset_uri` est spécifié, l'index est utilisé pour localiser la colonne d'étiquettes prédites dans le jeu de données d'étiquettes prédites.
+ Si dataset\$1type a pour valeur **application/x-parquet**, `predicted_label` doit être un nom de colonne valide.
+ Si dataset\$1type l'est**application/jsonlines**, il `predicted_label` doit s'agir d'une [JMESPath](https://jmespath.org/)expression valide écrite pour extraire l'étiquette prédite de l'ensemble de données. Par convention, si `headers` est spécifié, il doit contenir le nom de l'étiquette prédite.
+ Si tel `dataset_type` est **application/json** le cas, `predicted_label` il doit s'agir [JMESPath](https://jmespath.org/)d'une expression écrite pour extraire l'étiquette prévue pour chaque enregistrement de l'ensemble de données. L' JMESPath expression doit produire une liste d'étiquettes prédites où l'étiquette prédite est destinée à l'enregistrement i.
+ **fonctionnalités** — (Facultatif) Obligatoire pour les cas non-time-series d'utilisation si `dataset_type` c'est le cas `application/jsonlines` ou`application/json`. Expression de JMESPath chaîne écrite pour localiser les entités dans le jeu de données en entrée. En `application/jsonlines` effet, une JMESPath expression sera appliquée à chaque ligne pour extraire les caractéristiques de cet enregistrement. Car`application/json`, une JMESPath expression sera appliquée à l'ensemble du jeu de données en entrée. L' JMESPath expression doit extraire une liste de listes ou une 2D array/matrix d'entités où la i ème ligne contient les entités en corrélation avec le i ème enregistrement. Pour un `dataset_type` défini sur `text/csv` ou `application/x-parquet`, toutes les colonnes, à l'exception des colonnes d'étiquettes de vérité terrain et d'étiquettes prédites, sont automatiquement affectées comme des fonctionnalités.
+ **predicted\$1label\$1dataset\$1uri** : (facultatif) applicable uniquement lorsque dataset\$1type a pour valeur `text/csv`. URI S3 d’un jeu de données contenant les étiquettes prédites utilisées pour calculer les **indicateurs de biais** de post-entraînement. La tâche de traitement SageMaker Clarify chargera les prédictions à partir de l'URI fourni au lieu d'obtenir des prédictions à partir du modèle. Dans ce cas, `predicted_label` est requis pour localiser la colonne d'étiquettes prédites dans le jeu de données d'étiquettes prédites. Si le jeu de données d’étiquettes prédites ou le jeu de données principal est divisé en plusieurs fichiers, une colonne d’identifiants doit être spécifiée par `joinsource_name_or_index` pour joindre les deux jeux de données.
+ **predicted\$1label\$1headers** : (facultatif) applicable uniquement quand `predicted_label_dataset_uri` est spécifié. Tableau de chaînes contenant les noms de colonnes du jeu de données d’étiquettes prédites. Outre l'en-tête d'étiquette prédite, `predicted_label_headers` peut également contenir l'en-tête de la colonne d'identifiants pour joindre le jeu de données d'étiquette prédite et le jeu de données principal. Pour plus d'informations, consultez la description suivante du paramètre `joinsource_name_or_index`.
+ **joinsource\$1name\$1or\$1index** : (facultatif) nom ou indice basé sur zéro de la colonne dans les jeux de données tabulaires à utiliser comme colonne d’identification dans le cadre d’une jointure interne. Cette colonne est uniquement utilisée comme identifiant. Elle n'est pas utilisée pour d'autres calculs tels que l'analyse de biais ou l'analyse d'attribution de fonctionnalités. Une valeur pour `joinsource_name_or_index` est nécessaire dans les cas suivants :
+ Il existe plusieurs jeux de données en entrée et chacun d'eux est réparti entre plusieurs fichiers.
+ Le traitement distribué est activé en définissant la tâche de traitement SageMaker [InstanceCount](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingClusterConfig.html#sagemaker-Type-ProcessingClusterConfig-InstanceCount)Clarify sur une valeur supérieure à`1`.
+ **excluded\$1columns** : (facultatif) tableau de noms ou d’index basés sur zéro de colonnes à exclure de l’envoi au modèle en tant qu’entrée pour les prédictions. L’étiquette de vérité terrain et l’étiquette prédite sont déjà automatiquement exclues. Cette caractéristique n’est pas prise en charge pour les séries temporelles.
+ **probability\$1threshold** : (facultatif) nombre à virgule flottante au-dessus duquel une étiquette ou un objet sont sélectionnés. La valeur par défaut est `0.5`. La tâche de traitement SageMaker Clarify est utilisée `probability_threshold` dans les cas suivants :
+ Dans l'analyse des biais de post-entraînement, `probability_threshold` convertit une prédiction du modèle numérique (score ou valeur de probabilité) en étiquette binaire, si le modèle est un classificateur binaire. Un score supérieur au seuil est converti à `1`. En revanche, un score inférieur ou égal au seuil est converti à `0`.
+ Dans le cas de problèmes d'explicabilité de vision par ordinateur, si model\$1type a pour valeur **OBJECT\$1DETECTION**`, probability_threshold` filtre les objets détectés avec des scores de confiance inférieurs à la valeur seuil.
+ **label\$1values\$1or\$1threshold** : (facultatif) obligatoire pour l’analyse des biais. Tableau de valeurs d’étiquette ou valeur seuil indiquant un résultat positif pour la vérité terrain et les étiquettes prédites pour les indicateurs de biais. Pour plus d’informations, consultez les valeurs d’étiquette positives dans [Amazon SageMaker précise les termes relatifs à la partialité et à l'équité](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms). Si l’étiquette est numérique, le seuil est appliqué comme limite inférieure pour sélectionner le résultat positif. Pour définir `label_values_or_threshold` pour différents types de problèmes, reportez-vous aux exemples suivants :
+ Pour un problème de classification binaire, l'étiquette a deux valeurs possibles, `0` et `1`. Si la valeur d'étiquette `1` est favorable à un groupe démographique observé dans un échantillon, `label_values_or_threshold` doit être défini sur `[1]`.
+ Pour un problème de classification multi-classes, l'étiquette a trois valeurs possibles, **bird**, **cat** et **dog**. Si les deux derniers définissent un groupe démographique que le biais favorise, `label_values_or_threshold` doit être défini sur `["cat","dog"]`.
+ Pour un problème de régression, la valeur d'étiquette est continue, comprise entre `0` et `1`. Si une valeur supérieure à `0.5` doit indiquer qu'un échantillon a un résultat positif, `label_values_or_threshold` doit être défini sur `0.5`.
+ **facet** : (facultatif) requis pour l’analyse des biais. Tableau d’objets facettes, composés d’attributs sensibles par rapport auxquels le biais est mesuré. Vous pouvez utiliser des facettes pour comprendre les caractéristiques de biais de votre jeu de données et de votre modèle, même si votre modèle est entraîné sans utiliser d’attributs sensibles. Pour plus d’informations, consultez **Facette** dans [Amazon SageMaker précise les termes relatifs à la partialité et à l'équité](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms). Cet objet facette inclut les champs suivants :
+ **name\$1or\$1index** : (facultatif) nom ou indice basé sur zéro de la colonne d’attributs sensibles dans un jeu de données tabulaire. Si `facet_dataset_uri` est spécifié, l'index fait référence au jeu de données de facettes plutôt qu'au jeu de données principal.
+ **value\$1or\$1threshold** : (facultatif) requis si `facet` est numérique et si `label_values_or_threshold` est appliqué comme limite inférieure pour sélectionner le groupe sensible. Tableau de valeurs de facettes ou valeur seuil indiquant le groupe démographique sensible favorisé par le biais. Si le type de données des facettes est catégoriel et que `value_or_threshold` n'est pas fourni, les métriques de biais sont calculées comme un groupe pour chaque valeur unique (plutôt que toutes les valeurs). Pour définir `value_or_threshold` pour différents types de données de `facet`, reportez-vous aux exemples suivants :
+ Pour un type de données de facette binaire, la fonctionnalité a deux valeurs possibles, `0` et `1`. Si vous souhaitez calculer les métriques de biais pour chaque valeur, `value_or_threshold` peut être omis ou défini sur un tableau vide.
+ Pour un type de données de facette catégoriel, la fonctionnalité a trois valeurs possibles **bird**, **cat** et **dog**. Si les deux premières définissent un groupe démographique que le biais favorise, `value_or_threshold` doit être défini sur `["bird", "cat"]`. Dans cet exemple, les échantillons du jeu de données sont divisés en deux groupes démographiques. La facette du groupe avantagé a la valeur **bird** ou **cat**, tandis que celle du groupe défavorisé a la valeur **dog**.
+ Pour un type de données de facette numérique, la valeur de la fonctionnalité est continue, comprise entre `0` et `1`. Par exemple, si une valeur supérieure à `0.5` doit indiquer qu'un échantillon est favorisé, `value_or_threshold` doit être défini sur `0.5`. Dans cet exemple, les échantillons du jeu de données sont divisés en deux groupes démographiques. La facette du groupe avantagé a une valeur supérieure à `0.5`, tandis que la facette du groupe défavorisé a une valeur inférieure ou égale à `0.5`.
+ **group\$1variable** : (facultatif) nom ou indice basé sur zéro de la colonne qui indique le sous-groupe à utiliser pour l’indicateur de biais [Disparité démographique conditionnelle (CDD)](clarify-data-bias-metric-cddl.md) ou [Disparité démographique conditionnelle dans les étiquettes prédites (CDDPL)](clarify-post-training-bias-metric-cddpl.md).
+ **facet\$1dataset\$1uri** : (facultatif) applicable uniquement lorsque dataset\$1type a pour valeur `text/csv`. URI S3 d’un jeu de données contenant des attributs sensibles pour l’analyse des biais. Vous pouvez utiliser des facettes pour comprendre les caractéristiques de biais de votre jeu de données et de votre modèle, même si votre modèle est entraîné sans utiliser d'attributs sensibles.
**Note**
Si le jeu de données de facettes ou le jeu de données principal est divisé en plusieurs fichiers, une colonne d'identifiants doit être spécifiée par `joinsource_name_or_index` pour joindre les deux jeux de données. Vous devez utiliser le paramètre `facet` pour identifier chaque facette du jeu de données de facettes.
+ **facet\$1headers** : (facultatif) applicable uniquement quand `facet_dataset_uri` est spécifié. Tableau de chaînes contenant les noms de colonnes pour le jeu de données de facettes et, éventuellement, en-tête de colonne d’identifiants pour joindre le jeu de données de facettes et le jeu de données principal. Consultez `joinsource_name_or_index`.
+ **time\$1series\$1data\$1config** : (facultatif) spécifie la configuration à utiliser pour le traitement des données d’une série temporelle.
+ **item\$1id** : chaîne ou indice entier basé sur zéro. Ce champ est utilisé pour localiser un identifiant d’élément dans le jeu de données d’entrée partagé.
+ **timestamp** : chaîne ou indice entier basé sur zéro. Ce champ est utilisé pour localiser un horodatage dans le jeu de données d’entrée partagé.
+ **dataset\$1format** : les valeurs possibles sont `columns`, `item_records` ou `timestamp_records`. Ce champ est utilisé pour décrire le format d’un jeu de données JSON, qui est le seul format pris en charge pour l’explicabilité des séries temporelles.
+ **target\$1time\$1series** — JMESPath Chaîne ou index entier basé sur zéro. Ce champ est utilisé pour localiser la série temporelle cible dans le jeu de données d’entrée partagé. Si ce paramètre est une chaîne, tous les autres paramètres, à l’exception de `dataset_format`, doivent être des chaînes ou des listes de chaînes. Si ce paramètre est un entier, tous les autres paramètres, à l’exception de `dataset_format`, doivent être des entiers ou des listes d’entiers.
+ **related\$1time\$1series** — (Facultatif) Un tableau d'expressions. JMESPath Ce champ est utilisé pour localiser toutes les séries temporelles associées dans le jeu de données d’entrée partagé, le cas échéant.
+ **static\$1covariates** — (Facultatif) Un tableau d'expressions. JMESPath Ce champ est utilisé pour localiser tous les champs de covariables statiques dans le jeu de données d’entrée partagé, le cas échéant.
Pour obtenir des exemples, consultez [Exemples de configuration de jeux de données de séries temporelles](clarify-processing-job-data-format-time-series.md#clarify-processing-job-data-format-time-series-ex).
+ **methods** : objet contenant une ou plusieurs méthodes d’analyse et leurs paramètres. Si une méthode est omise, elle n'est pas utilisée pour l'analyse ni signalée.
+ **pre\$1training\$1bias** : incluez cette méthode si vous souhaitez calculer des métriques de biais de pré-entraînement. Vous trouverez la description détaillée des métriques dans [Indicateurs de biais de pré-entraînement](clarify-measure-data-bias.md). L’objet possède les paramètres suivants :
+ **methods** : tableau contenant une ou plusieurs des métriques de biais de pré-entraînement de la liste suivante que vous souhaitez calculer. Définissez `methods` sur **all** pour calculer toutes les métriques de biais de pré-entraînement. À titre d’exemple, le tableau `["CI", "DPL"]` calculera le **déséquilibre de classe** et la **différence dans les proportions d’étiquettes**.
+ `CI` pour [Déséquilibre de classe (CI)](clarify-bias-metric-class-imbalance.md)
+ `DPL` pour [Différence dans les proportions d'étiquettes (DPL)](clarify-data-bias-metric-true-label-imbalance.md)
+ `KL` pour [Divergence de Kullback-Leibler (KL)](clarify-data-bias-metric-kl-divergence.md)
+ `JS` pour [Divergence de Jensen-Shannon (JS)](clarify-data-bias-metric-jensen-shannon-divergence.md)
+ `LP` pour [Norme Lp (LP)](clarify-data-bias-metric-lp-norm.md)
+ `TVD` pour [Distance de variation totale (TVD)](clarify-data-bias-metric-total-variation-distance.md)
+ `KS` pour [Kolmogorov-Smirnov (KS)](clarify-data-bias-metric-kolmogorov-smirnov.md)
+ `CDDL` pour [Disparité démographique conditionnelle (CDD)](clarify-data-bias-metric-cddl.md)
+ **post\$1training\$1bias** : incluez cette méthode si vous souhaitez calculer des métriques de biais de post-entraînement. Vous trouverez la description détaillée des métriques dans [Indicateurs de biais de post-entraînement dans les données et les modèles](clarify-measure-post-training-bias.md). L’objet `post_training_bias` possède les paramètres suivants.
+ **methods** : tableau contenant une ou plusieurs des métriques de biais de post-entraînement de la liste suivante que vous souhaitez calculer. Définissez `methods` sur **all** pour calculer toutes les métriques de biais de post-entraînement. Par exemple, le tableau `["DPPL", "DI"]` calcule la **différence entre les proportions positives des étiquettes prédites** et l'**impact disparate**. Les méthodes disponibles sont les suivantes :
+ `DPPL` pour [Différence dans les proportions positives des étiquettes prédites (DPPL)](clarify-post-training-bias-metric-dppl.md)
+ `DI` pour [Impact disparate (DI)](clarify-post-training-bias-metric-di.md)
+ `DCA` pour [Différence d'acceptation conditionnelle (DCAcc)](clarify-post-training-bias-metric-dcacc.md)
+ `DCR` pour [Différence dans les rejets conditionnels (DCR)](clarify-post-training-bias-metric-dcr.md)
+ `SD` pour [Différence de spécificité (SD)](clarify-post-training-bias-metric-sd.md)
+ `RD` pour [Différence de rappel (RD)](clarify-post-training-bias-metric-rd.md)
+ `DAR` pour [Différence dans les taux d'acceptation (DAR)](clarify-post-training-bias-metric-dar.md)
+ `DRR` pour [Différence dans les taux de rejets (DRR)](clarify-post-training-bias-metric-drr.md)
+ `AD` pour [Différence de précision (AD)](clarify-post-training-bias-metric-ad.md)
+ `TE` pour [Égalité de traitement (TE)](clarify-post-training-bias-metric-te.md)
+ `CDDPL` pour [Disparité démographique conditionnelle dans les étiquettes prédites (CDDPL)](clarify-post-training-bias-metric-cddpl.md)
+ `FT` pour [FlipTest contrefactuel (FT)](clarify-post-training-bias-metric-ft.md)
+ `GE` pour [Entropie généralisée (GE)](clarify-post-training-bias-metric-ge.md)
+ **shap** : incluez cette méthode si vous souhaitez calculer des valeurs SHAP. La tâche de traitement SageMaker Clarify prend en charge l'algorithme Kernel SHAP. L'objet `shap` possède les paramètres suivants.
+ **baseline** : (facultatif) jeu de données de référence SHAP, également appelé jeu de données d’arrière-plan. Les exigences supplémentaires relatives au jeu de données de référence dans un jeu de données tabulaire ou un problème de vision par ordinateur sont les suivantes. Pour plus d’informations sur les références SHAP, consultez [Bases de référence SHAP pour l’explicabilité](clarify-feature-attribute-shap-baselines.md)
+ Pour un jeu de données **tabulaire**, `baseline` peut correspondre aux données de référence sur place ou à l’URI S3 d’un fichier de référence. Si `baseline` ce n'est pas le cas, la tâche de traitement SageMaker Clarify calcule une ligne de base en regroupant le jeu de données en entrée. La base de référence doit respecter les exigences suivantes :
+ Le format doit être identique au format du jeu de données spécifié par `dataset_type`.
+ La base de référence ne peut contenir que les fonctionnalités que le modèle peut accepter en entrée.
+ Le jeu de données de référence peut comporter une ou plusieurs instances. Le nombre d'instances de référence affecte directement la taille du jeu de données synthétique et la durée d'exécution de la tâche.
+ Si `text_config` est spécifié, la valeur de référence d'une colonne de texte est une chaîne utilisée pour remplacer l'unité de texte spécifiée par `granularity`. Par exemple, un espace réservé courant est "[MASK]". Il est utilisé pour représenter un mot ou un extrait de texte manquant ou inconnu.
Les exemples suivants montrent comment définir des données de référence sur place pour différents paramètres `dataset_type` :
+ Si `dataset_type` a pour valeur `text/csv` ou `application/x-parquet`, le modèle accepte quatre fonctionnalités numériques, et la base de référence comporte deux instances. Dans cet exemple, si un enregistrement a toutes ses valeurs de fonctionnalités égales à 0 et que l'autre enregistrement a toutes ses valeurs de fonctionnalités égales à 1, la base de référence doit être définie sur `[[0,0,0,0],[1,1,1,1]]`, sans aucun en-tête.
+ Si `dataset_type` a pour valeur `application/jsonlines`, `features` est la clé d'une liste de quatre valeurs de fonctionnalités numériques. En outre, dans cet exemple, si la base de référence contient un seul enregistrement dont toutes les valeurs sont égales à 0, `baseline` doit être `[{"features":[0,0,0,0]}]`.
+ Si `dataset_type` a pour valeur `application/json`, le jeu de données `baseline` doit avoir la même structure et le même format que le jeu de données en entrée.
+ Pour les problèmes de **vision par ordinateur**, `baseline` peut être l'URI S3 d'une image utilisée pour masquer des fonctionnalités (segments) de l'image en entrée. La tâche de traitement SageMaker Clarify charge l'image du masque et la redimensionne à la même résolution que l'image d'entrée. Si aucune ligne de base n'est fournie, la tâche de traitement SageMaker Clarify génère une image de masque de [bruit blanc](https://en.wikipedia.org/wiki/White_noise) à la même résolution que l'image d'entrée.
+ **features\$1to\$1explain** : (facultatif) tableau de chaînes ou d'index basés sur zéro de colonnes de fonctionnalités pour lesquelles calculer les valeurs SHAP. Si `features_to_explain` n'est pas fourni, les valeurs SHAP sont calculées pour toutes les colonnes de fonctionnalités. Ces colonnes de fonctionnalités ne peuvent pas inclure la colonne d'étiquettes ni la colonne d'étiquettes prédites. Le paramètre `features_to_explain` n'est pris en charge que pour les jeux de données tabulaires comportant des colonnes numériques et catégorielles.
+ **num\$1clusters** : (facultatif) nombre de clusters dans lesquels le jeu de données est divisé pour calculer le jeu de données de référence. Chaque cluster est utilisé pour calculer une seule instance de référence. Si `baseline` ce n'est pas spécifié, la tâche de traitement SageMaker Clarify tente de calculer le jeu de données de référence en divisant le jeu de données tabulaire en un nombre optimal de clusters compris entre `1` et`12`. Le nombre d'instances de référence affecte directement l'exécution de l'analyse SHAP.
+ **num\$1samples** : (facultatif) nombre d'échantillons à utiliser dans l'algorithme Kernel SHAP. Si `num_samples` ce n'est pas le cas, la tâche de traitement SageMaker Clarify choisit le numéro pour vous. Le nombre d'échantillons affecte directement la taille du jeu de données synthétique et la durée d'exécution de la tâche.
+ **seed** : (facultatif) nombre entier utilisé pour initialiser le générateur de nombres pseudo-aléatoires dans l'outil d'explication SHAP afin de générer des valeurs SHAP cohérentes pour une même tâche. Si seed n'est pas spécifié, chaque fois qu'une même tâche s'exécute, le modèle peut générer des valeurs SHAP légèrement différentes.
+ **use\$1logit** : (facultatif) valeur booléenne indiquant si vous voulez appliquer la fonction logit aux prédictions de modèle. La valeur par défaut est `false` . Si `use_logit` a pour valeur `true`, les valeurs SHAP sont calculées à l'aide des coefficients de régression logistique, qui peuvent être interprétés comme des ratios log-odds.
+ **save\$1local\$1shap\$1values** : (facultatif) valeur booléenne qui indique si vous souhaitez que les valeurs SHAP locales de chaque enregistrement du jeu de données soient incluses dans le résultat de l'analyse. La valeur par défaut est `false` .
Si le jeu de données principal est divisé en plusieurs fichiers ou si le traitement distribué est activé, spécifiez également une colonne d'identifiants à l'aide du paramètre `joinsource_name_or_index`. La colonne d'identifiants et les valeurs SHAP locales sont enregistrées dans le résultat de l'analyse. Ainsi, vous pouvez mapper chaque enregistrement à ses valeurs SHAP locales.
+ **agg\$1method** : (facultatif) méthode utilisée pour agréger les valeurs SHAP locales (valeurs SHAP pour chaque instance) de toutes les instances avec les valeurs SHAP globales (valeurs SHAP pour le jeu de données entier). La valeur par défaut est `mean_abs` . Les méthodes suivantes peuvent être utilisées pour agréger les valeurs SHAP.
+ **mean\$1abs** : moyenne des valeurs SHAP locales absolues de toutes les instances.
+ **mean\$1sq** : moyenne des valeurs SHAP locales au carré de toutes les instances.
+ **median** : médiane des valeurs SHAP locales de toutes les instances.
+ **text\$1config** : nécessaire pour l’explicabilité du traitement du langage naturel. Incluez cette configuration si vous souhaitez traiter les colonnes de texte comme du texte et des explications doivent être fournies pour les unités de texte individuelles. Pour un exemple de configuration d’analyse pour l’explicabilité du traitement du langage naturel, consultez [Configuration d'analyse pour l'explicabilité du traitement du langage naturel](#clarify-analysis-configure-nlp-example).
+ **granularity** : unité de granularité pour l’analyse des colonnes de texte. Les valeurs valides sont `token`, `sentence` ou `paragraph`. **Chaque unité de texte est considérée comme une fonctionnalité** et les valeurs SHAP locales sont calculées pour chaque unité.
+ **language** : langue des colonnes de texte. Les valeurs valides sont **chinese**, **danish**, **dutch**, **english**, **french**, **german**, **greek**, **italian**, **japanese**, **lithuanian**, **multi-language**, **norwegian bokmål**, **polish**, **portuguese**, **romanian**, **russian**, **spanish**, **afrikaans**, **albanian**, **arabic**, **armenian**, **basque**, **bengali**, **bulgarian**, **catalan**, **croatian**, **czech**, **estonian**, **finnish**, **gujarati**, **hebrew**, **hindi**, **hungarian**, **icelandic**, **indonesian**, **irish**, **kannada**, **kyrgyz**, **latvian**, **ligurian**, **luxembourgish**, **macedonian**, **malayalam**, **marathi**, **nepali**, **persian**, **sanskrit**, **serbian**, **setswana**, **sinhala**, **slovak**, **slovenian**, **swedish**, **tagalog**, **tamil**, **tatar**, **telugu**, **thai**, **turkish**, **ukrainian**, **urdu**, **vietnamese**, **yoruba**. Entrez `multi-language` pour un mélange de plusieurs langues.
+ **max\$1top\$1tokens** : (facultatif) nombre maximal de jetons principaux, basé sur les valeurs SHAP globales. La valeur par défaut est `50` . Il est possible qu'un jeton apparaisse plusieurs fois dans le jeu de données. La tâche de traitement SageMaker Clarify agrège les valeurs SHAP de chaque jeton, puis sélectionne les meilleurs jetons en fonction de leurs valeurs SHAP globales. Les valeurs SHAP globales des jetons principaux sélectionnés sont incluses dans la section `global_top_shap_text` du fichier analysis.json.
+ Valeur SHAP locale d'agrégation.
+ **image\$1config** : nécessaire pour l'explicabilité de la vision par ordinateur. Incluez cette configuration si vous disposez d'un jeu de données en entrée composé d'images et que vous souhaitez les analyser afin de déterminer l'explicabilité dans un problème de vision par ordinateur.
+ **model\$1type** : type du modèle. Les valeurs valides sont les suivantes :
+ `IMAGE_CLASSIFICATION` pour un modèle de classification d'image.
+ `OBJECT_DETECTION` pour un modèle de détection d'objet.
+ **max\$1objects** : applicable uniquement quand model\$1type a pour valeur **OBJECT\$1DETECTION**. Nombre maximal d'objets, ordonnés par score de confiance, détectés par le modèle de vision par ordinateur. Tous les objets classés en dessous des max\$1objects objets principaux en termes de score de confiance sont retirés par filtrage. La valeur par défaut est `3` .
+ **context** : applicable uniquement quand model\$1type a pour valeur **OBJECT\$1DETECTION**. Il indique si la zone autour du cadre de délimitation de l'objet détecté est masquée par l'image de référence ou non. Les valeurs valides sont `0` pour tout masquer, ou `1` pour ne rien masquer. La valeur par défaut est 1.
+ **iou\$1threshold** : applicable uniquement quand `model_type` a pour valeur **OBJECT\$1DETECTION**. Métrique d'intersection minimale sur union (IOU) pour évaluer les prédictions par rapport à la détection initiale. Une métrique IOU élevée correspond à un chevauchement important entre le cadre de détection de valeur prédite et le cadre de détection de vérité terrain. La valeur par défaut est `0.5` .
+ **num\$1segments** : (facultatif) entier qui détermine le nombre approximatif de segments à étiqueter dans l'image en entrée. Chaque segment de l'image est considéré comme une fonctionnalité et les valeurs SHAP locales sont calculées pour chaque segment. La valeur par défaut est `20` .
+ **segment\$1compactness** : (facultatif) entier qui détermine la forme et la taille des segments d'image générés par la méthode [scikit-image slic](https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.slic). La valeur par défaut est `5` .
+ **pdp** — Incluez cette méthode pour calculer les diagrammes de dépendance partielle (PDPs). Pour un exemple de configuration d'analyse à générer PDPs, voir [Calculer des diagrammes de dépendance partielle (PDPs)](#clarify-analysis-configure-csv-example-pdp)
+ **features** : obligatoire si la méthode `shap` n’est pas demandée. Tableau de noms de fonctionnalités ou d'index permettant de calculer et de tracer des graphiques PDP.
+ **top\$1k\$1features** : (facultatif) spécifie le nombre de fonctionnalités principales utilisées pour générer des graphiques PDP. Si `features` ce n'est pas le cas, mais que la `shap` méthode est demandée, la tâche de traitement SageMaker Clarify choisit les principales fonctionnalités en fonction de leurs attributions SHAP. La valeur par défaut est `10` .
+ **grid\$1resolution** : nombre de compartiments dans lesquels diviser la plage de valeurs numériques. Cela spécifie la granularité de la grille pour les graphiques PDP.
+ **asymmetric\$1shapley\$1value** : incluez cette méthode si vous souhaitez calculer des métriques d’explicabilité pour les modèles de prévision de séries temporelles. La tâche de traitement SageMaker Clarify prend en charge l'algorithme de valeurs asymétriques de Shapley. Les valeurs de Shapley asymétriques sont une variante de la valeur de Shapley qui supprime l’axiome de symétrie. Pour plus d’informations, consultez [Asymmetric Shapley values: incorporating causal knowledge into model-agnostic explainability](https://arxiv.org/abs/1910.06358). Utilisez ces valeurs pour déterminer dans quelle mesure les caractéristiques contribuent aux résultats des prévisions. Les valeurs de Shapley asymétriques prennent en compte les dépendances temporelles des données de séries temporelles que les modèles de prévision acceptent en entrée.
L’algorithme inclut les paramètres suivants :
+ **direction** : les types disponibles sont `chronological`, `anti_chronological` et `bidirectional`. La structure temporelle peut être parcourue dans l’ordre chronologique, antichronologique ou les deux. Les explications chronologiques sont élaborées en ajoutant des informations de manière itérative dès la première étape temporelle. Les explications antichronologiques ajoutent des informations en partant de la dernière étape et en revenant en arrière. Ce dernier ordre peut être plus approprié en présence d’un biais de récence, par exemple pour la prévision du cours des actions.
+ **granularity** : la granularité des explications à utiliser. Les options de granularité disponibles sont les suivantes :
+ **timewise** : les explications `timewise` sont peu coûteuses et fournissent des informations uniquement sur des étapes temporelles spécifiques, par exemple pour déterminer dans quelle mesure les informations du nième jour dans le passé ont contribué à la prévision du m-ième jour dans le futur. Les attributions qui en résultent n’expliquent pas les covariables statiques individuelles et ne font pas de distinction entre les séries temporelles cibles et associées.
+ **fine\$1grained** : les explications `fine_grained` sont plus gourmandes en calculs mais fournissent une ventilation complète de toutes les attributions des variables d’entrée. La méthode calcule des explications approximatives pour réduire le temps d’exécution. Pour plus d’informations, consultez le paramètre `num_samples` suivant.
**Note**
Les explications `fine_grained` prennent en charge uniquement l’ordre `chronological`.
+ **num\$1samples** : (facultatif) cet argument est obligatoire pour les explications `fine_grained`. Plus le nombre est élevé, plus l’approximation est précise. Ce nombre doit évoluer proportionnellement à la dimensionnalité des caractéristiques d’entrée. En règle générale, définissez cette variable sur *(1 \$1 max(nombre de séries temporelles associées, nombre de covariables statiques))^2* si le résultat n’est pas trop important.
+ **baseline** — (Facultatif) La configuration de référence pour remplacer out-of-coalition les valeurs des ensembles de données correspondants (également appelés données d'arrière-plan). L’extrait de code suivant montre un exemple de configuration de référence :
```
{
"related_time_series": "zero",
"static_covariates": {
: [0, 2],
: [-1, 1]
},
"target_time_series": "zero"
}
```
+ Pour les données temporelles telles que les séries temporelles cibles ou les séries temporelles associées, les types de valeur de référence peuvent être l’une des valeurs suivantes :
+ `zero`— Toutes les out-of-coalition valeurs sont remplacées par 0,0.
+ `mean`— Toutes les out-of-coalition valeurs sont remplacées par la moyenne d'une série chronologique.
+ Pour les covariables statiques, une entrée de référence ne doit être fournie que lorsque la demande de modèle prend les valeurs des covariables statiques, auquel cas ce champ est requis. La référence doit être fournie pour chaque élément sous forme de liste. Par exemple, si vous avez un jeu de données avec deux covariables statiques, votre configuration de référence peut être la suivante :
```
"static_covariates": {
: [1, 1],
: [0, 1]
}
```
Dans l'exemple précédent, ** et ** sont les identifiants des éléments de l'ensemble de données.
+ **report** : (facultatif) utilisez cet objet pour personnaliser le rapport d’analyse. Ce paramètre n’est pas pris en charge pour les tâches d’explication de séries temporelles. Le résultat de l’analyse contient trois copies du même rapport : un rapport de bloc-notes Jupyter, un rapport HTML et un rapport PDF. L'objet possède les paramètres suivants :
+ **name** : nom de fichier des fichiers de rapport. Par exemple, si `name` a pour valeur **MyReport**, les fichiers de rapport sont `MyReport.ipynb`, `MyReport.html` et `MyReport.pdf`. La valeur par défaut est `report` .
+ **title** : (facultatif) chaîne de titre du rapport. La valeur par défaut est **SageMaker AI Analysis Report** .
+ **predictor** : requis si l’analyse nécessite des prédictions issues du modèle. Par exemple, quand la méthode `shap`, `asymmetric_shapley_value`, `pdp` ou `post_training_bias` est demandée, mais que les étiquettes prédites ne sont pas fournies dans le cadre du jeu de données d’entrée. Les paramètres suivants doivent être utilisés conjointement à `predictor` :
+ **model\$1name** — Le nom de votre modèle d' SageMaker IA créé par l'[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API. Si vous spécifiez `model_name` plutôt que endpoint\$1name, la tâche de traitement SageMaker Clarify crée un point de terminaison éphémère portant le nom du modèle, connu sous le nom de point de terminaison **fictif, et obtient des prédictions à partir du point de terminaison**. Une fois les calculs terminés, la tâche supprime le point de terminaison miroir. Si le modèle est multi-modèle, le paramètre `target_model` doit être spécifié. Pour plus d’informations à propos de l’utilisation des points de terminaison multimodèles, consultez [Points de terminaison multimodèles](multi-model-endpoints.md).
+ **endpoint\$1name\$1prefix** : (facultatif) préfixe de nom personnalisé pour le point de terminaison miroir. Applicable si vous spécifiez `model_name` à la place de `endpoint_name`. Par exemple, spécifiez `endpoint_name_prefix` si vous souhaitez restreindre l'accès au point de terminaison par le nom de point de terminaison. Le préfixe doit correspondre au [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html#sagemaker-CreateEndpoint-request-EndpointName)modèle et sa longueur maximale est `23` de. La valeur par défaut est `sm-clarify` .
+ **initial\$1instance\$1count** : spécifie le nombre d'instances pour le point de terminaison miroir. Requis si vous spécifiez model\$1name à la place de endpoint\$1name. La valeur pour `initial_instance_count` peut être différente de celle [InstanceCount](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_ProcessingClusterConfig.html#sagemaker-Type-ProcessingClusterConfig-InstanceCount)de la tâche, mais nous recommandons un ratio de 1:1.
+ **instance\$1type** : spécifie le type d'instance pour le point de terminaison miroir. Requis si vous spécifiez `model_name` à la place de `endpoint_name`. Par exemple, `instance_type` peut être défini sur "ml.m5.large". Dans certains cas, la valeur spécifiée pour `instance_type` peut contribuer à réduire le temps d'inférence de modèle. Par exemple, pour fonctionner efficacement, les modèles de traitement du langage naturel et les modèles de vision par ordinateur nécessitent généralement un type d’instance d’unité de traitement graphique (GPU).
+ **endpoint\$1name — Le nom** de votre point de terminaison SageMaker AI créé par l'API. [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) S’il est fourni, `endpoint_name` a priorité sur le paramètre `model_name`. L'utilisation d'un point de terminaison existant réduit le temps d'amorçage du point de terminaison miroir, mais elle peut également entraîner une augmentation significative de la charge de ce point de terminaison. En outre, certaines méthodes d'analyse (telles que `shap` et `pdp`) génèrent des jeux de données synthétiques qui sont envoyés au point de terminaison. Cela peut entraîner la contamination des métriques du point de terminaison ou des données capturées par des données synthétiques, qui peuvent ne pas refléter avec précision l'utilisation réelle. Pour ces raisons, il n'est généralement pas recommandé d'utiliser un point de production existant pour l'analyse SageMaker Clarify.
+ **target\$1model** — La valeur de chaîne transmise au TargetModel paramètre de l' SageMaker API AI. [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax) Requis si votre modèle (spécifié par le paramètre model\$1name) ou votre point de terminaison (spécifié par le paramètre endpoint\$1name) est multimodèle. Pour plus d’informations à propos de l’utilisation des points de terminaison multimodèles, consultez [Points de terminaison multimodèles](multi-model-endpoints.md).
+ **custom\$1attributes** : (facultatif) chaîne qui vous permet de fournir des informations supplémentaires sur une demande d’inférence soumise au point de terminaison. La valeur de chaîne est transmise au `CustomAttributes` paramètre de l'[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)API SageMaker AI.
+ **content\$1type** :format d’entrée de modèle à utiliser pour obtenir des prédictions à partir du point de terminaison. S'il est fourni, il est transmis au `ContentType` paramètre de l'[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)API SageMaker AI.
+ Pour l’explicabilité de la vision par ordinateur, les valeurs valides sont **image/jpeg**, **image/png** ou **application/x-npy**. Si `content_type` n’est pas fourni, la valeur par défaut est **image/jpeg**.
+ Pour l’explicabilité des prévisions de séries temporelles, la valeur valide est **application/json**.
+ Pour les autres types d’explicabilité, les valeurs valides sont **text/csv**, **application/jsonlines,** et **application/json**. Une valeur pour `content_type` est requise si `dataset_type` a pour valeur **application/x-parquet**. Dans le cas contraire, `content_type` a pour valeur par défaut la valeur du paramètre `dataset_type`.
+ **accept\$1type** : format de sortie du modèle à utiliser pour obtenir des prédictions à partir du point de terminaison. La valeur pour `accept_type` est transmise au `Accept` paramètre de l'[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)API SageMaker AI.
+ Pour l’explicabilité de la vision par ordinateur, si `model_type` a pour valeur "OBJECT\$1DETECTION", `accept_type` a pour valeur par défaut **application/json**.
+ Pour l’explicabilité des prévisions de séries temporelles, la valeur valide est **application/json**.
+ Pour les autres types d’explicabilité, les valeurs valides sont **text/csv**, **application/jsonlines** et **application/json**. Si aucune valeur n'est fournie pour `accept_type`, `accept_type` a pour valeur par défaut la valeur du paramètre `content_type`.
+ **content\$1template** : chaîne de modèle utilisée pour construire l'entrée de modèle à partir d'enregistrements de jeu de données. Le paramètre `content_template` est utilisé et requis seulement si la valeur du paramètre `content_type` est `application/jsonlines` ou `application/json`.
Quand le paramètre `content_type` a pour valeur `application/jsonlines`, le modèle doit avoir un seul espace réservé, `$features`, qui est remplacé par une liste de fonctionnalités au moment de l'exécution. Par exemple, si le modèle est `"{\"myfeatures\":$features}"` et qu'un enregistrement comporte trois valeurs de fonctionnalités numériques : `1`, `2` et `3`, l'enregistrement est envoyé au modèle sous forme de ligne JSON `{"myfeatures":[1,2,3]}`.
Quand `content_type` a pour valeur `application/json`, le modèle peut avoir l'espace réservé `$record` ou `records`. Si l'espace réservé est `record`, un enregistrement individuel est remplacé par un enregistrement auquel le modèle figurant dans `record_template` est appliqué. Dans ce cas, un seul enregistrement est envoyé au modèle à la fois. Si l'espace réservé est `$records`, les enregistrements sont remplacés par une liste d'enregistrements, chacun avec un modèle fourni par `record_template`.
+ **record\$1template** : chaîne de modèle à utiliser pour construire chaque enregistrement de l'entrée de modèle à partir des instances du jeu de données. Il est utilisé et requis seulement quand `content_type` a pour valeur `application/json`. La chaîne de modèle peut contenir l'un des éléments suivants :
+ Un paramètre `$features` d'espace réservé qui est remplacé par un tableau de valeurs de fonctionnalités. Un espace réservé facultatif supplémentaire peut remplacer les noms des en-têtes des colonnes de fonctionnalités dans `$feature_names`. Cet espace réservé facultatif sera remplacé par un tableau de noms de fonctionnalités.
+ Un et un seul espace réservé `$features_kvp`, qui est remplacé par les paires clé-valeur, le nom de fonctionnalité et la valeur de fonctionnalité.
+ Une fonctionnalité dans la configuration de `headers`. Par exemple, un nom de fonctionnalité `A`, noté par la syntaxe d'espace réservé `"${A}"`, sera remplacé par la valeur de fonctionnalité pour `A`.
La valeur pour `record_template` est utilisée avec `content_template` pour construire l'entrée de modèle. Voici un exemple de configuration montrant comment construire une entrée de modèle à l'aide d'un modèle de contenu et d'enregistrement.
Dans l'exemple de code suivant, les en-têtes et les fonctionnalités sont définis comme suit.
+ ``headers`:["A", "B"]`
+ ``features`:[[0,1], [3,4]]`
Voici l'exemple d'entrée de modèle :
```
{
"instances": [[0, 1], [3, 4]],
"feature_names": ["A", "B"]
}
```
Les exemples de valeurs des paramètres `content_template` et `record_template` permettant de construire l'exemple d'entrée de modèle précédent sont les suivants.
+ `content_template: "{\"instances\": $records, \"feature_names\": $feature_names}"`
+ `record_template: "$features"`
Dans l'exemple de code suivant, les en-têtes et les fonctionnalités sont définis comme suit.
```
[
{ "A": 0, "B": 1 },
{ "A": 3, "B": 4 },
]
```
Les exemples de valeurs des paramètres ` content_template` et `record_template` permettant de construire l'exemple d'entrée de modèle précédent sont les suivants.
+ `content_template: "$records"`
+ `record_template: "$features_kvp"`
Voici un autre exemple de code pour construire l'exemple d'entrée de modèle précédent.
+ `content_template: "$records"`
+ `record_template: "{\"A\": \"${A}\", \"B\": \"${B}\"}"`
Dans l'exemple de code suivant, les en-têtes et les fonctionnalités sont définis comme suit.
```
{ "A": 0, "B": 1 }
```
Les exemples de valeurs des paramètres content\$1template et record\$1template utilisés pour construire l’exemple d’entrée de modèle précédent sont les suivants.
+ `content_template: "$record"`
+ `record_template: "$features_kvp"`
Pour obtenir plus d’exemples, consultez [Demandes de données de séries temporelles aux points de terminaison](clarify-processing-job-data-format-time-series-request-jsonlines.md).
+ **label** — (Facultatif) Indice entier de base zéro ou chaîne JMESPath d'expression utilisé pour extraire les étiquettes prédites de la sortie du modèle à des fins d'analyse des biais. Si le modèle est multiclasse et que le paramètre `label` extrait toutes les étiquettes prédites de la sortie du modèle, les points suivants s’appliquent. Cette caractéristique n’est pas prise en charge pour les séries temporelles.
+ Le paramètre `probability` est requis pour obtenir les probabilités (ou scores) correspondantes à partir de la sortie du modèle.
+ L'étiquette prédite du score le plus élevé est choisie.
La valeur de `label` dépend de la valeur du paramètre accept\$1type, comme suit.
+ Si `accept_type` a pour valeur **text/csv**, `label` est l'index de toutes les étiquettes prédites dans la sortie du modèle.
+ If `accept_type` is **application/jsonlines** or**application/json**, then `label` est une JMESPath expression appliquée à la sortie du modèle pour obtenir les étiquettes prédites.
+ **label\$1headers** : (facultatif) tableau de valeurs que l’étiquette peut prendre dans le jeu de données. Si une analyse de biais est demandée, le paramètre `probability` est également requis pour obtenir les valeurs de probabilité correspondantes (scores) à partir de la sortie du modèle et l’étiquette prédite du score le plus élevé est choisie. Si une analyse d'explicabilité est demandée, les en-têtes des étiquettes sont utilisés pour embellir le rapport d'analyse. Une valeur pour `label_headers` est requise pour l'explicabilité de la vision par ordinateur. Par exemple, pour un problème de classification multi-classes, si l’étiquette a trois valeurs possibles, **bird**, **cat** et **dog**, `label_headers` doit être défini sur `["bird","cat","dog"]`.
+ **probabilité** — (Facultatif) Indice entier basé sur zéro ou chaîne d' JMESPath expression utilisé pour extraire des probabilités (scores) pour une analyse d'explicabilité (mais pas pour l'explicabilité des séries chronologiques), ou pour choisir l'étiquette prédite pour l'analyse des biais. La valeur de `probability` dépend de la valeur du paramètre `accept_type`, comme suit.
+ Si `accept_type` a pour valeur **text/csv**, `probability` est l'index des probabilités (scores) figurant dans la sortie du modèle. Si `probability` n'est pas fourni, la totalité de la sortie du modèle est considérée comme les probabilités (scores).
+ S'il s'`accept_type`agit de données JSON (**application/jsonlines**ou**application/json**), `probability` il doit s'agir JMESPath d'une expression utilisée pour extraire les probabilités (scores) de la sortie du modèle.
+ **time\$1series\$1predictor\$1config** : (facultatif) utilisé uniquement pour l’explicabilité des séries temporelles. Utilisé pour indiquer au processeur SageMaker Clarify comment analyser correctement les données à partir des données transmises sous forme d'URI S3. `dataset_uri`
+ **forecast** — JMESPath Expression utilisée pour extraire le résultat de la prévision.
## Exemples de fichiers de configuration d’analyse
Les sections suivantes contiennent des exemples de fichiers de configuration d’analyse pour des données au format CSV et au format JSON Lines, ainsi que pour l’explicabilité du traitement du langage naturel (NLP), de la vision par ordinateur et des séries temporelles (TS).
### Configuration d’analyse pour un jeu de données CSV
Les exemples suivants montrent comment configurer l'analyse des biais et de l'explicabilité pour un jeu de données tabulaire au format CSV. Dans ces exemples, le jeu de données entrant comporte quatre colonnes de fonctionnalités et une colonne d'étiquettes binaires, `Target`. Le contenu du jeu de données est le suivant. Une valeur d’étiquette de `1` indique un résultat positif. L'ensemble de données est fourni à la tâche SageMaker Clarify par l'entrée `dataset` de traitement.
```
"Target","Age","Gender","Income","Occupation"
0,25,0,2850,2
1,36,0,6585,0
1,22,1,1759,1
0,48,0,3446,1
...
```
Les sections suivantes montrent comment calculer les mesures de biais avant et après l'entraînement, les valeurs SHAP et les diagrammes de dépendance partielle (PDPs) indiquant l'importance des fonctionnalités pour un ensemble de données au format CSV.
#### Calcul de toutes les métriques de biais de pré-entraînement
Cet exemple de configuration montre comment mesurer si l'exemple de jeu de données précédent est favorablement biaisé en faveur des échantillons avec une valeur de **Gender** égale à `0`. La configuration d'analyse suivante indique à la tâche de traitement SageMaker Clarify de calculer toutes les mesures de biais préalables à l'entraînement pour l'ensemble de données.
```
{
"dataset_type": "text/csv",
"label": "Target",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Calcul de toutes les métriques de biais de post-entraînement
Vous pouvez calculer les métriques de biais de pré-entraînement avant l'entraînement. Toutefois, vous devez disposer d'un modèle entraîné pour calculer les métriques de biais de post-entraînement. L'exemple de sortie suivant provient d'un modèle de classification binaire qui fournit en sortie des données au format CSV. Dans cet exemple de sortie, chaque ligne contient deux colonnes. La première colonne contient l’étiquette prédite et la deuxième colonne contient la valeur de probabilité pour cette étiquette.
```
0,0.028986845165491
1,0.825382471084594
...
```
L'exemple de configuration suivant indique à la tâche de traitement SageMaker Clarify de calculer toutes les mesures de biais possibles à l'aide du jeu de données et des prédictions issues de la sortie du modèle. Dans l'exemple, le modèle est déployé sur un point de terminaison d' SageMaker IA`your_endpoint`.
**Note**
Dans l’exemple de code suivant, les paramètres `content_type` et `accept_type` ne sont pas définis. Par conséquent, ils utilisent automatiquement la valeur du paramètre dataset\$1type, qui est `text/csv`.
```
{
"dataset_type": "text/csv",
"label": "Target",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"label": 0
}
}
```
#### Calcul des valeurs SHAP
L'exemple de configuration d'analyse suivant indique à la tâche de calculer les valeurs SHAP désignant la colonne `Target` comme des étiquettes et toutes les autres colonnes comme des fonctionnalités.
```
{
"dataset_type": "text/csv",
"label": "Target",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
}
}
```
Dans cet exemple, le paramètre SHAP `baseline` est omis et la valeur du paramètre `num_clusters` est `1`. Cela indique au processeur SageMaker Clarify de calculer un échantillon de base SHAP. Dans cet exemple, la probabilité est définie sur `1`. Cela indique à la tâche de traitement SageMaker Clarify d'extraire le score de probabilité de la deuxième colonne de la sortie du modèle (en utilisant une indexation basée sur zéro).
#### Calculer des diagrammes de dépendance partielle (PDPs)
L'exemple suivant montre comment visualiser l'importance de la `Income` fonctionnalité dans le rapport d'analyse à l'aide de PDPs. Le paramètre report indique à la tâche de traitement SageMaker Clarify de générer un rapport. Une fois la tâche terminée, le rapport généré est enregistré en tant que report.pdf à l'emplacement `analysis_result`. Le paramètre `grid_resolution` divise la plage de valeurs des caractéristiques en `10` compartiments. Ensemble, les paramètres spécifiés dans l'exemple suivant indiquent à la tâche de traitement SageMaker Clarify de générer un rapport contenant un graphique PDP pour les `Income` `10` segments sur l'axe X. L’axe Y montre l’impact marginal de `Income` sur les prédictions.
```
{
"dataset_type": "text/csv",
"label": "Target",
"methods": {
"pdp": {
"features": ["Income"],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
},
}
```
#### Calcul simultané des métriques de biais et de l'importance des fonctionnalités
Vous pouvez combiner toutes les méthodes des exemples de configuration précédents dans un fichier de configuration d'analyse unique et les calculer toutes à l'aide d'une seule tâche. L'exemple suivant montre une configuration d'analyse avec toutes les étapes combinées.
Dans cet exemple, le paramètre `probability` est défini sur `1` pour indiquer que les probabilités sont contenues dans la deuxième colonne (en utilisant une indexation basée sur zéro). Toutefois, comme l'analyse des biais nécessite une étiquette prédite, le paramètre `probability_threshold` est défini sur `0.5` pour convertir le score de probabilité en étiquette binaire. Dans cet exemple, le paramètre `top_k_features` de la méthode `pdp` des graphiques de dépendance partielle est défini sur `2`. Cela indique à la tâche de traitement SageMaker Clarify de calculer des diagrammes de dépendance partiels (PDPs) pour les principales `2` entités présentant les valeurs SHAP globales les plus élevées.
```
{
"dataset_type": "text/csv",
"label": "Target",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
}
}
```
Au lieu de déployer le modèle sur un point de terminaison, vous pouvez fournir le nom de votre modèle d' SageMaker IA à la tâche de traitement SageMaker Clarify à l'aide du `model_name` paramètre. L’exemple suivant montre comment spécifier un modèle nommé **your\$1model**. La tâche de traitement SageMaker Clarify créera un point de terminaison fictif à l'aide de la configuration.
```
{
...
"predictor": {
"model_name": "your_model",
"initial_instance_count": 1,
"instance_type": "ml.m5.large",
"probability": 1
}
}
```
### Configuration d'analyse pour un jeu de données JSON Lines
Les exemples suivants montrent comment configurer l’analyse des biais et l’analyse de l’explicabilité pour un jeu de données tabulaire au format JSON Lines. Dans ces exemples, le jeu de données entrant contient les mêmes données que dans la section précédente, mais elles sont au format dense SageMaker AI JSON Lines. Chaque ligne est un objet JSON valide. La clé "Features" pointe sur un tableau de valeurs de fonctionnalités, et la clé "Label" pointe sur l'étiquette de vérité terrain. L'ensemble de données est fourni à la tâche SageMaker Clarify par l'entrée de traitement « ensemble de données ». Pour plus d’informations sur les lignes JSON, consultez [Format de demande JSONLINES](cdf-inference.md#cm-jsonlines).
```
{"Features":[25,0,2850,2],"Label":0}
{"Features":[36,0,6585,0],"Label":1}
{"Features":[22,1,1759,1],"Label":1}
{"Features":[48,0,3446,1],"Label":0}
...
```
Les sections suivantes montrent comment calculer les métriques de biais avant et après l'entraînement, les valeurs SHAP et les diagrammes de dépendance partielle (PDPs) indiquant l'importance des fonctionnalités pour un ensemble de données au format JSON Lines.
#### Calcul des métriques de biais de pré-entraînement
Spécifiez l'étiquette, les fonctionnalités, le format et les méthodes pour mesurer les métriques de biais de pré-entraînement pour une valeur `Gender` de `0`. Dans l'exemple suivant, le paramètre `headers` fournit d'abord les noms des fonctionnalités. Le nom d'étiquette est fourni en dernier. Par convention, le dernier en-tête est l'en-tête d'étiquette.
Le `features` paramètre est défini sur l' JMESPath expression « Features » afin que la tâche de traitement SageMaker Clarify puisse extraire le tableau de caractéristiques de chaque enregistrement. Le `label` paramètre est défini sur JMESPath l'expression « Label » afin que la tâche de traitement SageMaker Clarify puisse extraire l'étiquette Ground Truth de chaque enregistrement. Utilisez un nom de facette pour spécifier l'attribut sensible, comme suit.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Calcul de toutes les métriques de biais
Vous devez disposer d'un modèle entraîné pour calculer les métriques de biais de post-entraînement. L'exemple suivant provient d'un modèle de classification binaire qui fournit en sortie des données JSON Lines dans le format de l'exemple. Chaque ligne de la sortie du modèle est un objet JSON valide. La clé `predicted_label` pointe vers l’étiquette prédite et la clé `probability` pointe vers la valeur de probabilité.
```
{"predicted_label":0,"probability":0.028986845165491}
{"predicted_label":1,"probability":0.825382471084594}
...
```
Vous pouvez déployer le modèle sur un point de terminaison d' SageMaker IA nommé`your_endpoint`. L'exemple de configuration d'analyse suivant indique à la tâche de traitement SageMaker Clarify de calculer toutes les mesures de biais possibles pour le jeu de données et le modèle. Dans cet exemple, les paramètres `content_type` et `accept_type` ne sont pas définis. Par conséquent, ils sont définis automatiquement sur la valeur du paramètre dataset\$1type, qui est `application/jsonlines`. La tâche de traitement SageMaker Clarify utilise le `content_template` paramètre pour composer l'entrée du modèle, en remplaçant l'`$features`espace réservé par un ensemble de fonctionnalités.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"label": "predicted_label"
}
}
```
#### Calcul des valeurs SHAP
Comme l'analyse SHAP ne nécessite pas d'étiquette de vérité terrain, le paramètre `label` est omis. Dans cet exemple, le paramètre `headers` est également omis. Par conséquent, la tâche de traitement SageMaker Clarify doit générer des espaces réservés utilisant des noms génériques tels que `column_0` ou `column_1` pour les en-têtes de fonctionnalités et `label0` pour un en-tête d'étiquette. Vous pouvez spécifier des valeurs pour `headers` et pour `label` afin d'améliorer la lisibilité du résultat de l'analyse. Le paramètre de probabilité étant défini sur JMESPath expression`probability`, la valeur de probabilité sera extraite de la sortie du modèle. Voici un exemple de calcul des valeurs SHAP.
```
{
"dataset_type": "application/jsonlines",
"features": "Features",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
#### Calculer les diagrammes de dépendance partiels () PDPs
L'exemple suivant montre comment visualiser l'importance de "Income" (revenus) sur un graphique PDP. Dans cet exemple, les en-têtes des fonctionnalités ne sont pas fournis. Par conséquent, le paramètre `features` de la méthode `pdp` doit utiliser un index basé sur zéro pour faire référence à l’emplacement de la colonne de caractéristiques. Le paramètre `grid_resolution` divise la plage de valeurs des caractéristiques en `10` compartiments. Ensemble, les paramètres de l'exemple indiquent à la tâche de traitement SageMaker Clarify de générer un rapport contenant un graphique PDP pour `Income` les `10` segments sur l'axe X. L’axe Y montre l’impact marginal de `Income` sur les prédictions.
```
{
"dataset_type": "application/jsonlines",
"features": "Features",
"methods": {
"pdp": {
"features": [2],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
#### Calcul simultané des métriques de biais et de l'importance des fonctionnalités
Vous pouvez combiner toutes les méthodes précédentes dans un fichier de configuration d'analyse unique et les calculer toutes à l'aide d'une seule tâche. L'exemple suivant montre une configuration d'analyse avec toutes les étapes combinées. Dans cet exemple, le paramètre `probability` est défini. Cependant, comme l'analyse des biais nécessite une étiquette prédite, le paramètre `probability_threshold` est défini sur `0.5` pour convertir le score de probabilité en étiquette binaire. Dans cet exemple, le paramètre `top_k_features` de la méthode `pdp` est défini sur `2`. Cela indique à la tâche de traitement SageMaker Clarify de calculer PDPs les principales `2` fonctionnalités présentant les valeurs SHAP globales les plus élevées.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
### Configuration d'analyse pour un jeu de données JSON
Les exemples suivants montrent comment configurer l’analyse des biais et de l’explicabilité pour un jeu de données tabulaire au format JSON. Dans ces exemples, le jeu de données entrant contient les mêmes données que dans la section précédente, mais elles sont au format dense SageMaker AI JSON. Pour plus d’informations sur les lignes JSON, consultez [Format de demande JSONLINES](cdf-inference.md#cm-jsonlines).
L’ensemble de la demande en entrée est une demande JSON valide où la structure externe est une liste et chaque élément correspond aux données d’un enregistrement. Dans chaque enregistrement, la clé `Features` pointe sur un tableau de valeurs de fonctionnalités et la clé `Label` pointe sur l'étiquette de vérité terrain. L'ensemble de données est fourni à la tâche SageMaker Clarify par l'entrée `dataset` de traitement.
```
[
{"Features":[25,0,2850,2],"Label":0},
{"Features":[36,0,6585,0],"Label":1},
{"Features":[22,1,1759,1],"Label":1},
{"Features":[48,0,3446,1],"Label":0},
...
]
```
Les sections suivantes montrent comment calculer les métriques de biais avant et après l'entraînement, les valeurs SHAP et les diagrammes de dépendance partielle (PDPs) qui montrent l'importance des fonctionnalités pour un ensemble de données au format JSON Lines.
#### Calcul des métriques de biais de pré-entraînement
Spécifiez l'étiquette, les fonctionnalités, le format et les méthodes pour mesurer les métriques de biais de pré-entraînement pour une valeur `Gender` de `0`. Dans l'exemple suivant, le paramètre `headers` fournit d'abord les noms des fonctionnalités. Le nom d'étiquette est fourni en dernier. Pour les jeux de données JSON, le dernier en-tête est l'en-tête d'étiquette.
Le `features` paramètre est défini sur l' JMESPath expression qui extrait un tableau ou une matrice 2D. Chaque ligne de cette matrice doit contenir la liste de `Features` pour chaque enregistrement. Le `label` paramètre est défini sur une JMESPath expression qui extrait une liste d'étiquettes de vérité fondamentale. Chaque élément de cette liste doit contenir l'étiquette d'un enregistrement.
Utilisez un nom de facette pour spécifier l'attribut sensible, comme suit.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Calcul de toutes les métriques de biais
Vous devez disposer d'un modèle entraîné pour calculer les métriques de biais de post-entraînement. L'exemple de code suivant provient d'un modèle de classification binaire qui fournit en sortie des données JSON dans le format de l'exemple. Dans cet exemple, chaque élément sous `predictions` est la sortie de prédiction d'un enregistrement. Cet exemple de code contient la clé `predicted_label`, qui pointe vers l’étiquette prédite, et la clé `probability` pointe vers la valeur de probabilité.
```
{
"predictions": [
{"predicted_label":0,"probability":0.028986845165491},
{"predicted_label":1,"probability":0.825382471084594},
...
]
}
```
Vous pouvez déployer le modèle sur un point de terminaison d' SageMaker IA nommé`your_endpoint`.
Dans l’exemple suivant, les paramètres `content_type` et `accept_type` ne sont pas définis. Par conséquent, `content_type` et `accept_type` sont définis automatiquement pour utiliser la valeur du paramètre `dataset_type`, qui est `application/json`. La tâche de traitement SageMaker Clarify utilise ensuite le `content_template` paramètre pour composer l'entrée du modèle.
Dans l'exemple suivant, l'entrée du modèle est composée en remplaçant l'espace réservé `$records` par un tableau d'enregistrements. Le paramètre `record_template` compose ensuite la structure JSON de chaque enregistrement et remplace l'espace réservé `$features` par le tableau de fonctionnalités de chaque enregistrement.
L'exemple de configuration d'analyse suivant indique à la tâche de traitement SageMaker Clarify de calculer toutes les mesures de biais possibles pour le jeu de données et le modèle.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"label": "predictions[*].predicted_label"
}
}
```
#### Calcul des valeurs SHAP
Vous n'avez pas besoin de spécifier d'étiquette pour l'analyse SHAP. Dans l'exemple suivant, le paramètre `headers` n'est pas spécifié. Par conséquent, la tâche de traitement SageMaker Clarify générera des espaces réservés utilisant des noms génériques tels que `column_0` ou `column_1` pour les en-têtes de fonctionnalités et `label0` pour un en-tête d'étiquette. Vous pouvez spécifier des valeurs pour `headers` et pour `label` afin d'améliorer la lisibilité du résultat de l'analyse.
Dans l'exemple de configuration suivant, le paramètre de probabilité est défini sur une JMESPath expression qui extrait les probabilités de chaque prédiction pour chaque enregistrement. Voici un exemple de calcul des valeurs SHAP.
```
{
"dataset_type": "application/json",
"features": "[*].Features",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
#### Calculer des diagrammes de dépendance partielle (PDPs)
L'exemple suivant vous montre comment afficher l'importance d'une fonctionnalité dans PDPs. Dans cet exemple, les en-têtes des fonctionnalités ne sont pas fournis. Par conséquent, le paramètre `features` de la méthode `pdp` doit utiliser un index basé sur zéro pour faire référence à l'emplacement de la colonne de fonctionnalités. Le paramètre `grid_resolution` divise la plage de valeurs des caractéristiques en `10` compartiments.
Ensemble, les paramètres de l'exemple suivant indiquent à la tâche de traitement SageMaker Clarify de générer un rapport contenant un graphique PDP pour `Income` les `10` segments sur l'axe X. L'axe Y montre l'impact marginal de `Income` sur les prédictions.
L'exemple de configuration suivant montre comment évaluer l'importance de `Income` on PDPs.
```
{
"dataset_type": "application/json",
"features": "[*].Features",
"methods": {
"pdp": {
"features": [2],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
#### Calcul simultané des métriques de biais et de l'importance des fonctionnalités
Vous pouvez combiner toutes les méthodes de configuration précédentes dans un fichier de configuration d'analyse unique et les calculer toutes à l'aide d'une seule tâche. L'exemple suivant montre une configuration d'analyse avec toutes les étapes combinées.
Dans cet exemple, le paramètre `probability` est défini. Comme l'analyse des biais nécessite une étiquette prédite, le paramètre `probability_threshold` est défini sur `0.5` et est utilisé pour convertir le score de probabilité en étiquette binaire. Dans cet exemple, le paramètre `top_k_features` de la méthode `pdp` est défini sur `2`. Cela indique à la tâche de traitement SageMaker Clarify de calculer PDPs les principales `2` fonctionnalités présentant les valeurs SHAP globales les plus élevées.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
### Configuration d'analyse pour l'explicabilité du traitement du langage naturel
L'exemple suivant montre un fichier de configuration d'analyse permettant de calculer l'importance des fonctionnalités pour le traitement du langage naturel (NLP). Dans cet exemple, le jeu de données entrant est un jeu de données tabulaire au format CSV, avec une seule colonne d'étiquettes binaires et deux colonnes de fonctionnalités, comme suit. L'ensemble de données est fourni à la tâche SageMaker Clarify par le paramètre d'entrée de `dataset` traitement.
```
0,2,"They taste gross"
1,3,"Flavor needs work"
1,5,"Taste is awful"
0,1,"The worst"
...
```
Dans cet exemple, un modèle de classification binaire a été entraîné sur le jeu de données précédent. Le modèle accepte les données CSV et produit un score unique compris entre `0` et `1`, comme suit.
```
0.491656005382537
0.569582343101501
...
```
Le modèle est utilisé pour créer un modèle d' SageMaker IA nommé « your\$1model ». La configuration d’analyse suivante montre comment exécuter une analyse d’explicabilité par jeton à l’aide du modèle et du jeu de données. Le paramètre `text_config` active l'analyse d'explicabilité du NLP. Le paramètre `granularity` indique que l’analyse doit analyser les jetons.
En anglais, chaque jeton est un mot. L'exemple suivant montre également comment fournir une instance "baseline" SHAP sur place en utilisant une note ("Rating") moyenne de 4. Un jeton de masque spécial "[MASK]" est utilisé pour remplacer un jeton (mot) dans les commentaires ("Comments"). Cet exemple utilise également un type d'instance de point de terminaison GPU pour accélérer l'inférence.
```
{
"dataset_type": "text/csv",
"headers": ["Target","Rating","Comments"]
"label": "Target",
"methods": {
"shap": {
"text_config": {
"granularity": "token",
"language": "english"
}
"baseline": [[4,"[MASK]"]],
}
},
"predictor": {
"model_name": "your_nlp_model",
"initial_instance_count": 1,
"instance_type": "ml.g4dn.xlarge"
}
}
```
### Configuration d'analyse pour l'explicabilité de la vision par ordinateur
L'exemple suivant montre un fichier de configuration d'analyse calculant l'importance des fonctionnalités pour la vision par ordinateur. Dans cet exemple, le jeu de données en entrée est constitué d'images JPEG. L'ensemble de données est fourni à la tâche SageMaker Clarify par le paramètre d'entrée de `dataset` traitement. L'exemple montre comment configurer une analyse d'explicabilité à l'aide d'un modèle de classification d' SageMaker images. Dans cet exemple, un modèle nommé `your_cv_ic_model` a été entraîné pour classer les animaux sur les images JPEG en entrée.
```
{
"dataset_type": "application/x-image",
"methods": {
"shap": {
"image_config": {
"model_type": "IMAGE_CLASSIFICATION",
"num_segments": 20,
"segment_compactness": 10
}
},
"report": {
"name": "report"
}
},
"predictor": {
"model_name": "your_cv_ic_model",
"initial_instance_count": 1,
"instance_type": "ml.p2.xlarge",
"label_headers": ["bird","cat","dog"]
}
}
```
Pour plus d’informations sur la classification des images, consultez [Classification des images - MXNet](image-classification.md).
Dans cet exemple, un [modèle de détection d'objets basé sur l'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/object-detection.html) `your_cv_od_model` est entraîné sur les mêmes images JPEG afin d'identifier les animaux qui s'y trouvent. L’exemple suivant montre comment configurer une analyse d’explicabilité pour le modèle de détection d’objet.
```
{
"dataset_type": "application/x-image",
"probability_threshold": 0.5,
"methods": {
"shap": {
"image_config": {
"model_type": "OBJECT_DETECTION",
"max_objects": 3,
"context": 1.0,
"iou_threshold": 0.5,
"num_segments": 20,
"segment_compactness": 10
}
},
"report": {
"name": "report"
}
},
"predictor": {
"model_name": "your_cv_od_model",
"initial_instance_count": 1,
"instance_type": "ml.p2.xlarge",
"label_headers": ["bird","cat","dog"]
}
}
```
### Configuration d’analyse pour l’explicabilité du modèle de prévision des séries temporelles
L’exemple suivant montre un fichier de configuration d’analyse pour le calcul de l’importance des caractéristiques pour une série temporelle (TS). Dans cet exemple, le jeu de données entrant est un jeu de données de séries temporelles au format JSON avec un jeu de caractéristiques de covariables dynamiques et statiques. L'ensemble de données est fourni à la tâche SageMaker Clarify par le paramètre d'entrée de traitement de l'ensemble de données`dataset_uri`.
```
[
{
"item_id": "item1",
"timestamp": "2019-09-11",
"target_value": 47650.3,
"dynamic_feature_1": 0.4576,
"dynamic_feature_2": 0.2164,
"dynamic_feature_3": 0.1906,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item1",
"timestamp": "2019-09-12",
"target_value": 47380.3,
"dynamic_feature_1": 0.4839,
"dynamic_feature_2": 0.2274,
"dynamic_feature_3": 0.1889,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item2",
"timestamp": "2020-04-23",
"target_value": 35601.4,
"dynamic_feature_1": 0.5264,
"dynamic_feature_2": 0.3838,
"dynamic_feature_3": 0.4604,
"static_feature_1": 1,
"static_feature_2": 2
},
]
```
Les sections suivantes expliquent comment calculer les attributions de caractéristiques pour un modèle de prévision à l’aide de l’algorithme de valeurs de Shapley asymétriques pour un jeu de données JSON.
#### Calcul des explications pour les modèles de prévision de séries temporelles
L’exemple de configuration d’analyse suivant affiche les options utilisées par la tâche pour calculer les explications pour les modèles de prévision des séries temporelles.
```
{
'dataset_type': 'application/json',
'dataset_uri': 'DATASET_URI',
'methods': {
'asymmetric_shapley_value': {
'baseline': {
"related_time_series": "zero",
"static_covariates": {
"item1": [0, 0], "item2": [0, 0]
},
"target_time_series": "zero"
},
'direction': 'chronological',
'granularity': 'fine_grained',
'num_samples': 10
},
'report': {'name': 'report', 'title': 'Analysis Report'}
},
'predictor': {
'accept_type': 'application/json',
'content_template': '{"instances": $records}',
'endpoint_name': 'ENDPOINT_NAME',
'content_type': 'application/json',
'record_template': '{
"start": $start_time,
"target": $target_time_series,
"dynamic_feat": $related_time_series,
"cat": $static_covariates
}',
'time_series_predictor_config': {'forecast': 'predictions[*].mean[:2]'}
},
'time_series_data_config': {
'dataset_format': 'timestamp_records',
'item_id': '[].item_id',
'related_time_series': ['[].dynamic_feature_1', '[].dynamic_feature_2', '[].dynamic_feature_3'],
'static_covariates': ['[].static_feature_1', '[].static_feature_2'],
'target_time_series': '[].target_value',
'timestamp': '[].timestamp'
}
}
```
##### Configuration de l’explicabilité des séries temporelles
L’exemple précédent utilise `asymmetric_shapley_value` dans `methods` pour définir les arguments d’explicabilité des séries temporelles tels que la référence, la direction, la granularité et le nombre d’échantillons. Les valeurs de référence sont définies pour les trois types de données : séries temporelles associées, covariables statiques et séries temporelles cibles. Ces champs indiquent au processeur SageMaker Clarify de calculer les attributions de fonctionnalités pour un élément à la fois.
##### Configuration du prédicteur
Vous pouvez contrôler entièrement la structure de charge utile envoyée par le processeur SageMaker Clarify à l'aide de JMESPath la syntaxe. Dans l’exemple précédent, la configuration `predictor` indique à Clarify d’agréger les enregistrements dans `'{"instances": $records}'`, chaque enregistrement étant défini avec les arguments donnés pour `record_template` dans l’exemple. Notez que `$start_time`, `$target_time_series`, `$related_time_series` et `$static_covariates` sont des jetons internes utilisés pour mapper les valeurs du jeu de données aux valeurs des demandes de point de terminaison.
De même, l’attribut `forecast` dans `time_series_predictor_config` est utilisé pour extraire la prévision du modèle à partir de la réponse du point de terminaison. Par exemple, la réponse par lots de votre point de terminaison peut être la suivante :
```
{
"predictions": [
{"mean": [13.4, 3.6, 1.0]},
{"mean": [23.0, 4.7, 3.0]},
{"mean": [3.4, 5.6, 2.0]}
]
}
```
Supposons que vous spécifiez la configuration du prédicteur de série temporelle suivante :
```
'time_series_predictor_config': {'forecast': 'predictions[*].mean[:2]'}
```
La valeur de prévision est analysée comme suit :
```
[
[13.4, 3.6],
[23.0, 4.7],
[3.4, 5.6]
]
```
##### Configuration des données
Utilisez l'`time_series_data_config`attribut pour demander au processeur SageMaker Clarify d'analyser correctement les données à partir des données transmises sous forme d'URI S3. `dataset_uri`
# Guide de compatibilité des formats de données
Ce guide décrit les types de formats de données compatibles avec les tâches de traitement SageMaker Clarify. Les types de format de données pris en charge incluent les extensions de fichier, la structure des données et des exigences ou restrictions spécifiques pour les jeux de données tabulaires, d’images et de séries temporelles. Ce guide explique également comment vérifier si votre jeu de données est conforme à ces exigences.
À un niveau élevé, la tâche de traitement SageMaker Clarify suit le modèle entrée-processus-sortie pour calculer les métriques de biais et les attributions de fonctionnalités. Consultez les exemples suivants pour plus de détails.
Les entrées de la tâche de traitement SageMaker Clarify sont les suivantes :
+ Le jeu de données à analyser
+ La configuration d’analyse Pour plus d’informations sur la manière de configurer une analyse, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
Au cours de la phase de traitement, SageMaker Clarify calcule les métriques de biais et les attributions de fonctionnalités. La tâche de traitement SageMaker Clarify effectue les étapes suivantes dans le backend :
+ La tâche de traitement SageMaker Clarify analyse votre configuration d'analyse et charge votre **ensemble de données**.
+ Pour calculer les métriques de biais et les attributions de fonctionnalités de post-entraînement, la tâche nécessite des prédictions de modèle à partir de votre modèle. **La tâche de traitement SageMaker Clarify sérialise vos données et les envoie sous forme de **demande** à votre modèle qui est déployé sur un point de terminaison d'inférence en temps réel SageMaker basé sur l'IA.** Ensuite, la tâche de traitement SageMaker Clarify extrait les prédictions de la **réponse**.
+ La tâche de traitement SageMaker Clarify effectue l'analyse du biais et de l'explicabilité, puis produit les résultats.
Pour plus d’informations, consultez [Comment fonctionnent les tâches SageMaker Clarify Processing](clarify-configure-processing-jobs.md#clarify-processing-job-configure-how-it-works).
Le paramètre que vous utilisez pour spécifier le format des données dépend de l'endroit où les données sont utilisées dans le flux de traitement, comme suit :
+ Pour un **jeu de données en entrée**, utilisez le paramètre `dataset_type` pour spécifier le format ou le type MIME.
+ Pour une **demande** adressée à un point de terminaison, utilisez le paramètre `content_type` pour spécifier le format.
+ Pour une **réponse** provenant d'un point de terminaison, utilisez le paramètre `accept_type` pour spécifier le format.
Le jeu de données en entrée, la demande et la réponse en direction et en provenance du point de terminaison ne nécessitent pas le même format. Par exemple, vous pouvez utiliser un jeu de données Parquet avec une charge utile de **demande** CSV et une charge utile de **réponse** JSON Lines dans les conditions suivantes.
+ Votre analyse est correctement configurée.
+ Votre modèle prend en charge les formats de demande et de réponse.
**Note**
S'`content_type``accept_type`ils ne sont pas fournis, le conteneur SageMaker Clarify en déduit le `content_type` et`accept_type`.
**Topics**
+ [
# Données tabulaires
](clarify-processing-job-data-format-tabular.md)
+ [
# Exigences relatives aux données d’image
](clarify-processing-job-data-format-image.md)
+ [
# Données de séries temporelles
](clarify-processing-job-data-format-time-series.md)
# Données tabulaires
Les données tabulaires font référence à des données qui peuvent être chargées dans un bloc de données bidimensionnel. Dans ce bloc, chaque ligne représente un enregistrement et chaque enregistrement comporte une ou plusieurs colonnes. Les valeurs de chaque cellule du bloc de données peuvent être de type numérique, catégoriel ou texte.
## Prérequis relatifs aux jeux de données tabulaires
Avant l'analyse, toutes les étapes de prétraitement nécessaires devraient déjà avoir été appliquées à votre jeu de données. Cela inclut le nettoyage des données ou l'ingénierie des fonctionnalités.
Vous pouvez fournir un ou plusieurs jeux de données. Si vous fournissez plusieurs ensembles de données, utilisez ce qui suit pour les identifier dans le cadre de la tâche de traitement SageMaker Clarify.
+ Utilisez une configuration [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)nommée `dataset` ou la configuration d'analyse `dataset_uri` pour spécifier le jeu de données principal. Pour plus d’informations sur `dataset_uri`, reportez-vous à la liste des paramètres dans [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
+ Utilisez le paramètre `baseline` fourni dans le fichier de configuration d’analyse. Le jeu de données de référence est requis pour l’analyse SHAP. Pour plus d’informations sur le fichier de configuration d’analyse, y compris des exemples, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
Le tableau suivant répertorie les formats de données pris en charge, leurs extensions de fichier et les types MIME.
| Format de données | Extension de fichier | Type MIME |
| --- | --- | --- |
| CSV | csv | `text/csv` |
| JSON Lines | jsonl | `application/jsonlines` |
| JSON | json | `application/json` |
| Parquet | parquet | "application/x-parquet" |
Les sections suivantes présentent des exemples de jeux de données tabulaires aux formats CSV, JSON Lines et Apache Parquet.
### Prérequis relatifs aux jeux de données tabulaires au format CSV
La tâche de traitement SageMaker Clarify est conçue pour charger des fichiers de données CSV dans le dialecte [csv .excel.](https://docs.python.org/3/library/csv.html#csv.excel) Toutefois, il est suffisamment flexible pour prendre en charge d'autres délimiteurs de ligne, notamment `\n` et `\r`.
Pour des raisons de compatibilité, tous les fichiers de données CSV fournis à la tâche de traitement SageMaker Clarify doivent être codés en UTF-8.
Si votre jeu de données ne contient pas de ligne d'en-têtes, procédez comme suit :
+ Définissez l'étiquette de configuration d'analyse sur l'index `0`. Cela signifie que la première colonne est l'étiquette de vérité terrain.
+ Si le paramètre `headers` est défini, définissez `label` sur l'en-tête de la colonne d'étiquettes pour indiquer l'emplacement de la colonne d'étiquettes. Toutes les autres colonnes sont désignées comme des fonctionnalités.
Voici un exemple de jeu de données qui ne contient pas de ligne d'en-têtes.
```
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
Si vos données contiennent une ligne d'en-têtes, définissez le paramètre `label` sur l'index `0`. Pour indiquer l'emplacement de la colonne d'étiquettes, utilisez l'en-tête de l'étiquette de vérité terrain `Label`. Toutes les autres colonnes sont désignées comme des fonctionnalités.
Voici un exemple de jeu de données qui contient une ligne d'en-têtes.
```
Label,Rating,A12,A13,Comments
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
### Prérequis des jeux de données tabulaires au format JSON
Le format JSON est un format flexible permettant de représenter des données structurées qui contiennent un niveau quelconque de complexité. La prise en charge de JSON par SageMaker Clarify n'est limitée à aucun format spécifique et permet donc des formats de données plus flexibles par rapport aux ensembles de données au format CSV ou JSON Lines. Ce guide explique comment définir une configuration d'analyse pour des données tabulaires au format JSON.
**Note**
Pour garantir la compatibilité, tous les fichiers de données JSON fournis à la tâche de traitement SageMaker Clarify doivent être codés en UTF-8.
Voici un exemple de données d'entrée avec des enregistrements contenant une clé de niveau supérieur, une liste de fonctionnalités et une étiquette.
```
[
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0},
...
]
```
Un exemple de configuration d'analyse pour l'exemple de jeu de données en entrée précédent doit définir les paramètres suivants :
+ Le `label` paramètre doit utiliser l'[JMESPath](https://jmespath.org/)expression `[*].label` pour extraire l'étiquette de vérité fondamentale pour chaque enregistrement de l'ensemble de données. L' JMESPath expression doit produire une liste d'étiquettes où le i the label correspond au i the record.
+ Le `features` paramètre doit utiliser l' JMESPathexpression `[*].features` pour extraire un tableau d'entités pour chaque enregistrement de l'ensemble de données. L' JMESPath expression doit produire un tableau ou une matrice 2D dans lequel la première ligne contient les valeurs des caractéristiques correspondant à l'enregistrement.
Voici un exemple de données d'entrée avec des enregistrements contenant une clé de niveau supérieur et une clé imbriquée contenant une liste de fonctionnalités et des étiquettes pour chaque enregistrement.
```
{
"data": [
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
]
}
```
Un exemple de configuration d'analyse pour l'exemple de jeu de données en entrée précédent doit définir les paramètres suivants :
+ Le `label` paramètre utilise l'[JMESPath](https://jmespath.org/)expression `data[*].label` pour extraire l'étiquette de vérité fondamentale pour chaque enregistrement de l'ensemble de données. L' JMESPath expression doit produire une liste d'étiquettes où le i the label est destiné au i the record.
+ Le `features` paramètre utilise l' JMESPath expression `data[*].features` pour extraire le tableau d'entités, pour chaque enregistrement de l'ensemble de données. L' JMESPath expression doit produire un tableau ou une matrice 2D dans lequel la première ligne contient les valeurs des caractéristiques du premier enregistrement.
### Prérequis des jeux de données tabulaires au format JSON Lines
JSON Lines est un format de texte permettant de représenter des données structurées où chaque ligne est un objet JSON valide. Actuellement, les tâches de traitement SageMaker Clarify ne prennent en charge que les lignes JSON au format SageMaker AI Dense. Pour respecter le format requis, toutes les fonctionnalités d’un enregistrement doivent être répertoriées dans un tableau JSON unique. Pour plus d’informations sur les lignes JSON, consultez [Format de demande JSONLINES](cdf-inference.md#cm-jsonlines).
**Note**
Tous les fichiers de données JSON Lines fournis à la tâche de traitement SageMaker Clarify doivent être codés en UTF-8 pour garantir la compatibilité.
Voici un exemple de définition d'une configuration d'analyse pour un enregistrement contenant une **clé de niveau supérieur** et une **liste** d'éléments.
```
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}
...
```
La configuration d'analyse pour l'exemple de jeu de données précédent doit définir les paramètres suivants :
+ Pour indiquer l'emplacement de l'étiquette de vérité fondamentale, le paramètre `label` doit être défini sur l' JMESPath expression`label`.
+ Pour indiquer l'emplacement du réseau de fonctionnalités, le paramètre `features` doit être défini sur l' JMESPath expression`features`.
Voici un exemple de définition d'une configuration d'analyse pour un enregistrement contenant une **clé de niveau supérieur** et une **clé imbriquée** contenant une **liste** d'éléments.
```
{"data":{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}}
{"data":{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
...
```
La configuration d'analyse pour l'exemple de jeu de données précédent doit définir les paramètres suivants :
+ Le paramètre `label` doit être défini sur l' JMESPathexpression indiquant `data.label` l'emplacement de l'étiquette de vérité fondamentale.
+ Le paramètre `features` doit être défini sur l' JMESPathexpression `data.features` pour indiquer l'emplacement du réseau d'entités.
### Prérequis des jeux de données tabulaires au format Parquet
[Parquet](https://parquet.apache.org/) est un format de données binaire orienté colonne. Actuellement, les tâches de traitement SageMaker Clarify prennent en charge le chargement des fichiers de données Parquet uniquement lorsque le nombre d'instances de traitement est égal `1` à
Étant donné que SageMaker les tâches de traitement Clarify ne prennent pas en charge les demandes de point de terminaison ou les réponses de point de terminaison au format Parquet, vous devez spécifier le format de données de la demande de point de terminaison en définissant le paramètre de configuration `content_type` d'analyse sur un format pris en charge. Pour plus d’informations, consultez `content_type` dans [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
Les données Parquet doivent avoir des noms de colonnes formatés sous forme de chaînes. Utilisez le paramètre `label` de configuration d'analyse pour définir le nom de la colonne d'étiquettes afin d'indiquer l'emplacement des étiquettes de vérité terrain. Toutes les autres colonnes sont désignées comme des fonctionnalités.
# Demandes du point de terminaison pour des données tabulaires
Pour obtenir des prédictions du modèle pour l'analyse des biais après l'entraînement et l'analyse de l'importance des fonctionnalités, les tâches de traitement SageMaker Clarify sérialisent les données tabulaires en octets et les envoient à un point de terminaison d'inférence sous forme de charge utile de demande. Ces données tabulaires proviennent du jeu de données en entrée ou sont générées. S'il s'agit de données synthétiques, elles sont générées par l'outil d'explication pour l'analyse SHAP ou l'analyse de PDP.
Le format de données de la charge utile de demande doit être spécifié par le `content_type` paramètre de la configuration d'analyse. Si le paramètre n'est pas fourni, la tâche de traitement SageMaker Clarify utilisera la valeur du `dataset_type` paramètre comme type de contenu. Pour plus d’informations sur `content_type` ou `dataset_type`, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
Les sections suivantes présentent des exemples de demande du point de terminaison aux formats CSV et JSON Lines.
## Demande du point de terminaison au format CSV
La tâche de traitement SageMaker Clarify peut sérialiser les données au format CSV (type MIME :`text/csv`). Le tableau suivant présente des exemples des charges utiles de demande sérialisée.
| Charge utile de demande du point de terminaison (représentation sous forme de chaîne) | Commentaires |
| --- | --- |
| '1,2,3,4' | Enregistrement unique (quatre caractéristiques numériques). |
| '1,2,3,4\$1n5,6,7,8' | Deux enregistrements, séparés par un saut de ligne '\$1n'. |
| ’"This is a good product",5’ | Enregistrement unique (fonctionnalité de texte et fonctionnalité numérique). |
| ‘"This is a good product",5\$1n"Bad shopping experience",1’ | Deux enregistrements. |
## Demande du point de terminaison au format JSON Lines
La tâche de traitement SageMaker Clarify peut sérialiser les données au format dense SageMaker AI JSON Lines (type MIME :`application/jsonlines`). Pour plus d’informations sur les lignes JSON, consultez [Format de demande JSONLINES](cdf-inference.md#cm-jsonlines).
Pour transformer des données tabulaires en données JSON, fournissez une chaîne de modèle au paramètre `content_template` de configuration d’analyse. Pour plus d’informations sur `content_template`, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md). Le tableau suivant montre des exemples de charges utiles de demande JSON Lines sérialisée.
| Charge utile de demande du point de terminaison (représentation sous forme de chaîne) | Commentaires |
| --- | --- |
| ’\$1"data":\$1"features":[1,2,3,4]\$1\$1’ | Enregistrement unique. Dans ce cas, le modèle ressemble à `'{"data":{"features":$features}}' ` et `$features` est remplacé par la liste de fonctionnalités `[1,2,3,4]`. |
| ’\$1"data":\$1"features":[1,2,3,4]\$1\$1\$1n\$1"data":\$1"features":[5,6,7,8]\$1\$1’ | Deux enregistrements. |
| ’\$1"features":["This is a good product",5]\$1’ | Enregistrement unique. Dans ce cas, le modèle ressemble à `'{"features":$features}'` et \$1features est remplacé par la liste de fonctionnalités `["This is a good product",5]`. |
| ’\$1"features":["This is a good product",5]\$1\$1n\$1"features":["Bad shopping experience",1]\$1’ | Deux enregistrements. |
## Demande du point de terminaison au format JSON
Une tâche de traitement SageMaker Clarify peut sérialiser des données dans des structures JSON arbitraires (type MIME :`application/json`). Pour ce faire, vous devez fournir une chaîne de modèle au paramètre `content_template` de configuration d’analyse. Ceci est utilisé par la tâche de traitement SageMaker Clarify pour construire la structure JSON externe. Vous devez également fournir une chaîne de modèle pour `record_template`, qui est utilisée pour construire la structure JSON pour chaque enregistrement. Pour plus d’informations sur `content_template` et `record_template`, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
**Note**
Étant donné que `content_template` et `record_template` sont des paramètres de chaîne, tous les guillemets doubles (`"`) faisant partie de la structure sérialisée JSON doivent être notés comme des caractères échappés dans votre configuration. Par exemple, si vous voulez échapper des guillemets doubles en Python, vous pouvez entrer ce qui suit pour `content_template`.
```
"{\"data\":{\"features\":$record}}}"
```
Le tableau suivant montre des exemples de charges utiles de demandes JSON sérialisées ainsi que les paramètres `content_template` et `record_template` correspondants, qui sont requis pour les construire.
| Charge utile de demande du point de terminaison (représentation sous forme de chaîne) | Commentaires | content\$1template | record\$1template |
| --- | --- | --- | --- |
| ’\$1"data":\$1"features":[1,2,3,4]\$1\$1’ | Un seul enregistrement à la fois. | '\$1"data":\$1"features":\$1record\$1\$1\$1' | “\$1features” |
| '\$1"instances":[[0, 1], [3, 4]], "feature-names": ["A", "B"]\$1' | Enregistrements multiples avec noms de fonctionnalités. | ‘\$1"instances":\$1records, "feature-names":\$1feature\$1names\$1' | “\$1features" |
| '[\$1"A": 0, "B": 1\$1, \$1"A": 3, "B": 4\$1]' | Enregistrements multiples et paires clé-valeur. | “\$1records" | “\$1features\$1kvp" |
| ‘\$1"A": 0, "B": 1\$1' | Un seul enregistrement à la fois et paires clé-valeur. | "\$1record" | "\$1features\$1kvp" |
| ‘\$1"A": 0, "nested": \$1"B": 1\$1\$1' | Vous pouvez également utiliser l'élément record\$1template entièrement détaillé pour les structures arbitraires. | "\$1record" | '\$1"A": "\$1\$1A\$1", "nested": \$1"B": "\$1\$1B\$1"\$1\$1' |
# Réponse du point de terminaison pour des données tabulaires
Une fois que la tâche de traitement SageMaker Clarify a reçu la réponse d'un appel de point de terminaison d'inférence, elle désérialise la charge utile de la réponse et en extrait des prédictions. Utilisez le paramètre `accept_type` de configuration d'analyse pour spécifier le format de données de la charge utile de réponse. Si `accept_type` ce n'est pas le cas, la tâche de traitement SageMaker Clarify utilisera la valeur du paramètre content\$1type comme format de sortie du modèle. Pour plus d’informations sur `accept_type`, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
Les prédictions peuvent se composer des étiquettes prédites pour l’analyse des biais ou des valeurs de probabilité (scores) pour l’analyse de l’importance des caractéristiques. Dans la configuration d'analyse `predictor`, les trois paramètres suivants extraient les prédictions.
+ Le paramètre `probability` est utilisé pour localiser les valeurs de probabilité (scores) dans la réponse du point de terminaison.
+ Le paramètre `label` est utilisé pour localiser les étiquettes prédites dans la réponse du point de terminaison.
+ (Facultatif) Le paramètre `label_headers` fournit les étiquettes prédites pour un modèle multiclasse.
Les directives suivantes concernent les réponses du point de terminaison aux formats CSV, JSON Lines et JSON.
## Réponse du point de terminaison au format CSV
Si la charge utile de la réponse est au format CSV (type MIME :`text/csv`), la tâche de traitement SageMaker Clarify désérialise chaque ligne. Elle extrait ensuite les prédictions des données désérialisées à l'aide des index de colonnes fournis dans la configuration d'analyse. Les lignes de la charge utile de réponse doivent correspondre aux enregistrements figurant dans la charge utile de demande.
Les tableaux suivants fournissent des exemples de données de réponse dans différents formats et pour différents types de problèmes. Vos données peuvent varier par rapport à ces exemples, à condition que les prédictions puissent être extraites conformément à la configuration d'analyse.
Les sections suivantes présentent des exemples de réponse du point de terminaison au format CSV.
### La réponse du point de terminaison est au format CSV et contient uniquement une probabilité
Le tableau suivant présente un exemple de réponse du point de terminaison pour des problèmes de régression et de classification binaire.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique. | ’0.6’ |
| Deux enregistrements (résultats sur une ligne, séparés par une virgule). | ’0.6,0.3’ |
| Deux enregistrements (résultats sur deux lignes). | ’0.6\$1n0.3’ |
Dans l'exemple précédent, le point de terminaison fournit en sortie une valeur de probabilité unique (score) de l'étiquette prédite. Pour extraire les probabilités à l'aide de l'index et les utiliser pour l'analyse de l'importance des fonctionnalités, définissez le paramètre de configuration d'analyse `probability` sur l'index de colonne `0`. Ces probabilités peuvent également être utilisées pour l’analyse des biais si elles sont converties en valeur binaire à l’aide du paramètre `probability_threshold`. Pour plus d’informations sur `probability_threshold`, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
Le tableau suivant est un exemple de réponse du point de terminaison pour un problème multiclasse.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique d'un modèle multiclasse (trois classes). | ’0.1,0.6,0.3’ |
| Deux enregistrements d'un modèle multiclasse (trois classes). | ’0.1,0.6,0.3\$1n0.2,0.5,0.3’ |
Dans l'exemple précédent, le point de terminaison fournit en sortie une liste de probabilités (scores). Si aucun index n'est fourni, toutes les valeurs sont extraites et utilisées pour l'analyse de l'importance des fonctionnalités. Si le paramètre de configuration d'analyse `label_headers` est fourni, La tâche de traitement SageMaker Clarify peut ensuite sélectionner l'en-tête de l'étiquette présentant la probabilité maximale comme étiquette prédite, qui peut être utilisée pour l'analyse des biais. Pour plus d’informations sur `label_headers`, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
### La réponse du point de terminaison est au format CSV et contient uniquement l’étiquette prédite
Le tableau suivant présente un exemple de réponse du point de terminaison pour des problèmes de régression et de classification binaire.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | ’1’ |
| Deux enregistrements (résultats sur une ligne, séparés par une virgule) | '1,0' |
| Deux enregistrements (résultats sur deux lignes) | '1\$1n0' |
Dans l'exemple précédent, le point de terminaison fournit en sortie l'étiquette prédite à la place de la probabilité. Définissez le paramètre `label` de la configuration de `predictor` sur l'index de colonne `0` afin que les étiquettes prédites puissent être extraites à l'aide de l'index et utilisées pour l'analyse des biais.
### La réponse du point de terminaison est au format CSV et contient l'étiquette prédite et la probabilité
Le tableau suivant présente un exemple de réponse du point de terminaison pour des problèmes de régression et de classification binaire.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '1,0.6' |
| Deux enregistrements | ’1,0.6\$1n0,0.3’ |
Dans l'exemple précédent, le point de terminaison fournit en sortie l'étiquette prédite suivie de sa probabilité. Définissez le paramètre `label` de la configuration de `predictor` sur l'index de colonne `0` et définissez `probability` sur l'index de colonne `1` pour extraire les deux valeurs de paramètre.
### La réponse du point de terminaison est au format CSV et contient les étiquettes prédites et les probabilités (multiclasses)
Un modèle multiclasse entraîné par Amazon SageMaker Autopilot peut être configuré pour générer la représentation sous forme de chaîne de la liste des étiquettes et des probabilités prédites. Le tableau d’exemple suivant montre un exemple de réponse du point de terminaison d’un modèle configuré pour fournir en sortie `predicted_label`, `probability`, `labels` et `probabilities`.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '"dog",0.6,"[\$1'cat\$1', \$1'dog\$1', \$1'fish\$1']","[0.1, 0,6, 0.3]"' |
| Deux enregistrements | '"dog",0.6,"[\$1'cat\$1', \$1'dog\$1', \$1'fish\$1']","[0.1, 0,6, 0.3]"\$1n""cat",0.7,[\$1'cat\$1', \$1'dog\$1', \$1'fish\$1']","[0.7, 0,2, 0.1]"' |
Dans l'exemple précédent, la tâche de traitement SageMaker Clarify peut être configurée de la manière suivante pour extraire les prédictions.
Pour l'analyse des biais, l'exemple précédent peut être configuré des différentes manières suivantes.
+ Définissez le paramètre `label` de la configuration de `predictor` sur `0` pour extraire l'étiquette prédite.
+ Définissez ce paramètre sur `2` pour extraire les étiquettes prédites et définissez `probability` sur `3` pour extraire les probabilités correspondantes. La tâche de traitement SageMaker Clarify peut déterminer automatiquement l'étiquette prévue en identifiant l'étiquette présentant la valeur de probabilité la plus élevée. En se référant à l'exemple précédent d'un enregistrement unique, le modèle prédit trois étiquettes : `cat`, `dog` et `fish`, avec les probabilités correspondantes de `0.1`, `0.6` et `0.3`. Sur la base de ces probabilités, l'étiquette prédite est `dog`, car elle a la valeur de probabilité la plus élevée de `0.6`.
+ Définissez `probability` sur `3` pour extraire les probabilités. Si tel `label_headers` est le cas, la tâche de traitement SageMaker Clarify peut déterminer automatiquement l'étiquette prévue en identifiant l'en-tête de l'étiquette présentant la valeur de probabilité la plus élevée.
Pour l'analyse de l'importance des fonctionnalités, l'exemple précédent peut être configuré comme suit.
+ Définissez `probability` sur `3` pour extraire les probabilités de toutes les étiquettes prédites. Ensuite, les attributions de fonctionnalités seront calculées pour toutes les étiquettes. Si le client ne spécifie pas `label_headers`, les étiquettes prédites seront utilisées comme en-têtes d'étiquettes dans le rapport d'analyse.
## Réponse du point de terminaison au format JSON Lines
Si la charge utile de la réponse est au format JSON Lines (type MIME :`application/jsonlines`), la tâche de traitement SageMaker Clarify désérialise chaque ligne au format JSON. Il extrait ensuite les prédictions des données désérialisées à l'aide des JMESPath expressions fournies dans la configuration de l'analyse. Les lignes de la charge utile de réponse doivent correspondre aux enregistrements figurant dans la charge utile de demande. Les tableaux suivants présentent des exemples de données de réponse dans différents formats. Vos données peuvent varier par rapport à ces exemples, à condition que les prédictions puissent être extraites conformément à la configuration d'analyse.
Les sections suivantes présentent des exemples de réponse du point de terminaison au format JSON Lines.
### La réponse du point de terminaison est au format JSON Lines et contient seulement la probabilité
Le tableau suivant est un exemple de réponse du point de terminaison qui fournit en sortie uniquement la valeur de probabilité (score).
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '\$1"score":0.6\$1' |
| Deux enregistrements | ’\$1"score":0.6\$1\$1n\$1"score":0.3\$1’ |
Pour l'exemple précédent, définissez le paramètre de configuration de l'analyse `probability` sur JMESPath l'expression « score » pour en extraire la valeur.
### La réponse du point de terminaison est au format JSON Lines et contient uniquement l'étiquette prédite
Le tableau suivant est un exemple de réponse du point de terminaison qui fournit en sortie uniquement l'étiquette prédite.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '\$1"prediction":1\$1' |
| Deux enregistrements | '\$1"prediction":1\$1\$1n\$1"prediction":0\$1' |
Pour l'exemple précédent, définissez le `label` paramètre de configuration du prédicteur sur JMESPath expression`prediction`. La tâche de traitement SageMaker Clarify peut ensuite extraire les étiquettes prédites à des fins d'analyse des biais. Pour de plus amples informations, veuillez consulter [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
### La réponse du point de terminaison est au format JSON Lines et contient l’étiquette prédite et la probabilité
Le tableau suivant est un exemple de réponse du point de terminaison qui fournit en sortie l'étiquette prédite et son score.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '\$1"prediction":1,"score":0.6\$1' |
| Deux enregistrements | '\$1"prediction":1,"score":0.6\$1\$1n\$1"prediction":0,"score":0.3\$1' |
Pour l'exemple précédent, définissez le `label` paramètre de `predictor` configuration sur l' JMESPath expression « prédiction » pour extraire les étiquettes prédites. Définissez `probability` l' JMESPath expression « score » pour extraire la probabilité. Pour de plus amples informations, veuillez consulter [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
### La réponse du point de terminaison est au format JSON Lines et contient les étiquettes prédites et les probabilités (multiclasses)
Le tableau suivant est un exemple de réponse du point de terminaison provenant d'un modèle multiclasse qui fournit en sortie les résultats suivants :
+ La liste des étiquettes prédites.
+ Les probabilités, et l'étiquette prédite sélectionnée et sa probabilité.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| Deux enregistrements | '\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1label":"cat","probability":0.7,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.7,0.2,0.1]\$1' |
Dans l'exemple précédent, la tâche de traitement SageMaker Clarify peut être configurée de plusieurs manières pour extraire les prédictions.
Pour l'analyse des biais, l'exemple précédent peut être configuré d'**une** des manières suivantes.
+ Définissez le `label` paramètre de `predictor` configuration sur l' JMESPath expression « predicted\$1label » pour extraire l'étiquette prédite.
+ Définissez le paramètre sur l' JMESPath expression « predicted\$1labels » pour extraire les étiquettes prédites. Définissez `probability` l' JMESPath expression « probabilités » pour extraire leurs probabilités. La tâche SageMaker Clarify détermine automatiquement l'étiquette prévue en identifiant l'étiquette présentant la valeur de probabilité la plus élevée.
+ Définissez `probability` l' JMESPath expression « probabilités » pour extraire leurs probabilités. Si elle `label_headers` est fournie, la tâche de traitement SageMaker Clarify peut déterminer automatiquement l'étiquette prévue en identifiant l'étiquette présentant la valeur de probabilité la plus élevée.
Pour l'analyse de l'importance des fonctionnalités, procédez comme suit.
+ Définissez `probability` l' JMESPath expression « probabilités » pour extraire leurs probabilités de toutes les étiquettes prédites. Ensuite, les attributions de fonctionnalités seront calculées pour toutes les étiquettes.
## Réponse du point de terminaison au format JSON
Si la charge utile de la réponse est au format JSON (type MIME :`application/json`), la tâche de traitement SageMaker Clarify désérialise la totalité de la charge utile au format JSON. Il extrait ensuite les prédictions des données désérialisées à l'aide des JMESPath expressions fournies dans la configuration d'analyse. Les enregistrements de la charge utile de réponse doivent correspondre aux enregistrements figurant dans la charge utile de demande.
Les sections suivantes présentent des exemples de réponse du point de terminaison au format JSON. Ces sections contiennent des tableaux indiquant des exemples de données de réponse dans différents formats et pour différents types de problèmes. Vos données peuvent varier par rapport à ces exemples, à condition que les prédictions puissent être extraites conformément à la configuration d'analyse.
### La réponse du point de terminaison est au format JSON et contient uniquement la probabilité
Le tableau suivant est un exemple de réponse d'un point de terminaison qui fournit en sortie uniquement la valeur de probabilité (score).
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '[0.6]' |
| Deux enregistrements | '[0.6,0.3]' |
Dans l'exemple précédent, il n'y a aucun saut de ligne dans la charge utile de réponse. Au lieu de cela, un seul objet JSON contient la liste des scores, un pour chaque enregistrement figurant dans la demande. Définissez le paramètre de configuration de `probability` l'analyse sur JMESPath l'expression « [\$1] » pour extraire la valeur.
### La réponse du point de terminaison est au format JSON et contient uniquement l'étiquette prédite
Le tableau suivant est un exemple de réponse d'un point de terminaison qui fournit en sortie uniquement l'étiquette prédite.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '\$1"predicted\$1labels":[1]\$1' |
| Deux enregistrements | '\$1"predicted\$1labels":[1,0]\$1' |
Définissez le `label` paramètre de `predictor` configuration sur l' JMESPath expression « predicted\$1labels », puis la tâche de traitement SageMaker Clarify pourra extraire les étiquettes prédites à des fins d'analyse des biais.
### La réponse du point de terminaison est au format JSON et contient l'étiquette prédite et la probabilité
Le tableau suivant est un exemple de réponse d'un point de terminaison qui fournit en sortie l'étiquette prédite et son score.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '\$1"predictions":[\$1"label":1,"score":0.6\$1' |
| Deux enregistrements | ‘\$1"predictions":[\$1"label":1,"score":0.6\$1,\$1"label":0,"score":0.3\$1]\$1' |
Pour l'exemple précédent, définissez le `label` paramètre de `predictor` configuration sur l' JMESPath expression « predictions [\$1] .label » pour extraire les étiquettes prédites. Définissez `probability` l' JMESPath expression « predictions [\$1] .score » pour extraire la probabilité.
### La réponse du point de terminaison est au format JSON et contient les étiquettes prédites et les probabilités (multiclasses)
Le tableau suivant est un exemple de réponse d'un point de terminaison provenant d'un modèle multiclasse qui fournit en sortie les résultats suivants :
+ La liste des étiquettes prédites.
+ Les probabilités, et l'étiquette prédite sélectionnée et sa probabilité.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '[\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1]' |
| Deux enregistrements | '[\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1,\$1"predicted\$1label":"cat","probability":0.7,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.7,0.2,0.1]\$1]' |
La tâche de traitement SageMaker Clarify peut être configurée de plusieurs manières pour extraire les prédictions.
Pour l'analyse des biais, l'exemple précédent peut être configuré d'**une** des manières suivantes.
+ Définissez le `label` paramètre de `predictor` configuration sur l' JMESPath expression « [\$1] .predicted\$1label » pour extraire l'étiquette prédite.
+ Définissez le paramètre sur l' JMESPath expression « [\$1] .predicted\$1labels » pour extraire les étiquettes prédites. Définissez `probability` l' JMESPath expression « [\$1] .probabilities » pour extraire leurs probabilités. La tâche de traitement SageMaker Clarify peut déterminer automatiquement l'étiquette prévue en identifiant l'étiquette présentant la valeur de proximité la plus élevée.
+ Définissez `probability` l' JMESPath expression « [\$1] .probabilities » pour extraire leurs probabilités. Si elle `label_headers` est fournie, la tâche de traitement SageMaker Clarify peut déterminer automatiquement l'étiquette prévue en identifiant l'étiquette présentant la valeur de probabilité la plus élevée.
Pour l'analyse de l'importance des caractéristiques, définissez `probability` JMESPath l'expression « [\$1] .probabilités » pour extraire leurs probabilités de toutes les étiquettes prédites. Ensuite, les attributions de fonctionnalités seront calculées pour toutes les étiquettes.
# Vérification préalable de la demande et de la réponse du point de terminaison pour des données tabulaires
Nous vous recommandons de déployer votre modèle sur un point de terminaison d'inférence en temps réel basé sur l' SageMaker IA et d'envoyer des demandes à ce point de terminaison. Examinez manuellement les demandes et les réponses pour vous assurer qu’elles sont toutes conformes aux exigences spécifiées dans la section [Demandes du point de terminaison pour des données tabulaires](clarify-processing-job-data-format-tabular-request.md) et dans la section [Réponse du point de terminaison pour des données tabulaires](clarify-processing-job-data-format-tabular-response.md). Si votre conteneur de modèle prend en charge les demandes par lots, vous pouvez commencer par une seule demande d’enregistrement, puis essayer avec deux enregistrements ou plus.
Les commandes suivantes montrent comment demander une réponse à l’aide de l’ AWS CLI. AWS CLI Il est préinstallé dans les instances SageMaker Studio et SageMaker Notebook. Pour l'installer AWS CLI, suivez ce [guide d'installation](https://aws.amazon.com/cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Les paramètres sont définis, comme suit :
+ `$ENDPOINT NAME` : nom du point de terminaison.
+ `$CONTENT_TYPE` : type MIME de la demande (entrée du conteneur de modèle).
+ `$ACCEPT_TYPE` : type MIME de la réponse (sortie du conteneur de modèle).
+ `$REQUEST_DATA` : chaîne de données utiles demandée.
+ `$CLI_BINARY_FORMAT` : format du paramètre de l'interface de ligne de commande (CLI). Pour AWS CLI la version 1, ce paramètre doit rester vide. Pour la version 2, ce paramètre doit être défini sur `--cli-binary-format raw-in-base64-out`.
**Note**
AWS CLI v2 transmet les paramètres binaires sous forme de chaînes codées en base64 [par](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam) défaut.
# AWS CLI exemples v1
L'exemple de la section précédente concernait la AWS CLI version 2. Les exemples de demande et de réponse suivants à destination et en provenance du point de terminaison utilisent la version 1 d' AWS CLI .
## Demande et réponse du point de terminaison au format CSV
Dans l'exemple de code suivant, la demande se compose d'un seul enregistrement et la réponse est sa valeur de probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
0.6
```
Dans l'exemple de code suivant, la demande se compose de deux enregistrements et la réponse inclut leurs probabilités, séparées par une virgule.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, l'expression `$'content'` contenue dans `--body` indique à la commande d'interpréter `'\n'` dans le contenu comme un saut de ligne. La sortie de la réponse est la suivante.
```
0.6,0.3
```
Dans l'exemple de code suivant, la demande se compose de deux enregistrements et la réponse inclut leurs probabilités, séparées par un saut de ligne.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
0.6
0.3
```
Dans l'exemple de code suivant, la demande se compose d'un seul enregistrement et la réponse est constituée des valeurs de probabilité issues d'un modèle multiclasse contenant trois classes.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
0.1,0.6,0.3
```
Dans l'exemple de code suivant, la demande se compose de deux enregistrements et la réponse inclut leurs valeurs de probabilité issues d'un modèle multiclasse contenant trois classes.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
0.1,0.6,0.3
0.2,0.5,0.3
```
Dans l'exemple de code suivant, la demande se compose de deux enregistrements et la réponse inclut l'étiquette prédite et la probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
1,0.6
0,0.3
```
Dans l'exemple de code suivant, la demande se compose de deux enregistrements et la réponse inclut les en-têtes d'étiquettes et les probabilités.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
"['cat','dog','fish']","[0.1,0.6,0.3]"
"['cat','dog','fish']","[0.2,0.5,0.3]"
```
## Demande et réponse du point de terminaison au format JSON Lines
Dans l'exemple de code suivant, la demande se compose d'un seul enregistrement et la réponse est sa valeur de probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
{"score":0.6}
```
Dans l'exemple de code suivant, la demande contient deux enregistrements et la réponse inclut l'étiquette prédite et la probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
{"predicted_label":1,"probability":0.6}
{"predicted_label":0,"probability":0.3}
```
Dans l'exemple de code suivant, la demande contient deux enregistrements et la réponse inclut les en-têtes d'étiquettes et les probabilités.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}
```
## Demande et réponse du point de terminaison dans des formats mixtes
Dans l'exemple de code suivant, la demande est au format CSV et la réponse au format JSON Lines.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
{"probability":0.6}
{"probability":0.3}
```
Dans l'exemple de code suivant, la demande est au format JSON Lines et la réponse au format CSV.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
0.6
0.3
```
Dans l'exemple de code suivant, la demande est au format CSV et la réponse au format JSON.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dans l’exemple de code précédent, la sortie de la réponse est la suivante.
```
{"predictions":[{"label":1,"score":0.6},{"label":0,"score":0.3}]}
```
# Exigences relatives aux données d’image
Une tâche de traitement SageMaker Clarify permet d'expliquer les images. Cette rubrique fournit les exigences de format de données pour des données d’image. Pour en savoir plus sur le traitement des données d’image, consultez [Analyse de données d’image pour l’explicabilité de la vision par ordinateur](clarify-processing-job-run.md#clarify-processing-job-run-cv).
Un jeu de données d’image contient un ou plusieurs fichiers image. Pour identifier un ensemble de données d'entrée pour la tâche de traitement SageMaker Clarify, définissez un [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html#sagemaker-CreateProcessingJob-request-ProcessingInputs)nom `dataset` ou un `dataset_uri` paramètre de configuration d'analyse sur un préfixe d'URI Amazon S3 de vos fichiers image.
Les formats de fichier image et les extensions de fichier pris en charge sont répertoriés dans le tableau suivant.
| Format d'image | Extension de fichier |
| --- | --- |
| JPEG | jpg, jpeg |
| PNG | png |
Définissez le paramètre `dataset_type` de configuration d'analyse sur **application/x-image**. Comme le type n'est pas un format de fichier image spécifique, `content_type` sera utilisé pour décider du format et de l'extension des fichiers image.
La tâche de traitement SageMaker Clarify charge chaque fichier image dans un [NumPytableau](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html) tridimensionnel pour un traitement ultérieur. Les trois dimensions incluent la hauteur, la largeur et les valeurs RVB de chaque pixel.
## Format de demande de point de terminaison
La tâche de traitement SageMaker Clarify convertit les données RGB brutes d'une image en un format d'image compatible, tel que JPEG. Elle fait cela avant d'envoyer les données au point de terminaison pour les prédictions. Les formats d'image pris en charge sont les suivants.
| Format de données | Type MIME | Extension de fichier |
| --- | --- | --- |
| JPEG | `image/jpeg` | jpg, jpeg |
| PNG | `image/png` | png |
| NPY | `application/x-npy` | Toutes les opérations ci-dessus |
Spécifiez le format de données de la charge utile de demande en utilisant le paramètre `content_type` de configuration d'analyse. Si `content_type` n’est pas fourni, le format de données par défaut est `image/jpeg`.
## Format de réponse de point de terminaison
Dès réception de la réponse à un appel d'un point de terminaison d'inférence, la tâche de traitement SageMaker Clarify désérialise la charge utile de la réponse, puis en extrait les prédictions.
### Problème de classification d'image
Le format de données de la charge utile de la réponse doit être spécifié par le paramètre accept\$1type de configuration d'analyse. Si `accept_type` n'est pas fourni, le format de données par défaut est `application/json`. Les formats pris en charge sont les mêmes que ceux décrits dans **Réponse du point de terminaison pour des données tabulaires**, dans la section des données tabulaires.
Voici un [Inférence avec l'algorithme de classification d'images](image-classification.md#IC-inference) exemple d'algorithme de classification d'images intégré à l' SageMaker IA qui accepte une seule image puis renvoie un tableau de valeurs de probabilité (scores), chacune pour une classe.
Comme indiqué dans le tableau suivant, lorsque le paramètre `content_type` est défini sur `application/jsonlines`, la réponse est un objet JSON.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Image unique | '\$1"prediction":[0.1,0.6,0.3]\$1' |
Dans l'exemple précédent, définissez le `probability` paramètre sur l' JMESPath expression « prédiction » pour extraire les scores.
Lorsque `content_type` est défini sur `application/json`, la réponse est un objet JSON, comme indiqué dans le tableau suivant.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Image unique | '[0.1,0.6,0.3]' |
Dans l'exemple précédent, définissez `probability` l' JMESPath expression « [\$1] » pour extraire tous les éléments du tableau. Dans l'exemple précédent, [`0.1, 0.6, 0.3]` est extrait. Sinon, si vous ne définissez pas le paramètre `probability` de configuration, tous les éléments du tableau sont également extraits. Cela est dû au fait que la totalité de la charge utile est désérialisée sous forme de prédictions.
### Problème de détection d'objet
Par défaut, le paramètre `accept_type` de configuration d’analyse a pour valeur `application/json` et le seul format pris en charge est le format d’inférence de détection d’objet. Pour plus d’informations sur les formats de réponse, consultez [Formats de réponse](object-detection-in-formats.md#object-detection-recordio).
Le tableau suivant est un exemple de réponse d’un point de terminaison qui fournit en sortie un tableau. Chaque élément de ce tableau est un tableau de valeurs contenant l'index de classe, le score de confiance et les coordonnées du cadre de délimitation de l'objet détecté.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Image unique (un seul objet) | '[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244]]' |
| Image unique (deux objets) | '[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475]]' |
Le tableau suivant est un exemple de réponse d'un point de terminaison qui fournit en sortie un objet JSON avec une clé faisant référence au tableau. Définissez le paramètre `probability` de configuration d'analyse sur la clé "prediction" pour extraire les valeurs.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) |
| --- | --- |
| Image unique (un seul objet) | '\$1"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244]]\$1' |
| Image unique (deux objets) | '\$1"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475]]\$1' |
## Vérification préalable de la demande et de la réponse du point de terminaison pour des données d’image
Nous vous recommandons de déployer votre modèle sur un point de terminaison d'inférence en temps réel basé sur l' SageMaker IA et d'envoyer des demandes à ce point de terminaison. Examinez manuellement les demandes et les réponses. Assurez-vous que les deux sont conformes aux exigences spécifiées dans la section **Demande du point de terminaison pour des données d'image** et dans la section **Réponse du point de terminaison pour des données d'image**.
Voici deux exemples de code montrant comment envoyer des demandes et examiner les réponses pour des problèmes de classification d'image et de détection d'objet.
### Problème de classification d'image
L'exemple de code suivant indique à un point de terminaison de lire un fichier PNG, puis classe ce dernier.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-image-classification \
--content-type "image/png" \
--accept "application/json" \
--body fileb://./test.png \
/dev/stderr 1>/dev/null
```
Dans l'exemple de code précédent, la sortie de la réponse est la suivante.
```
[0.1,0.6,0.3]
```
### Problème de détection d'objet
L'exemple de code suivant indique à un point de terminaison de lire un fichier JPEG, puis classe les objets qu'il contient.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-object-detection \
--content-type "image/jpg" \
--accept "application/json" \
--body fileb://./test.jpg \
/dev/stderr 1>/dev/null
```
Dans l’exemple de code précédent, la sortie de la réponse est la suivante.
```
{"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475],[4.0, 0.32643985450267792, 0.3677481412887573, 0.034883320331573486, 0.6318609714508057, 0.5967587828636169],[8.0, 0.22552496790885925, 0.6152569651603699, 0.5722782611846924, 0.882301390171051, 0.8985623121261597],[3.0, 0.42260299175977707, 0.019305512309074402, 0.08386176824569702, 0.39093565940856934, 0.9574796557426453]]}
```
# Données de séries temporelles
Les données de séries temporelles font référence à des données qui peuvent être chargées dans un dataframe tridimensionnel. Dans ce dataframe, dans chaque horodatage, chaque ligne représente un enregistrement cible et chaque enregistrement cible a une ou plusieurs colonnes associées. Les valeurs de chaque cellule du bloc de données peuvent être de type numérique, catégoriel ou texte.
## Conditions préalables relatives aux jeux de données de séries temporelles
Avant l’analyse, effectuez les étapes de prétraitement nécessaires à la préparation de vos données, telles que le nettoyage des données ou l’ingénierie des caractéristiques. Vous pouvez fournir un ou plusieurs jeux de données. Si vous fournissez plusieurs ensembles de données, utilisez l'une des méthodes suivantes pour les fournir à la tâche de traitement SageMaker Clarify :
+ Utilisez une configuration [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)nommée `dataset` ou la configuration d'analyse `dataset_uri` pour spécifier le jeu de données principal. Pour plus d’informations sur `dataset_uri`, reportez-vous à la liste des paramètres dans [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
+ Utilisez le paramètre `baseline` fourni dans le fichier de configuration d’analyse. Le jeu de données de référence est requis pour `static_covariates`, s’il est présent. Pour plus d’informations sur le fichier de configuration d’analyse, y compris des exemples, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
Le tableau suivant répertorie les formats de données pris en charge, leurs extensions de fichier et les types MIME.
| Format de données | Extension de fichier | Type MIME |
| --- | --- | --- |
| `item_records` | json | `application/json` |
| `timestamp_records` | json | `application/json` |
| `columns` | json | `application/json` |
JSON est un format flexible qui peut représenter un niveau quelconque de complexité dans vos données structurées. Comme indiqué dans le tableau, SageMaker Clarify prend en charge `item_records` les formats`timestamp_records`, et`columns`.
## Exemples de configuration de jeux de données de séries temporelles
Cette section vous montre comment définir une configuration d’analyse utilisant `time_series_data_config` pour des données de séries temporelles au format JSON. Supposons que vous disposez d’un jeu de données comportant deux éléments, chacun doté d’un horodatage (t), d’une série temporelle cible (x), de deux séries temporelles connexes (r) et de deux covariables statiques (u), comme suit :
t1 = [0,1,2], t2 = [2,3]
x1 = [5,6,4], x2 = [0,4]
r1 = [0,1,0], r21 = [1,1]
r12 = [0,0,0], r22 = [1,0]
u11 = -1, u21 = 0
u12 = 1, u22 = 2
Vous pouvez encoder le jeu de données en utilisant `time_series_data_config` de trois manières différentes, selon `dataset_format`. Les sections suivantes décrivent chaque méthode.
### Configuration des données de séries temporelles quand `dataset_format` a pour valeur `columns`
L’exemple suivant utilise la valeur `columns` pour `dataset_format`. Le fichier JSON suivant représente le jeu de données précédent.
```
{
"ids": [1, 1, 1, 2, 2],
"timestamps": [0, 1, 2, 2, 3], # t
"target_ts": [5, 6, 4, 0, 4], # x
"rts1": [0, 1, 0, 1, 1], # r1
"rts2": [0, 0, 0, 1, 0], # r2
"scv1": [-1, -1, -1, 0, 0], # u1
"scv2": [1, 1, 1, 2, 2], # u2
}
```
Notez que les identifiants des éléments sont répétés dans le champ `ids`. L’implémentation correcte de `time_series_data_config` est illustrée comme suit :
```
"time_series_data_config": {
"item_id": "ids",
"timestamp": "timestamps",
"target_time_series": "target_ts",
"related_time_series": ["rts1", "rts2"],
"static_covariates": ["scv1", "scv2"],
"dataset_format": "columns"
}
```
### Configuration des données de séries temporelles quand `dataset_format` a pour valeur `item_records`
L’exemple suivant utilise la valeur `item_records` pour `dataset_format`. Le fichier JSON suivant représente le jeu de données.
```
[
{
"id": 1,
"scv1": -1,
"scv2": 1,
"timeseries": [
{"timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0},
{"timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0},
{"timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0}
]
},
{
"id": 2,
"scv1": 0,
"scv2": 2,
"timeseries": [
{"timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1},
{"timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0}
]
}
]
```
Chaque élément est représenté sous la forme d’une entrée distincte dans le code JSON. L'extrait suivant montre le correspondant `time_series_data_config` (qui utilise JMESPath).
```
"time_series_data_config": {
"item_id": "[*].id",
"timestamp": "[*].timeseries[].timestamp",
"target_time_series": "[*].timeseries[].target_ts",
"related_time_series": ["[*].timeseries[].rts1", "[*].timeseries[].rts2"],
"static_covariates": ["[*].scv1", "[*].scv2"],
"dataset_format": "item_records"
}
```
### Configuration des données de séries temporelles quand `dataset_format` a pour valeur `timestamp_record`
L’exemple suivant utilise la valeur `timestamp_record` pour `dataset_format`. Le fichier JSON suivant représente le jeu de données précédent.
```
[
{"id": 1, "timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 2, "timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1, "svc1": 0, "svc2": 2},
{"id": 2, "timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0, "svc1": 0, "svc2": 2},
]
```
Chaque entrée du code JSON représente un horodatage unique et correspond à un élément unique. L’implémentation `time_series_data_config` est illustrée comme suit :
```
{
"item_id": "[*].id",
"timestamp": "[*].timestamp",
"target_time_series": "[*].target_ts",
"related_time_series": ["[*].rts1"],
"static_covariates": ["[*].scv1"],
"dataset_format": "timestamp_records"
}
```
# Demandes de données de séries temporelles aux points de terminaison
Une tâche de traitement SageMaker Clarify sérialise les données dans des structures JSON arbitraires (avec le type MIME :`application/json`). Pour ce faire, vous devez fournir une chaîne de modèle au paramètre `content_template` de configuration d’analyse. Ceci est utilisé par la tâche de traitement SageMaker Clarify pour créer la requête JSON fournie à votre modèle. `content_template`contient un ou plusieurs enregistrements de votre ensemble de données. Vous devez également fournir une chaîne de modèle pour `record_template`, qui est utilisée pour construire la structure JSON de chaque enregistrement. Ces enregistrements sont ensuite insérés dans `content_template`. Pour plus d’informations sur `content_type` ou `dataset_type`, consultez [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md).
**Note**
Étant donné que `content_template` et `record_template` sont des paramètres de chaîne, tous les guillemets doubles (") faisant partie de la structure sérialisée JSON doivent être notés comme des caractères échappés dans votre configuration. Par exemple, si vous voulez échapper des guillemets doubles en Python, vous pouvez entrer la valeur suivante pour `content_template` :
```
'$record'
```
Le tableau suivant montre des exemples de données utiles de demandes JSON sérialisées ainsi que les paramètres `content_template` et `record_template` correspondants, requis pour les construire.
| Cas d’utilisation | Charge utile de demande du point de terminaison (représentation sous forme de chaîne) | content\$1template | record\$1template |
| --- | --- | --- | --- |
| Un seul enregistrement à la fois | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Un seul enregistrement avec `$related_time_series` et `$static_covariates` | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
| Enregistrements multiples | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00"}]}` | `'{"instances": $records}'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Enregistrements multiples avec `$related_time_series` et `$static_covariates` | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}]}` | `'{"instances": $records}'` | `''{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
# Réponse des points de terminaison pour des données de séries temporelles
La tâche de traitement SageMaker Clarify désérialise l'intégralité de la charge utile au format JSON. Il extrait ensuite les prédictions des données désérialisées à l'aide des JMESPath expressions fournies dans la configuration d'analyse. Les enregistrements de la charge utile de réponse doivent correspondre aux enregistrements figurant dans la charge utile de demande.
Le tableau suivant est un exemple de réponse d’un point de terminaison qui fournit en sortie uniquement la valeur de prédiction moyenne. La valeur `forecast` utilisée dans le `predictor` champ de la [configuration d'analyse](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-configure-analysis.html#clarify-processing-job-configure-analysis-parameters) doit être fournie sous forme d' JMESPath expression pour trouver le résultat de la prédiction pour la tâche de traitement.
| Charge utile de demande du point de terminaison | Charge utile de réponse du point de terminaison (représentation sous forme de chaîne) | JMESPath expression pour les prévisions dans la configuration d'analyse |
| --- | --- | --- |
| Exemple d’enregistrement unique. La configuration doit être `TimeSeriesModelConfig(forecast="prediction.mean")` pour extraire correctement la prédiction. | `'{"prediction": {"mean": [1, 2, 3, 4, 5]}'` | `'prediction.mean'` |
| Enregistrements multiples. Une réponse AWS approfondie du point de terminaison. | `'{"predictions": [{"mean": [1, 2, 3, 4, 5]}, {"mean": [1, 2, 3, 4, 5]}]}'` | `'predictions[*].mean'` |
# Vérification préalable de la demande et de la réponse du point de terminaison pour des données de séries temporelles
Il est conseillé de déployer votre modèle sur un point de terminaison d'inférence en temps réel basé sur l' SageMaker IA et d'envoyer des demandes au point de terminaison. Examinez manuellement les demandes et les réponses pour vous assurer qu’elles sont toutes conformes aux exigences spécifiées dans les sections [Demandes de données de séries temporelles aux points de terminaison](clarify-processing-job-data-format-time-series-request-jsonlines.md) et [Réponse des points de terminaison pour des données de séries temporelles](clarify-processing-job-data-format-time-series-response-json.md). Si votre conteneur de modèle prend en charge les demandes par lots, vous pouvez commencer par une seule demande d’enregistrement, puis essayer avec deux enregistrements ou plus.
Les commandes suivantes montrent comment demander une réponse à l’aide de l’ AWS CLI. AWS CLI Il est préinstallé dans les instances Studio et SageMaker Notebook. Pour l'installer AWS CLI, suivez le [guide d'installation](https://aws.amazon.com//cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Les paramètres sont définis, comme suit :
+ \$1ENDPOINT NAME : nom du point de terminaison.
+ \$1CONTENT\$1TYPE : type MIME de la demande (entrée du conteneur de modèle).
+ \$1ACCEPT\$1TYPE : type MIME de la réponse (sortie du conteneur de modèle).
+ \$1REQUEST\$1DATA : chaîne de données utiles demandée.
+ \$1CLI\$1BINARY\$1FORMAT : format du paramètre de l’interface de ligne de commande (CLI). Pour AWS CLI la version 1, ce paramètre doit rester vide. Pour la version 2, ce paramètre doit être défini sur `--cli-binary-format raw-in-base64-out`.
**Note**
AWS CLI v2 transmet les paramètres binaires sous forme de chaînes codées en base64 par défaut. Les exemples de demande et de réponse suivants à destination et en provenance du point de terminaison utilisent la AWS CLI version v1.
------
#### [ Example 1 ]
Dans l’exemple de code suivant, la demande se compose d’un seul enregistrement.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json \
--content-type application/json \
--accept application/json \
--body '{"target": [1, 2, 3, 4, 5],
"start": "2024-01-01 01:00:00"}' \
/dev/stderr 1>/dev/null
```
L’extrait suivant montre la sortie de réponse correspondante.
```
{'predictions': {'mean': [1, 2, 3, 4, 5]}
```
------
#### [ Example 2 ]
Dans l’exemple de code suivant, la demande contient deux enregistrements.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json-2 \
--content-type application/json \
--accept application/json \
--body $'{"instances": [{"target":[1, 2, 3],
"start":"2024-01-01 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}], {"target":[1, 2, 3],
"start":"2024-01-02 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}]}' \
dev/stderr 1>/dev/null
```
En voici la sortie de réponse :
```
{'predictions': [{'mean': [1, 2, 3, 4, 5]}, {'mean': [1, 2, 3, 4, 5]}]}
```
------