Previsão de séries temporais (funções baseadas em Snowflake Cortex ML)¶

Sobre o algoritmo de previsão¶

O algoritmo de previsão é alimentado por uma máquina de gradient boosting (GBM). Como um modelo ARIMA, ele usa uma transformação diferencial para modelar dados com uma tendência não estacionária e usa atrasos auto-regressivos dos dados de destino históricos como variáveis de modelo.

Além disso, o algoritmo usa médias contínuas de dados de destino históricos para ajudar a prever tendências e produz automaticamente variáveis de calendário cíclico (como dia da semana e semana do ano) a partir de dados do carimbo de data/hora.

Você pode ajustar modelos apenas com dados históricos de destino e carimbo de data/hora ou pode incluir dados exógenos (variáveis) que podem ter influenciado o valor de destino. As variáveis exógenas podem ser numéricas ou categóricas e podem ser NULL (linhas contendo NULLs para variáveis exógenas não são descartadas).

O algoritmo não depende de one-hot encoding ao treinar em variáveis categóricos, portanto, você pode usar dados categóricos com muitas dimensões (alta cardinalidade).

Se o seu modelo incorporar variáveis exógenas, ao gerar uma previsão, você deverá fornecer valores para essas variáveis em cada carimbo de data/hora do horizonte completo da previsão. Variáveis exógenas apropriadas podem incluir dados meteorológicos (temperatura, precipitação), informações específicas da empresa (feriados históricos e planejados da empresa, campanhas publicitárias, programações de eventos) ou quaisquer outros fatores externos que você acredita que possam ajudar a prever sua variável desejada.

O algoritmo também gera intervalos de previsão, além de previsões. Um intervalo de previsão é um intervalo estimado de valores dentro de um limite superior e um limite inferior no qual uma certa porcentagem de dados provavelmente ficará. Por exemplo, um valor de 0,95 significa que 95% dos dados provavelmente aparecem dentro do intervalo. Você pode especificar uma porcentagem do intervalo de previsão ou usar o padrão, que é 0,95. Os limites inferior e superior do intervalo de previsão são retornados como parte da saída da previsão.

Preparação para previsão¶

Antes de poder usar a previsão, você deve:

• Selecionar um warehouse virtual para treinar e executar seus modelos.

• Conceder os privilégios para criar objetos de previsão

Você também pode modificar seu caminho de pesquisa para incluir SNOWFLAKE.ML.

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

USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;

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

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

Configuração dos dados para os exemplos¶

O exemplo abaixo cria duas tabelas. As exibições dessas tabelas estão incluídas nos exemplos posteriormente neste tópico.

A tabela sales_data contém dados de vendas. Cada venda inclui uma ID da loja, um identificador de item, um carimbo de data/hora e o valor da venda. Variáveis exógenas ou externas (temperatura, umidade e feriado) também estão incluídas.

A tabela future_features contém valores futuros das variáveis exógenas, que são necessários ao prever com tais variáveis.

CREATE OR REPLACE TABLE sales_data (store_id NUMBER, item VARCHAR, date TIMESTAMP_NTZ,
  sales FLOAT, temperature NUMBER, humidity FLOAT, holiday VARCHAR);

INSERT INTO sales_data VALUES
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-01'), 2.0, 50, 0.3, 'new year'),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-02'), 3.0, 52, 0.3, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-03'), 4.0, 54, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-04'), 5.0, 54, 0.3, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-05'), 6.0, 55, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-06'), 7.0, 55, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-07'), 8.0, 55, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-08'), 9.0, 55, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-09'), 10.0, 55, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-10'), 11.0, 55, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-11'), 12.0, 55, 0.2, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-12'), 13.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-01'), 2.0, 50, 0.3, 'new year'),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-02'), 3.0, 52, 0.3, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-03'), 4.0, 54, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-04'), 5.0, 54, 0.3, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-05'), 6.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-06'), 7.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-07'), 8.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-08'), 9.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-09'), 10.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-10'), 11.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-11'), 12.0, 55, 0.2, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-12'), 13.0, 55, 0.2, NULL);

