

Após uma análise cuidadosa, decidimos descontinuar o Amazon Kinesis Data Analytics para aplicativos SQL:

1. A partir de **1º de setembro de 2025,** não forneceremos nenhuma correção de bug para aplicativos do Amazon Kinesis Data Analytics para SQL porque teremos suporte limitado para ele, devido à próxima descontinuação.

2. A partir **de 15 de outubro de 2025,** você não poderá criar novos aplicativos Kinesis Data Analytics para SQL.

3. Excluiremos as aplicações a partir de **27 de janeiro de 2026**. Você não poderá mais iniciar nem operar as aplicações do Amazon Kinesis Data Analytics para SQL. A partir dessa data, não haverá mais suporte ao Amazon Kinesis Data Analytics para SQL. Para obter mais informações, consulte [Descontinuação de aplicações do Amazon Kinesis Data Analytics para SQL](discontinuation.md).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Exemplo: como detectar anomalias de dados e obter uma explicação (função RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION)
<a name="app-anomaly-detection-with-explanation"></a>

O Amazon Kinesis Data Analytics fornece a função `RANDOM_CUT_FOREST_WITH_EXPLANATION` que atribui uma pontuação de anomalias a cada registro de acordo com os valores nas colunas numéricas. A função também fornece uma explicação da anomalia. Para obter mais informações, consulte [RANDOM\$1CUT\$1FOREST\$1WITH\$1EXPLANATION](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-random-cut-forest-with-explanation.html) em *Amazon Managed Service for Apache Flink SQL Reference*. 

Neste exercício, você escreve o código de aplicativo para obter pontuações de anomalias para os registros na origem de streaming do aplicativo. Você também pode obter uma explicação para cada anomalia.

**Topics**
+ [Etapa 1: Preparar os dados](app-anomaly-with-ex-prepare.md)
+ [Etapa 2: Criar um aplicativo de análise](app-anom-with-exp-create-app.md)
+ [Etapa 3: Examinar os resultados](examine-results-with-exp.md)

**Primeira etapa**  
[Etapa 1: Preparar os dados](app-anomaly-with-ex-prepare.md)

# Etapa 1: Preparar os dados
<a name="app-anomaly-with-ex-prepare"></a>

Antes de criar um Amazon Kinesis Data Analytics para este [exemplo](app-anomaly-detection-with-explanation.md), crie um fluxo de dados do Kinesis para usar como origem de streaming para o seu aplicativo. Além disso, execute o código Python para gravar dados simulados de pressão arterial no fluxo. 

