

Après mûre réflexion, nous avons décidé de mettre fin à Amazon Kinesis Data Analytics pour les applications SQL :

1. À compter du **1er septembre 2025,** nous ne fournirons aucune correction de bogue pour les applications Amazon Kinesis Data Analytics for SQL, car leur support sera limité, compte tenu de l'arrêt prochain.

2. À compter du **15 octobre 2025,** vous ne pourrez plus créer de nouvelles applications Kinesis Data Analytics for SQL.

3. Nous supprimerons vos candidatures à compter **du 27 janvier 2026**. Vous ne serez pas en mesure de démarrer ou d'utiliser vos applications Amazon Kinesis Data Analytics for SQL. Support ne sera plus disponible pour Amazon Kinesis Data Analytics for SQL à partir de cette date. Pour de plus amples informations, veuillez consulter [Arrêt d'Amazon Kinesis Data Analytics pour les applications SQL](discontinuation.md).

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exemple : détection d'anomalies de données et message d'explication (fonction RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION)
<a name="app-anomaly-detection-with-explanation"></a>

Amazon Kinesis Data Analytics fournit la fonction `RANDOM_CUT_FOREST_WITH_EXPLANATION`, qui attribue un score d’anomalie à chaque enregistrement en fonction de valeurs dans les colonnes numériques. La fonction fournit également une explication de l'anomalie. Pour plus d’informations, consultez [RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-random-cut-forest-with-explanation.html) dans le manuel *Référence SQL du service géré Amazon pour Apache Flink*. 

Dans cet exercice, vous allez écrire du code d'application pour obtenir des scores d'anomalie pour des enregistrements dans la source de diffusion de votre application. Vous allez également obtenir une explication pour chaque anomalie.

**Topics**
+ [Étape 1 : Préparation des données](app-anomaly-with-ex-prepare.md)
+ [Étape 2 : Création d'une application d'analyse](app-anom-with-exp-create-app.md)
+ [Étape 3 : Évaluation des résultats](examine-results-with-exp.md)

**Première étape**  
[Étape 1 : Préparation des données](app-anomaly-with-ex-prepare.md)

# Étape 1 : Préparation des données
<a name="app-anomaly-with-ex-prepare"></a>

Avant de créer une application Amazon Kinesis Data Analytics pour cet [exemple](app-anomaly-detection-with-explanation.md), vous devez créer un flux de données Kinesis que vous allez utiliser comme source de streaming pour votre application. Vous pouvez également exécuter un code Python pour écrire des données simulées de pression artérielle dans le flux. 

