Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Aktivieren Sie die Erkennung von Anomalien auf Sensoren in allen Anlagen
<a name="anom-detection-sensors-across-asset"></a>

## Erstellen Sie ein Berechnungsmodell ()AWS CLI
<a name="create-computation-model-across-assets"></a>

Verwenden Sie die AWS Befehlszeilenschnittstelle ()AWS CLI, um ein Berechnungsmodell zu erstellen. Nachdem Sie das Berechnungsmodell definiert haben, trainieren Sie das Modell und planen Sie die Inferenz so ein, dass die Anomalieerkennung in allen Anlagen erfolgt. AWS IoT SiteWise

In den folgenden Schritten wird dieser Prozess erklärt:

1. Um die Erkennung von Anomalien einzurichten, verwenden Sie die [UpdateAssetModel(AWS CLI)](https://docs.aws.amazon.com/cli/latest/reference/iotsitewise/update-asset-model.html) und erfüllen Sie die folgenden Anforderungen:

   1. Mindestens eine Eingabeeigenschaft, die entweder vom `INTEGER` Datentyp `DOUBLE` oder ist. Sie ist entweder eine Mess- oder eine Transformationseigenschaft und wird zum Trainieren des Modells verwendet.

   1. Eine Ergebniseigenschaft vom `STRING` Datentyp. Es muss sich um eine Messeigenschaft handeln und speichert die Ergebnisse der Anomalieerkennung.

1. Erstellen Sie eine Datei `anomaly-detection-computation-model-payload.json` mit dem folgenden Inhalt:
**Anmerkung**  
Erstellen Sie ein Berechnungsmodell, indem Sie es direkt `assetProperty` als Datenquelle angeben.

   ```
   {
       "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. Führen Sie den folgenden Befehl aus, um ein Berechnungsmodell zu erstellen:

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

## ExecuteAction Vorbereitung der API-Nutzlast
<a name="create-action-payload-across-assets"></a>

 Die nächsten Schritte zur Durchführung von Training und Inferenz werden mit der [ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API durchgeführt. Sowohl Training als auch Inferenz werden mit einer JSON-Aktionsnutzlastkonfiguration konfiguriert. Beim Aufrufen der [ExecuteAction](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteAction.html)API muss die Aktionsnutzlast als Wert zusammen mit einer Nutzlast bereitgestellt werden. `stringValue` 

 Die Payload muss sich strikt an die API-Anforderungen halten. Insbesondere muss der Wert eine **flache Zeichenfolge** ohne **Steuerzeichen** sein (z. B. Zeilenumbrüche, Tabulatoren oder Zeilenumbrüche). Die folgenden Optionen bieten zwei zuverlässige Methoden, um eine gültige Aktions-Payload bereitzustellen. 

### Option 1: Verwenden Sie eine saubere Payload-Datei
<a name="clean-payload-file-across-assets"></a>

Das folgende Verfahren beschreibt die Schritte für eine saubere Payload-Datei:

1. Säubern Sie die Datei, um Steuerzeichen zu entfernen.

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

1. Führen Sie die Aktion mit der Datei aus`@=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: Inline-Zeichenfolge mit maskierten Anführungszeichen
<a name="inline-string-quotes-across-assets"></a>

In den folgenden Schritten werden die Schritte beschrieben, um die Nutzdaten inline bereitzustellen und Zwischendateien zu vermeiden:
+ Verwenden Sie maskierte Anführungszeichen (`\"`) innerhalb der JSON-Zeichenfolge.
+ Setzen Sie den gesamten `StringValue=..` Ausdruck in doppelte Anführungszeichen.

**Example einer Payload einer Aktion, der entgangen ist:**  

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

## Trainiere das Modell ()AWS CLI
<a name="start-training-cli-across-assets"></a>

1. Führen Sie den folgenden Befehl aus, um die `AWS/ANOMALY_DETECTION_TRAINING` Aktion `actionDefinitionId` zu ermitteln. `computation-model-id`Ersetzen Sie es durch die im vorherigen Schritt zurückgegebene ID.

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

1. Erstellen Sie eine Datei mit dem Namen `anomaly-detection-training-payload.json` und fügen Sie die folgenden Werte hinzu:
**Anmerkung**  
 Die Nutzlast muss den Anforderungen entsprechen. [Option 1: Verwenden Sie eine saubere Payload-Datei](#clean-payload-file-across-assets) 

   1. `StartTime`mit dem Beginn der Trainingsdaten, angegeben in Epochensekunden.

   1. `EndTime`mit dem Ende der Trainingsdaten, angegeben in Epochensekunden.

   1. Sie können optional konfigurieren[Erweiterte Inferenzkonfigurationen](advanced-inference-configurations.md).

      1. (Optional) `TargetSamplingRate` mit der Abtastrate der Daten.

      1. (Optional) `LabelInputConfiguration` zur Angabe von Zeiträumen, in denen anomales Verhalten auftrat, um das Modelltraining zu verbessern.

      1. (Optional) `ModelEvaluationConfiguration` um die Leistung des Modells zu bewerten, indem nach Abschluss des Trainings Inferenzen für einen bestimmten Zeitraum ausgeführt werden.

   ```
   {
     "exportDataStartTime": StartTime,
     "exportDataEndTime": EndTime
   }
   ```  
**Example eines Beispiels für eine Trainingsnutzlast:**  

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

1. Führen Sie den folgenden Befehl aus, um das Training zu starten (ohne die Ressource als Zielressource bereitzustellen). Ersetzen Sie die folgenden Parameter im Befehl:

   ```
   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. Führen Sie den folgenden Befehl aus, um den Status des Modelltrainingsprozesses zu überprüfen. Die letzte Ausführungsübersicht zeigt den Ausführungsstatus (`RUNNING`/`COMPLETED`/`FAILED`).

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

1. Führen Sie den folgenden Befehl aus, um die Konfiguration des zuletzt trainierten Modells zu überprüfen. Dieser Befehl erzeugt nur dann eine Ausgabe, wenn mindestens ein Modell das Training erfolgreich abgeschlossen hat.

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

## Startet und beendet das erneute Trainieren des Modells ()AWS CLI
<a name="start-stop-retraining-cli-model"></a>

 Nach dem ersten Modelltraining können Sie automatisches Retraining konfigurieren, um Datenabweichungen entgegenzuwirken und die Modellgenauigkeit im Laufe der Zeit aufrechtzuerhalten. Mit dem Retrainingsplaner können Sie regelmäßige Modellaktualisierungen mit konfigurierbaren Promotion-Modi einrichten. 

### Starten Sie den Retrainingsplaner
<a name="start-retraining-scheduler-model"></a>

1. Bereiten Sie dieselbe Nutzlast wie unter beschrieben vor. [Starten Sie den Retrainingsplaner](anom-detection-sensors-asset.md#start-retraining-scheduler)

1. Führen Sie die Trainingsaktion aus (ohne die Ressource als Zielressource anzugeben). Ersetzen Sie die folgenden Parameter im Befehl:

   1. `computation-model-id`mit der ID des Zielberechnungsmodells.

   1. `training-action-definition-id`mit der ID der `AWS/ANOMALY_DETECTION_TRAINING` Aktion.

   ```
   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. Führen Sie den folgenden Befehl aus, um den Status des Prozesses Start Retraining Scheduler zu überprüfen. Die letzte Ausführungsübersicht zeigt den Ausführungsstatus (`RUNNING`/`COMPLETED`/`FAILED`).

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

### Beenden Sie das erneute Training des Schedulers
<a name="stop-retraining-scheduler-model"></a>

1. Bereiten Sie dieselbe Nutzlast wie unter beschrieben vor. [Beenden Sie das erneute Training des Schedulers](anom-detection-sensors-asset.md#stop-retraining-scheduler)

1. Führen Sie die Trainingsaktion aus (ohne die Ressource als Zielressource anzugeben). Ersetzen Sie die folgenden Parameter im Befehl:

   1. `computation-model-id`mit der ID des Zielberechnungsmodells.

   1. `training-action-definition-id`mit der ID der `AWS/ANOMALY_DETECTION_TRAINING` Aktion.

   ```
   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. Führen Sie den folgenden Befehl aus, um den Status des Scheduler-Prozesses zum Beenden des Retrainings zu überprüfen. In der Zusammenfassung der letzten Ausführung wird der Ausführungsstatus (`RUNNING`/`COMPLETED`/`FAILED`) angezeigt.

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

## Inferenz starten und beenden ()AWS CLI
<a name="start-stop-inference-across-assets"></a>

Nachdem Sie das Modell trainiert haben, starten Sie die Inferenz, die Sie anweist, mit der Überwachung Ihrer Industrieanlagen auf Anomalien AWS IoT SiteWise zu beginnen.

### Starten Sie die Inferenz
<a name="start-inference-across-assets"></a>

1. Führen Sie den folgenden Befehl aus, um die `AWS/ANOMALY_DETECTION_INFERENCE` Aktion `actionDefinitionId` zu ermitteln. `computation-model-id`Ersetzen Sie es durch die tatsächliche ID des zuvor erstellten Berechnungsmodells.

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

1. Erstellen Sie eine Datei `anomaly-detection-start-inference-payload.json` und fügen Sie den folgenden Code hinzu. Ersetzen Sie die folgenden Parameter wie beschrieben:
**Anmerkung**  
 Die Nutzlast muss den Anforderungen entsprechen. [Option 1: Verwenden Sie eine saubere Payload-Datei](#clean-payload-file-across-assets) 

   1. `DataUploadFrequency`: Konfigurieren Sie die Häufigkeit, mit der der Inferenzplan ausgeführt wird, um Anomalien zu erkennen. Zulässige Werte sind:. `PT5M, PT10M, PT15M, PT30M, PT1H, PT2H..PT12H, PT1D`

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

   1. (Optional) `DataDelayOffsetInMinutes` mit dem Verzögerungsoffset in Minuten. Stellen Sie diesen Wert zwischen 0 und 60 Minuten ein.

   1. (Optional) `TargetModelVersion` mit der zu aktivierenden Modellversion.

   1. (Optional) Konfigurieren Sie das `weeklyOperatingWindow` mit einer Schichtkonfiguration.

   1. Sie können optional konfigurieren[Erweiterte Inferenzkonfigurationen](advanced-inference-configurations.md).

      1. [Hochfrequente Inferenzierung (5 Minuten — 1 Stunde)](advanced-inference-configurations.md#high-frequency-inferencing).

      1. [Niederfrequenz-Inferenzierung (2 Stunden — 1 Tag)](advanced-inference-configurations.md#low-frequency-inferencing).

      1. [Flexible Planung](advanced-inference-configurations.md#flexible-scheduling).

1. Führen Sie den folgenden Befehl aus, um die Inferenz zu starten. Ersetzen Sie die folgenden Parameter in der Payload-Datei.

   1. `computation-model-id`mit der ID des Zielberechnungsmodells.

   1. `inference-action-definition-id`mit der ID der `AWS/ANOMALY_DETECTION_INFERENCE` Aktion aus Schritt 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. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Inference noch läuft. Das `inferenceTimerActive` Feld ist auf „`TRUE`Wenn Inferenz aktiv“ gesetzt ist.

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

1. Der folgende Befehl listet alle Inferenzausführungen auf:

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

1. Führen Sie den folgenden Befehl aus, um eine einzelne Ausführung zu beschreiben. `execution-id`Ersetzen Sie es durch die ID aus dem vorherigen Schritt 5.

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

### Beenden Sie die Inferenz
<a name="stop-inference-across-assets"></a>

1. Führen Sie den folgenden Befehl aus, um die `AWS/ANOMALY_DETECTION_INFERENCE` Aktion `actionDefinitionId` zu ermitteln. `computation-model-id`Ersetzen Sie es durch die tatsächliche ID des zuvor erstellten Berechnungsmodells.

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

1. Erstellen Sie eine Datei `anomaly-detection-stop-inference-payload.json` und fügen Sie den folgenden Code hinzu.

   ```
   {
       "inferenceMode": "STOP"
   }
   ```
**Anmerkung**  
 Die Nutzlast muss den Anforderungen entsprechen. [Option 1: Verwenden Sie eine saubere Payload-Datei](anom-detection-sensors-asset.md#clean-payload-file) 

1. Führen Sie den folgenden Befehl aus, um die Inferenz zu beenden. Ersetzen Sie den folgenden Parameter in der Payload-Datei:

   1. `computation-model-id`mit der ID des Zielberechnungsmodells.

   1. `inference-action-definition-id`mit der ID der `AWS/ANOMALY_DETECTION_INFERENCE` Aktion aus Schritt 1.  
**Example des Befehls 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
   ```