

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Habilite a detecção de anomalias em sensores em todos os ativos
<a name="anom-detection-sensors-across-asset"></a>

## Crie um modelo de computação ()AWS CLI
<a name="create-computation-model-across-assets"></a>

Para criar um modelo computacional, use a interface de linha de AWS comando (AWS CLI). Depois de definir o modelo de computação, treine o modelo e programe a inferência para fazer a detecção de anomalias nos ativos em. AWS IoT SiteWise

As etapas a seguir explicam esse processo:

1. Para configurar a detecção de anomalias, use o [UpdateAssetModel(AWS CLI)](https://docs.aws.amazon.com/cli/latest/reference/iotsitewise/update-asset-model.html) e atenda aos seguintes requisitos:

   1. Pelo menos uma propriedade de entrada que seja de um `DOUBLE` ou do tipo de `INTEGER` dados. É uma propriedade de medição ou transformação e é usada para treinar o modelo.

   1. Uma propriedade de resultado do tipo de `STRING` dados. Ela deve ser uma propriedade de medição e armazena os resultados da detecção de anomalias.

1. Crie um arquivo `anomaly-detection-computation-model-payload.json` com o seguinte conteúdo:
**nota**  
Crie um modelo de computação fornecendo diretamente `assetProperty` como fonte de dados.

   ```
   {
       "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. Execute o comando a seguir para criar um modelo de computação:

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

## ExecuteAction Preparação da carga útil da API
<a name="create-action-payload-across-assets"></a>

 As próximas etapas para executar o treinamento e a inferência são realizadas com a [ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API. Tanto o treinamento quanto a inferência são configurados com uma configuração de carga de ação JSON. Ao invocar a [ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API, a carga útil da ação deve ser fornecida como um valor com uma `stringValue` carga útil. 

 A carga útil deve seguir rigorosamente os requisitos da API. Especificamente, o valor deve ser uma **string simples** sem **caracteres de controle** (por exemplo, novas linhas, guias ou retornos de carro). As opções a seguir fornecem duas maneiras confiáveis de fornecer uma carga útil de ação válida. 

### Opção 1: usar um arquivo de carga útil limpo
<a name="clean-payload-file-across-assets"></a>

O procedimento a seguir descreve as etapas para um arquivo de carga útil limpo:

1. Limpe o arquivo para remover os caracteres de controle.

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

1. Execute a ação com o arquivo`@=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
   ```

### Opção 2: string embutida com aspas escapadas
<a name="inline-string-quotes-across-assets"></a>

As etapas a seguir descrevem as etapas para fornecer a carga em linha e evitar arquivos intermediários:
+ Use aspas duplas de escape (`\"`) dentro da string JSON.
+ Coloque a `StringValue=..` expressão inteira entre aspas duplas.

**Example de uma carga útil de ação que escapou:**  

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

## Treine o modelo (AWS CLI)
<a name="start-training-cli-across-assets"></a>

1. Execute o seguinte comando para encontrar `actionDefinitionId` da ação `AWS/ANOMALY_DETECTION_TRAINING`. `computation-model-id`Substitua pela ID retornada na etapa anterior.

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

1. Crie um arquivo chamado `anomaly-detection-training-payload.json` e adicione os seguintes valores:
**nota**  
 A carga útil deve estar em conformidade com. [Opção 1: usar um arquivo de carga útil limpo](#clean-payload-file-across-assets) 

   1. `StartTime`com o início dos dados de treinamento, fornecidos em segundos de época.

   1. `EndTime`com o final dos dados de treinamento, fornecidos em segundos de época.

   1. Você pode configurar [Configurações avançadas de inferência](advanced-inference-configurations.md) opcionalmente.

      1. (Opcional) `TargetSamplingRate` com a taxa de amostragem dos dados.

      1. (Opcional) `LabelInputConfiguration` para especificar períodos de tempo em que ocorreu um comportamento anômalo para melhorar o treinamento do modelo.

      1. (Opcional) `ModelEvaluationConfiguration` para avaliar o desempenho do modelo executando inferências em um intervalo de tempo especificado após a conclusão do treinamento.

   ```
   {
     "exportDataStartTime": StartTime,
     "exportDataEndTime": EndTime
   }
   ```  
**Example de um exemplo de carga útil de treinamento:**  

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

1. Execute o comando a seguir para iniciar o treinamento (sem fornecer o ativo como recurso de destino). Substitua os parâmetros a seguir no 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. Execute o comando a seguir para verificar o status do processo de treinamento do modelo. O resumo da execução mais recente mostra o status da execução (`RUNNING`/`COMPLETED`/`FAILED`).

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

1. Execute o comando a seguir para verificar a configuração do modelo treinado mais recente. Esse comando produz uma saída somente se pelo menos um modelo tiver concluído o treinamento com êxito.

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

## Inicie e pare de treinar novamente o modelo ()AWS CLI
<a name="start-stop-retraining-cli-model"></a>

 Após o treinamento inicial do modelo, você pode configurar o retreinamento automático para lidar com o desvio de dados e manter a precisão do modelo ao longo do tempo. O programador de reciclagem permite que você configure atualizações periódicas do modelo com modos de promoção configuráveis. 

### Inicie o agendador de reciclagem
<a name="start-retraining-scheduler-model"></a>

1. Prepare a mesma carga útil mencionada em[Inicie o agendador de reciclagem](anom-detection-sensors-asset.md#start-retraining-scheduler).

1. Execute a ação de treinamento (sem fornecer o ativo como recurso alvo). Substitua os parâmetros a seguir no comando:

   1. `computation-model-id`com o ID do modelo de computação de destino.

   1. `training-action-definition-id`com o ID da `AWS/ANOMALY_DETECTION_TRAINING` ação.

   ```
   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. Execute o comando a seguir para verificar o status do processo inicial do agendador de reciclagem. O resumo da execução mais recente mostra o status da execução (`RUNNING`/`COMPLETED`/`FAILED`).

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

### Pare o agendador de treinamento
<a name="stop-retraining-scheduler-model"></a>

1. Prepare a mesma carga útil mencionada em[Pare o agendador de treinamento](anom-detection-sensors-asset.md#stop-retraining-scheduler).

1. Execute a ação de treinamento (sem fornecer o ativo como recurso alvo). Substitua os parâmetros a seguir no comando:

   1. `computation-model-id`com o ID do modelo de computação de destino.

   1. `training-action-definition-id`com o ID da `AWS/ANOMALY_DETECTION_TRAINING` ação.

   ```
   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. Execute o comando a seguir para verificar o status do processo de interrupção do agendador de reciclagem. O resumo da execução mais recente mostra o status da execução (`RUNNING`/`COMPLETED`/`FAILED`).

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

## Iniciar e interromper a inferência ()AWS CLI
<a name="start-stop-inference-across-assets"></a>

Depois de treinar o modelo, inicie a inferência, que instrui você AWS IoT SiteWise a começar a monitorar seus ativos industriais em busca de anomalias.

### Iniciar inferência
<a name="start-inference-across-assets"></a>

1. Execute o seguinte comando para encontrar `actionDefinitionId` da ação `AWS/ANOMALY_DETECTION_INFERENCE`. `computation-model-id`Substitua pelo ID real do modelo de computação criado anteriormente.

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

1. Crie um arquivo `anomaly-detection-start-inference-payload.json` e adicione o código a seguir. Substitua os seguintes parâmetros conforme descrito:
**nota**  
 A carga útil deve estar em conformidade com. [Opção 1: usar um arquivo de carga útil limpo](#clean-payload-file-across-assets) 

   1. `DataUploadFrequency`: configure a frequência com que o cronograma de inferência é executado para realizar a detecção de anomalias. Os valores permitidos são: `PT5M, PT10M, PT15M, PT30M, PT1H, PT2H..PT12H, PT1D`.

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

   1. (Opcional) `DataDelayOffsetInMinutes` com a compensação de atraso em minutos. Defina esse valor entre 0 e 60 minutos.

   1. (Opcional) `TargetModelVersion` com a versão do modelo a ser ativada.

   1. (Opcional) Configure o `weeklyOperatingWindow` com uma configuração de turno.

   1. Você pode configurar [Configurações avançadas de inferência](advanced-inference-configurations.md) opcionalmente.

      1. [Inferência de alta frequência (5 minutos — 1 hora)](advanced-inference-configurations.md#high-frequency-inferencing).

      1. [Inferência de baixa frequência (2 horas — 1 dia)](advanced-inference-configurations.md#low-frequency-inferencing).

      1. [Programação flexível](advanced-inference-configurations.md#flexible-scheduling).

1. Execute o comando a seguir para iniciar a inferência. Substitua os parâmetros a seguir no arquivo de carga útil.

   1. `computation-model-id`com o ID do modelo de computação de destino.

   1. `inference-action-definition-id`com o ID da `AWS/ANOMALY_DETECTION_INFERENCE` ação da Etapa 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. Execute o comando a seguir para verificar se a inferência ainda está em execução. O `inferenceTimerActive` campo é definido como `TRUE` quando a inferência está ativa.

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

1. O comando a seguir lista todas as execuções de inferência:

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

1. Execute o comando a seguir para descrever uma execução individual. `execution-id`Substitua pelo id da Etapa 5 anterior.

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

### Pare a inferência
<a name="stop-inference-across-assets"></a>

1. Execute o seguinte comando para encontrar `actionDefinitionId` da ação `AWS/ANOMALY_DETECTION_INFERENCE`. `computation-model-id`Substitua pelo ID real do modelo de computação criado anteriormente.

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

1. Crie um arquivo `anomaly-detection-stop-inference-payload.json` e adicione o código a seguir.

   ```
   {
       "inferenceMode": "STOP"
   }
   ```
**nota**  
 A carga útil deve estar em conformidade com. [Opção 1: usar um arquivo de carga útil limpo](anom-detection-sensors-asset.md#clean-payload-file) 

1. Execute o comando a seguir para interromper a inferência. Substitua o seguinte parâmetro no arquivo de carga:

   1. `computation-model-id`com o ID do modelo de computação de destino.

   1. `inference-action-definition-id`com o ID da `AWS/ANOMALY_DETECTION_INFERENCE` ação da Etapa 1.  
**Example do 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
   ```