

Nach reiflicher Überlegung haben wir uns entschieden, Amazon Kinesis Data Analytics für SQL-Anwendungen einzustellen:

1. Ab dem **1. September 2025** werden wir keine Bugfixes für Amazon Kinesis Data Analytics for SQL-Anwendungen bereitstellen, da wir aufgrund der bevorstehenden Einstellung nur eingeschränkten Support dafür haben werden.

2. Ab dem **15. Oktober 2025** können Sie keine neuen Kinesis Data Analytics for SQL-Anwendungen mehr erstellen.

3. Wir werden Ihre Anwendungen ab dem **27. Januar 2026** löschen. Sie können Ihre Amazon Kinesis Data Analytics for SQL-Anwendungen nicht starten oder betreiben. Ab diesem Zeitpunkt ist kein Support mehr für Amazon Kinesis Data Analytics for SQL verfügbar. Weitere Informationen finden Sie unter [Einstellung von Amazon Kinesis Data Analytics für SQL-Anwendungen](discontinuation.md).

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.

# Beispiel: Erkennen von Datenanomalien und Suchen nach einer Erklärung (Funktion RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION)
<a name="app-anomaly-detection-with-explanation"></a>

Amazon-Kinesis-Data-Analytics stellt die `RANDOM_CUT_FOREST_WITH_EXPLANATION`-Funktion bereit, die jedem Datensatz basierend auf Werten in den numerischen Spalten eine Anomaliebewertung zuweist. Die Funktion liefert auch eine Erläuterung für die Anomalie. *Weitere Informationen finden Sie unter [RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION in der ](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-random-cut-forest-with-explanation.html)SQL-Referenz für Amazon-Managed-Service für Apache Flink*. 

In dieser Übung schreiben Sie Anwendungscode, um Anomaliebewertungen für Datensätzen in der Streaming-Quelle Ihrer Anwendung anzufordern. Sie können auch eine Erklärung für jede Anomalie anfordern.

**Topics**
+ [Schritt 1: Vorbereitung der Daten](app-anomaly-with-ex-prepare.md)
+ [Schritt 2: Erstellen einer Analyseanwendung](app-anom-with-exp-create-app.md)
+ [Schritt 3: Untersuchen der Ergebnisse](examine-results-with-exp.md)

**Erster Schritt**  
[Schritt 1: Vorbereitung der Daten](app-anomaly-with-ex-prepare.md)

# Schritt 1: Vorbereitung der Daten
<a name="app-anomaly-with-ex-prepare"></a>

Bevor Sie für dieses [Beispiel](app-anomaly-detection-with-explanation.md) eine Amazon-Kinesis-Data-Analytics-Anwendung erstellen, erstellen Sie einen Kinesis-Datenstrom zur Verwendung als Streaming-Quelle für Ihre Anwendung. Sie führen auch Python-Code aus, um simulierte Blutdruckdaten in den Stream zu schreiben. 

