

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 un asset
<a name="anom-detection-sensors-asset"></a>

## Crea un modello di calcolo ()AWS CLI
<a name="create-computation-model"></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 programmate l'inferenza per il rilevamento delle anomalie su un asset. AWS IoT SiteWise
+ Create un file `anomaly-detection-computation-model-payload.json` con il seguente contenuto:

  ```
  {
      "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"
              }
          }
      }
  }
  ```
+ 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"></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"></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> \
       --resolve-to assetId=<ASSET_ID> \
       --action-payload stringValue@=file://training-or-inference-action-payload.json
   ```

### Opzione 2: stringa in linea con virgolette sfuggite
<a name="inline-string-quotes"></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> \
    --resolve-to assetId=<ASSET_ID> \
    --action-payload "stringValue={\"exportDataStartTime\":1717225200,\"exportDataEndTime\":1722789360,\"targetSamplingRate\":\"PT1M\"}"
```

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

Con un modello di calcolo creato, è possibile addestrare un modello rispetto agli asset. Segui i passaggi seguenti per addestrare un modello per un asset:

1. Eseguite il comando seguente 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) 

   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 allenamento avanzate](adv-training-configs.md), per migliorare le prestazioni del modello.

      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.

      1. (Facoltativo) `ModelMetricsDestination` per raccogliere dati completi sulle prestazioni (precisione, richiamo, Area Under the Curve).

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

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

1. Esegui il seguente comando per iniziare l'allenamento. Sostituite i seguenti parametri nel comando:

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

   1. `asset-id`con l'ID della risorsa sulla quale addestrerai il modello.

   1. `training-action-definition-id`con l'ID dell'`AWS/ANOMALY_DETECTION_TRAINING`azione della Fase 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 di un'azione di esecuzione:**  

   ```
   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. Esegui 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\
       --resolve-to-resource-type ASSET \
       --resolve-to-resource-id asset-id
   ```

1. Esegui il comando seguente per verificare la configurazione dell'ultimo modello addestrato. Questo comando produce un output solo se almeno un modello è stato addestrato correttamente.

   ```
   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. Quando `ComputationModel` si utilizza a AssetModelProperty, utilizzate l'[ListComputationModelResolveToResources](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ListComputationModelResolveToResources.html)API per identificare gli asset con azioni eseguite.

   ```
   aws iotsitewise list-computation-model-resolve-to-resources \
       --computation-model-id computation-model-id
   ```

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

1. Esegui il seguente comando per trovare l'`actionDefinitionId``AWS/ANOMALY_DETECTION_TRAINING`azione. Sostituisci `computation-model-id` con l'ID restituito dalla creazione del modello di calcolo.

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

1. Create un file chiamato `anomaly-detection-start-retraining-payload.json` e aggiungete il codice seguente. Sostituite i parametri con i valori descritti.
**Nota**  
 Il carico utile deve essere conforme a. [Opzione 1: utilizzare un file di payload pulito](#clean-payload-file) 

   1. `lookbackWindow`con la finestra dei dati storici da utilizzare per la riqualificazione (`P180D`//`P360D`/`P540D`). `P720D`

   1. `retrainingFrequency`con quale frequenza riqualificare il modello (minima`P30D`, massima`P1Y`).

   1. (Facoltativo) `promotion` con la modalità di promozione del modello (`SERVICE_MANAGED`o`CUSTOMER_MANAGED`). Il valore predefinito è “`SERVICE_MANAGED`”.

   1. (Facoltativo) `retrainingStartDate` con la data di inizio del programma di riqualificazione, fornita in secondi epocali. Tronca l'ora al giorno UTC più vicino. Facoltativo, il valore predefinito è la data corrente.

   1. Facoltativamente, è possibile configurare [Configurazioni di allenamento avanzate](adv-training-configs.md) per migliorare le prestazioni del modello.

      1. (Facoltativo) `ModelMetricsDestination` per ottenere dati completi sulle prestazioni (precisione, richiamo, Area Under the Curve).

   ```
   {
       "trainingMode": "START_RETRAINING_SCHEDULER",
       "retrainingConfiguration": {
           "lookbackWindow": "P180D",
           "promotion": "SERVICE_MANAGED",
           "retrainingFrequency": "P30D",
           "retrainingStartDate": "StartDate"
       }
   }
   ```

1. Esegui il comando seguente per avviare lo scheduler di riqualificazione. Sostituisci i seguenti parametri nel comando:

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

   1. `asset-id`con l'ID della risorsa sulla quale addestrerai il modello.

   1. `training-action-definition-id`con l'ID dell'`AWS/ANOMALY_DETECTION_TRAINING`azione della Fase 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 Esempio di comando execute action**  

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

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

1. Esegui il seguente comando per trovare l'`actionDefinitionId``AWS/ANOMALY_DETECTION_TRAINING`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. Crea un file `anomaly-detection-stop-retraining-payload.json` e aggiungi quanto segue:
**Nota**  
 Il payload deve essere conforme a. [Opzione 1: utilizzare un file di payload pulito](#clean-payload-file) 

   ```
   {
       "trainingMode": "STOP_RETRAINING_SCHEDULER"
   }
   ```

1. Esegui il comando seguente per arrestare lo scheduler di riqualificazione. Sostituisci i seguenti parametri nel comando:

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

   1. `asset-id`con l'ID della risorsa sulla quale addestrerai il modello.

   1. `training-action-definition-id`con l'ID dell'`AWS/ANOMALY_DETECTION_TRAINING`azione della Fase 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
   ```

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

