

Tras considerarlo detenidamente, hemos decidido dejar de utilizar Amazon Kinesis Data Analytics para aplicaciones SQL:

1. A partir del **1 de septiembre de 2025,** no proporcionaremos ninguna corrección de errores para las aplicaciones de Amazon Kinesis Data Analytics for SQL porque tendremos un soporte limitado debido a la próxima discontinuación.

2. A partir del **15 de octubre de 2025,** no podrá crear nuevas aplicaciones de Kinesis Data Analytics for SQL.

3. Eliminaremos sus aplicaciones a partir del **27 de enero de 2026**. No podrá iniciar ni utilizar sus aplicaciones de Amazon Kinesis Data Analytics para SQL. A partir de ese momento, el servicio de soporte de Amazon Kinesis Data Analytics para SQL dejará de estar disponible. Para obtener más información, consulte [Retirada de las aplicaciones de Amazon Kinesis Data Analytics para SQL](discontinuation.md).

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejemplo: Detección de anomalías de datos y obtención de una explicación (función RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION)
<a name="app-anomaly-detection-with-explanation"></a>

Amazon Kinesis Data Analytics proporciona la función `RANDOM_CUT_FOREST_WITH_EXPLANATION`, que asigna una puntuación de anomalías a cada registro en función de los valores de las columnas numéricas. La función también ofrece una explicación de la anomalía. Para obtener más información, consulte [RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-random-cut-forest-with-explanation.html) en la *Referencia de SQL de Amazon Managed Service para Apache Flink*. 

En este ejercicio, escribirá el código de una aplicación para obtener las puntuaciones de anomalías para los registros del origen de streaming de la aplicación. También obtendrá una explicación para cada anomalía.

**Topics**
+ [Paso 1: Preparar los datos](app-anomaly-with-ex-prepare.md)
+ [Paso 2: Crear una aplicación de análisis](app-anom-with-exp-create-app.md)
+ [Paso 3: Examinar los resultados](examine-results-with-exp.md)

**Primer paso**  
[Paso 1: Preparar los datos](app-anomaly-with-ex-prepare.md)

# Paso 1: Preparar los datos
<a name="app-anomaly-with-ex-prepare"></a>

Antes de crear una aplicación de Amazon Kinesis Data Analytics para este [ejemplo](app-anomaly-detection-with-explanation.md), debe crear un flujo de datos de Kinesis para utilizarla como origen de streaming para su aplicación. También debe ejecutar código de Python para escribir datos simulados de tensión arterial en la secuencia. 

