Detecção de anomalias (funções baseadas em ML do Snowflake Cortex)¶

Limitações¶

• Você não pode escolher ou ajustar o algoritmo de detecção de anomalias. Em especial, o algoritmo não fornece parâmetros para substituir a tendência, a sazonalidade ou as amplitudes sazonais; elas são inferidas a partir dos dados.

• O número mínimo de linhas para o algoritmo principal de detecção de anomalias é 12 por série temporal. Para séries temporais com observações entre 2 e 11, a detecção de anomalias produz um resultado «ingênuo» em que todos os valores previstos são iguais ao último valor nominal observado. Para o caso de detecção de anomalia rotulada, o número de observações utilizadas é o número de linhas onde a coluna do rótulo é falsa.

• A granularidade mínima aceitável de dados é um segundo. (Carimbos de data/hora não devem ter menos de um segundo de intervalo.)

• A granularidade mínima dos componentes sazonais é de um minuto. (A função não pode detectar padrões cíclicos em deltas de tempo menores.)

• Os carimbos de data/hora em seus dados devem representar intervalos de tempo fixos. Se seus dados de entrada forem irregulares, tente DATE_TRUNC ou TIME_SLICE na coluna de carimbo de data/hora ao treinar o modelo.

• A “duração da temporada” dos recursos autorregressivos está vinculada à frequência de entrada (24 para dados horários, 7 para dados diários e assim por diante).

• Depois de treinados, os modelos de detecção de anomalias são imutáveis. Você não pode atualizar modelos existentes com novos dados; você deve treinar um modelo inteiramente novo. Os modelos não oferecem suporte ao controle de versão. Em geral, você deve retreinar os modelos em uma cadência regular, como uma vez por semana ou uma vez por mês, dependendo da frequência com que recebe novos dados, para ajudar o modelo a acompanhar as tendências em constante mudança.

• Esse recurso detecta apenas anomalias nos dados de teste relativos aos dados de treinamento. Ele não pode detectar anomalias nos dados de treinamento. Como os dados de treinamento são a fonte do modelo, por definição, ele não possui exceções relativas a si mesmo. Certifique-se de que os dados de treinamento abranjam um período típico livre de exceções reais ou rotule as exceções conhecidas em uma coluna booleana.

• Você não pode clonar modelos ou compartilhar modelos entre funções ou contas. Ao clonar um esquema ou banco de dados, os objetos do modelo são ignorados.

• Você não pode replicar uma instância da classe ANOMALY_DETECTION.

Seleção de um warehouse virtual¶

Um warehouse virtual do Snowflake fornece os recursos de computação para treinamento e uso dos modelos de machine learning para esse recurso. Esta seção fornece orientações gerais sobre como selecionar o melhor tamanho e tipo de warehouse para essa finalidade, com foco na etapa de treinamento (a parte mais demorada e que consome muita memória do processo).

Concessão de privilégios para criar objetos de detecção de anomalias¶

O treinamento de um modelo de detecção de anomalias resulta em um objeto em nível de esquema. Portanto, a função que você usa para criar modelos deve ter o privilégio CREATE SNOWFLAKE.ML.ANOMALY_DETECTION no esquema onde o modelo é criado, o que permite que o modelo seja armazenado lá. Este privilégio é semelhante a outros privilégios de esquema como CREATE TABLE ou CREATE VIEW.

Snowflake recomenda que você crie uma função chamada analyst para ser usada por pessoas que precisam detectar anomalias.

No exemplo a seguir, a função admin é a proprietária do esquema admin_db.admin_schema. A função analyst precisa criar modelos neste esquema.

USE ROLE admin;
GRANT USAGE ON admin_db TO ROLE analyst;
GRANT USAGE ON admin_schema TO ROLE analyst;
GRANT CREATE SNOWFLAKE.ML.ANOMALY_DETECTION ON SCHEMA admin_db.admin_schema TO ROLE analyst;

Para usar este esquema, um usuário assume a função analyst:

USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;