Dopo aver addestrato il modello, avvia l'inferenza. Ciò consente di monitorare attivamente AWS IoT SiteWise gli asset industriali per rilevare eventuali anomalie.

### Inizia l'inferenza
<a name="start-inference"></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 i seguenti valori:
**Nota**  
 Il payload deve essere conforme a. [Opzione 1: utilizzare un file di payload pulito](#clean-payload-file) 

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

   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`

   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. `asset-id`con l'ID della risorsa sulla quale è stato addestrato il modello.

   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 \
       --resolve-to assetId=asset-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 \
       --resolve-to-resource-type ASSET \
       --resolve-to-resource-id asset-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 \
      --resolve-to-resource-type ASSET \
      --resolve-to-resource-id asset-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"></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](#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. `asset-id`con l'ID della risorsa sulla quale è stato addestrato il modello.

   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 \
       --resolve-to assetId=asset-id \
       --action-definition-id inference-action-definition-id \
       --action-payload stringValue@=file://anomaly-detection-stop-inference-payload.json
   ```

## Trova modelli di calcolo che utilizzano una determinata risorsa nell'associazione dei dati
<a name="find-computation-models-data-binding"></a>

Per elencare i modelli di calcolo associati a una determinata risorsa:
+ **modello di asset** (recupera tutti i modelli di calcolo a cui è associata una qualsiasi delle proprietà di questo modello di asset).
+ **asset** (recupera tutti i modelli di calcolo in cui è associata una qualsiasi delle proprietà di questa risorsa)
+ **proprietà del modello di asset** (recupera tutti i modelli di calcolo in cui questa proprietà è associata)
+ **proprietà dell'asset** (recupera tutti i modelli di calcolo in cui questa proprietà è associata). Questo potrebbe essere a scopo informativo o richiesto quando l'utente tenta di associare questa proprietà a un altro modello di calcolo ma è già associata da qualche altra parte)

Utilizza l'[ ListComputationModelDataBindingUsages](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ListComputationModelDataBindingUsages.html)API per recuperare un elenco di `ComputationModelId` utenti che accettano l'asset (proprietà) o il modello di asset (proprietà) come associazione dati.

Prepara un `request.json` file con le seguenti informazioni:

```
{
  "dataBindingValueFilter": {
    "asset": {
      "assetId": "<string>"
    }
    // OR
    "assetModel": {
      "assetModelId": "<string>"
    }
    // OR
    "assetProperty": {
      "assetId": "<string>",
      "propertyId": "<string>"
    }
    // OR
    "assetModelProperty": {
      "assetModelId": "<string>",
      "propertyId": "<string>"
    }
  },
  "nextToken": "<string>",
  "maxResults": "<number>"
}
```

Utilizzate il `list-computation-model-data-binding-usages` comando per recuperare i modelli con risorse o modelli di asset come associazioni di dati.

```
aws iotsitewise list-computation-model-data-binding-usages \
--cli-input-json file://request.json
```