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.

# Ejemplos: Aprendizaje automático
<a name="examples-machine"></a>

En esta sección, se proporcionan ejemplos de aplicaciones de Amazon Kinesis Data Analytics que utilizan consultas de machine learning. Las consultas de aprendizaje automático realizan un análisis complejo de los datos, basándose en el historial de los datos de la secuencia para descubrir patrones inusuales. Los ejemplos proporcionan step-by-step instrucciones para configurar y probar la aplicación Kinesis Data Analytics. 

**Topics**
+ [Ejemplo: Detección de anomalías de datos en una secuencia (función RANDOM\$1CUT\$1FOREST)](app-anomaly-detection.md)
+ [Ejemplo: Detección de anomalías de datos y obtención de una explicación (función RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION)](app-anomaly-detection-with-explanation.md)
+ [Ejemplo: Detección de puntos calientes en una secuencia (función HOTSPOSTS)](app-hotspots-detection.md)

# Ejemplo: Detección de anomalías de datos en una secuencia (función RANDOM\$1CUT\$1FOREST)
<a name="app-anomaly-detection"></a>

Amazon Kinesis Data Analytics proporciona una función (`RANDOM_CUT_FOREST`) que puede asignar una puntuación de anomalías para cada registro en función de los valores en las columnas numéricas. Para obtener más información, consulte [Función `RANDOM_CUT_FOREST`](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/analytics-sql-reference.html) en la *Referencia de SQL de Amazon Managed Service para Apache Flink*. 

En este ejercicio, escribirá el código de la aplicación para asignar una puntuación de anomalías a los registros en el origen de streaming de la aplicación. Haga lo siguiente para configurar la aplicación:

1. **Configure un origen de streaming**: configure un flujo de datos de Kinesis y escriba datos de `heartRate` de muestra, tal y como se muestra a continuación:

   ```
   {"heartRate": 60, "rateType":"NORMAL"}
   ...
   {"heartRate": 180, "rateType":"HIGH"}
   ```

   El procedimiento proporciona un script de Python para que pueda rellenar la secuencia. Los valores de `heartRate` se generan de forma aleatoria. El 99 por ciento de los registros tienen valores de `heartRate` entre 60 y 100, y solo un 1 por ciento de ellos tienen valores de `heartRate` entre 150 y 200. Por lo tanto, los registros que tienen valores de `heartRate` comprendidos entre 150 y 200 son anomalías. 

1. **Configure la entrada**: use la consola para crear una aplicación de Kinesis Data Analytics y configure la entrada de la aplicación mapeando el origen de streaming a una secuencia en la aplicación (`SOURCE_SQL_STREAM_001`). Cuando se inicia la aplicación, Kinesis Data Analytics lee continuamente el origen de streaming e introduce los registros en la secuencia en la aplicación.

1. **Especifique el código de la aplicación**: el ejemplo utiliza el siguiente código de la aplicación:

   ```
   --Creates a temporary stream.
   CREATE OR REPLACE STREAM "TEMP_STREAM" (
   	        "heartRate"        INTEGER,
   	        "rateType"         varchar(20),
   	        "ANOMALY_SCORE"    DOUBLE);
   
   --Creates another stream for application output.	        
   CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
   	        "heartRate"        INTEGER,
   	        "rateType"         varchar(20),
   	        "ANOMALY_SCORE"    DOUBLE);
   
   -- Compute an anomaly score for each record in the input stream
   -- using Random Cut Forest
   CREATE OR REPLACE PUMP "STREAM_PUMP" AS 
      INSERT INTO "TEMP_STREAM"
         SELECT STREAM "heartRate", "rateType", ANOMALY_SCORE 
         FROM TABLE(RANDOM_CUT_FOREST(
                 CURSOR(SELECT STREAM * FROM "SOURCE_SQL_STREAM_001")));
   
   -- 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;
   ```

   El código lee filas de la puntuación `SOURCE_SQL_STREAM_001`, asigna un puntaje de anomalía, y escribe las filas resultante a otra secuencia en la aplicación (`TEMP_STREAM`). El código de la aplicación luego clasifica los registros en `TEMP_STREAM` y guarda los resultados en otra secuencia en la aplicación (`DESTINATION_SQL_STREAM`). Utilice bombas para insertar filas en secuencias en la aplicación. Para obtener más información, consulte [Secuencias y bombeos en la aplicación](streams-pumps.md).