Se a função analyst tiver privilégios CREATE SCHEMA no banco de dados analyst_db, a função pode criar um novo esquema analyst_db.analyst_schema e criar modelos de detecção de anomalias nesse esquema:

USE ROLE analyst;
CREATE SCHEMA analyst_db.analyst_schema;
USE SCHEMA analyst_db.analyst_schema;

Para revogar o privilégio de criação de modelo de uma função no esquema, use REVOKE <privilégios>:

REVOKE CREATE SNOWFLAKE.ML.ANOMALY_DETECTION ON SCHEMA admin_db.admin_schema FROM ROLE analyst;

Detecção de anomalias para uma única série temporal (sem supervisão)¶

Para detectar anomalias em seus dados:

1. Treine um modelo de detecção de anomalias usando dados históricos.

2. Use o modelo treinado de detecção de anomalias para detectar anomalias em dados históricos ou projetados. Os carimbos de data/hora nos dados de teste devem seguir cronologicamente os carimbos de data/hora nos dados de treinamento. Você precisa de pelo menos 2 pontos de dados para treinar um modelo, pelo menos 12 para resultados não ingênuos e pelo menos 60 para resultados não lineares.

Consulte ANOMALY_DETECTION para obter informações sobre os parâmetros usados na criação e uso de um modelo.

BEGIN
  CALL basic_model!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
     TIMESTAMP_COLNAME =>'date',
     TARGET_COLNAME => 'sales'
  );
  LET x := SQLID;
  CREATE TABLE my_anomalies AS SELECT * FROM TABLE(RESULT_SCAN(:x));
END;

SELECT * FROM my_anomalies;

Treinamento de um modelo de detecção de anomalias com dados rotulados¶

No exemplo anterior, o resultado do modelo parece ser impreciso. Isso acontece provavelmente porque:

• O modelo de detecção de anomalias foi treinado com poucos dados de entrada.

• Um número maior de jaquetas (30) foi vendido em 2020-01-03. Isso distorceu as previsões para cima e aumentou o tamanho do intervalo de previsão.

Para melhorar a precisão do modelo de detecção de anomalias, você pode incluir mais dados de treinamento ou rotular os dados de treinamento (treinamento supervisionado). Os dados de treinamento rotulados têm uma coluna booleana adicional que indica se cada linha é uma anomalia conhecida. O rótulo pode ajudar o modelo de detecção de anomalias a evitar o ajuste excessivo a anomalias conhecidas nos dados de treinamento.

Para incluir dados rotulados nos dados de treinamento, especifique a coluna que contém o rótulo no argumento do construtor LABEL_COLNAME do comando CREATE SNOWFLAKE.ML.ANOMALY_DETECTION. Por exemplo:

1. Crie uma exibição ou crie uma consulta que retorne os rótulos com os dados de treinamento.

   Para este exemplo, execute o comando CREATE VIEW para criar uma exibição chamada view_with_labeled_data que contém os rótulos em uma coluna chamada label:

   CREATE OR REPLACE VIEW view_with_labeled_data_for_training
     AS SELECT date, sales, label FROM historical_sales_data
       WHERE store_id=1 and item='jacket';
   

   Copy

2. Crie um objeto para o modelo de detecção de anomalias e treine o modelo nos dados dessa exibição.

   Para este exemplo, execute o comando CREATE SNOWFLAKE.ML.ANOMALY_DETECTION para criar um objeto de detecção de anomalias chamado model_trained_with_labeled_data. A instrução a seguir cria o objeto de detecção de anomalias:

   CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_trained_with_labeled_data(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_labeled_data_for_training'),
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     LABEL_COLNAME => 'label'
   );
   

   Copy

3. Usando este novo modelo de detecção de anomalias, chame o método <nome>!DETECT_ANOMALIES, passando os mesmos argumentos que você usou em Detecção de anomalias para uma única série temporal (sem supervisão):

   CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
     TIMESTAMP_COLNAME =>'date',
     TARGET_COLNAME => 'sales'
   );
   

   Copy

   O método retorna uma tabela que inclui linhas para os dados atualmente na exibição view_with_data_to_analyze juntamente com a previsão do detector. Para obter uma descrição das colunas nesta tabela, consulte Saída.

