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

Nota

A previsão faz parte do Snowflake Cortex, o serviço de ML e AI inteligente e totalmente gerenciado do Snowflake. Este recurso faz parte do conjunto de funções baseadas em ML do Snowflake Cortex.

A previsão emprega um algoritmo de machine learning para prever dados futuros usando dados históricos de séries temporais. A previsão de séries temporais produz previsões univariadas de dados futuros com base em dados de entrada históricos. Um caso de uso comum é prever vendas com base na sazonalidade e outros fatores.

Os dados históricos devem incluir:

  • Uma coluna de carimbo de data/hora, que deve ter uma frequência fixa (por exemplo, de hora em hora, a cada 5 minutos e assim por diante).

  • Uma coluna de destino que representa alguma quantidade de interesse em cada carimbo de data/hora.

Os dados históricos também podem incluir colunas adicionais que podem ter influenciado o destino (variáveis exógenas). Essas colunas podem ser dados numéricos ou de caracteres.

Os dados históricos são usados para treinar um modelo de aprendizado de máquina que produz uma previsão do valor de destino em carimbos de data/hora futuros. O modelo é um objeto no nível do esquema e pode ser usado para diversas previsões após ter sido treinado. (O modelo não pode ser usado para produzir previsões no mesmo intervalo dos dados históricos.)

A previsão funciona com dados de série única ou multissérie. Os dados multisséries representam vários threads distintos de eventos. Por exemplo, se você tiver dados de vendas para várias lojas, as vendas de cada loja podem ser previstas separadamente por um único modelo baseado no identificador da loja.

Para produzir previsões de dados de séries temporais, use a classe integrada FORECAST do Snowflake e siga estas etapas:

  1. Crie um objeto de modelo de previsão, passando uma referência aos dados de treinamento. Este objeto ajustará (treinará) um modelo aos dados de treinamento que você fornecer. O modelo é um objeto em nível de esquema.

  2. Usando esse objeto de modelo de previsão, chame o método de previsão para produzir uma previsão da meta para carimbos de data/hora futuros, transmitindo o número de intervalos de tempo ou, se estiver usando variáveis exógenas, os dados exógenos com valor futuro.

Importante

Aviso legal. Esta função baseada em ML do Snowflake Cortex é alimentada por tecnologia de aprendizado de máquina. A tecnologia de aprendizado de máquina e os resultados fornecidos podem ser imprecisos, inadequados ou tendenciosos. As decisões baseadas em resultados de aprendizado de máquina, incluindo aquelas incorporadas em pipelines automáticos, devem ter supervisão humana e processos de revisão para garantir que o conteúdo gerado pelo modelo seja preciso. As consultas de função baseadas em ML do Snowflake Cortex serão tratadas como qualquer outra consulta SQL e podem ser consideradas metadados.

Metadados. Quando você usa funções baseadas em ML do Snowflake Cortex, o Snowflake registra mensagens de erro genéricas retornadas por uma função ML, além do que é mencionado em campos de metadados. Esses logs de erros nos ajudam a solucionar problemas que surgem e a melhorar essas funções para melhor atender você.

Para obter mais informações, consulte FAQ sobre confiança e segurança do Snowflake AI.

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.

Importante

De tempos em tempos, o Snowflake pode refinar o algoritmo de previsão e implementar essas melhorias por meio do processo regular de lançamento do Snowflake. Você não pode reverter para uma versão anterior do recurso, mas os modelos que você criou com uma versão anterior continuarão a usar essa versão para previsões.

Limitações atuais

A versão atual tem as seguintes limitações:

  • Você não pode escolher ou ajustar o algoritmo de previsão.

  • O número mínimo de linhas para o algoritmo de previsão principal é 12 por série temporal. Para séries temporais com observações entre 2 e 11, a previsão produz uma previsão «ingênua» em que todos os valores previstos são iguais ao último valor nominal observado.

  • As funções de previsão não fornecem parâmetros para substituir tendência, sazonalidade ou amplitudes sazonais; estes são inferidos a partir dos dados.

  • 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 usar 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).

  • Os modelos de previsão, uma vez treinados, 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. Snowflake recomenda treinar novamente um modelo em uma cadência regular, talvez diariamente, semanalmente ou mensalmente, dependendo da frequência com que você recebe novos dados, permitindo que o modelo se ajuste às mudanças de padrões e tendências.

  • 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 FORECAST.

Preparação para previsão

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

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

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.

Treinamento em dados de série única

Para modelos treinados em dados de série única, escolha o tipo de warehouse com base no tamanho dos seus dados de treinamento. Os warehouses padrão estão sujeitos a um limite de memória do Snowpark menor e são mais apropriados para tarefas de treinamento com menos linhas variáveis exógenas.

