Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Abilita il rilevamento delle anomalie sui sensori di tutti gli asset
<a name="anom-detection-sensors-across-asset"></a>

## Crea un modello di calcolo ()AWS CLI
<a name="create-computation-model-across-assets"></a>

Per creare un modello di calcolo, utilizzate l'interfaccia a riga di AWS comando ()AWS CLI. Dopo aver definito il modello di calcolo, addestrate il modello e pianificate l'inferenza per il rilevamento delle anomalie tra gli asset in. AWS IoT SiteWise

I passaggi seguenti spiegano questo processo:

1. Per configurare il rilevamento delle anomalie, utilizzate il comando [UpdateAssetModel(AWS CLI)](https://docs.aws.amazon.com/cli/latest/reference/iotsitewise/update-asset-model.html) e soddisfate i seguenti requisiti:

   1. Almeno una proprietà di input che sia di uno dei due tipi `DOUBLE` di `INTEGER` dati. È una proprietà di misurazione o trasformazione e viene utilizzata per addestrare il modello.

   1. Una proprietà di risultato del tipo di `STRING` dati. Deve essere una proprietà di misurazione e memorizza i risultati del rilevamento delle anomalie.

1. Crea un file `anomaly-detection-computation-model-payload.json` con il seguente contenuto:
**Nota**  
Crea un modello di calcolo fornendolo direttamente `assetProperty` come fonte di dati.

   ```
   {
       "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. Esegui il comando seguente per creare un modello di calcolo:

   ```
   aws iotsitewise create-computation-model \
       --cli-input-json file://anomaly-detection-computation-model-payload.json
   ```

## ExecuteAction Preparazione del payload dell'API
<a name="create-action-payload-across-assets"></a>

 I passaggi successivi per eseguire l'addestramento e l'inferenza vengono eseguiti con l'[ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API. Sia l'addestramento che l'inferenza sono configurati con una configurazione del payload d'azione JSON. Quando si richiama l'[ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API, il payload dell'azione deve essere fornito come valore con un payload. `stringValue` 

 Il payload deve rispettare rigorosamente i requisiti dell'API. In particolare, il valore deve essere una **stringa piatta** senza **caratteri di controllo** (ad esempio, newline, tabs o carriage return). Le seguenti opzioni forniscono due modi affidabili per fornire un payload d'azione valido. 

### Opzione 1: utilizzare un file di payload pulito
<a name="clean-payload-file-across-assets"></a>

La procedura seguente descrive i passaggi per un file di payload pulito:

1. Pulite il file per rimuovere i caratteri di controllo.

   ```
   tr -d '\n\r\t' < original-action-payload.json > training-or-inference-action-payload.json
   ```

1. Esegui l'azione con il file`@=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
   ```

### Opzione 2: stringa in linea con virgolette sfuggite
<a name="inline-string-quotes-across-assets"></a>

I passaggi seguenti descrivono i passaggi per fornire il payload in linea ed evitare file intermedi:
+ Usa le virgolette doppie con escape (`\"`) all'interno della stringa JSON.
+ Raccogli l'intera `StringValue=..` espressione tra virgolette doppie.

**Example di un payload di azione sfuggito:**  

```
aws iotsitewise execute-action \
    --target-resource computationModelId=<MODEL_ID> \
    --action-definition-id <ACTION_DEFINITION_ID> \
    --action-payload "stringValue={\"exportDataStartTime\":1717225200,\"exportDataEndTime\":1722789360,\"targetSamplingRate\":\"PT1M\"}"
```

## Addestra il modello ()AWS CLI
<a name="start-training-cli-across-assets"></a>

1. Esegui il seguente comando per trovare `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_TRAINING`azione. Sostituisci `computation-model-id` con l'ID restituito nel passaggio precedente.

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

1. Create un file chiamato `anomaly-detection-training-payload.json` e aggiungete i seguenti valori:
**Nota**  
 Il payload deve essere conforme a. [Opzione 1: utilizzare un file di payload pulito](#clean-payload-file-across-assets) 

   1. `StartTime`con l'inizio dei dati di allenamento, forniti in secondi epocali.

   1. `EndTime`con i dati di fine addestramento, forniti in secondi d'epoca.

   1. È possibile configurare opzionalmente. [Configurazioni di inferenza avanzate](advanced-inference-configurations.md)

      1. (Facoltativo) `TargetSamplingRate` con la frequenza di campionamento dei dati.

      1. (Facoltativo) `LabelInputConfiguration` per specificare i periodi di tempo in cui si è verificato un comportamento anomalo per migliorare l'addestramento del modello.

      1. (Facoltativo) `ModelEvaluationConfiguration` per valutare le prestazioni del modello eseguendo l'inferenza su un intervallo di tempo specificato dopo il completamento dell'addestramento.

   ```
   {
     "exportDataStartTime": StartTime,
     "exportDataEndTime": EndTime
   }
   ```  
**Example di un esempio di payload di addestramento:**  

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

1. Esegui il comando seguente per iniziare l'addestramento (senza fornire la risorsa come risorsa di destinazione). Sostituite i seguenti parametri nel comando:

   ```
   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. Eseguite il comando seguente per verificare lo stato del processo di addestramento del modello. L'ultimo riepilogo dell'esecuzione mostra lo stato di esecuzione (`RUNNING``COMPLETED`//`FAILED`).

   ```
   aws iotsitewise list-executions \
       --target-resource-type COMPUTATION_MODEL \
       --target-resource-id computation-model-id
   ```

1. Esegui il comando seguente per verificare la configurazione dell'ultimo modello addestrato. Questo comando produce un output solo se almeno un modello ha completato correttamente l'addestramento.

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

## Avvia e interrompi la riqualificazione del modello ()AWS CLI
<a name="start-stop-retraining-cli-model"></a>

 Dopo l'addestramento iniziale del modello, è possibile configurare la riqualificazione automatica per affrontare la deriva dei dati e mantenere l'accuratezza del modello nel tempo. Lo strumento di pianificazione della riqualificazione consente di impostare aggiornamenti periodici del modello con modalità di promozione configurabili. 

### Avvia lo scheduler di riqualificazione
<a name="start-retraining-scheduler-model"></a>

1. Prepara lo stesso carico utile indicato in. [Avvia lo scheduler di riqualificazione](anom-detection-sensors-asset.md#start-retraining-scheduler)

1. Esegui azioni di formazione (senza fornire risorse come risorsa target). Sostituite i seguenti parametri nel comando:

   1. `computation-model-id`con l'ID del modello di calcolo di destinazione.

   1. `training-action-definition-id`con l'ID dell'`AWS/ANOMALY_DETECTION_TRAINING`azione.

   ```
   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. Esegui il comando seguente per verificare lo stato del processo di start retraining scheduler. L'ultimo riepilogo dell'esecuzione mostra lo stato dell'esecuzione (`RUNNING`/`COMPLETED`/`FAILED`).

   ```
   aws iotsitewise list-executions \
       --target-resource-type COMPUTATION_MODEL \
       --target-resource-id computation-model-id
   ```

### Interrompi lo scheduler di riqualificazione
<a name="stop-retraining-scheduler-model"></a>

1. Prepara lo stesso carico utile indicato in. [Interrompi lo scheduler di riqualificazione](anom-detection-sensors-asset.md#stop-retraining-scheduler)

1. Esegui azioni di formazione (senza fornire risorse come risorsa target). Sostituite i seguenti parametri nel comando:

   1. `computation-model-id`con l'ID del modello di calcolo di destinazione.

   1. `training-action-definition-id`con l'ID dell'`AWS/ANOMALY_DETECTION_TRAINING`azione.

   ```
   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. Esegui il comando seguente per verificare lo stato del processo di stop retraining scheduler. L'ultimo riepilogo dell'esecuzione mostra lo stato dell'esecuzione (`RUNNING`/`COMPLETED`/`FAILED`).

   ```
   aws iotsitewise list-executions \
       --target-resource-type COMPUTATION_MODEL \
       --target-resource-id computation-model-id
   ```

## Avvia e interrompi l'inferenza ()AWS CLI
<a name="start-stop-inference-across-assets"></a>

Dopo aver addestrato il modello, avviate l'inferenza, che indica di iniziare AWS IoT SiteWise a monitorare gli asset industriali per individuare eventuali anomalie.

### Inizia l'inferenza
<a name="start-inference-across-assets"></a>

1. Esegui il seguente comando per trovare `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_INFERENCE`azione. Sostituisci `computation-model-id` con l'ID effettivo del modello di calcolo creato in precedenza.

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

1. Create un file `anomaly-detection-start-inference-payload.json` e aggiungete il codice seguente. Sostituite i seguenti parametri come descritto:
**Nota**  
 Il carico utile deve essere conforme a. [Opzione 1: utilizzare un file di payload pulito](#clean-payload-file-across-assets) 

   1. `DataUploadFrequency`: Configura la frequenza di esecuzione del programma di inferenza per eseguire il rilevamento delle anomalie. I valori consentiti sono:. `PT5M, PT10M, PT15M, PT30M, PT1H, PT2H..PT12H, PT1D`

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

   1. (Facoltativo) `DataDelayOffsetInMinutes` con la compensazione del ritardo in minuti. Imposta questo valore tra 0 e 60 minuti.

   1. (Facoltativo) `TargetModelVersion` con la versione del modello da attivare.

   1. (Facoltativo) Configurare la configurazione `weeklyOperatingWindow` con un turno.

   1. È possibile configurare [Configurazioni di inferenza avanzate](advanced-inference-configurations.md) facoltativamente.

      1. [Inferenza ad alta frequenza (5 minuti — 1 ora)](advanced-inference-configurations.md#high-frequency-inferencing).

      1. [Inferenza a bassa frequenza (2 ore — 1 giorno)](advanced-inference-configurations.md#low-frequency-inferencing).

      1. [Pianificazione flessibile](advanced-inference-configurations.md#flexible-scheduling).

1. Esegui il seguente comando per avviare l'inferenza. Sostituite i seguenti parametri nel file di payload.

   1. `computation-model-id`con l'ID del modello di calcolo di destinazione.

   1. `inference-action-definition-id`con l'ID dell'`AWS/ANOMALY_DETECTION_INFERENCE`azione della Fase 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. Esegui il comando seguente per verificare se l'inferenza è ancora in esecuzione. Il `inferenceTimerActive` campo è impostato su `TRUE` quando l'inferenza è attiva.

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

1. Il comando seguente elenca tutte le esecuzioni di inferenza:

   ```
   aws iotsitewise list-executions \
       --target-resource-type COMPUTATION_MODEL \
       --target-resource-id computation-model-id
   ```

1. Eseguite il comando seguente per descrivere una singola esecuzione. Sostituisci `execution-id` con l'id del passaggio 5 precedente.

   ```
   aws iotsitewise describe-execution \
       --execution-id execution-id
   ```

### Interrompi l'inferenza
<a name="stop-inference-across-assets"></a>

1. Esegui il seguente comando per trovare `actionDefinitionId` l'`AWS/ANOMALY_DETECTION_INFERENCE`azione. Sostituisci `computation-model-id` con l'ID effettivo del modello di calcolo creato in precedenza.

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

1. Create un file `anomaly-detection-stop-inference-payload.json` e aggiungete il codice seguente.

   ```
   {
       "inferenceMode": "STOP"
   }
   ```
**Nota**  
 Il carico utile deve essere conforme a. [Opzione 1: utilizzare un file di payload pulito](anom-detection-sensors-asset.md#clean-payload-file) 

1. Esegui il comando seguente per interrompere l'inferenza. Sostituite il seguente parametro nel file di payload:

   1. `computation-model-id`con l'ID del modello di calcolo di destinazione.

   1. `inference-action-definition-id`con l'ID dell'`AWS/ANOMALY_DETECTION_INFERENCE`azione della Fase 1.  
**Example del comando stop inference:**  

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