Saída

Os resultados foram arredondados para facilitar a leitura.

+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+
| TS                      |  Y | FORECAST |   LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |   PERCENTILE |   DISTANCE |
|-------------------------+----+----------+---------------+--------------+------------+--------------+------------|
| 2020-01-16 00:00:00.000 |  6 |        6 |  0.82         | 11.18        | False      | 0.5          | 0          |
| 2020-01-17 00:00:00.000 | 20 |        6 | -0.39         | 12.33        | True       | 0.99         | 5.70       |
+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+

Especificação do intervalo de previsão para detecção de anomalias¶

Você pode detectar anomalias com vários níveis de sensibilidade. Para especificar a porcentagem de observações a serem classificadas como anomalias, crie um OBJECT que contenha definições de configuração para <nome>!DETECT_ANOMALIES e defina a chave prediction_interval para a porcentagem das observações que devem ser marcadas como anomalias.

Para construir esse objeto, você pode usar uma constante de objeto ou a função OBJECT_CONSTRUCT.

Então, ao chamar o método <nome>!DETECT_ANOMALIES, passe este objeto como o argumento CONFIG_OBJECT.

Por padrão, o valor associado à chave intervalo_de_previsão é definido como 0,99, o que significa que aproximadamente 1% dos dados é marcado como anomalias. Você pode especificar um valor entre 0 e 1:

• Para marcar mais observações como anomalias, especifique um valor mais alto para prediction_interval.

• Para marcar mais observações como anomalias, reduza o valor prediction_interval.

O exemplo a seguir configura a detecção de anomalias para ser mais rigorosa, definindo prediction_interval como 0,995. O exemplo também usa o modelo treinado em dados rotulados (que você configurou em Treinamento de um modelo de detecção de anomalias com dados rotulados) com a exibição que contenha os dados a serem analisados (que você configurou em Detecção de anomalias para uma única série temporal (sem supervisão)).

CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales',
  CONFIG_OBJECT => {'prediction_interval':0.995}
);

Esta instrução produz uma tabela que inclui linhas para os dados atualmente na exibição view_with_data_to_analyze. Cada linha inclui uma coluna com a previsão do detector. Você pode ver que o resultado desse modelo é mais preciso do que o exemplo sem rótulo.

Saída

Os resultados foram arredondados para facilitar a leitura.

+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+
| TS                      |  Y | FORECAST |   LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |   PERCENTILE |   DISTANCE |
|-------------------------+----+----------+---------------+--------------+------------+--------------+------------|
| 2020-01-16 00:00:00.000 |  6 |        6 |  0.36         | 11.64        | False      | 0.5          | 0          |
| 2020-01-17 00:00:00.000 | 20 |        6 | -0.90         | 12.90        | True       | 0.99         | 5.70       |
+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+

Como incluir colunas adicionais para análise¶

Você pode incluir colunas adicionais nos dados (por exemplo, temperature, weather, is_black_friday) nos dados para treinamento e análise, se essas colunas puderem ajudar você a melhorar a identificação de verdadeiras anomalias.

Para incluir novas colunas para análise:

1. Para os dados de treinamento, crie uma exibição ou projete uma consulta que inclua as novas colunas e crie um novo objeto de detecção de anomalias, transmitindo uma referência a essa exibição ou consulta.

2. Para os dados a serem analisados, crie uma exibição ou projete uma consulta que inclua as novas colunas e passe uma referência a essa exibição ou consulta para o método <nome>!DETECT_ANOMALIES.

O modelo de detecção de anomalias detecta e usa as colunas adicionais automaticamente.

Por exemplo, suponha que você queira adicionar as colunas temperature, humidity e holiday:

