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 den Sensoren einer Anlage
## Erstellen Sie ein Berechnungsmodell ()AWS CLI
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 für die Erkennung von Anomalien an einer Anlage in. AWS IoT SiteWise
+ Erstellen Sie eine Datei `anomaly-detection-computation-model-payload.json` mit dem folgenden Inhalt:
```
{
"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"
}
}
}
}
```
+ 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
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 zur Bereitstellung einer gültigen Aktions-Payload:
### Option 1: Verwenden Sie eine saubere Payload-Datei
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= \
--action-definition-id \
--resolve-to assetId= \
--action-payload stringValue@=file://training-or-inference-action-payload.json
```
### Option 2: Inline-Zeichenfolge mit maskierten Anführungszeichen
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= \
--action-definition-id \
--resolve-to assetId= \
--action-payload "stringValue={\"exportDataStartTime\":1717225200,\"exportDataEndTime\":1722789360,\"targetSamplingRate\":\"PT1M\"}"
```
## Trainiere das Modell ()AWS CLI
Mit einem erstellten Berechnungsmodell können Sie ein Modell anhand der Ressourcen trainieren. Gehen Sie wie folgt vor, um ein Modell für eine Anlage zu trainieren:
1. Führen Sie den folgenden Befehl aus, um `actionDefinitionId` die `AWS/ANOMALY_DETECTION_TRAINING` Aktion 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)
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[Fortgeschrittene Trainingskonfigurationen](adv-training-configs.md), um die Modellleistung zu verbessern.
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.
1. (Optional) `ModelMetricsDestination` zur Erfassung umfassender Leistungsdaten (Präzision, Recall, Area Under the Curve).
```
{
"trainingMode": "TRAIN_MODEL",
"exportDataStartTime": StartTime,
"exportDataEndTime": EndTime
}
```
**Example eines Beispiels für eine Trainingsnutzlast:**
```
{
"trainingMode": "TRAIN_MODEL",
"exportDataStartTime": 1717225200,
"exportDataEndTime": 1722789360
}
```
1. Führen Sie den folgenden Befehl aus, um das Training zu starten. Ersetzen Sie die folgenden Parameter im Befehl:
1. `computation-model-id`mit der ID des Zielberechnungsmodells.
1. `asset-id`mit der ID des Assets, anhand dessen Sie das Modell trainieren werden.
1. `training-action-definition-id`mit der ID der `AWS/ANOMALY_DETECTION_TRAINING` Aktion aus Schritt 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 einer Ausführungsaktion:**
```
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. 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\
--resolve-to-resource-type ASSET \
--resolve-to-resource-id asset-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 erfolgreich trainiert wurde.
```
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. Wenn a verwendet `ComputationModel` wird AssetModelProperty, verwenden Sie die [ListComputationModelResolveToResources](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ListComputationModelResolveToResources.html)API, um die Assets zu identifizieren, für die Aktionen ausgeführt wurden.
```
aws iotsitewise list-computation-model-resolve-to-resources \
--computation-model-id computation-model-id
```
## Startet und beendet das erneute Training des Modells ()AWS CLI
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
1. Führen Sie den folgenden Befehl aus, um die Aktion `actionDefinitionId` zu ermitteln. `AWS/ANOMALY_DETECTION_TRAINING` `computation-model-id`Ersetzen Sie es durch die ID, die Sie bei der Erstellung Ihres Berechnungsmodells zurückgegeben haben.
```
aws iotsitewise describe-computation-model \
--computation-model-id computation-model-id
```
1. Erstellen Sie eine Datei mit dem Namen `anomaly-detection-start-retraining-payload.json` und fügen Sie den folgenden Code hinzu. Ersetzen Sie die Parameter wie beschrieben durch Werte.
**Anmerkung**
Die Nutzlast muss den Anforderungen entsprechen. [Option 1: Verwenden Sie eine saubere Payload-Datei](#clean-payload-file)
1. `lookbackWindow`mit dem historischen Datenfenster, das für die Umschulung verwendet werden soll (`P180D`//`P360D`/`P540D`). `P720D`
1. `retrainingFrequency`mit der Häufigkeit, mit der das Modell neu trainiert werden soll (Minimum`P30D`, Maximum`P1Y`).
1. (Optional) `promotion` mit dem Model-Promotion-Modus (`SERVICE_MANAGED`oder`CUSTOMER_MANAGED`). Der Standardwert ist `SERVICE_MANAGED`.
1. (Optional) `retrainingStartDate` mit dem Startdatum für den Umschulungsplan, angegeben in Epochensekunden. Kürzt die Zeit auf den nächsten UTC-Tag. Optional, standardmäßig das aktuelle Datum.
1. Sie können optional konfigurieren[Fortgeschrittene Trainingskonfigurationen](adv-training-configs.md), um die Modellleistung zu verbessern.
1. (Optional)`ModelMetricsDestination`, um umfassende Leistungsdaten (Präzision, Recall, Area Under the Curve) zu erhalten.
```
{
"trainingMode": "START_RETRAINING_SCHEDULER",
"retrainingConfiguration": {
"lookbackWindow": "P180D",
"promotion": "SERVICE_MANAGED",
"retrainingFrequency": "P30D",
"retrainingStartDate": "StartDate"
}
}
```
1. Führen Sie den folgenden Befehl aus, um den Retrainingsplaner zu starten. Ersetzen Sie die folgenden Parameter im Befehl:
1. `computation-model-id`mit der ID des Zielberechnungsmodells.
1. `asset-id`mit der ID des Assets, anhand dessen Sie das Modell trainieren werden.
1. `training-action-definition-id`mit der ID der `AWS/ANOMALY_DETECTION_TRAINING` Aktion aus Schritt 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 Beispiel für den Befehl „Aktion ausführen“**
```
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
```
### Beenden Sie das erneute Training des Schedulers
1. Führen Sie den folgenden Befehl aus, um die Aktion `actionDefinitionId` zu ermitteln. `AWS/ANOMALY_DETECTION_TRAINING` `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-retraining-payload.json` und fügen Sie Folgendes hinzu:
**Anmerkung**
Die Nutzlast muss den Anforderungen entsprechen. [Option 1: Verwenden Sie eine saubere Payload-Datei](#clean-payload-file)
```
{
"trainingMode": "STOP_RETRAINING_SCHEDULER"
}
```
1. Führen Sie den folgenden Befehl aus, um den Retrainingsplaner zu beenden. Ersetzen Sie die folgenden Parameter im Befehl:
1. `computation-model-id`mit der ID des Zielberechnungsmodells.
1. `asset-id`mit der ID des Assets, anhand dessen Sie das Modell trainieren werden.
1. `training-action-definition-id`mit der ID der `AWS/ANOMALY_DETECTION_TRAINING` Aktion aus Schritt 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
```
## Inferenz starten und beenden ()AWS CLI
Starten Sie nach dem Training des Modells die Inferenz. Dies weist Sie an AWS IoT SiteWise , Ihre Industrieanlagen aktiv auf Anomalien zu überwachen.
### Inferenz starten
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 die folgenden Werte hinzu:
**Anmerkung**
Die Nutzlast muss den Anforderungen entsprechen. [Option 1: Verwenden Sie eine saubere Payload-Datei](#clean-payload-file)
```
"inferenceMode": "START",
"dataUploadFrequency": "DataUploadFrequency"
```
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`
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. `asset-id`mit der ID des Assets, für das das Modell trainiert wurde.
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 \
--resolve-to assetId=asset-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 \
--resolve-to-resource-type ASSET \
--resolve-to-resource-id asset-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 \
--resolve-to-resource-type ASSET \
--resolve-to-resource-id asset-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
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](#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. `asset-id`mit der ID des Assets, für das das Modell trainiert wurde.
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 \
--resolve-to assetId=asset-id \
--action-definition-id inference-action-definition-id \
--action-payload stringValue@=file://anomaly-detection-stop-inference-payload.json
```
## Findet Berechnungsmodelle, die eine bestimmte Ressource bei der Datenbindung verwenden
Um Berechnungsmodelle aufzulisten, die an eine bestimmte Ressource gebunden sind:
+ **Asset-Modell** (ruft alle Berechnungsmodelle ab, an die Eigenschaften dieses Asset-Modells gebunden sind).
+ **Asset** (ruft alle Berechnungsmodelle ab, bei denen die Eigenschaften dieses Assets gebunden sind)
+ **Eigenschaft des Asset-Modells** (ruft alle Berechnungsmodelle ab, an die diese Eigenschaft gebunden ist)
+ **Anlageneigenschaft** (ruft alle Berechnungsmodelle ab, an die diese Eigenschaft gebunden ist). Dies kann zu Informationszwecken dienen oder erforderlich sein, wenn der Benutzer versucht, diese Eigenschaft an ein anderes Berechnungsmodell zu binden, sie aber bereits an eine andere Stelle gebunden ist)
Verwenden Sie die [ ListComputationModelDataBindingUsages](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ListComputationModelDataBindingUsages.html)API, um eine Liste von `ComputationModelId` s abzurufen, die das Asset (Property) oder das Asset-Modell (Property) als Datenbindung verwenden.
Bereiten Sie eine `request.json` mit den folgenden Informationen vor:
```
{
"dataBindingValueFilter": {
"asset": {
"assetId": ""
}
// OR
"assetModel": {
"assetModelId": ""
}
// OR
"assetProperty": {
"assetId": "",
"propertyId": ""
}
// OR
"assetModelProperty": {
"assetModelId": "",
"propertyId": ""
}
},
"nextToken": "",
"maxResults": ""
}
```
Verwenden Sie den `list-computation-model-data-binding-usages` Befehl, um die Modelle mit Assets oder Asset-Modellen als Datenbindungen abzurufen.
```
aws iotsitewise list-computation-model-data-binding-usages \
--cli-input-json file://request.json
```