**Topics**
+ [Étape 1.1 : Création d’un flux de données Kinesis](#app-anomaly-create-two-streams)
+ [Étape 1.2 : Ecriture d'exemples d'enregistrements dans le flux d'entrée](#app-anomaly-write-sample-records-inputstream)

## Étape 1.1 : Création d’un flux de données Kinesis
<a name="app-anomaly-create-two-streams"></a>

Dans cette section, vous allez créer un flux de données Kinesis nommé `ExampleInputStream`. Vous pouvez créer ce flux de données à l'aide du AWS Management Console ou du AWS CLI.
+ Pour utiliser la console :

  1. [Connectez-vous à la console Kinesis AWS Management Console et ouvrez-la à https://console.aws.amazon.com l'adresse /kinesis.](https://console.aws.amazon.com/kinesis)

  1. Choisissez **Data Streams (Flux de données)** dans le volet de navigation. Ensuite, choisissez **Create Kinesis stream (Créer un flux Kinesis)**.

  1. Pour le nom, saisissez **ExampleInputStream**. Pour le nombre de partitions, saisissez **1**.
+ Vous pouvez également utiliser le AWS CLI pour créer le flux de données, exécutez la commande suivante :

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

## Étape 1.2 : Ecriture d'exemples d'enregistrements dans le flux d'entrée
<a name="app-anomaly-write-sample-records-inputstream"></a>

Dans cette étape, vous exécutez du code Python pour générer en continu des exemples d'enregistrements et les écrire dans le flux de données que vous avez créé. 

1. Installez Python et pip.

   Pour plus d'informations sur l'installation de Python, consultez le site [Python](https://www.python.org/). 

   Vous pouvez installer des dépendances à l'aide de pip. Pour plus d'informations sur l'installation de pip, consultez la section [Installation](https://pip.pypa.io/en/stable/installing/) dans la documentation de pip.

1. Exécutez le code Python suivant. Vous pouvez modifier la région en choisissant celle que vous souhaitez utiliser pour cet exemple. La commande `put-record` dans le code écrit les enregistrements JSON dans le flux.

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

**Étape suivante**  
[Étape 2 : Création d'une application d'analyse](app-anom-with-exp-create-app.md)

# Étape 2 : Création d'une application d'analyse
<a name="app-anom-with-exp-create-app"></a>

Dans cette section, vous allez créer une application Amazon Kinesis Data Analytics et la configurer pour utiliser le flux de données Kinesis que vous avez créé en tant que source de streaming dans [Étape 1 : Préparation des données](app-anomaly-with-ex-prepare.md). Vous pouvez ensuite exécuter le code de l'application qui utilise la fonction `RANDOM_CUT_FOREST_WITH_EXPLANATION`.

**Pour créer une application**

1. [Ouvrez la console Kinesis à l'adresse /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis)

1. Choisissez **Data Analytics (Analyse des données)** dans le volet de navigation, puis **Create application (Créer une application)**.

1. Attribuez un nom et une description (facultatif) à votre application, puis sélectionnez **Create application**

1. Choisissez **Connect streaming data**, puis sélectionnez-en un **ExampleInputStream**dans la liste. 

1. Sélectionnez **Discover schema** et vérifiez que `Systolic` et `Diastolic` apparaissent sous la forme de colonnes `INTEGER`. S'ils sont associés à un autre type, sélectionnez **Edit schema** et attribuez-leur le type `INTEGER`. 

1. Sous **Real time analytics**, sélectionnez **Go to SQL editor**. À l'invite, choisissez d'exécuter votre application. 

1. Collez le code suivant dans l'éditeur SQL, puis choisissez **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;
   ```

**Étape suivante**  
[Étape 3 : Évaluation des résultats](examine-results-with-exp.md)

# Étape 3 : Évaluation des résultats
<a name="examine-results-with-exp"></a>

Lorsque vous exécutez le code SQL pour cet [exemple](app-anomaly-detection-with-explanation.md), vous devez d'abord voir des lignes avec un score d'anomalie égal à zéro. Cela se produit au cours de la phase d'apprentissage initiale. Vous obtenez ensuite des résultats similaires à ce qui suit:

```
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"}}
```
+ L'algorithme de la fonction `RANDOM_CUT_FOREST_WITH_EXPLANATION` voit que les colonnes `Systolic` et `Diastolic` sont au format numérique et les utilise en tant qu'entrées.
+ La colonne `BloodPressureLevel` contient des données texte et n'est donc pas prise en compte par l'algorithme. Cette colonne est une simple aide visuelle qui, dans cet exemple, vous permet d'identifier rapidement les différents niveaux de pression artérielle (normal, élevé et faible).
+ Dans la colonne `ANOMALY_SCORE`, les enregistrements associés à des scores plus élevés sont anormaux. Avec une score d'anomalie de 3,855851061, le deuxième enregistrement dans cet exemple d'ensemble de résultats est le plus anormal.
+ Pour comprendre dans quelle mesure chaque colonne numérique prise en compte par l'algorithme contribue au score d'anomalie, consultez le champ JSON nommé `ATTRIBUTION_SCORE` dans la colonne `ANOMALY_SCORE`. Dans le cas de la deuxième ligne de cet exemple d'ensemble de résultats, les colonnes `Systolic` et `Diastolic` contribuent au score d'anomalie selon une proportion de 1.7447:2 .1111. En d'autres termes, 45 % de l'explication du score d'anomalie est imputable à la valeur systolique, le reste étant attribué à la valeur diastolique.
+ Pour déterminer la direction dans laquelle le point représenté par la seconde ligne de cet exemple est anormal, consultez le champ JSON nommé `DIRECTION`. Les valeurs systolique et diastolique sont marquées en tant que `HIGH` dans ce cas. Pour déterminer le degré de confiance quant à l'exactitude de ces directions, consultez le champ JSON nommé `STRENGTH`. Dans cet exemple, l'algorithme a d'autant plus confiance que la valeur diastolique est élevée. En effet, la valeur normale du relevé diastolique est généralement comprise dans la plage 60 à 80, ce qui signifie qu’une valeur de 123 est bien plus élevée que prévu. 