1. Crie uma exibição ou crie uma consulta que retorne os dados de treinamento com essas colunas adicionais.

   Para este exemplo, execute o comando CREATE VIEW para criar uma exibição chamada view_with_training_data_extra_columns:

   CREATE OR REPLACE VIEW view_with_training_data_extra_columns
     AS SELECT date, sales, label, temperature, humidity, holiday
       FROM historical_sales_data
       WHERE store_id=1 AND item='jacket';
   

   Copy

2. Crie um objeto para o modelo de detecção de anomalias e treine o modelo nos dados dessa exibição.

   Para este exemplo, execute o comando CREATE SNOWFLAKE.ML.ANOMALY_DETECTION para criar um objeto de detecção de anomalias chamado model_with_additional_columns, passando uma referência à nova exibição:

   CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_with_additional_columns(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_training_data_extra_columns'),
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     LABEL_COLNAME => 'label'
   );
   

   Copy

3. Crie uma exibição ou crie uma consulta que retorne os dados para análise com essas colunas adicionais.

   Para este exemplo, execute o comando CREATE VIEW para criar uma exibição chamada view_with_data_for_analysis_extra_columns:

   CREATE OR REPLACE VIEW view_with_data_for_analysis_extra_columns
     AS SELECT date, sales, temperature, humidity, holiday
       FROM new_sales_data
       WHERE store_id=1 AND item='jacket';
   

   Copy

4. Usando esse novo objeto de detecção de anomalias, chame o método <nome>!DETECT_ANOMALIES, passando a nova exibição:

   CALL model_with_additional_columns!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_for_analysis_extra_columns'),
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     CONFIG_OBJECT => {'prediction_interval':0.93}
   );
   

   Copy

   Esta instrução produz uma tabela que inclui linhas para os dados atualmente na exibição view_with_data_for_analysis_extra_columns juntamente com a previsão do detector. O formato da saída é o mesmo que o formato da saída mostrado para os comandos executados anteriormente.

Saída

Os resultados foram arredondados para facilitar a leitura.

+-------------------------+----+----------+-------------+--------------+------------+--------------+------------+
| TS                      |  Y | FORECAST | LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |   PERCENTILE |   DISTANCE |
|-------------------------+----+----------+-------------+--------------+------------+--------------+------------|
| 2020-01-16 00:00:00.000 |  6 |        6 | 2.34        |  9.64        | False      | 0.5          | 0          |
| 2020-01-17 00:00:00.000 | 20 |        6 | 1.56        | 10.451       | True       | 0.99         | 5.70       |
+-------------------------+----+----------+-------------+--------------+------------+--------------+------------+

Detecção de anomalias em séries múltiplas¶

As seções anteriores forneceram exemplos de detecção de anomalias para uma única série. Esses exemplos sinalizaram anomalias para a venda de um tipo de item (jaquetas) em uma loja (ID da loja 1). Para detectar anomalias em múltiplas séries temporais ao mesmo tempo (por exemplo, para diversas combinações de itens e lojas):

1. Para os dados de treinamento, crie uma exibição ou projete uma consulta que inclua uma coluna que identifique a série e crie um novo objeto de detecção de anomalias, passando uma referência a essa exibição ou consulta e especificando o nome da coluna da série para o argumento SERIES_COLNAME.

2. Para os dados a serem analisados, crie uma exibição ou desenhe uma consulta que inclua a coluna que identifica a série. Chame o método <nome>!DETECT_ANOMALIES, passando uma referência a essa exibição ou consulta e especificando o nome da coluna da série para o argumento SERIES_COLNAME.

Por exemplo, suponha que você queira usar a combinação das colunas store_id e item para identificar a série:

1. Crie uma exibição ou crie uma consulta que retorne os dados de treinamento com a coluna da série.

   Para este exemplo, execute o comando CREATE VIEW para criar uma exibição chamada view_with_training_data_multiple_series que contém uma coluna chamada store_item que identifica a série como uma combinação de ID da loja e artigo:

   CREATE OR REPLACE VIEW view_with_training_data_multiple_series
     AS SELECT
       [store_id, item] AS store_item,
       date,
       sales,
       label,
       temperature,
       humidity,
       holiday
     FROM historical_sales_data;
   

   Copy