**Topics**
+ [Paso 1.1: crear un flujo de datos de Kinesis](#app-anomaly-create-two-streams)
+ [Paso 1.2: Escribir registros de muestra en la secuencia de entrada](#app-anomaly-write-sample-records-inputstream)

## Paso 1.1: crear un flujo de datos de Kinesis
<a name="app-anomaly-create-two-streams"></a>

En esta sección creará un flujo de datos de Kinesis denominada `ExampleInputStream`. Puede crear este flujo de datos utilizando el Consola de administración de AWS o el AWS CLI.
+ Para utilizar la consola:

  1. [Inicie sesión en la consola de Kinesis Consola de administración de AWS y ábrala en https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis)

  1. Elija **Flujos de datos** en el panel de navegación. A continuación, elija **Create Kinesis stream (Crear secuencia de Kinesis)**.

  1. Escriba **ExampleInputStream** como nombre del parámetro. Para el número de fragmentos, escriba **1**.
+ Como alternativa, para usar el AWS CLI para crear el flujo de datos, ejecute el siguiente comando:

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

## Paso 1.2: Escribir registros de muestra en la secuencia de entrada
<a name="app-anomaly-write-sample-records-inputstream"></a>

En este paso, ejecutará código de Python para generar continuamente registros de muestra y escribirlos en el flujo de datos que ha creado. 

1. Instale Python y pip.

   Para obtener información sobre la instalación de Python, consulte [Python](https://www.python.org/). 

   Puede instalar dependencias con pip. Para obtener información sobre la instalación de pip, consulte [Installation](https://pip.pypa.io/en/stable/installing/) en la documentación de pip.

1. Ejecute el siguiente código de Python. Puede cambiar la región por la que desee utilizar en este ejemplo. El comando `put-record` en el código escribe los registros JSON en la secuencia.

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

**Paso siguiente**  
[Paso 2: Crear una aplicación de análisis](app-anom-with-exp-create-app.md)

# Paso 2: Crear una aplicación de análisis
<a name="app-anom-with-exp-create-app"></a>

En esta sección creará una aplicación de análisis de datos de Amazon Kinesis Data Analytics y la configurará para que utilice el flujo de datos de Kinesis que ha creado como origen de streaming en [Paso 1: Preparar los datos](app-anomaly-with-ex-prepare.md). A continuación, ejecutará código de la aplicación que utiliza la función `RANDOM_CUT_FOREST_WITH_EXPLANATION`.

**Cómo crear una aplicación de**

1. [Abra la consola de Kinesis en https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis)

1. Elija **Data Analytics (Análisis de datos)** en el panel de navegación y, a continuación, elija **Create application (Crear aplicación)**.

1. Proporcione un nombre y una descripción (opcional) para la aplicación y elija **Create application**.

1. Selecciona **Conectar datos de streaming** y, a continuación, selecciona una opción **ExampleInputStream**de la lista. 

1. Elija **Discover esquema** y asegúrese de que `Systolic` y `Diastolic` aparecen como columnas de tipo `INTEGER`. Si son de otro tipo, seleccione **Edit schema** y asigne el tipo `INTEGER` a cada una de ellas. 

1. En **Real time analytics**, elija **Go to SQL editor**. Cuando se le pregunte, elija la opción de ejecutar la aplicación. 

1. Pegue el código siguiente en el editor de SQL y, a continuación, elija **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;
   ```

**Paso siguiente**  
[Paso 3: Examinar los resultados](examine-results-with-exp.md)

# Paso 3: Examinar los resultados
<a name="examine-results-with-exp"></a>

Cuando ejecute el código SQL de este [ejemplo](app-anomaly-detection-with-explanation.md), primero verá filas con una puntuación de anomalías igual a cero. Esto ocurre durante la fase de aprendizaje inicial. A continuación, obtendrá resultados similares a los siguientes:

```
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"}}
```
+ El algoritmo de la función `RANDOM_CUT_FOREST_WITH_EXPLANATION` considera que las columnas `Systolic` y `Diastolic` son numéricas y las utiliza como entrada.
+ La columna `BloodPressureLevel` contiene datos de texto, por lo que el algoritmo no la tiene en cuenta. Esta columna simplemente es una ayuda visual para ayudarle a reconocer rápidamente los niveles normales, altos y bajos de tensión arterial de este ejemplo.
+ En la columna `ANOMALY_SCORE`, los registros con puntuaciones más altas son los que presentan una mayor anomalía. El segundo registro de este conjunto de resultados de ejemplo el más anómalo, con una puntuación de anomalías de 3,855851061.
+ Para comprender en qué medida contribuye cada una de las columnas numéricas analizadas por el algoritmo a la puntuación de anomalías, consulte el campo JSON denominado `ATTRIBUTION_SCORE` en la columna `ANOMALY_SCORE`. En el caso de la segunda fila de este conjunto de resultados de muestra, las columnas `Systolic` y `Diastolic` contribuyen a la anomalía en la proporción de 1.7447:2.1111. En otras palabras, el 45 por ciento de la explicación de la puntuación de anomalías puede atribuirse al valor sistólico y el resto se debe al valor diastólico.
+ Para determinar en qué dirección es anómalo el punto representado por la segunda fila de este ejemplo, consulte el campo JSON denominado `DIRECTION`. En este caso, tanto el valor diastólico como el valor sistólico están marcados como `HIGH`. Para determinar la confianza con la que estas direcciones son correctas, consulte el campo JSON denominado `STRENGTH`. En este ejemplo, el algoritmo está más seguro de que el valor diastólico es alto. En efecto, el valor normal para la lectura diastólica suele estar entre 60 y 80, y 123 es mucho mayor de lo esperado. 