1. **Configure la salida**: configure la salida de la aplicación para conservar los datos de `DESTINATION_SQL_STREAM` en un destino externo, que es otro flujo de datos de Kinesis. La revisión de las puntuaciones de anomalías que se han asignado a cada registro y la determinación de qué puntuación indica que se ha producido una anomalía (y que es necesario que le avisen) es algo ajeno a la aplicación. Puede utilizar una AWS Lambda función para procesar estas puntuaciones de anomalías y configurar las alertas. 

El ejercicio utiliza la región de Este de EE. UU. (Norte de Virginia) (`us-east-1`) para crear estas secuencias y su aplicación. Si utiliza cualquier otra región, debe actualizar el código en consecuencia.

**Topics**
+ [Paso 1: Preparación](app-anomaly-prepare.md)
+ [Paso 2: Cree una aplicación](app-anom-score-create-app.md)
+ [Paso 3: Configurar la salida de la aplicación](app-anomaly-create-ka-app-config-destination.md)
+ [Paso 4: Verificar la salida](app-anomaly-verify-output.md)

**Paso siguiente**  
[Paso 1: Preparación](app-anomaly-prepare.md)

# Paso 1: Preparación
<a name="app-anomaly-prepare"></a>

Antes de crear una aplicación de análisis de datos de Amazon Kinesis Data Analytics para este ejercicio, deberá crear dos flujos de datos de Kinesis. Configure una de las secuencias como el origen de streaming de su aplicación y otra secuencia como el destino, donde Kinesis Data Analytics sigue siendo la salida de su aplicación. 