2. Crie um objeto para a detecção de anomalias e treine o modelo nos dados dessa exibição.

   Para este exemplo, execute o comando CREATE SNOWFLAKE.ML.ANOMALY_DETECTION para criar um objeto de detecção de anomalias chamado model_for_multiple_series, passando uma referência para a nova exibição e especificando store_item para o argumento SERIES_COLNAME:

   CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_for_multiple_series(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_training_data_multiple_series'),
     SERIES_COLNAME => 'store_item',
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     LABEL_COLNAME => 'label'
   );
   

   Copy

3. Crie uma exibição ou crie uma consulta que retorne os dados para análise com a coluna da série.

   Para este exemplo, execute o comando CREATE VIEW para criar uma exibição chamada view_with_data_for_analysis_multiple_series que contém uma coluna chamada store_item para a série:

   CREATE OR REPLACE VIEW view_with_data_for_analysis_multiple_series
     AS SELECT
       [store_id, item] AS store_item,
       date,
       sales,
       temperature,
       humidity,
       holiday
     FROM new_sales_data;
   

   Copy

4. Usando este novo objeto de detecção de anomalias, chame o método <nome>!DETECT_ANOMALIES, passando a nova exibição e especificando store_item para o argumento SERIES_COLNAME:

   CALL model_for_multiple_series!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_for_analysis_multiple_series'),
     SERIES_COLNAME => 'store_item',
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     CONFIG_OBJECT => {'prediction_interval':0.995}
   );
   

   Copy

   Esta instrução produz uma tabela que inclui linhas para os dados atualmente na exibição view_with_data_for_analysis_multiple_series juntamente com a previsão do detector. A saída inclui a coluna que identifica a série.

Saída

Os resultados foram arredondados para facilitar a leitura.