Se seus dados de treinamento não contiverem nenhuma variável exógena, você poderá treinar em um warehouse padrão se o conjunto de dados tiver 5 milhões de linhas ou menos. Se seus dados de treinamento usarem 5 ou mais variáveis exógenas, a contagem máxima de linhas será menor. Caso contrário, Snowflake sugere usar um warehouse otimizado para Snowpark para tarefas de treinamento maiores.

Em geral, para dados de série única, um tamanho de warehouse maior não resulta em um tempo de treinamento mais rápido ou em limites de memória mais altos. Como regra geral, o tempo de treinamento é proporcional ao número de linhas em sua série temporal. Por exemplo, em um warehouse padrão XS, o treinamento em um conjunto de dados de 100.000 linhas leva cerca de 30 segundos. O treinamento em um conjunto de dados de 1.000.000 linhas leva cerca de 140 segundos.

Para obter melhor desempenho, Snowflake recomenda usar um warehouse dedicado sem outras cargas de trabalho simultâneas para treinar seu modelo.

Treinamento em dados multisséries

Tal como acontece com os dados de série única, o Snowflake recomenda escolher o tipo de warehouse com base no número de linhas na sua maior série temporal. Se sua maior série temporal contiver mais de 5 milhões de linhas, a tarefa de treinamento provavelmente excederá os limites de memória em um warehouse padrão.

Ao contrário dos dados de série única, os dados multisséries são treinados consideravelmente mais rápido em warehouses maiores. Os seguintes pontos de dados podem orientar você em sua seleção.

Tipo do warehouse

Número de séries temporais

Número de linhas por série temporal

Tamanho do warehouse

Tempo de treinamento

Padrão

1

100,000

XS

38 segundos

10

100,000

XS

112 segundos

100

100,000

XS

594 segundos

10

100,000

XL

34 segundos

100

100,000

XL

114 segundos

1000

100,000

XL

572 segundos

Otimizado para Snowpark

10

100,000

XL

74 segundos

100

100,000

XL

215 segundos

1000

100,000

XL

1429 segundos

Concessão de privilégios para criar objetos de previsão

O treinamento de um modelo de previsão resulta em um objeto no nível do esquema. Portanto, a função que você usa para criar modelos deve ter o privilégio CREATE SNOWFLAKE.ML.FORECAST no esquema onde o modelo é criado, permitindo 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 criar previsões.

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.FORECAST ON SCHEMA admin_db.admin_schema TO ROLE analyst;
Copy

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

USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;
Copy

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

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

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

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

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);
Copy

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>(...);
Copy

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

Nota

SNOWFLAKE.ML.FORECAST é executado com privilégios limitados, portanto, por padrão, ele não tem acesso aos seus dados. Você deve, portanto, passar tabelas e exibições como referências, que transmitem os privilégios do chamador. Você também pode fornecer uma referência de consulta, em vez de uma referência à tabela ou uma exibição.

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

CALL <name>!FORECAST(...)
Copy

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

SHOW SNOWFLAKE.ML.FORECAST;
Copy

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

DROP SNOWFLAKE.ML.FORECAST <name>;
Copy

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.

Dica

Para usar um modelo com um conjunto de dados com nomes de coluna diferentes daqueles no conjunto de dados usado para treinar o modelo, crie uma exibição ou consulta que renomeie as colunas (usando AS) aos nomes que o modelo espera. Use essa exibição ou consulta como entrada para o método FORECAST.

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.

Previsão em uma única série

Este exemplo usa uma única série temporal (ou seja, todas as linhas fazem parte de uma única série) que possui duas colunas, uma coluna de carimbo de data/hora e uma coluna de valor de destino, sem recursos adicionais. Primeiro, prepare o conjunto de dados de sales_data para treinar o modelo. O código a seguir cria uma exibição chamada v1:

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

A instrução SELECT retorna:

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

A instrução a seguir treina um modelo de previsão usando o conjunto de dados acima:

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

A seguinte mensagem aparece após o treinamento do modelo:

Instance MODEL1 successfully created.

O modelo de previsão agora está disponível como model1. Para prever os próximos três carimbos de data/hora:

call model1!FORECAST(FORECASTING_PERIODS => 3);
Copy

Saída

Observe que o modelo inferiu o intervalo entre os carimbos de data/hora dos dados de treinamento.

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

Neste exemplo, como a previsão produz uma previsão perfeitamente linear que tem erro zero em comparação com os valores reais, o intervalo de previsão (LOWER_BOUND, UPPER_BOUND) é o mesmo que o valor FORECAST.

Para personalizar o tamanho do intervalo de previsão, passe prediction_interval como parte de um objeto de configuração:

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

Para salvar seus resultados diretamente em uma tabela, use o seguinte código:

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;
Copy