**Topics**
+ [Paso 1.1: crear los flujos de datos de entrada y de salida](#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 los flujos de datos de entrada y de salida
<a name="app-anomaly-create-two-streams"></a>

En esta sección, creará dos secuencias de Kinesis: `ExampleInputStream` y `ExampleOutputStream`. Puede crear estas secuencias mediante la Consola de administración de AWS o la AWS CLI.
+ 

**Para utilizar la consola de**

  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 **Create data stream (Crear flujo de datos)**. Cree una secuencia con un fragmento denominado `ExampleInputStream`. Para obtener más información, consulte [Crear secuencia](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html) en la *Guía para desarrolladores de Amazon Kinesis Data Streams*.

  1. Repita el paso anterior y cree una secuencia con un fragmento denominada `ExampleOutputStream`.
+ 

**Para usar el AWS CLI**

  1. Utilice el siguiente `create-stream` AWS CLI comando de Kinesis para crear la primera transmisión ()`ExampleInputStream`.

     ```
     $ aws kinesis create-stream \
     --stream-name ExampleInputStream \
     --shard-count 1 \
     --region us-east-1 \
     --profile adminuser
     ```

  1. Ejecute el mismo comando, pero cambie el nombre de la secuencia por `ExampleOutputStream`. Este comando crea la segunda secuencia que usa la aplicación para escribir la salida.

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

En este paso, ejecute el código de Python para generar registros de muestra y escribirlos en la secuencia `ExampleInputStream`.

```
{"heartRate": 60, "rateType":"NORMAL"} 
...
{"heartRate": 180, "rateType":"HIGH"}
```

1. Instale Python y `pip`.

   Para obtener más información sobre la instalación de Python, consulte la página web de [Python](https://www.python.org/). 

   Puede instalar dependencias con pip. Para obtener más información sobre la instalación de pip, consulte la sección [Installation](https://pip.pypa.io/en/stable/installing/) en la página web de pip.

1. Ejecute el siguiente código de Python. 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 RateType(Enum):
       normal = "NORMAL"
       high = "HIGH"
   
   
   def get_heart_rate(rate_type):
       if rate_type == RateType.normal:
           rate = random.randint(60, 100)
       elif rate_type == RateType.high:
           rate = random.randint(150, 200)
       else:
           raise TypeError
       return {"heartRate": rate, "rateType": rate_type.value}
   
   
   def generate(stream_name, kinesis_client, output=True):
       while True:
           rnd = random.random()
           rate_type = RateType.high if rnd < 0.01 else RateType.normal
           heart_rate = get_heart_rate(rate_type)
           if output:
               print(heart_rate)
           kinesis_client.put_record(
               StreamName=stream_name,
               Data=json.dumps(heart_rate),
               PartitionKey="partitionkey",
           )
   
   
   if __name__ == "__main__":
       generate(STREAM_NAME, boto3.client("kinesis"))
   ```



**Paso siguiente**  
[Paso 2: Cree una aplicación](app-anom-score-create-app.md)

# Paso 2: Cree una aplicación
<a name="app-anom-score-create-app"></a>

En esta sección va a crear una aplicación de análisis de datos de Amazon Kinesis Data Analytics de la siguiente manera:
+ Configure la entrada de la aplicación para que utilice el flujo de datos de Kinesis que ha creado en [Paso 1: Preparación](app-anomaly-prepare.md) como origen de streaming.
+ Utilice la plantilla **Anomaly Detection (Detección de anomalías)** en la consola. 

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

1. Siga los pasos 1, 2 y 3 del ejercicio de **Introducción** a Kinesis Data Analytics (consulte [Paso 3.1: Cree una aplicación](get-started-create-app.md)). 
   + En la configuración fuente, haga lo siguiente:
     + Especifique el origen de streaming que ha creado en la sección anterior. 
     + Después de que la consola infiera el esquema, edite este y establezca el tipo de columna de `heartRate` en `INTEGER`. 

       La mayor parte de los valores de la frecuencia cardíaca son normales y el proceso de detección probablemente asignará el tipo `TINYINT` a esta columna. Pero un pequeño porcentaje de valores muestran una frecuencia cardíaca alta. Si estos valores no encajan en el tipo `TINYINT`, Kinesis Data Analytics envía estas filas a una secuencia de errores. Actualice el tipo de datos a `INTEGER` para que pueda adaptarse a todos los datos de frecuencia cardíaca que se han generado.
   + Utilice la plantilla **Anomaly Detection (Detección de anomalías)** en la consola. A continuación, actualice el código de la plantilla para proporcionar el nombre de columna apropiado.

1. Actualice el código de la aplicación al proporcionar los nombres de columnas. El código de la aplicación resultante se muestra a continuación (pegue este código en el editor de SQL):

   ```
   --Creates a temporary stream.
   CREATE OR REPLACE STREAM "TEMP_STREAM" (
   	        "heartRate"        INTEGER,
   	        "rateType"         varchar(20),
   	        "ANOMALY_SCORE"    DOUBLE);
   
   --Creates another stream for application output.	        
   CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
   	        "heartRate"        INTEGER,
   	        "rateType"         varchar(20),
   	        "ANOMALY_SCORE"    DOUBLE);
   
   -- Compute an anomaly score for each record in the input stream
   -- using Random Cut Forest
   CREATE OR REPLACE PUMP "STREAM_PUMP" AS 
      INSERT INTO "TEMP_STREAM"
         SELECT STREAM "heartRate", "rateType", ANOMALY_SCORE 
         FROM TABLE(RANDOM_CUT_FOREST(
                 CURSOR(SELECT STREAM * FROM "SOURCE_SQL_STREAM_001")));
   
   -- 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;
   ```

   

1. Ejecute el código SQL y revise los resultados en la consola de Kinesis Data Analytics:  
![\[Imagen de pantalla de la consola que muestra la pestaña de análisis en tiempo real con los datos resultantes en la secuencia en la aplicación.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/anom-v2-40.png)





**Paso siguiente**  
[Paso 3: Configurar la salida de la aplicación](app-anomaly-create-ka-app-config-destination.md)

# Paso 3: Configurar la salida de la aplicación
<a name="app-anomaly-create-ka-app-config-destination"></a>

Una vez completado el [Paso 2: Cree una aplicación](app-anom-score-create-app.md), dispone de código de la aplicación que lee datos de frecuencia cardíaca de un origen de streaming y asigna una puntuación de anomalías a cada uno de ellos. 

Ahora puede enviar el resultado de la aplicación desde la secuencia en la aplicación hasta un destino externo, que es otro flujo de datos de Kinesis (`OutputStreamTestingAnomalyScores`). Puede analizar las puntuaciones de anomalías y determinar qué frecuencia cardíaca es anómala. Puede ampliar aún más esta aplicación para generar alertas. 

Siga estos pasos para configurar la salida de la aplicación:



1. Abra la consola de Amazon Kinesis Data Analytics. En el editor de SQL, puede elegir tanto **Destination** como **Add a destination** en el panel de la aplicación. 

1. En la página **Connect to destination (Conectarse a un destino)**, elija la secuencia `OutputStreamTestingAnomalyScores` que ha creado en la sección anterior.

   Ahora tiene un destino externo, donde Amazon Kinesis Data Analytics persiste en cualquier registro que escriba su aplicación en la secuencia en la aplicación `DESTINATION_SQL_STREAM`. 

1. Si lo desea, puede configurarlo AWS Lambda para que supervise la `OutputStreamTestingAnomalyScores` transmisión y le envíe alertas. Para obtener instrucciones, consulte [Procesamiento previo de registros con una función de Lambda](lambda-preprocessing.md). Si no configura alertas, puede revisar los registros que Kinesis Data Analytics escribe en el destino externo, que es un flujo de datos Kinesis de `OutputStreamTestingAnomalyScores`, tal como se describe en [Paso 4: Verificar la salida](app-anomaly-verify-output.md).

**Paso siguiente**  
[Paso 4: Verificar la salida](app-anomaly-verify-output.md)

# Paso 4: Verificar la salida
<a name="app-anomaly-verify-output"></a>

Después de configurar la salida de la aplicación en [Paso 3: Configurar la salida de la aplicación](app-anomaly-create-ka-app-config-destination.md), utilice los siguientes comandos de la AWS CLI para leer los registros de la secuencia de destino que escribe la aplicación:

1. Ejecute el comando `get-shard-iterator` para obtener un puntero a los datos en la secuencia de salida.

   ```
   aws kinesis get-shard-iterator \
   --shard-id shardId-000000000000 \
   --shard-iterator-type TRIM_HORIZON \
   --stream-name OutputStreamTestingAnomalyScores \
   --region us-east-1 \
   --profile adminuser
   ```

   Puede obtener una respuesta con un valor iterador de fragmento, tal y como se muestra en el ejemplo siguiente respuesta:

   ```
     {      
         "ShardIterator":
         "shard-iterator-value"   }
   ```

   Copie el valor de iterador de fragmento. 

1. Ejecute el comando AWS CLI `get-records`.

   ```
   aws kinesis get-records \
   --shard-iterator shared-iterator-value \
   --region us-east-1 \
   --profile adminuser
   ```

   El comando devuelve una página de registros y otro iterador de fragmento que puede utilizar en el comando `get-records` posterior para recuperar el siguiente conjunto de registros.

# 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. 

# Ejemplo: Detección de puntos calientes en una secuencia (función HOTSPOSTS)
<a name="app-hotspots-detection"></a>

Amazon Kinesis Data Analytics dispone de la función `HOTSPOTS` que localiza y devuelve información sobre las regiones relativamente densas en los datos. Para obtener más información, consulte [HOTSPOTS](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-hotspots.html) en la *Referencia de SQL de Amazon Managed Service para Apache Flink*. 

En este ejercicio, puede escribir código de la aplicación para localizar puntos calientes en el origen de streaming de su aplicación. Realice los pasos siguientes para configurar la aplicación:

1. **Configure un origen de streaming**: configure una secuencia de Kinesis y escriba datos coordinados de muestra, tal y como se muestra a continuación:

   ```
   {"x": 7.921782426109737, "y": 8.746265312709893, "is_hot": "N"}
   {"x": 0.722248626528026, "y": 4.648868803193405, "is_hot": "Y"}
   ```

   El ejemplo proporciona un script de Python para que pueda rellenar la secuencia. Los valores `x` e `y` se generan de forma aleatoria. Algunos registros se agrupan en torno a determinadas ubicaciones.

   El campo `is_hot` se suministra como indicador si el script ha generado el valor de forma intencionada como parte de un punto caliente. Esto puede ayudarle a evaluar si la función de detección de puntos calientes funciona correctamente.

1. **Cree la aplicación**: utilice la Consola de administración de AWS para crear la aplicación de análisis de datos de Kinesis Data Analytics. Configure la entrada de la aplicación mapeando el origen de streaming a una secuencia en la aplicación (`SOURCE_SQL_STREAM_001`). Cuando se inicia la aplicación, Kinesis Data Analytics lee continuamente el origen de streaming e introduce los registros en la secuencia en la aplicación.

   En este ejercicio, utilizará el siguiente código para la aplicación:

   ```
   CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
       "x" DOUBLE, 
       "y" DOUBLE, 
       "is_hot" VARCHAR(4),
       HOTSPOTS_RESULT VARCHAR(10000)
   ); 
   CREATE OR REPLACE PUMP "STREAM_PUMP" AS 
       INSERT INTO "DESTINATION_SQL_STREAM" 
       SELECT "x", "y", "is_hot", "HOTSPOTS_RESULT" 
       FROM TABLE (
           HOTSPOTS(   
               CURSOR(SELECT STREAM "x", "y", "is_hot" FROM "SOURCE_SQL_STREAM_001"), 
               1000, 
               0.2, 
               17)
       );
   ```

   El código lee filas en `SOURCE_SQL_STREAM_001`, las analiza en busca de puntos calientes relevantes y escribe los datos resultantes en otra secuencia en la aplicación (`DESTINATION_SQL_STREAM`). Utilice bombas para insertar filas en secuencias en la aplicación. Para obtener más información, consulte [Secuencias y bombeos en la aplicación](streams-pumps.md).

1. **Configure la salida**: configure la salida de la aplicación para que envíe los datos desde la aplicación a un destino externo, que es otro flujo de datos de Kinesis. Revise las puntuaciones de los puntos calientes y determine qué puntuaciones indican que se ha producido un punto caliente (del cual desea que se le avise). Puede utilizar una AWS Lambda función para seguir procesando la información de los puntos de acceso y configurar las alertas. 

1. **Verifique el resultado**: el ejemplo incluye una JavaScript aplicación que lee los datos del flujo de salida y los muestra gráficamente, de modo que pueda ver los puntos de acceso que genera la aplicación en tiempo real. 



El ejercicio utiliza la región de Oeste de EE. UU. (Oregón) (`us-west-2`) para crear estas secuencias y su aplicación. Si utiliza otra región, deberá actualizar el código en consecuencia.

**Topics**
+ [Paso 1: Crear las secuencias de entrada y de salida](app-hotspots-prepare.md)
+ [Paso 2: creación de una aplicación de Kinesis Data Analytics](app-hotspot-create-app.md)
+ [Paso 3: Configurar la salida de la aplicación](app-hotspots-create-ka-app-config-destination.md)
+ [Paso 4: Verificar la salida de la aplicación](app-hotspots-verify-output.md)

# Paso 1: Crear las secuencias de entrada y de salida
<a name="app-hotspots-prepare"></a>

Antes de crear una aplicación de análisis de datos de Amazon Kinesis Data Analytics para el [Ejemplo de puntos de acceso](app-hotspots-detection.md), deberá crear dos flujos de datos de Kinesis. Configure una de las secuencias como el origen de streaming de su aplicación y otra secuencia como el destino, donde Kinesis Data Analytics sigue siendo la salida de su aplicación. 

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

## Paso 1.1: crear los flujos de datos de Kinesis
<a name="app-hotspots-create-two-streams"></a>

En esta sección, creará dos secuencias de Kinesis: `ExampleInputStream` y `ExampleOutputStream`. 

Cree estas flujos de datos con la consola o la AWS CLI.
+ Para crear estas flujos de datos con 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.

  1. Elija **Create Kinesis Stream (Crear secuencia de Kinesis)** y, a continuación, cree una secuencia con un fragmento denominado `ExampleInputStream`.

  1. Repita el paso anterior y cree una secuencia con un fragmento denominada `ExampleOutputStream`.
+ Para crear flujos de datos con la AWS CLI:
  + Cree transmisiones (`ExampleInputStream`y`ExampleOutputStream`) mediante el siguiente comando de Kinesis `create-stream` AWS CLI . Para crear la segunda secuencia, que la aplicación utilizará para escribir la salida, ejecute el mismo comando, cambiando el nombre de la secuencia a `ExampleOutputStream`.

    ```
    $ aws kinesis create-stream \
    --stream-name ExampleInputStream \
    --shard-count 1 \
    --region us-west-2 \
    --profile adminuser
                             
    $ aws kinesis create-stream \
    --stream-name ExampleOutputStream \
    --shard-count 1 \
    --region us-west-2 \
    --profile adminuser
    ```

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

En este paso, ejecute el código de Python para generar registros de muestra y escribir en la secuencia `ExampleInputStream`.

```
{"x": 7.921782426109737, "y": 8.746265312709893, "is_hot": "N"}
{"x": 0.722248626580026, "y": 4.648868803193405, "is_hot": "Y"}
```

1. Instale Python y `pip`.

   Para obtener más información sobre la instalación de Python, consulte la página web de [Python](https://www.python.org/). 

   Puede instalar dependencias con pip. Para obtener más información sobre la instalación de pip, consulte la sección [Installation](https://pip.pypa.io/en/stable/installing/) en la página web de pip.

1. Ejecute el siguiente código de Python. Este código hace lo siguiente:
   + Genera un punto caliente potencial en algún lugar del plano (X, Y).
   + Genera un conjunto de 1000 puntos para cada punto caliente. De estos puntos, el 20 % se agrupa en torno a un punto caliente. El resto se genera de forma aleatoria en todo el espacio.
   + El comando `put-record` escribe los registros JSON en la secuencia.
**importante**  
No cargue este archivo en un servidor web, ya que contiene sus credenciales de AWS .

   ```
    
   import json
   from pprint import pprint
   import random
   import time
   import boto3
   
   STREAM_NAME = "ExampleInputStream"
   
   
   def get_hotspot(field, spot_size):
       hotspot = {
           "left": field["left"] + random.random() * (field["width"] - spot_size),
           "width": spot_size,
           "top": field["top"] + random.random() * (field["height"] - spot_size),
           "height": spot_size,
       }
       return hotspot
   
   
   def get_record(field, hotspot, hotspot_weight):
       rectangle = hotspot if random.random() < hotspot_weight else field
       point = {
           "x": rectangle["left"] + random.random() * rectangle["width"],
           "y": rectangle["top"] + random.random() * rectangle["height"],
           "is_hot": "Y" if rectangle is hotspot else "N",
       }
       return {"Data": json.dumps(point), "PartitionKey": "partition_key"}
   
   
   def generate(
       stream_name, field, hotspot_size, hotspot_weight, batch_size, kinesis_client
   ):
       """
       Generates points used as input to a hotspot detection algorithm.
       With probability hotspot_weight (20%), a point is drawn from the hotspot;
       otherwise, it is drawn from the base field. The location of the hotspot
       changes for every 1000 points generated.
       """
       points_generated = 0
       hotspot = None
       while True:
           if points_generated % 1000 == 0:
               hotspot = get_hotspot(field, hotspot_size)
           records = [
               get_record(field, hotspot, hotspot_weight) for _ in range(batch_size)
           ]
           points_generated += len(records)
           pprint(records)
           kinesis_client.put_records(StreamName=stream_name, Records=records)
   
           time.sleep(0.1)
   
   
   if __name__ == "__main__":
       generate(
           stream_name=STREAM_NAME,
           field={"left": 0, "width": 10, "top": 0, "height": 10},
           hotspot_size=1,
           hotspot_weight=0.2,
           batch_size=10,
           kinesis_client=boto3.client("kinesis"),
       )
   ```



**Paso siguiente**  
[Paso 2: creación de una aplicación de Kinesis Data Analytics](app-hotspot-create-app.md)

# Paso 2: creación de una aplicación de Kinesis Data Analytics
<a name="app-hotspot-create-app"></a>

En esta sección del [Ejemplo de puntos de acceso](app-hotspots-detection.md), crea una aplicación de análisis de datos de Kinesis Data Analytics tal como se indica a continuación:
+ Configure la entrada de la aplicación para que utilice el flujo de datos de Kinesis que ha creado como origen de streaming en el [Paso 1](app-hotspots-prepare.md).
+ Utilice el código de la aplicación proporcionado en la Consola de administración de AWS.

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

1. Cree una aplicación de análisis de datos de Kinesis Data Analytics; para ello, siga los pasos 1, 2 y 3 del ejercicio de [Introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html) (consulte [Paso 3.1: Cree una aplicación](get-started-create-app.md)).

   En la configuración fuente, haga lo siguiente:
   + Especifique el origen de streaming que creó en [Paso 1: Crear las secuencias de entrada y de salida](app-hotspots-prepare.md).
   + Después de que la consola deduzca el esquema, edítelo. Asegúrese de que los tipos de columna `x` e `y` estén establecidos en `DOUBLE` y que el tipo de columna `IS_HOT` esté establecido en `VARCHAR`. 

1. Utilice el siguiente código de la aplicación (puede pegar este código en el editor de SQL):

   ```
   CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
       "x" DOUBLE, 
       "y" DOUBLE, 
       "is_hot" VARCHAR(4),
       HOTSPOTS_RESULT VARCHAR(10000)
   ); 
   CREATE OR REPLACE PUMP "STREAM_PUMP" AS 
       INSERT INTO "DESTINATION_SQL_STREAM" 
       SELECT "x", "y", "is_hot", "HOTSPOTS_RESULT" 
       FROM TABLE (
           HOTSPOTS(   
               CURSOR(SELECT STREAM "x", "y", "is_hot" FROM "SOURCE_SQL_STREAM_001"), 
               1000, 
               0.2, 
               17)
       );
   ```

   

1. Ejecute el código SQL y revise los resultados.  
![\[Resultados del código SQL que muestran los valores de rowtime, hotspot y hotspot_heat.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/hotspot-v2-40.png)





**Paso siguiente**  
[Paso 3: Configurar la salida de la aplicación](app-hotspots-create-ka-app-config-destination.md)

# Paso 3: Configurar la salida de la aplicación
<a name="app-hotspots-create-ka-app-config-destination"></a>

Llegados a este punto del [Ejemplo de puntos de acceso](app-hotspots-detection.md), el código de la aplicación de Amazon Kinesis Data Analytics ha descubierto ya numerosos puntos de acceso de un origen de streaming y les ha asignado una puntuación a cada uno. 

Ahora puede enviar el resultado de la aplicación desde la secuencia en la aplicación hasta un destino externo, que es otro flujo de datos de Kinesis (`ExampleOutputStream`). A continuación, puede analizar las puntuaciones de los puntos calientes y determinar cuál podría ser un umbral adecuado de calor de los puntos calientes. Puede ampliar esta aplicación más para generar alertas. 

**Para configurar la salida de la aplicación**

1. Abra la consola de Kinesis Data Analytics [ https://console---aws.amazon.com.rproxy.govskope.caen](https://console.aws.amazon.com/kinesisanalytics) /kinesisanalytics.

1. En el editor de SQL, puede elegir tanto **Destination** como **Add a destination** en el panel de la aplicación. 

1. En la página **Add a destination (Añadir un destino)**, seleccione **Select from your streams (Seleccionar de sus secuencias)**. A continuación, elija la secuencia `ExampleOutputStream` que ha creado en la sección anterior.

   Ahora tiene un destino externo, donde Amazon Kinesis Data Analytics persiste en cualquier registro que escriba su aplicación en la secuencia en la aplicación `DESTINATION_SQL_STREAM`. 

1. Si lo desea, puede configurarla para AWS Lambda que supervise la transmisión y le envíe alertas`ExampleOutputStream`. Para obtener más información, consulte [Uso de una función de Lambda como salida](how-it-works-output-lambda.md). También puede revisar los registros que escribe Kinesis Data Analytics en el destino externo, que es la secuencia `ExampleOutputStream` de Kinesis, tal como se describe en [Paso 4: Verificar la salida de la aplicación](app-hotspots-verify-output.md).

**Paso siguiente**  
[Paso 4: Verificar la salida de la aplicación](app-hotspots-verify-output.md)

# Paso 4: Verificar la salida de la aplicación
<a name="app-hotspots-verify-output"></a>

En esta sección del [ejemplo de puntos calientes](app-hotspots-detection.md), debe configurar una aplicación web que muestre la información de puntos calientes en un control de gráficos vectoriales escalables (SVG).

1. Cree un archivo denominado `index.html` con el siguiente contenido:

   ```
   <!doctype html>
   <html lang=en>
   <head>
       <meta charset=utf-8>
       <title>hotspots viewer</title>
   
       <style>
       #visualization {
         display: block;
         margin: auto;
       }
   
       .point {
         opacity: 0.2;
       }
   
       .hot {
         fill: red;
       }
   
       .cold {
         fill: blue;
       }
   
       .hotspot {
         stroke: black;
         stroke-opacity: 0.8;
         stroke-width: 1;
         fill: none;
       }
       </style>
       <script src="https://sdk.amazonaws.com/js/aws-sdk-2.202.0.min.js"></script>
       <script src="https://d3js.org/d3.v4.min.js"></script>
   </head>
   <body>
   <svg id="visualization" width="600" height="600"></svg>
   <script src="hotspots_viewer.js"></script>
   </body>
   </html>
   ```

1. Cree un archivo en el mismo directorio denominado `hotspots_viewer.js` con el siguiente contenido. Proporcione su región, las credenciales y el nombre de la secuencia de salida en las variables suministradas.

   ```
   // Visualize example output from the Kinesis Analytics hotspot detection algorithm.
   // This script assumes that the output stream has a single shard.
   
   // Modify this section to reflect your AWS configuration
   var awsRegion = "",        // The  where your Kinesis Analytics application is configured.
       accessKeyId = "",      // Your Access Key ID
       secretAccessKey = "",  // Your Secret Access Key
       outputStream = "";     // The name of the Kinesis Stream where the output from the HOTSPOTS function is being written
   
   // The variables in this section should reflect way input data was generated and the parameters that the HOTSPOTS
   // function was called with.
   var windowSize = 1000, // The window size used for hotspot detection
       minimumDensity = 40,  // A filter applied to returned hotspots before visualization
       xRange = [0, 10],  // The range of values to display on the x-axis
       yRange = [0, 10];  // The range of values to display on the y-axis
   
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   // D3 setup
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
   var svg = d3.select("svg"),
       margin = {"top": 20, "right": 20, "bottom": 20, "left": 20},
       graphWidth = +svg.attr("width") - margin.left - margin.right,
       graphHeight = +svg.attr("height") - margin.top - margin.bottom;
   
   // Return the linear function that maps the segment [a, b] to the segment [c, d].
   function linearScale(a, b, c, d) {
       var m = (d - c) / (b - a);
       return function(x) {
           return c + m * (x - a);
       };
   }
   
   // helper functions to extract the x-value from a stream record and scale it for output
   var xValue = function(r) { return r.x; },
       xScale = linearScale(xRange[0], xRange[1], 0, graphWidth),
       xMap = function(r) { return xScale(xValue(r)); };
   
   // helper functions to extract the y-value from a stream record and scale it for output
   var yValue = function(r) { return r.y; },
       yScale = linearScale(yRange[0], yRange[1], 0, graphHeight),
       yMap = function(r) { return yScale(yValue(r)); };
   
   // a helper function that assigns a CSS class to a point based on whether it was generated as part of a hotspot
   var classMap = function(r) { return r.is_hot == "Y" ? "point hot" : "point cold"; };
   
   var g = svg.append("g")
       .attr("transform", "translate(" + margin.left + "," + margin.top + ")");
   
   function update(records, hotspots) {
   
       var points = g.selectAll("circle")
           .data(records, function(r) { return r.dataIndex; });
   
       points.enter().append("circle")
           .attr("class", classMap)
           .attr("r", 3)
           .attr("cx", xMap)
           .attr("cy", yMap);
   
       points.exit().remove();
   
       if (hotspots) {
           var boxes = g.selectAll("rect").data(hotspots);
   
           boxes.enter().append("rect")
               .merge(boxes)
               .attr("class", "hotspot")
               .attr("x", function(h) { return xScale(h.minValues[0]); })
               .attr("y", function(h) { return yScale(h.minValues[1]); })
               .attr("width", function(h) { return xScale(h.maxValues[0]) - xScale(h.minValues[0]); })
               .attr("height", function(h) { return yScale(h.maxValues[1]) - yScale(h.minValues[1]); });
   
           boxes.exit().remove();
       }
   }
   
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   // Use the AWS SDK to pull output records from Kinesis and update the visualization
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
   var kinesis = new AWS.Kinesis({
       "region": awsRegion,
       "accessKeyId": accessKeyId,
       "secretAccessKey": secretAccessKey
   });
   
   var textDecoder = new TextDecoder("utf-8");
   
   // Decode an output record into an object and assign it an index value
   function decodeRecord(record, recordIndex) {
       var record = JSON.parse(textDecoder.decode(record.Data));
       var hotspots_result = JSON.parse(record.HOTSPOTS_RESULT);
       record.hotspots = hotspots_result.hotspots
           .filter(function(hotspot) { return hotspot.density >= minimumDensity});
       record.index = recordIndex
       return record;
   }
   
   // Fetch a new records from the shard iterator, append them to records, and update the visualization
   function getRecordsAndUpdateVisualization(shardIterator, records, lastRecordIndex) {
       kinesis.getRecords({
           "ShardIterator": shardIterator
       }, function(err, data) {
           if (err) {
               console.log(err, err.stack);
               return;
           }
   
           var newRecords = data.Records.map(function(raw) { return decodeRecord(raw, ++lastRecordIndex); });
           newRecords.forEach(function(record) { records.push(record); });
   
           var hotspots = null;
           if (newRecords.length > 0) {
               hotspots = newRecords[newRecords.length - 1].hotspots;
           }
   
           while (records.length > windowSize) {
               records.shift();
           }
   
           update(records, hotspots);
   
           getRecordsAndUpdateVisualization(data.NextShardIterator, records, lastRecordIndex);
       });
   }
   
   // Get a shard iterator for the output stream and begin updating the visualization. Note that this script will only
   // read records from the first shard in the stream.
   function init() {
       kinesis.describeStream({
           "StreamName": outputStream
       }, function(err, data) {
           if (err) {
               console.log(err, err.stack);
               return;
           }
   
           var shardId = data.StreamDescription.Shards[0].ShardId;
   
           kinesis.getShardIterator({
               "StreamName": outputStream,
               "ShardId": shardId,
               "ShardIteratorType": "LATEST"
           }, function(err, data) {
               if (err) {
                   console.log(err, err.stack);
                   return;
               }
               getRecordsAndUpdateVisualization(data.ShardIterator, [], 0);
           })
       });
   }
   
   // Start the visualization
   init();
   ```

1. Cuando el código de Python de la primera sección se esté ejecutando, abra `index.html` en un navegador web. La información de punto caliente aparece en la página, como se muestra a continuación.

     
![\[Diagrama de gráficos vectoriales escalables que muestra información de los puntos calientes.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/hotspots_visualizer.png)