+--------------+-------------------------+----+----------+---------------+--------------+------------+---------------+--------------+
| SERIES       | TS                      |  Y | FORECAST |   LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |    PERCENTILE |     DISTANCE |
|--------------+-------------------------+----+----------+---------------+--------------+------------+---------------+--------------|
| [            | 2020-01-16 00:00:00.000 |  3 |      6.3 |  2.07         | 10.53        | False      | 0.01          | -2.19         |
|   2,         |                         |    |          |               |              |            |               |              |
|   "umbrella" |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
| [            | 2020-01-17 00:00:00.000 | 70 |      2.9 | -1.33         |  7.13        | True       | 1             | 44.54         |
|   2,         |                         |    |          |               |              |            |               |              |
|   "umbrella" |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
| [            | 2020-01-16 00:00:00.000 |  6 |      6   |  0.36         | 11.64        | False      | 0.5           |  0           |
|   1,         |                         |    |          |               |              |            |               |              |
|   "jacket"   |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
| [            | 2020-01-17 00:00:00.000 | 20 |      6   | -0.90         | 12.90        | True       | 0.99          |  5.70         |
|   1,         |                         |    |          |               |              |            |               |              |
|   "jacket"   |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
+--------------+-------------------------+----+----------+---------------+--------------+------------+---------------+--------------+

Treinamento recorrente com uma tarefa Snowflake¶

Você pode atualizar seu modelo para refletir os dados mais atualizados usando as tarefas Snowflake.

Para criar uma tarefa que atualize o objeto de detecção de anomalias a cada hora, execute a instrução a seguir, substituindo your_warehouse_name pelo nome do seu warehouse:

CREATE OR REPLACE TASK ad_model_retrain_task
WAREHOUSE = <your_warehouse_name>
SCHEDULE = '60 MINUTE'
AS
EXECUTE IMMEDIATE
$$
BEGIN
  CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_trained_with_labeled_data(
    INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_labeled_data_for_training'),
    TIMESTAMP_COLNAME => 'date',
    TARGET_COLNAME => 'sales',
    LABEL_COLNAME => 'label'
  );
END;
$$;

Por padrão, as tarefas recém-criadas são suspensas.

Para retomar a tarefa, execute o comando ALTER TASK … RESUME:

ALTER TASK ad_model_retrain_task RESUME;

Para pausar a tarefa, execute o comando ALTER TASK … SUSPEND:

ALTER TASK ad_model_retrain_task SUSPEND;

Monitoramento com uma tarefa Snowflake¶

Você também pode usar as tarefas Snowflake para monitorar seus dados em uma determinada frequência.

Primeiro, crie uma tabela para armazenar os resultados da detecção de anomalias:

CREATE OR REPLACE TABLE anomaly_res_table (
  ts TIMESTAMP_NTZ, y FLOAT, forecast FLOAT, lower_bound FLOAT, upper_bound FLOAT,
  is_anomaly BOOLEAN, percentile FLOAT, distance FLOAT);

Crie uma tarefa para armazenar os resultados de uma operação recorrente de detecção de anomalias na tabela. Este exemplo define o parâmetro WAREHOUSE como snowhouse. Você pode substituir isso pelo seu próprio warehouse:

CREATE OR REPLACE TASK ad_model_monitoring_task
WAREHOUSE = snowhouse
SCHEDULE = '1 minute'
AS
EXECUTE IMMEDIATE
$$
BEGIN
  CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
    INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
    TIMESTAMP_COLNAME => 'date',
    TARGET_COLNAME => 'sales',
    CONFIG_OBJECT => {'prediction_interval':0.99}
  );

  INSERT INTO anomaly_res_table (ts, y, forecast, lower_bound, upper_bound, is_anomaly, percentile, distance)
    SELECT * FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));
END;
$$;

Para retomar a tarefa, execute o comando ALTER TASK … RESUME:

ALTER TASK ad_model_monitoring_task RESUME;

anomaly_res_table conterá então todos os resultados para cada tarefa executada.

Para pausar a tarefa, execute o comando ALTER TASK … SUSPEND:

ALTER TASK ad_model_monitoring_task SUSPEND;

Monitoramento com um alerta Snowflake¶

Você também pode usar alertas Snowflake para monitorar seus dados com uma determinada frequência e enviar um e-mail a você com as anomalias detetadas. As instruções a seguir criam um alerta que detecta anomalias a cada minuto. Primeiro você define um procedimento armazenado para detectar anomalias, depois crie um alerta que use esse procedimento armazenado.

CREATE OR REPLACE PROCEDURE extract_anomalies()
  RETURNS TABLE()
  LANGUAGE SQL
  AS
  $$
    BEGIN
      CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
        INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
        TIMESTAMP_COLNAME => 'date',
        TARGET_COLNAME => 'sales',
        CONFIG_OBJECT => {'prediction_interval':0.99}
      );

      DECLARE
        res RESULTSET DEFAULT (SELECT * FROM TABLE(RESULT_SCAN(-1)) WHERE is_anomaly = TRUE);
      BEGIN
        RETURN TABLE(res);
      END;
    END;
  $$
  ;

CREATE OR REPLACE ALERT sample_sales_alert
WAREHOUSE = <your_warehouse_name>
SCHEDULE = '1 MINUTE'
IF (EXISTS (CALL extract_anomalies()))
THEN
CALL SYSTEM$SEND_EMAIL(
  'sales_email_alert',
  'your_email@snowflake.com',
  'Anomalous Sales Data Detected in data stream',
  CONCAT(
    'Anomalous Sales Data Detected in data stream \n',
    'Value outside of prediction interval detected in the most recent run at ',
    current_timestamp(1)
  ));

Para iniciar ou retomar o alerta, execute o comando ALTER ALERT … RESUME:

ALTER ALERT sample_sales_alert RESUME;

Para pausar o alerta, execute o comando ALTER ALERT … SUSPEND:

ALTER ALERT sample_sales_alert SUSPEND;

Limitações¶

• Você não pode escolher a técnica usada para calcular a importância do recurso.

