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.

# Permettre la détection des anomalies sur les capteurs des actifs
<a name="anom-detection-sensors-across-asset"></a>

## Création d'un modèle de calcul ()AWS CLI
<a name="create-computation-model-across-assets"></a>

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înez-le et planifiez l'inférence pour détecter les anomalies sur les actifs de. AWS IoT SiteWise

Les étapes suivantes expliquent ce processus :

1. Pour configurer la détection des anomalies, utilisez le [UpdateAssetModel(AWS CLI)](https://docs.aws.amazon.com/cli/latest/reference/iotsitewise/update-asset-model.html) et répondez aux exigences suivantes :

   1. Au moins une propriété d'entrée de type `DOUBLE` ou de `INTEGER` données. Il s'agit d'une propriété de mesure ou de transformation, utilisée pour entraîner le modèle.

   1. Propriété de résultat de type `STRING` donnée. Il doit s'agir d'une propriété de mesure et enregistrer les résultats de détection des anomalies.

1. Créez un fichier `anomaly-detection-computation-model-payload.json` avec le contenu suivant :
**Note**  
Créez un modèle de calcul en le fournissant directement `assetProperty` comme source de données.

   ```
   {
       "computationModelName": "name of ComputationModel",
       "computationModelConfiguration": {
           "anomalyDetection": {
               "inputProperties": "${properties}",
               "resultProperty": "${p3}"
           }
       },
       "computationModelDataBinding": {
           "properties": {
               "list": [
                   {
                       "assetProperty": { 
                           "assetId": "asset-id",
                           "propertyId": "input-property-id-1"
                       }
                   },
                   {
                       "assetProperty": { 
                           "assetId": "asset-id",
                           "propertyId": "input-property-id-2"
                       }
                   }
               ]
           },
           "p3": {
               "assetProperty": { 
                   "assetId": "asset-id",
                   "propertyId": "results-property-id"
               }
           }
       }
   }
   ```

1. 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
<a name="create-action-payload-across-assets"></a>

 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
<a name="clean-payload-file-across-assets"></a>

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=<MODEL_ID> \
       --action-definition-id <ACTION_DEFINITION_ID> \
       --action-payload stringValue@=file://training-or-inference-action-payload.json
   ```

### Option 2 : chaîne en ligne avec guillemets échappés
<a name="inline-string-quotes-across-assets"></a>

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=<MODEL_ID> \
    --action-definition-id <ACTION_DEFINITION_ID> \
    --action-payload "stringValue={\"exportDataStartTime\":1717225200,\"exportDataEndTime\":1722789360,\"targetSamplingRate\":\"PT1M\"}"
```

## Entraînez le modèle (AWS CLI)
<a name="start-training-cli-across-assets"></a>

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-across-assets) 

   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'inférence avancées](advanced-inference-configurations.md).

      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é.

   ```
   {
     "exportDataStartTime": StartTime,
     "exportDataEndTime": EndTime
   }
   ```  
**Example d'un exemple de charge utile d'entraînement :**  

   ```
   {
     "exportDataStartTime": 1717225200,
     "exportDataEndTime": 1722789360
   }
   ```

1. Exécutez la commande suivante pour démarrer l'entraînement (sans fournir d'actif comme ressource cible). Remplacez les paramètres suivants dans la commande :

   ```
   aws iotsitewise execute-action \
       --target-resource computationModelId=computation-model-id \
       --action-definition-id training-action-definition-id \
       --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
   ```

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 terminé l'entraînement avec succès.

   ```
   aws iotsitewise describe-computation-model-execution-summary \
       --computation-model-id computation-model-id
   ```

## Démarrer et arrêter le réentraînement du modèle ()AWS CLI
<a name="start-stop-retraining-cli-model"></a>

 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
<a name="start-retraining-scheduler-model"></a>

1. Préparez la même charge utile que celle mentionnée dans. [Lancer le planificateur de reconversion](anom-detection-sensors-asset.md#start-retraining-scheduler)

1. Exécuter une action de formation (sans fournir d'actif comme ressource cible). Remplacez les paramètres suivants dans la commande :

   1. `computation-model-id`avec l'ID du modèle de calcul cible.

   1. `training-action-definition-id`avec l'identifiant de l'`AWS/ANOMALY_DETECTION_TRAINING`action.

   ```
   aws iotsitewise execute-action \
       --target-resource computationModelId=computation-model-id \
       --action-definition-id training-action-definition-id \
       --action-payload stringValue@=file://anomaly-detection-start-retraining-payload.json
   ```

1. Exécutez la commande suivante pour vérifier l'état du processus de démarrage du planificateur de réentraînement. 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
   ```

### Arrêter le planificateur de reconversion
<a name="stop-retraining-scheduler-model"></a>

1. Préparez la même charge utile que celle mentionnée dans. [Arrêter le planificateur de reconversion](anom-detection-sensors-asset.md#stop-retraining-scheduler)

1. Exécuter une action de formation (sans fournir d'actif comme ressource cible). Remplacez les paramètres suivants dans la commande :

   1. `computation-model-id`avec l'ID du modèle de calcul cible.

   1. `training-action-definition-id`avec l'identifiant de l'`AWS/ANOMALY_DETECTION_TRAINING`action.

   ```
   aws iotsitewise execute-action \
       --target-resource computationModelId=computation-model-id \
       --action-definition-id training-action-definition-id \
       --action-payload stringValue@=file://anomaly-detection-stop-retraining-payload.json
   ```

1. Exécutez la commande suivante pour vérifier l'état du processus d'arrêt du planificateur de réentraînement. 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
   ```

## Démarrer et arrêter l'inférence ()AWS CLI
<a name="start-stop-inference-across-assets"></a>

Après avoir entraîné le modèle, lancez l'inférence, qui indique de commencer AWS IoT SiteWise à surveiller vos actifs industriels pour détecter les anomalies.

### Lancer l'inférence
<a name="start-inference-across-assets"></a>

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 le code suivant. Remplacez les paramètres suivants comme décrit :
**Note**  
 La charge utile doit être conforme à. [Option 1 : utiliser un fichier de charge utile propre](#clean-payload-file-across-assets) 

   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`.

      ```
      "inferenceMode": "START",
      "dataUploadFrequency": "DataUploadFrequency"
      ```

   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. `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 \
       --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
   ```

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
   ```

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
<a name="stop-inference-across-assets"></a>

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](anom-detection-sensors-asset.md#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. `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 \
   --action-definition-id inference-action-definition-id \
   --action-payload stringValue@=file://anomaly-detection-stop-inference-payload.json
   ```