Embora o código acima use RESULT_SCAN, ele não está sujeito a condições de corrida mesmo se vários processos estiverem sendo executados ao mesmo tempo. Os resultados da chamada de modelo acima são armazenados de forma determinística na tabela my_forecasts.

Previsão em uma única série com variáveis exógenas

Se você deseja que recursos adicionais (por exemplo, feriados ou clima) influenciem a previsão, você deve incluir esses recursos em seus dados de treinamento. Aqui você cria uma exibição contendo esses campos da tabela sales_data:

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;
Copy

Saída

Estas são as primeiras cinco linhas do resultado da consulta SELECT.

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

Agora você pode usar essa exibição para treinar um modelo. Você só precisa especificar o carimbo de data/hora e os nomes da coluna de destino; colunas adicionais nos dados de entrada são consideradas variáveis exógenas.

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

O novo modelo é chamado model2. Para realizar a previsão de carimbos de data/hora futuros, você deve fornecer valores futuros para as variáveis exógenas em seu modelo: neste caso, TEMPERATURE, HUMIDITY e HOLIDAY. Isso permite que você responda a perguntas “e se”, como “E se as temperaturas fossem mais baixas do que o normal?” Agora crie uma exibição da tabela future_features contendo esses dados para carimbos de data/hora futuros:

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;
Copy

Saída

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

Agora você pode gerar uma previsão usando estes dados:

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

Nesta variação do método FORECAST, você não especifica o número de carimbos de data/hora a serem previstos. Em vez disso, os carimbos de data/hora da previsão vêm da exibição v2_forecast.

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

Previsão em séries múltiplas

As previsões anteriores estão em uma única série: todas as linhas nos dados de treinamento representam uma única sequência de valores. Você também pode criar um modelo de previsão para várias séries ao mesmo tempo.

Os dados de amostra contêm colunas store_id e item. Para prever as vendas separadamente para cada combinação de loja/item no conjunto de dados, crie uma nova coluna que combine esses valores e especifique-a como a coluna da série.

Por exemplo, a consulta a seguir cria uma nova exibição combinando store_id e item em uma nova coluna chamada store_item:

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

Saída

As primeiras cinco linhas de cada série do conjunto de dados resultante são:

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

A instrução a seguir treina um modelo de previsão usando o conjunto de dados anterior. Certifique-se de especificar o nome da coluna da série, que é store_item:

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

Após o treinamento, você pode prever dois passos à frente em todas as séries ao mesmo tempo (ou seja, dois passos por série) com:

CALL model3!FORECAST(FORECASTING_PERIODS => 2);
Copy

Saída

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

Você também pode prever apenas uma série específica com:

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

Saída

O resultado mostra apenas as próximas duas etapas para as vendas de guarda-chuvas da loja 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          |
+-------------------+-------------------------+-----------+-------------+-------------+

Dica

Especificar uma série com o método FORECAST é mais eficiente do que filtrar os resultados de uma previsão multissérie para incluir apenas a série em que você está interessado, porque apenas uma previsão da série é gerada.

Previsão em séries múltiplas com variáveis exógenas

Para treinar e prever várias séries temporais em paralelo com variáveis exógenas, combinando essencialmente os dois exemplos anteriores, prepare seus dados da seguinte maneira, incorporando uma coluna de série (store_item neste caso) e pelo menos uma coluna exógena (temperature aqui):

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

Saída

As primeiras cinco linhas de cada série do conjunto de dados resultante têm esta aparência.

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

A instrução a seguir treina um modelo de previsão usando o conjunto de dados anterior. Certifique-se de especificar o nome da coluna da série, store_item:

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

Dica

Você pode passar uma referência de consulta para input_data em vez de criar uma exibição intermediária. A instrução a seguir cria um modelo com os mesmos dados de entrada que a instrução anterior criou:

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'
);
Copy

Como antes, ao prever, você precisa passar valores futuros para variáveis exógenas, mas desta vez para cada série. Prepare o valor futuro das variáveis exógenas:

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

Saída

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

Agora, você pode prever os carimbos de data/hora anteriores:

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

Saída

+-------------------+-------------------------+----------+-------------+-------------+
| 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));
Copy

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:

Exemplo de criação de um gráfico a partir de uma previsão de séries temporais

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.

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 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();
Copy

Saída

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

Limitações

  • O parâmetro n_splits deve ser definido como pelo menos 2.

  • Conjuntos de dados pequenos podem não ter dados suficientes para realizar a avaliação. O número total de linhas de treinamento deve ser igual ou superior a (n_splits * test_size) + gap. Se não houver dados suficientes disponíveis para treinar um modelo de avaliação, nenhuma métrica de avaliação estará disponível, mesmo quando evaluate for TRUE.

Exemplo

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();
Copy

Saída

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

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.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();
Copy

Saída

+--------+-------------------------------------------------------------------------------------------------+
| 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()
Copy