• As pontuações de importância do recurso podem ser úteis para obter intuição sobre quais recursos são importantes para a precisão do seu modelo, mas os valores reais devem ser considerados estimativas.

Exemplo¶

Para entender a importância relativa dos seus recursos para o modelo, treine um modelo e chame <nome>!EXPLAIN_FEATURE_IMPORTANCE. Neste exemplo, você primeiro cria dados aleatórios com duas variáveis exógenas: uma que é aleatória e, portanto, provavelmente não será muito importante para seu modelo, e outra que é uma cópia do seu destino e, portanto, provavelmente será mais importante para o seu modelo.

Execute as seguintes instruções para gerar os dados, treine um modelo nele e obtenha a importância dos recursos:

CREATE OR REPLACE VIEW v_random_data AS SELECT
  DATEADD('minute', ROW_NUMBER() over (ORDER BY 1), '2023-12-01')::TIMESTAMP_NTZ ts,
  MOD(SEQ1(),10) y,
  UNIFORM(1, 100, RANDOM(0)) exog_a
FROM TABLE(GENERATOR(ROWCOUNT => 500));

CREATE OR REPLACE VIEW v_feature_importance_demo AS SELECT
  ts,
  y,
  exog_a
FROM v_random_data;

SELECT * FROM v_feature_importance_demo;

CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION anomaly_model_feature_importance_demo(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v_feature_importance_demo'),
  TIMESTAMP_COLNAME => 'ts',
  TARGET_COLNAME => 'y',
  LABEL_COLNAME => ''
);

CALL anomaly_model_feature_importance_demo!EXPLAIN_FEATURE_IMPORTANCE();

Saída

Como este exemplo usa dados aleatórios, não espere que sua saída corresponda exatamente a isso.

+------+--------------------------------------+-------+-------------------------+
| RANK | FEATURE_NAME                         | SCORE | FEATURE_TYPE            |
+------+--------------------------------------+-------+-------------------------+
|    1 | aggregated_endogenous_trend_features |  0.36 | derived_from_endogenous |
|    2 | exog_a                               |  0.22 | user_provided           |
|    3 | epoch_time                           |  0.15 | derived_from_timestamp  |
|    4 | minute                               |  0.13 | derived_from_timestamp  |
|    5 | lag60                                |  0.07 | derived_from_endogenous |
|    6 | lag120                               |  0.06 | derived_from_endogenous |
|    7 | hour                                 |  0.01 | derived_from_timestamp  |
+------+--------------------------------------+-------+-------------------------+

Exemplo¶

CREATE TABLE t_error(date TIMESTAMP_NTZ, sales FLOAT, series VARCHAR);
INSERT INTO t_error VALUES
  (TO_TIMESTAMP_NTZ('2019-12-20'), 1.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-21'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-22'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-23'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-24'), 1.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-25'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-26'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-27'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-28'), 1.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-29'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-30'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-31'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-01'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-02'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-03'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-04'), 7.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-05'), 10.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-06'), 13.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-06'), 12.0, 'B'), -- duplicate timestamp
  (TO_TIMESTAMP_NTZ('2020-01-07'), 15.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-08'), 14.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-09'), 18.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-10'), 12.0, 'B');

CREATE SNOWFLAKE.ML.ANOMALY_DETECTION model(
  INPUT_DATA => SYSTEM$QUERY_REFERENCE('SELECT date, sales, series FROM t_error'),
  SERIES_COLNAME => 'series',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales',
  LABEL_COLNAME => '',
  CONFIG_OBJECT => {'ON_ERROR': 'SKIP'}
);

CALL model!SHOW_TRAINING_LOGS();

Saída

+--------+-------------------------------------------------------------------------------------------------+
| SERIES | LOGS                                                                                            |
+--------+-------------------------------------------------------------------------------------------------+
| "B"    | {   "Errors": [     "Frequency cannot be inferred when duplicate timestamps are present."   ] } |
| "A"    | NULL                                                                                            |
+--------+-------------------------------------------------------------------------------------------------+