-- future values for exogenous variables (additional features)
CREATE OR REPLACE TABLE future_features (store_id NUMBER, item VARCHAR,
  date TIMESTAMP_NTZ, temperature NUMBER, humidity FLOAT, holiday VARCHAR);

INSERT INTO future_features VALUES
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-13'), 52, 0.3, NULL),
  (1, 'jacket', TO_TIMESTAMP_NTZ('2020-01-14'), 53, 0.3, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-13'), 52, 0.3, NULL),
  (2, 'umbrella', TO_TIMESTAMP_NTZ('2020-01-14'), 53, 0.3, NULL);

Treinamento, uso, visualização, exclusão e atualização de modelos¶

Use CREATE SNOWFLAKE.ML.FORECAST para criar e treinar um modelo. O modelo é treinado no conjunto de dados que você fornece.

CREATE SNOWFLAKE.ML.FORECAST <name>(...);

Consulte FORECAST para obter detalhes completos sobre o construtor SNOWFLAKE.ML.FORECAST. Para obter exemplos de criação de um modelo, consulte Exemplos.

Para gerar uma previsão, chame o método <nome>!FORECAST do modelo:

CALL <name>!FORECAST(...)

Para visualizar uma lista dos seus modelos, use o comando SHOW SNOWFLAKE.ML.FORECAST:

SHOW SNOWFLAKE.ML.FORECAST;

Para remover um modelo, use o comando DROP SNOWFLAKE.ML.FORECAST:

DROP SNOWFLAKE.ML.FORECAST <name>;

Para atualizar um modelo, exclua-o e treine um novo. Os modelos são imutáveis e não podem ser atualizados no local.

Produção de previsões¶

Depois de criar seu modelo, você pode produzir uma previsão com name!FORECAST(...). Você pode criar previsões a partir de múltiplos conjuntos de dados usando o mesmo modelo.

Os exemplos a seguir demonstram como criar modelos e produzir previsões a partir deles; consulte <nome>!FORECAST para obter detalhes sobre todos os parâmetros.

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

Exemplos¶

Os exemplos a seguir demonstram o uso da previsão de séries temporais para vários casos de uso.

CREATE OR REPLACE VIEW v1 AS SELECT date, sales
  FROM sales_data WHERE store_id=1 AND item='jacket';
SELECT * FROM v1;

+-------------------------+-------+
| DATE                    | SALES |
+-------------------------+-------+
| 2020-01-01 00:00:00.000 | 2     |
| 2020-01-02 00:00:00.000 | 3     |
| 2020-01-03 00:00:00.000 | 4     |
| 2020-01-04 00:00:00.000 | 5     |
| 2020-01-05 00:00:00.000 | 6     |
+-------------------------+-------+

CREATE SNOWFLAKE.ML.FORECAST model1(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v1'),
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

Instance MODEL1 successfully created.

call model1!FORECAST(FORECASTING_PERIODS => 3);

+-------------------------+-----------+--------------+--------------+
| TS                      | FORECAST  | LOWER_BOUND  | UPPER_BOUND  |
+-------------------------+-----------+--------------+--------------+
| 2020-01-13 00:00:00.000 | 14        | 14           | 14           |
| 2020-01-14 00:00:00.000 | 15        | 15           | 15           |
| 2020-01-15 00:00:00.000 | 16        | 16           | 16           |
+-------------------------+-----------+--------------+--------------+

CALL model1!FORECAST(FORECASTING_PERIODS => 3, CONFIG_OBJECT => {'prediction_interval': 0.8});

BEGIN
  CALL model1!FORECAST(FORECASTING_PERIODS => 3);
  LET x := SQLID;
  CREATE TABLE my_forecasts AS SELECT * FROM TABLE(RESULT_SCAN(:x));
END;

SELECT * FROM my_forecasts;

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

+-------------------------+--------+-------------+----------+----------+
| DATE                    | SALES  | TEMPERATURE | HUMIDITY | HOLIDAY  |
+-------------------------+--------+-------------+----------+----------+
| 2020-01-01 00:00:00.000 | 2      | 50          | 0.3      | new year |
| 2020-01-02 00:00:00.000 | 3      | 52          | 0.3      | null     |
| 2020-01-03 00:00:00.000 | 4      | 54          | 0.2      | null     |
| 2020-01-04 00:00:00.000 | 5      | 54          | 0.3      | null     |
| 2020-01-05 00:00:00.000 | 6      | 55          | 0.2      | null     |
+-------------------------+--------+-------------+----------+----------+

CREATE SNOWFLAKE.ML.FORECAST model2(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v2'),
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

CREATE OR REPLACE VIEW v2_forecast AS select date, temperature, humidity, holiday
  FROM future_features WHERE store_id=1 AND item='jacket';
SELECT * FROM v2_forecast;

+-------------------------+-------------+----------+---------+
| DATE                    | TEMPERATURE | HUMIDITY | HOLIDAY |
+-------------------------+-------------+----------+---------+
| 2020-01-13 00:00:00.000 | 52          | 0.3      | null    |
| 2020-01-14 00:00:00.000 | 53          | 0.3      | null    |
+-------------------------+-------------+----------+---------+

CALL model2!FORECAST(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v2_forecast'),
  TIMESTAMP_COLNAME =>'date'
);

+-------------------------+-----------+--------------+--------------+
| TS                      | FORECAST  | LOWER_BOUND  | UPPER_BOUND  |
+-------------------------+-----------+--------------+--------------+
| 2020-01-13 00:00:00.000 | 14        | 14           | 14           |
| 2020-01-14 00:00:00.000 | 15        | 15           | 15           |
+-------------------------+-----------+--------------+--------------+

CREATE OR REPLACE VIEW v3 AS SELECT [store_id, item] AS store_item, date, sales FROM sales_data;
SELECT * FROM v3;

+-------------------+-------------------------+-------+
| STORE_ITEM        | DATE                    | SALES |
+-------------------+-------------------------+-------+
| [ 1, "jacket" ]   | 2020-01-01 00:00:00.000 | 2     |
| [ 1, "jacket" ]   | 2020-01-02 00:00:00.000 | 3     |
| [ 1, "jacket" ]   | 2020-01-03 00:00:00.000 | 4     |
| [ 1, "jacket" ]   | 2020-01-04 00:00:00.000 | 5     |
| [ 1, "jacket" ]   | 2020-01-05 00:00:00.000 | 6     |
| [ 2, "umbrella" ] | 2020-01-01 00:00:00.000 | 2     |
| [ 2, "umbrella" ] | 2020-01-02 00:00:00.000 | 3     |
| [ 2, "umbrella" ] | 2020-01-03 00:00:00.000 | 4     |
| [ 2, "umbrella" ] | 2020-01-04 00:00:00.000 | 5     |
| [ 2, "umbrella" ] | 2020-01-05 00:00:00.000 | 6     |
+-------------------+-------------------------+-------+

CREATE SNOWFLAKE.ML.FORECAST model3(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v3'),
  SERIES_COLNAME => 'store_item',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

CALL model3!FORECAST(FORECASTING_PERIODS => 2);

+-------------------+------------------------+----------+-------------+-------------+
| SERIES            | TS                     | FORECAST | LOWER_BOUND | UPPER_BOUND |
+-------------------+------------------------+----------+-------------+-------------+
| [ 1, "jacket" ]   | 2020-01-13 00:00:00.000 | 14      | 14          | 14          |
| [ 1, "jacket" ]   | 2020-01-14 00:00:00.000 | 15      | 15          | 15          |
| [ 2, "umbrella" ] | 2020-01-13 00:00:00.000 | 14      | 14          | 14          |
| [ 2, "umbrella" ] | 2020-01-14 00:00:00.000 | 15      | 15          | 15          |
+-------------------+-------------------------+---------+-------------+-------------+

CALL model3!FORECAST(SERIES_VALUE => [2,'umbrella'], FORECASTING_PERIODS => 2);

+-------------------+------------ ------------+-----------+-------------+-------------+
| SERIES            | TS                      | FORECAST  | LOWER_BOUND | UPPER_BOUND |
+-------------------+---------- --------------+-----------+-------------+-------------+
| [ 2, "umbrella" ] | 2020-01-13 00:00:00.000 | 14        | 14          | 14          |
| [ 2, "umbrella" ] | 2020-01-15 00:00:00.000 | 15        | 15          | 15          |
+-------------------+-------------------------+-----------+-------------+-------------+

CREATE OR REPLACE VIEW v4 AS SELECT [store_id, item] AS store_item,
  date, sales, temperature FROM sales_data;
SELECT * FROM v4;

+-------------------+-------------------------+-------+-------------+
| STORE_ITEM        | DATE                    | SALES | TEMPERATURE |
+-------------------+-------------------------+-------+-------------+
| [ 1, "jacket" ]   | 2020-01-01 00:00:00.000 | 2     | 50          |
| [ 1, "jacket" ]   | 2020-01-02 00:00:00.000 | 3     | 52          |
| [ 1, "jacket" ]   | 2020-01-03 00:00:00.000 | 4     | 54          |
| [ 1, "jacket" ]   | 2020-01-04 00:00:00.000 | 5     | 54          |
| [ 1, "jacket" ]   | 2020-01-05 00:00:00.000 | 6     | 55          |
| [ 2, "umbrella" ] | 2020-01-01 00:00:00.000 | 2     | 50          |
| [ 2, "umbrella" ] | 2020-01-02 00:00:00.000 | 3     | 52          |
| [ 2, "umbrella" ] | 2020-01-03 00:00:00.000 | 4     | 54          |
| [ 2, "umbrella" ] | 2020-01-04 00:00:00.000 | 5     | 54          |
| [ 2, "umbrella" ] | 2020-01-05 00:00:00.000 | 6     | 55          |
+-------------------+-------------------------+-------+-------------+

CREATE SNOWFLAKE.ML.FORECAST model4(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v4'),
  SERIES_COLNAME => 'store_item',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

CREATE SNOWFLAKE.ML.FORECAST model4(
  INPUT_DATA => SYSTEM$QUERY_REFERENCE('SELECT [store_id, item] AS store_item, date, sales, temperature FROM sales_data'),
  SERIES_COLNAME => 'store_item',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

CREATE OR REPLACE VIEW V4_FORECAST AS SELECT [store_id, item] AS store_item,
  date, temperature FROM future_features;
SELECT * FROM v4_forecast;

+-------------------+-------------------------+-------------+
| STORE_ITEM        | DATE                    | TEMPERATURE |
+-------------------+-------------------------+-------------+
| [ 1, "jacket" ]   | 2020-01-13 00:00:00.000 | 52          |
| [ 1, "jacket" ]   | 2020-01-14 00:00:00.000 | 53          |
| [ 2, "umbrella" ] | 2020-01-13 00:00:00.000 | 52          |
| [ 2, "umbrella" ] | 2020-01-14 00:00:00.000 | 53          |
+-------------------+-------------------------+-------------+

CALL model4!FORECAST(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v4_forecast'),
  SERIES_COLNAME => 'store_item',
  TIMESTAMP_COLNAME =>'date'
);

+-------------------+-------------------------+----------+-------------+-------------+
| SERIES            | TS                      | FORECAST | LOWER_BOUND | UPPER_BOUND |
+-------------------+-------------------------+----------+-------------+-------------+
| [ 1, "jacket" ]   | 2020-01-13 00:00:00.000 | 14       | 14          | 14          |
| [ 1, "jacket" ]   | 2020-01-14 00:00:00.000 | 15       | 15          | 15          |
| [ 2, "umbrella" ] | 2020-01-13 00:00:00.000 | 14       | 14          | 14          |
| [ 2, "umbrella" ] | 2020-01-14 00:00:00.000 | 15       | 15          | 15          |
+-------------------+-------------------------+----------+-------------+-------------+

Visualização de previsões¶

Para visualizar uma previsão, use o recurso de gráfico do Snowsight. Depois de gerar uma previsão, clique em Charts acima da tabela de resultados da consulta.

Você pode unir suas previsões ao seu conjunto de dados original usando UNION ALL para combinar SELECTs nos dados originais e nos resultados da previsão, para que você possa visualizar os dois juntos. Por exemplo:

CALL model4!FORECAST(FORECASTING_PERIODS => 3);

SELECT date AS ts, sales AS actual, NULL AS forecast, NULL AS lower_bound, NULL AS upper_bound
  FROM sales_data
UNION ALL
SELECT ts, NULL AS actual, forecast, lower_bound, upper_bound
  FROM TABLE(RESULT_SCAN(-1));

Renomeie o carimbo de data/hora e as colunas de variáveis exógenas, se necessário, para que correspondam ao conjunto de dados original e à previsão. Use NULL para representar o valor de destino da previsão nos dados de treinamento e, inversamente, para representar o valor de destino histórico nos resultados da previsão. No exemplo anterior, a coluna de meta real (histórica) foi renomeada como actual e a meta de previsão como forecast.

Depois de preparar seus dados dessa forma, siga estas etapas na seção Data no lado direito do gráfico:

1. Selecione a coluna ACTUAL e, em Aggregation, selecione None.

2. Selecione a coluna TS e, em Bucketing, selecione None.

3. Adicione a coluna FORECAST, escolhendo Use as Line e, em Aggregation, selecione None.

4. Adicione as colunas LOWER_BOUND e UPPER_BOUND da mesma maneira.

O gráfico resultante deve ser semelhante a este:

Como entender a importância do recurso¶

Um modelo de previsão pode explicar a importância relativa de todos os recursos usados em seu modelo, incluindo quaisquer variáveis exógenas que você escolher, recursos de tempo gerados automaticamente (como dia da semana ou semana do ano) e transformações de sua variável de destino (como médias rolantes e defasagens auto-regressivas). Essas informações são úteis para entender quais fatores estão realmente influenciando seus dados.

O método <nome>!EXPLAIN_FEATURE_IMPORTANCE conta o número de vezes que as árvores do modelo usaram cada recurso para tomar uma decisão. Essas pontuações de importância do recurso são então normalizadas para valores entre 0 e 1 para que sua soma seja 1. As pontuações resultantes representam uma classificação aproximada dos recursos em seu modelo treinado.

Recursos que estão próximos em pontuação têm importância semelhante. Para séries extremamente simples (por exemplo, quando a coluna de destino tem um valor constante), todas as pontuações de importância do recurso podem ser zero.

O uso de vários recursos muito semelhantes entre si pode resultar em pontuações de importância reduzidas para esses recursos. Por exemplo, se uma característica for a quantidade de itens vendidos e outra for a quantidade de itens em estoque, os valores podem estar correlacionados porque você não pode vender mais do que tem e porque tenta gerenciar o estoque para não ter mais em estoque do que você vai vender. Se dois recursos forem exatamente idênticos, o modelo pode tratá-los como intercambiáveis ao tomar decisões, resultando em pontuações de importância de recurso que são metade do que essas pontuações seriam se apenas um dos recursos idênticos fosse incluído.

A importância do recurso também informa recursos de atraso. Durante o treinamento, o modelo infere a frequência (por hora, diariamente ou semanalmente) dos seus dados de treinamento. O recurso lagx (por exemplo, lag24) é o valor da variável de destino x unidades de tempo atrás. Por exemplo, se seus dados forem inferidos por hora, lag24 representará sua variável de destino 24 horas atrás.

Todas as outras transformações da sua variável de destino (médias móveis etc.) são resumidas como aggregated_endogenous_features na tabela de resultados.

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 SNOWFLAKE.ML.FORECAST forecast_feature_importance_demo(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v_random_data'),
  TIMESTAMP_COLNAME => 'ts',
  TARGET_COLNAME => 'y'
);

CALL forecast_feature_importance_demo!EXPLAIN_FEATURE_IMPORTANCE();

+------+--------------------------------------+-------+-------------------------+
| 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  |
+------+--------------------------------------+-------+-------------------------+

Como entender as métricas de avaliação¶

Por padrão, todo modelo de previsão é validado de forma cruzada. Além de treinar um modelo em todos os dados de treinamento fornecidos, um ou mais modelos são treinados em subconjuntos de dados de treinamento e depois usados para «prever» os dados retidos. Os valores nominais previstos são então comparados com os valores nominais reais. Se você não precisar de métricas de avaliação ou não quiser gastar recursos de computação com elas, defina evaluate como FALSE ao instanciar o modelo.

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 SNOWFLAKE.ML.FORECAST model(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v_random_data'),
  TIMESTAMP_COLNAME => 'ts',
  TARGET_COLNAME => 'y'
);

CALL model!SHOW_EVALUATION_METRICS();

+--------------------------+--------------+--------------------+------+
| ERROR_METRIC             | METRIC_VALUE | STANDARD_DEVIATION | LOGS |
+--------------------------+--------------+--------------------+------+
| "MAE"                    |        7.107 |              1.998 | NULL |
| "MAPE"                   |        0.475 |              0.237 | NULL |
| "MDA"                    |        0.920 |              0.025 | NULL |
| "MSE"                    |       86.020 |             66.798 | NULL |
| "SMAPE"                  |        0.241 |              0.047 | NULL |
| "COVERAGE_INTERVAL=0.95" |        0.981 |              0.025 | NULL |
| "WINKLER_ALPHA=0.05"     |       56.697 |             45.199 | NULL |
+--------------------------+--------------+--------------------+------+

Inspeção de logs de treinamento¶

Quando você treina várias séries com CONFIG_OBJECT => 'ON_ERROR': 'SKIP', modelos de séries temporais individuais podem falhar no treinamento sem que o processo de treinamento geral falhe. Para entender quais séries temporais falharam e por quê, chame <instância_do_modelo>!SHOW_TRAINING_LOGS.

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.FORECAST model(
  INPUT_DATA => SYSTEM$QUERY_REFERENCE('SELECT date, sales, series FROM t_error'),
  SERIES_COLNAME => 'series',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales',
  CONFIG_OBJECT => {'ON_ERROR': 'SKIP'}
);

CALL model!SHOW_TRAINING_LOGS();

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

Considerações sobre custo¶

O treinamento e o uso de modelos de previsão incorrem em custos de armazenamento e computação.

Conforme descrito em Seleção de um warehouse virtual, o treinamento consome mais recurso de computação do que a previsão de um modelo treinado. No entanto, os custos da previsão podem acumular-se com o uso repetido do modelo. Consulte Explicação dos custos de computação para obter informações gerais sobre os custos de computação do Snowflake.

Os custos de armazenamento incorridos refletem o armazenamento das instâncias de modelo de ML criadas durante a etapa de treinamento. Para visualizar os objetos associados à sua instância de modelo, navegue até suas exibições do Account Usage (por exemplo, ACCOUNT_USAGE.TABLES e ACCOUNT_USAGE.STAGES). Esses objetos aparecerão com colunas de esquema e banco de dados NULL. A coluna instance_id, no entanto, é preenchida e indicará que esses objetos estão contidos em uma instância de modelo. Esses objetos são totalmente gerenciados pela instância do modelo e não é possível acessá-los ou excluí-los separadamente. Para reduzir os custos de armazenamento associados aos seus modelos, exclua modelos não utilizados ou obsoletos.

Uso da previsão no Snowpark¶

session.call ainda não é compatível com modelos de previsão. Para chamar um modelo de previsão no Snowpark, use session.sql, conforme mostrado aqui.

session.sql('call my_model!forecast(...)').collect()