**Topics**
+ [Etapa 1.1: Criar um fluxo de dados do Kinesis](#app-anomaly-create-two-streams)
+ [Etapa 1.2: Gravação de registros de amostra no stream de entrada](#app-anomaly-write-sample-records-inputstream)

## Etapa 1.1: Criar um fluxo de dados do Kinesis
<a name="app-anomaly-create-two-streams"></a>

Nesta seção, você cria um fluxo de dados do Kinesis chamado `ExampleInputStream`. Você pode criar esse fluxo de dados usando o Console de gerenciamento da AWS ou AWS CLI o.
+ Para usar o console:

  1. [Faça login no Console de gerenciamento da AWS e abra o console do Kinesis em https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis)

  1. Selecione **Data Streams (Fluxos de dados)** no painel de navegação. Em seguida, escolha **Create Kinesis stream (Criar fluxo do Kinesis)**.

  1. Para o nome, digite **ExampleInputStream**. Para o número de estilhaços, digite **1**.
+ Como alternativa, para usar o AWS CLI para criar o fluxo de dados, execute o seguinte comando:

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

## Etapa 1.2: Gravação de registros de amostra no stream de entrada
<a name="app-anomaly-write-sample-records-inputstream"></a>

Nesta etapa, execute o código Python para gerar continuamente os registros de exemplo e gravá-los no fluxo de dados que você criou. 

1. Instale o Python e o pip.

   Para obter informações sobre como instalar o Python, consulte [Python](https://www.python.org/). 

   Você pode instalar dependências usando o pip. Para obter informações sobre como instalar o pip, consulte [Instalação](https://pip.pypa.io/en/stable/installing/) na documentação do pip.

1. Execute o código do Python a seguir. Você pode alterar a região a ser usada neste exemplo. O comando `put-record` no código grava os registros JSON no fluxo.

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

**Próxima etapa**  
[Etapa 2: Criar um aplicativo de análise](app-anom-with-exp-create-app.md)

# Etapa 2: Criar um aplicativo de análise
<a name="app-anom-with-exp-create-app"></a>

Nesta seção, você cria um aplicativo do Amazon Kinesis Data Analytics e o configura para usar o fluxo de dados do Kinesis que você criou em [Etapa 1: Preparar os dados](app-anomaly-with-ex-prepare.md). Em seguida, você executa o código do aplicativo que usa a função `RANDOM_CUT_FOREST_WITH_EXPLANATION`.

**Como criar uma aplicação do**

1. [Abra o console do Kinesis em https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis)

1. Escolha **Data Analytics (Análise de dados)** no painel de navegação e, em seguida, **Create application (Criar aplicativo)**.

1. Forneça o nome e a descrição do aplicativo (opcional) e escolha **Create application**.

1. Escolha **Connect streaming data** e, em seguida, escolha **ExampleInputStream**na lista. 

1. Escolha **Discover schema** e verifique se `Systolic` e `Diastolic` aparecem como colunas `INTEGER`. Se elas tiverem um outro tipo, escolha **Edit schema** e atribua o tipo `INTEGER` a ambas. 

1. Em **Real time analytics**, escolha **Go to SQL editor**. Quando solicitado, confirme a execução do aplicativo. 

1. Cole o seguinte código no editor SQL e, em seguida, escolha **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;
   ```

**Próxima etapa**  
[Etapa 3: Examinar os resultados](examine-results-with-exp.md)

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

Quando você executa o código SQL para este [exemplo](app-anomaly-detection-with-explanation.md), primeiro consulte as linhas com uma pontuação de anomalias igual a zero. Isso acontece durante a fase de aprendizagem inicial. Em seguida, você obtém resultados semelhantes aos seguintes:

```
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"}}
```
+ O algoritmo da função `RANDOM_CUT_FOREST_WITH_EXPLANATION` vê que as colunas `Systolic` e `Diastolic` são numéricas e as utiliza como entrada.
+ A coluna `BloodPressureLevel` tem dados de texto e, portanto, não é levada em conta pelo algoritmo. Essa coluna é simplesmente um auxiliar visual para ajudá-lo a reconhecer rapidamente os níveis de pressão arterial normal, alto e baixo neste exemplo.
+ Na coluna `ANOMALY_SCORE`, os registros com pontuações mais altas são mais anormais. O segundo registro neste exemplo de conjunto de resultados é o mais anormal, com uma pontuação de anomalia de 3.855851061.
+ Para entender o quanto cada uma das colunas numéricas levadas em conta pelo algoritmo contribui para a pontuação de anomalia, consulte o campo JSON chamado `ATTRIBUTION_SCORE` na coluna `ANOMALY_SCORE`. No caso de uma segunda linha nesse conjuntos de resultados de amostra, as colunas `Systolic` e `Diastolic` contribuem para a anomalia na proporção 1.7447:2.1111. Em outras palavras, 45 por cento da explicação da pontuação de anomalia é atribuível ao valor sistólico, e a atribuição restante é por conta do valor diastólico.
+ Para determinar a direção na qual o ponto representado pela segunda linha neste exemplo é anormal, consulte o campo JSON chamado `DIRECTION`. Ambos os valores diastólico e sistólico são marcados como `HIGH` neste caso. Para determinar a confiança de que essas direções estão corretas, consulte o campo JSON chamado `STRENGTH`. Neste exemplo, o algoritmo está mais seguro que o valor diastólico é alto. De fato, o nível normal para a leitura do valor diastólico é geralmente 60-80, e 123 é muito mais alto do que o esperado. 