**Topics**
+ [Schritt 1.1: Erstellen eines Kinesis-Datenstrom](#app-anomaly-create-two-streams)
+ [Schritt 1.2: Schreiben Sie Beispieldatensätze in den Eingabe-Stream](#app-anomaly-write-sample-records-inputstream)

## Schritt 1.1: Erstellen eines Kinesis-Datenstrom
<a name="app-anomaly-create-two-streams"></a>

In diesem Abschnitt erstellen Sie einen Kinesis-Datenstrom mit dem Namen `ExampleInputStream`. Sie können diesen Datenstream mit dem AWS-Managementkonsole oder dem erstellen AWS CLI.
+ So verwenden Sie die Konsole:

  1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Kinesis-Konsole unter [https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis).

  1. Klicken Sie im Navigationsbereich auf **Data Streams (Daten-Streams)**. Wählen Sie dann **Create Kinesis-Stream (Kinesis-Stream erstellen)**.

  1. Geben Sie als Name **ExampleInputStream** ein. Geben Sie für die Anzahl von Shards **1** ein.
+ Um den Datenstream AWS CLI zu erstellen, führen Sie alternativ den folgenden Befehl aus:

  ```
  $ aws kinesis create-stream --stream-name ExampleInputStream --shard-count 1
  ```

## Schritt 1.2: Schreiben Sie Beispieldatensätze in den Eingabe-Stream
<a name="app-anomaly-write-sample-records-inputstream"></a>

In diesem Schritt führen Sie Python-Code aus, um kontinuierlich Beispieldatensätze zu generieren und in den von Ihnen erstellten Daten-Stream zu schreiben. 

1. Installieren Sie Python und pip.

   Informationen zum Installieren von Python finden Sie unter [Python](https://www.python.org/). 

   Sie können mithilfe von pip Abhängigkeiten installieren. Informationen zum Installieren von pip finden Sie unter [Installation](https://pip.pypa.io/en/stable/installing/) in der Dokumentation zu pip.

1. Führen Sie den folgenden Python-Code aus. Sie können zu der Region wechseln, die Sie in diesem Beispiel verwenden möchten. Der Befehl `put-record` im Code schreibt die JSON-Datensätze zum Stream.

   ```
    
   from enum import Enum
   import json
   import random
   import boto3
   
   STREAM_NAME = "ExampleInputStream"
   
   
   class PressureType(Enum):
       low = "LOW"
       normal = "NORMAL"
       high = "HIGH"
   
   
   def get_blood_pressure(pressure_type):
       pressure = {"BloodPressureLevel": pressure_type.value}
       if pressure_type == PressureType.low:
           pressure["Systolic"] = random.randint(50, 80)
           pressure["Diastolic"] = random.randint(30, 50)
       elif pressure_type == PressureType.normal:
           pressure["Systolic"] = random.randint(90, 120)
           pressure["Diastolic"] = random.randint(60, 80)
       elif pressure_type == PressureType.high:
           pressure["Systolic"] = random.randint(130, 200)
           pressure["Diastolic"] = random.randint(90, 150)
       else:
           raise TypeError
       return pressure
   
   
   def generate(stream_name, kinesis_client):
       while True:
           rnd = random.random()
           pressure_type = (
               PressureType.low
               if rnd < 0.005
               else PressureType.high
               if rnd > 0.995
               else PressureType.normal
           )
           blood_pressure = get_blood_pressure(pressure_type)
           print(blood_pressure)
           kinesis_client.put_record(
               StreamName=stream_name,
               Data=json.dumps(blood_pressure),
               PartitionKey="partitionkey",
           )
   
   
   if __name__ == "__main__":
       generate(STREAM_NAME, boto3.client("kinesis"))
   ```

**Nächster Schritt**  
[Schritt 2: Erstellen einer Analyseanwendung](app-anom-with-exp-create-app.md)

# Schritt 2: Erstellen einer Analyseanwendung
<a name="app-anom-with-exp-create-app"></a>

In diesem Abschnitt erstellen Sie eine Amazon-Kinesis-Data-Analytics-Anwendung und konfigurieren sie für die Verwendung des Kinesis-Datenstroms, den Sie in [Schritt 1: Vorbereitung der Daten](app-anomaly-with-ex-prepare.md) als Streaming-Quelle erstellt haben. Anschließend führen Sie Anwendungscode aus, von dem die Funktion `RANDOM_CUT_FOREST_WITH_EXPLANATION` genutzt wird.

**So erstellen Sie eine Anwendung**

1. Öffnen Sie die Kinesis-Konsole unter [https://console.aws.amazon.com/kinesis.](https://console.aws.amazon.com/kinesis)

1. Wählen Sie im Navigationsbereich **Data Analytics (Datenanalyse)** und dann **Create application (Anwendung erstellen)**.

1. Geben Sie einen Anwendungsnamen und (optional) eine Beschreibung ein und wählen Sie **Create application**.

1. Wählen Sie **Streaming-Daten Connect** und wählen Sie dann eine Option **ExampleInputStream**aus der Liste aus. 

1. Wählen Sie **Discover schema** und vergewissern Sie sich, dass als Spalten `Systolic` und `Diastolic` appear as `INTEGER` angezeigt werden. Wenn Sie über einen weiteren Typ verfügen, wählen Sie **Edit schema** und weisen Sie beiden den Typ `INTEGER` zu. 

1. Wählen Sie unter **Real time analytics** die Option **Go to SQL editor**. Wenn Sie dazu aufgefordert werden, bestimmen Sie, dass Ihre Anwendung ausgeführt wird. 

1. Fügen Sie den folgenden Code in den SQL-Editor ein und wählen Sie dann **Save and run SQL**.

   ```
   --Creates a temporary stream.
   CREATE OR REPLACE STREAM "TEMP_STREAM" (
   	        "Systolic"                  INTEGER,
   	        "Diastolic"                 INTEGER,
   	        "BloodPressureLevel"        varchar(20),
   	        "ANOMALY_SCORE"             DOUBLE,
   	        "ANOMALY_EXPLANATION"       varchar(512));
   
   --Creates another stream for application output.	        
   CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
   	        "Systolic"                  INTEGER,
   	        "Diastolic"                 INTEGER,
   	        "BloodPressureLevel"        varchar(20),
   	        "ANOMALY_SCORE"             DOUBLE,
   	        "ANOMALY_EXPLANATION"       varchar(512));
   
   -- Compute an anomaly score with explanation for each record in the input stream
   -- using RANDOM_CUT_FOREST_WITH_EXPLANATION
   CREATE OR REPLACE PUMP "STREAM_PUMP" AS 
      INSERT INTO "TEMP_STREAM"
         SELECT STREAM "Systolic", "Diastolic", "BloodPressureLevel", ANOMALY_SCORE, ANOMALY_EXPLANATION 
         FROM TABLE(RANDOM_CUT_FOREST_WITH_EXPLANATION(
                 CURSOR(SELECT STREAM * FROM "SOURCE_SQL_STREAM_001"), 100, 256, 100000, 1, true));
   
   -- Sort records by descending anomaly score, insert into output stream
   CREATE OR REPLACE PUMP "OUTPUT_PUMP" AS 
      INSERT INTO "DESTINATION_SQL_STREAM"
         SELECT STREAM * FROM "TEMP_STREAM"
         ORDER BY FLOOR("TEMP_STREAM".ROWTIME TO SECOND), ANOMALY_SCORE DESC;
   ```

**Nächster Schritt**  
[Schritt 3: Untersuchen der Ergebnisse](examine-results-with-exp.md)

# Schritt 3: Untersuchen der Ergebnisse
<a name="examine-results-with-exp"></a>

Wenn Sie den SQL-Code für dieses [Beispiel](app-anomaly-detection-with-explanation.md) ausführen, werden zuerst Zeilen mit einer Anomaliebewertung gleich null angezeigt. Dies geschieht während des anfänglichen Lernens. Danach sollten die Ergebnisse wie folgt aussehen:

```
ROWTIME SYSTOLIC DIASTOLIC BLOODPRESSURELEVEL ANOMALY_SCORE ANOMALY_EXPLANATION
27:49.0	101      66        NORMAL             0.711460417   {"Systolic":{"DIRECTION":"LOW","STRENGTH":"0.0922","ATTRIBUTION_SCORE":"0.3792"},"Diastolic":{"DIRECTION":"HIGH","STRENGTH":"0.0210","ATTRIBUTION_SCORE":"0.3323"}}
27:50.0	144      123       HIGH               3.855851061   {"Systolic":{"DIRECTION":"HIGH","STRENGTH":"0.8567","ATTRIBUTION_SCORE":"1.7447"},"Diastolic":{"DIRECTION":"HIGH","STRENGTH":"7.0982","ATTRIBUTION_SCORE":"2.1111"}}
27:50.0	113      69        NORMAL             0.740069409   {"Systolic":{"DIRECTION":"LOW","STRENGTH":"0.0549","ATTRIBUTION_SCORE":"0.3750"},"Diastolic":{"DIRECTION":"LOW","STRENGTH":"0.0394","ATTRIBUTION_SCORE":"0.3650"}}
27:50.0	105      64        NORMAL             0.739644157   {"Systolic":{"DIRECTION":"HIGH","STRENGTH":"0.0245","ATTRIBUTION_SCORE":"0.3667"},"Diastolic":{"DIRECTION":"LOW","STRENGTH":"0.0524","ATTRIBUTION_SCORE":"0.3729"}}
27:50.0	100      65        NORMAL             0.736993425   {"Systolic":{"DIRECTION":"HIGH","STRENGTH":"0.0203","ATTRIBUTION_SCORE":"0.3516"},"Diastolic":{"DIRECTION":"LOW","STRENGTH":"0.0454","ATTRIBUTION_SCORE":"0.3854"}}
27:50.0	108      69        NORMAL             0.733767202   {"Systolic":{"DIRECTION":"LOW","STRENGTH":"0.0974","ATTRIBUTION_SCORE":"0.3961"},"Diastolic":{"DIRECTION":"LOW","STRENGTH":"0.0189","ATTRIBUTION_SCORE":"0.3377"}}
```
+ Der Algorithmus in der Funktion `RANDOM_CUT_FOREST_WITH_EXPLANATION` erkennt, dass die Spalten `Systolic` und `Diastolic` numerisch sind und nutzt sie als Eingabe.
+ Da sich in der Spalte `BloodPressureLevel` Text befindet, wird sie vom Algorithmus nicht berücksichtigt. Diese Spalte ist dient nur als visuelle Hilfe, sodass sie normalen, hohen und niedrigen Blutdruckwerte in diesem Beispiel schnell zu erkennen sind.
+ In der Spalte `ANOMALY_SCORE` sind Datensätze mit höherer Bewertung anormal. Der zweite Datensatz in diesem Beispiel-Ergebnissatz ist mit einer Anomaliebewertung von 3,855851061 am meisten anormal.
+ Um zu verstehen, wie stark jede der numerischen Spalten, die vom Algorithmus berücksichtigt wird, zur Anomaliebewertung beiträgt, nehmen Sie auf das JSON-Feld mit dem Namen `ATTRIBUTION_SCORE` in der Spalte `ANOMALY_SCORE` Bezug. Im Falle der zweiten Zeile in dieser Gruppe von Beispielergebnissen tragen die Spalten `Systolic` und `Diastolic` im Verhältnis von 1,7447:2,1111 zur Anomalie bei. Anders ausgedrückt lässt sich die Begründung der Anomaliebewertung zu 45 Prozent auf den systolischen Wert zurückführen. Der verbleibende Beitrag ist im diastolischen Wert begründet.
+ Anhand des JSON-Feldes mit dem Namen `DIRECTION` können Sie bestimmen, in welcher Richtung der durch die zweite Zeile in diesem Beispiel dargestellte Punkt anormal ist. In diesem Fall sind sowohl der diastolische als auch der systolische Wert beide als `HIGH` gekennzeichnet. Dem JSON-Feld mit dem Namen `STRENGTH` können Sie entnehmen, mit welcher Wahrscheinlichkeit diese Richtungen richtig sind. In diesem Beispiel findet der Algorithmus es wahrscheinlicher, dass der diastolische Wert hoch ist. Tatsächlich liegt der normale Wert der diastolischen Messung gewöhnlich bei 60-80 und ein Wert von 123 ist viel höher als erwartet. 