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.
# Activer la détection des anomalies sur les capteurs d'un actif
## Création d'un modèle de calcul ()AWS CLI
Pour créer un modèle de calcul, utilisez l'interface de ligne de AWS commande (AWS CLI). Après avoir défini le modèle de calcul, entraîné le modèle et planifié l'inférence pour détecter les anomalies sur un actif dans. AWS IoT SiteWise
+ Créez un fichier `anomaly-detection-computation-model-payload.json` avec le contenu suivant :
```
{
"computationModelName": "anomaly-detection-computation-model-name",
"computationModelConfiguration": {
"anomalyDetection": {
"inputProperties": "${input_properties}",
"resultProperty": "${result_property}"
}
},
"computationModelDataBinding": {
"input_properties": {
"list": [{
"assetModelProperty": {
"assetModelId": "asset-model-id",
"propertyId": "input-property-id-1"
}
},
{
"assetModelProperty": {
"assetModelId": "asset-model-id",
"propertyId": "input-property-id-2"
}
}
]
},
"result_property": {
"assetModelProperty": {
"assetModelId": "asset-model-id",
"propertyId": "results-property-id"
}
}
}
}
```
+ Exécutez la commande suivante pour créer un modèle de calcul :
```
aws iotsitewise create-computation-model \
--cli-input-json file://anomaly-detection-computation-model-payload.json
```
## ExecuteAction Préparation de la charge utile de l'API
Les étapes suivantes pour exécuter l'entraînement et l'inférence sont effectuées avec l'[ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API. L'entraînement et l'inférence sont configurés avec une configuration de charge utile d'action JSON. Lors de l'appel de l'[ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API, la charge utile de l'action doit être fournie sous forme de valeur avec une `stringValue` charge utile.
La charge utile doit respecter strictement les exigences de l'API. Plus précisément, la valeur doit être une **chaîne plate**, sans **caractères de contrôle** (par exemple, nouvelles lignes, tabulations ou retours de chariot).
Les options suivantes fournissent deux méthodes fiables pour fournir une charge utile d'action valide :
### Option 1 : utiliser un fichier de charge utile propre
La procédure suivante décrit les étapes à suivre pour nettoyer le fichier de charge utile :
1. Nettoyez le fichier pour supprimer les caractères de contrôle.
```
tr -d '\n\r\t' < original-action-payload.json > training-or-inference-action-payload.json
```
1. Exécutez l'action avec le fichier`@=file://...`.
```
aws iotsitewise execute-action \
--target-resource computationModelId= \
--action-definition-id \
--resolve-to assetId= \
--action-payload stringValue@=file://training-or-inference-action-payload.json
```
### Option 2 : chaîne en ligne avec guillemets échappés
Les étapes suivantes décrivent les étapes à suivre pour fournir la charge utile en ligne et éviter les fichiers intermédiaires :
+ Utilisez des guillemets évadés (`\"`) dans la chaîne JSON.
+ Placez l'`StringValue=..`expression entière entre guillemets.
**Example d'une charge utile d'action échappée :**
```
aws iotsitewise execute-action \
--target-resource computationModelId= \
--action-definition-id \
--resolve-to assetId= \
--action-payload "stringValue={\"exportDataStartTime\":1717225200,\"exportDataEndTime\":1722789360,\"targetSamplingRate\":\"PT1M\"}"
```
## Entraînez le modèle (AWS CLI)
Une fois le modèle de calcul créé, vous pouvez entraîner un modèle en fonction des actifs. Suivez les étapes ci-dessous pour entraîner un modèle pour un actif :
1. Exécutez la commande suivante pour trouver `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_TRAINING`action. `computation-model-id`Remplacez-le par l'ID renvoyé à l'étape précédente.
```
aws iotsitewise describe-computation-model \
--computation-model-id computation-model-id
```
1. Créez un fichier appelé `anomaly-detection-training-payload.json` et ajoutez-y les valeurs suivantes :
**Note**
La charge utile doit être conforme à. [Option 1 : utiliser un fichier de charge utile propre](#clean-payload-file)
1. `StartTime`avec le début des données d'entraînement, fournies en secondes d'époque.
1. `EndTime`avec les données de fin d'entraînement, fournies en secondes d'époque.
1. Vous pouvez éventuellement configurer[Configurations d'entraînement avancées](adv-training-configs.md), pour améliorer les performances du modèle.
1. (Facultatif) `TargetSamplingRate` avec le taux d'échantillonnage des données.
1. (Facultatif) `LabelInputConfiguration` pour spécifier les périodes pendant lesquelles un comportement anormal s'est produit afin d'améliorer l'apprentissage des modèles.
1. (Facultatif) `ModelEvaluationConfiguration` pour évaluer les performances du modèle en exécutant l'inférence sur une plage de temps spécifiée une fois l'entraînement terminé.
1. (Facultatif) `ModelMetricsDestination` pour collecter des données de performance complètes (précision, rappel, surface sous la courbe).
```
{
"trainingMode": "TRAIN_MODEL",
"exportDataStartTime": StartTime,
"exportDataEndTime": EndTime
}
```
**Example d'un exemple de charge utile d'entraînement :**
```
{
"trainingMode": "TRAIN_MODEL",
"exportDataStartTime": 1717225200,
"exportDataEndTime": 1722789360
}
```
1. Exécutez la commande suivante pour démarrer l'entraînement. Remplacez les paramètres suivants dans la commande :
1. `computation-model-id`avec l'ID du modèle de calcul cible.
1. `asset-id`avec l'ID de l'actif sur lequel vous allez entraîner le modèle.
1. `training-action-definition-id`avec l'ID de l'`AWS/ANOMALY_DETECTION_TRAINING`action de l'étape 1.
```
aws iotsitewise execute-action \
--target-resource computationModelId=computation-model-id \
--resolve-to assetId=asset-id \
--action-definition-id training-action-definition-id \
--action-payload stringValue@=file://anomaly-detection-training-payload.json
```
**Example d'une action d'exécution :**
```
aws iotsitewise execute-action --target-resource computationModelId=27cb824c-fd84-45b0-946b-0a5b0466d890 --resolve-to assetId=cefd4b68-481b-4735-b466-6a4220cd19ee --action-definition-id e54cea94-5d1c-4230-a59e-4f54dcbc972d --action-payload stringValue@=file://anomaly-detection-training-payload.json
```
1. Exécutez la commande suivante pour vérifier l'état du processus d'entraînement du modèle. Le dernier résumé de l'exécution indique le statut de l'exécution (`RUNNING``COMPLETED`//`FAILED`).
```
aws iotsitewise list-executions \
--target-resource-type COMPUTATION_MODEL \
--target-resource-id computation-model-id\
--resolve-to-resource-type ASSET \
--resolve-to-resource-id asset-id
```
1. Exécutez la commande suivante pour vérifier la configuration du dernier modèle entraîné. Cette commande produit une sortie uniquement si au moins un modèle a été entraîné avec succès.
```
aws iotsitewise describe-computation-model-execution-summary \
--computation-model-id computation-model-id \
--resolve-to-resource-type ASSET \
--resolve-to-resource-id asset-id
```
1. Lorsqu'un `ComputationModel` est utilisé AssetModelProperty, utilisez l'[ListComputationModelResolveToResources](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ListComputationModelResolveToResources.html)API pour identifier les actifs sur lesquels des actions ont été exécutées.
```
aws iotsitewise list-computation-model-resolve-to-resources \
--computation-model-id computation-model-id
```
## Démarrer et arrêter le réentraînement du modèle ()AWS CLI
Après l'entraînement initial du modèle, vous pouvez configurer le réentraînement automatique pour remédier à la dérive des données et maintenir la précision du modèle au fil du temps. Le planificateur de reconversion vous permet de configurer des mises à jour périodiques du modèle avec des modes de promotion configurables.
### Lancer le planificateur de reconversion
1. Exécutez la commande suivante pour trouver `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_TRAINING`action. `computation-model-id`Remplacez-le par l'ID renvoyé lors de la création de votre modèle de calcul.
```
aws iotsitewise describe-computation-model \
--computation-model-id computation-model-id
```
1. Créez un fichier appelé `anomaly-detection-start-retraining-payload.json` et ajoutez le code suivant. Remplacez les paramètres par les valeurs décrites.
**Note**
La charge utile doit être conforme à. [Option 1 : utiliser un fichier de charge utile propre](#clean-payload-file)
1. `lookbackWindow`avec la fenêtre de données historiques à utiliser pour le recyclage (`P180D`//`P360D``P540D`/`P720D`).
1. `retrainingFrequency`avec la fréquence de réentraînement du modèle (minimum`P30D`, maximum`P1Y`).
1. (Facultatif) `promotion` avec le mode promotion du modèle (`SERVICE_MANAGED`ou`CUSTOMER_MANAGED`). La valeur par défaut est `SERVICE_MANAGED`.
1. (Facultatif) `retrainingStartDate` avec la date de début du programme de reconversion, exprimée en secondes d'époque. Tronque l'heure au jour UTC le plus proche. Facultatif, la date par défaut est la date du jour.
1. Vous pouvez éventuellement configurer [Configurations d'entraînement avancées](adv-training-configs.md) pour améliorer les performances du modèle.
1. (Facultatif) `ModelMetricsDestination` pour obtenir des données de performance complètes (précision, rappel, surface sous la courbe).
```
{
"trainingMode": "START_RETRAINING_SCHEDULER",
"retrainingConfiguration": {
"lookbackWindow": "P180D",
"promotion": "SERVICE_MANAGED",
"retrainingFrequency": "P30D",
"retrainingStartDate": "StartDate"
}
}
```
1. Exécutez la commande suivante pour démarrer le planificateur de reconversion. Remplacez les paramètres suivants dans la commande :
1. `computation-model-id`avec l'ID du modèle de calcul cible.
1. `asset-id`avec l'ID de l'actif sur lequel vous allez entraîner le modèle.
1. `training-action-definition-id`avec l'ID de l'`AWS/ANOMALY_DETECTION_TRAINING`action de l'étape 1.
```
aws iotsitewise execute-action \
--target-resource computationModelId=computation-model-id \
--resolve-to assetId=asset-id \
--action-definition-id training-action-definition-id \
--action-payload stringValue@=file://anomaly-detection-start-retraining-payload.json
```
**Example Exemple de commande d'action d'exécution**
```
aws iotsitewise execute-action --target-resource computationModelId=27cb824c-fd84-45b0-946b-0a5b0466d890 --resolve-to assetId=cefd4b68-481b-4735-b466-6a4220cd19ee --action-definition-id e54cea94-5d1c-4230-a59e-4f54dcbc972d --action-payload stringValue@=file://anomaly-detection-start-retraining-payload.json
```
### Arrêter le planificateur de reconversion
1. Exécutez la commande suivante pour trouver `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_TRAINING`action. Remplacez `computation-model-id` par l'ID réel du modèle de calcul créé précédemment.
```
aws iotsitewise describe-computation-model \
--computation-model-id computation-model-id
```
1. Créez un fichier `anomaly-detection-stop-retraining-payload.json` et ajoutez les éléments suivants :
**Note**
La charge utile doit être conforme à. [Option 1 : utiliser un fichier de charge utile propre](#clean-payload-file)
```
{
"trainingMode": "STOP_RETRAINING_SCHEDULER"
}
```
1. Exécutez la commande suivante pour arrêter le planificateur de reconversion. Remplacez les paramètres suivants dans la commande :
1. `computation-model-id`avec l'ID du modèle de calcul cible.
1. `asset-id`avec l'ID de l'actif sur lequel vous allez entraîner le modèle.
1. `training-action-definition-id`avec l'ID de l'`AWS/ANOMALY_DETECTION_TRAINING`action de l'étape 1.
```
aws iotsitewise execute-action \
--target-resource computationModelId=computation-model-id \
--resolve-to assetId=asset-id \
--action-definition-id training-action-definition-id \
--action-payload stringValue@=file://anomaly-detection-stop-retraining-payload.json
```
## Démarrer et arrêter l'inférence ()AWS CLI
Après avoir entraîné le modèle, lancez l'inférence. Cela indique de AWS IoT SiteWise surveiller activement vos actifs industriels pour détecter les anomalies.
### Lancer l'inférence
1. Exécutez la commande suivante pour trouver `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_INFERENCE`action. Remplacez `computation-model-id` par l'ID réel du modèle de calcul créé précédemment.
```
aws iotsitewise describe-computation-model \
--computation-model-id computation-model-id
```
1. Créez un fichier `anomaly-detection-start-inference-payload.json` et ajoutez les valeurs suivantes :
**Note**
La charge utile doit être conforme à. [Option 1 : utiliser un fichier de charge utile propre](#clean-payload-file)
```
"inferenceMode": "START",
"dataUploadFrequency": "DataUploadFrequency"
```
1. `DataUploadFrequency`: configurez la fréquence à laquelle le programme d'inférence s'exécute pour effectuer la détection des anomalies. Les valeurs autorisées sont :`PT5M, PT10M, PT15M, PT30M, PT1H, PT2H..PT12H, PT1D`.
1. (Facultatif) `DataDelayOffsetInMinutes` avec le décalage du délai en minutes. Définissez cette valeur entre 0 et 60 minutes.
1. (Facultatif) `TargetModelVersion` avec la version du modèle à activer.
1. (Facultatif) Configurez la `weeklyOperatingWindow` avec une configuration Shift.
1. Vous pouvez éventuellement configurer[Configurations d'inférence avancées](advanced-inference-configurations.md).
1. [Inférence à haute fréquence (5 minutes — 1 heure)](advanced-inference-configurations.md#high-frequency-inferencing).
1. [Inférence à basse fréquence (2 heures — 1 jour)](advanced-inference-configurations.md#low-frequency-inferencing).
1. [Planification flexible](advanced-inference-configurations.md#flexible-scheduling).
1. Exécutez la commande suivante pour démarrer l'inférence. Remplacez les paramètres suivants dans le fichier de charge utile.
1. `computation-model-id`avec l'ID du modèle de calcul cible.
1. `asset-id`avec l'identifiant de l'actif sur lequel le modèle a été entraîné.
1. `inference-action-definition-id`avec l'ID de l'`AWS/ANOMALY_DETECTION_INFERENCE`action de l'étape 1.
```
aws iotsitewise execute-action \
--target-resource computationModelId=computation-model-id \
--resolve-to assetId=asset-id \
--action-definition-id inference-action-definition-id \
--action-payload stringValue@=file://anomaly-detection-inference-payload.json
```
1. Exécutez la commande suivante pour vérifier si l'inférence est toujours en cours. Le `inferenceTimerActive` champ est défini sur `TRUE` lorsque l'inférence est active.
```
aws iotsitewise describe-computation-model-execution-summary \
--computation-model-id computation-model-id \
--resolve-to-resource-type ASSET \
--resolve-to-resource-id asset-id
```
1. La commande suivante répertorie toutes les exécutions d'inférence :
```
aws iotsitewise list-executions \
--target-resource-type COMPUTATION_MODEL \
--target-resource-id computation-model-id \
--resolve-to-resource-type ASSET \
--resolve-to-resource-id asset-id
```
1. Exécutez la commande suivante pour décrire une exécution individuelle. Remplacez `execution-id` par l'identifiant de l'étape 5 précédente.
```
aws iotsitewise describe-execution \
--execution-id execution-id
```
### Arrêter l'inférence
1. Exécutez la commande suivante pour trouver `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_INFERENCE`action. Remplacez `computation-model-id` par l'ID réel du modèle de calcul créé précédemment.
```
aws iotsitewise describe-computation-model \
--computation-model-id computation-model-id
```
1. Créez un fichier `anomaly-detection-stop-inference-payload.json` et ajoutez le code suivant.
```
{
"inferenceMode": "STOP"
}
```
**Note**
La charge utile doit être conforme à. [Option 1 : utiliser un fichier de charge utile propre](#clean-payload-file)
1. Exécutez la commande suivante pour arrêter l'inférence. Remplacez le paramètre suivant dans le fichier de charge utile :
1. `computation-model-id`avec l'ID du modèle de calcul cible.
1. `asset-id`avec l'identifiant de l'actif sur lequel le modèle a été entraîné.
1. `inference-action-definition-id`avec l'ID de l'`AWS/ANOMALY_DETECTION_INFERENCE`action de l'étape 1.
**Example de la commande d'arrêt de l'inférence :**
```
aws iotsitewise execute-action \
--target-resource computationModelId=computation-model-id \
--resolve-to assetId=asset-id \
--action-definition-id inference-action-definition-id \
--action-payload stringValue@=file://anomaly-detection-stop-inference-payload.json
```
## Trouver des modèles de calcul qui utilisent une ressource donnée pour la liaison de données
Pour répertorier les modèles de calcul liés à une ressource donnée :
+ **modèle d'actif** (récupère tous les modèles de calcul où l'une des propriétés de ce modèle d'actif est liée).
+ **actif** (récupère tous les modèles de calcul où l'une des propriétés de cet actif est liée)
+ **propriété du modèle d'actif** (récupère tous les modèles de calcul auxquels cette propriété est liée)
+ **asset property** (récupère tous les modèles de calcul auxquels cette propriété est liée). Cela peut être fourni à titre informatif ou obligatoire lorsque l'utilisateur essaie de lier cette propriété à un autre modèle de calcul (mais elle est déjà liée ailleurs)
Utilisez [ ListComputationModelDataBindingUsages](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ListComputationModelDataBindingUsages.html)l'API pour récupérer une liste de `ComputationModelId` s qui prennent l'actif (propriété) ou le modèle d'actif (propriété) comme liaison de données.
Préparez un `request.json` avec les informations suivantes :
```
{
"dataBindingValueFilter": {
"asset": {
"assetId": ""
}
// OR
"assetModel": {
"assetModelId": ""
}
// OR
"assetProperty": {
"assetId": "",
"propertyId": ""
}
// OR
"assetModelProperty": {
"assetModelId": "",
"propertyId": ""
}
},
"nextToken": "",
"maxResults": ""
}
```
Utilisez la `list-computation-model-data-binding-usages` commande pour récupérer les modèles contenant des actifs ou des modèles d'actifs sous forme de liaisons de données.
```
aws iotsitewise list-computation-model-data-binding-usages \
--cli-input-json file://request.json
```