Previsão de séries temporais (funções ML Snowflake)¶
A previsão emprega um algoritmo de machine learning para prever dados numérico futuros com base em dados de séries temporais históricas. Um caso de uso comum é prever vendas por item para as próximas duas semanas.
Guia de início rápido para previsão¶
Esta seção oferece a maneira mais rápida de começar a fazer previsões.
Pré-requisitos¶
Para começar, você deve fazer o seguinte:
Selecione um banco de dados, esquema e warehouse virtual.
Confirme que você é o proprietário do seu esquema ou tem privilégios CREATE SNOWFLAKE.ML.FORECAST no esquema escolhido.
Tenha uma tabela ou exibição com pelo menos duas colunas: uma coluna de carimbo de data/hora e uma coluna numérica. Certifique-se de que sua coluna de carimbo de data/hora tenha carimbos de data/hora em um intervalo fixo e não esteja perdendo muitos carimbos de data/hora. O exemplo a seguir mostra um conjunto de dados com intervalos de carimbo de data/hora de um dia:
('2020-01-01 00:00:00.000', 2.0), ('2020-01-02 00:00:00.000', 3.0), ('2020-01-03 00:00:00.000', 4.0);
Criação de previsões¶
Depois de ter os pré-requisitos, você pode usar AI & ML Studio em Snowsight para orientar você na configuração ou pode usar os seguintes comandos SQL para treinar um modelo e começar a criar previsões:
-- Train your model
CREATE SNOWFLAKE.ML.FORECAST my_model(
INPUT_DATA => TABLE(my_view),
TIMESTAMP_COLNAME => 'my_timestamps',
TARGET_COLNAME => 'my_metric'
);
-- Generate forecasts using your model
SELECT * FROM TABLE(my_model!FORECAST(FORECASTING_PERIODS => 7));
Para mais detalhes sobre sintaxe e métodos disponíveis, consulte a referência FORECAST (SNOWFLAKE.ML).
Como se aprofundar na previsão¶
A função de previsão é criada para prever quaisquer dados de séries temporais numéricas no futuro. Além do caso simples apresentado na seção Guia de início rápido para previsão, você pode fazer o seguinte:
Prever várias séries ao mesmo tempo. Por exemplo, você pode prever as vendas de vários itens nas próximas duas semanas.
Treinar e prever usando recursos. Os recursos são fatores adicionais que você acredita que influenciam a métrica que deseja prever.
Avaliar a precisão do seu modelo.
Entenda a importância relativa dos recursos nos quais o modelo foi treinado.
Depurar erros de treinamento.
As seções a seguir fornecem exemplos desses cenários e detalhes adicionais sobre como a previsão funciona.
Exemplos¶
Esta seção fornece exemplos de como definir seus dados para previsão e como criar um modelo de previsão com base em seus dados de séries temporais.
Nota
O ideal é que os dados de treinamento para um modelo de previsão tenham etapas de tempo em intervalos igualmente espaçados (por exemplo, diariamente). No entanto, o treinamento do modelo pode lidar com dados do mundo real que tenham etapas de tempo ausentes, duplicadas ou desalinhadas. Para obter mais informações, consulte Como lidar com dados do mundo real na previsão de séries temporais.
Configuração de dados de exemplo¶
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. Colunas adicionais, que são recursos adicionais (temperatura, umidade e feriado) também estão incluídas.
A tabela future_features contém valores futuros das colunas de recurso, que são necessários ao fazer previsões usando recursos como parte do seu processo de previsão.
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 additional columns (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);
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 exemplo para treinar o modelo:
CREATE OR REPLACE VIEW v1 AS SELECT date, sales
FROM sales_data WHERE store_id=1 AND item='jacket';
SELECT * FROM v1;
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 |
+-------------------------+-------+
Agora, treine um modelo de previsão usando esta exibição:
CREATE SNOWFLAKE.ML.FORECAST model1(
INPUT_DATA => TABLE(v1),
TIMESTAMP_COLNAME => 'date',
TARGET_COLNAME => 'sales'
);
A seguinte mensagem aparece após o treinamento do modelo:
Instance MODEL1 successfully created.
Em seguida, use o modelo de previsão para prever os próximos três carimbos de data/hora:
call model1!FORECAST(FORECASTING_PERIODS => 3);
Saída
Observe que o modelo inferiu o intervalo entre os carimbos de data/hora dos dados de treinamento.
+--------+-------------------------+-----------+--------------+--------------+
| SERIES | TS | FORECAST | LOWER_BOUND | UPPER_BOUND |
+--------+-------------------------+-----------+--------------+--------------+
| NULL | 2020-01-13 00:00:00.000 | 14 | 14 | 14 |
| NULL | 2020-01-14 00:00:00.000 | 15 | 15 | 15 |
| NULL | 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});
Para salvar seus resultados diretamente em uma tabela, use CREATE TABLE … AS SELECT … e chame o método FORECAST na cláusula FROM:
CREATE TABLE my_forecasts AS
SELECT * FROM TABLE(model1!FORECAST(FORECASTING_PERIODS => 3));
Conforme mostrado no exemplo acima, ao chamar o método, omita o comando CALL. Em vez disso, coloque a chamada entre parênteses, precedida pela palavra-chave TABLE.
Previsão em séries múltiplas¶
Para criar um modelo de previsão para várias séries de uma só vez, use o parâmetro series_colname.
Neste exemplo, os dados contêm as 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.
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;
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 |
+-------------------+-------------------------+-------+
Agora use a função de previsão para treinar um modelo para cada série, tudo em uma única etapa. Observe que o parâmetro series_colname está definido como store_item:
CREATE SNOWFLAKE.ML.FORECAST model2(
INPUT_DATA => TABLE(v3),
SERIES_COLNAME => 'store_item',
TIMESTAMP_COLNAME => 'date',
TARGET_COLNAME => 'sales'
);
Em seguida, use esse modelo para prever os próximos dois carimbos de data/hora para todas as séries:
CALL model2!FORECAST(FORECASTING_PERIODS => 2);
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 uma série específica com:
CALL model2!FORECAST(SERIES_VALUE => [2,'umbrella'], FORECASTING_PERIODS => 2);
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-14 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 com recursos¶
Se quiser que recursos adicionais (por exemplo, feriados ou clima) influenciem suas previsões, 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;
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 das colunas de destino; colunas adicionais nos dados de entrada são consideradas recursos para uso no treinamento.
CREATE SNOWFLAKE.ML.FORECAST model3(
INPUT_DATA => TABLE(v2),
TIMESTAMP_COLNAME => 'date',
TARGET_COLNAME => 'sales'
);
Para gerar previsões com este modelo, você deve fornecer valores futuros para os recursos do modelo: neste caso, TEMPERATURE, HUMIDITY e HOLIDAY. Isso permite que o modelo ajuste suas previsões de vendas com base nas previsões de temperatura, umidade e feriados.
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;
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 model3!FORECAST(
INPUT_DATA => TABLE(v2_forecast),
TIMESTAMP_COLNAME =>'date'
);
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.
+--------+-------------------------+-----------+--------------+--------------+
| SERIES | TS | FORECAST | LOWER_BOUND | UPPER_BOUND |
+--------+-------------------------+-----------+--------------+--------------+
| NULL | 2020-01-13 00:00:00.000 | 14 | 14 | 14 |
| NULL | 2020-01-14 00:00:00.000 | 15 | 15 | 15 |
+--------+-------------------------+-----------+--------------+--------------+
Solução de problemas e avaliação de modelo¶
Você pode usar as seguintes funções auxiliares para avaliar o desempenho do seu modelo, entender quais recursos são mais impactantes para o seu modelo e para ajudá-lo a depurar o processo de treinamento se ocorrer algum erro:
Métricas de avaliação¶
Para obter as métricas de avaliação do seu modelo, chame o método <nome_do_modelo>!SHOW_EVALUATION_METRICS. Por padrão, a função de previsão avalia todos os modelos que treina usando um método chamado validação cruzada. Isso significa que, internamente, além de treinar o modelo final em todos os dados de treinamento fornecidos, a função também treina modelos em subconjuntos dos seus dados de treinamento. Esses modelos são então usados para prever sua métrica de destino nos dados retidos, permitindo que a função compare essas previsões com valores reais em seus dados históricos.
Se você não precisar dessas métricas de avaliação, você pode definir evaluate como FALSE. Se você quiser controlar a maneira como a validação cruzada é executada, você pode usar os seguintes parâmetros:
n_splits: representa o número de divisões em seus dados para validação cruzada. O padrão é 1.
max_train_size: representa o número máximo de linhas para um único conjunto de treinamento.
test_size: limita o número de linhas incluídas em cada conjunto de teste.
gap: representa o intervalo entre o fim de cada conjunto de treinamento e o início do conjunto de teste.
Para obter detalhes completos sobre os parâmetros de avaliação, consulte Configuração de avaliação.
Nota
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 maior que (n_splits * test_size) + lacuna. 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 estiver definido como TRUE.
Quando n_splits é 1 (o padrão), o desvio padrão para valores de métricas de avaliação é NULL, pois apenas um conjunto de dados de validação é usado.
Exemplo¶
CREATE OR REPLACE VIEW v_random_data AS SELECT
DATEADD('minute', ROW_NUMBER() over (ORDER BY 1), '2023-12-01')::TIMESTAMP_NTZ ts,
UNIFORM(1, 100, RANDOM(0)) exog_a,
UNIFORM(1, 100, RANDOM(0)) exog_b,
(MOD(SEQ1(),10) + exog_a) y
FROM TABLE(GENERATOR(ROWCOUNT => 500));
CREATE OR REPLACE SNOWFLAKE.ML.FORECAST model(
INPUT_DATA => TABLE(v_random_data),
TIMESTAMP_COLNAME => 'ts',
TARGET_COLNAME => 'y'
);
CALL model!SHOW_EVALUATION_METRICS();
Saída
+--------+--------------------------+--------------+--------------------+------+
| SERIES | ERROR_METRIC | METRIC_VALUE | STANDARD_DEVIATION | LOGS |
+--------+--------------------------+--------------+--------------------+------+
| NULL | "MAE" | 2.49 | NaN | NULL |
| NULL | "MAPE" | 0.084 | NaN | NULL |
| NULL | "MDA" | 0.99 | NaN | NULL |
| NULL | "MSE" | 8.088 | NaN | NULL |
| NULL | "SMAPE" | 0.077 | NaN | NULL |
| NULL | "WINKLER_ALPHA=0.05" | 12.101 | NaN | NULL |
| NULL | "COVERAGE_INTERVAL=0.95" | 1 | NaN | NULL |
+--------+--------------------------+--------------+--------------------+------+
Importância do recurso¶
Para entender a importância relativa dos recursos usados no seu modelo, use o método <nome_do_modelo>!EXPLAIN_FEATURE_IMPORTANCE.
Quando você treina um modelo de previsão, ele usa os dados fornecidos, como carimbo de data/hora, sua métrica de destino, colunas adicionais fornecidas por você (recursos) e recursos gerados automaticamente para melhorar o desempenho de suas previsões, para aprender padrões em seus dados. O treinamento detecta o quão importante cada um deles é para fazer previsões precisas do que outros. O objetivo desta função auxiliar é entender a importância relativa desses recursos em uma escala de 0 a 1.
Internamente, essa função auxiliar conta o número de vezes que o modelo usou 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.
Principais considerações para esse recurso¶
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 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.
Exemplo¶
Este exemplo usa os dados do exemplo de avaliação e chama o método de importância do recurso. Você pode ver que a variável exog_a que foi criada é o segundo recurso mais importante, atrás de todas as médias móveis, que são agregadas sob o nome do recurso aggregated_endogenous_trend_features.
Execute as seguintes instruções para obter a importância dos recursos:
CALL model!EXPLAIN_FEATURE_IMPORTANCE();
Saída
+--------+------+--------------+---------------+---------------+
| SERIES | RANK | FEATURE_NAME | SCORE | FEATURE_TYPE |
+--------+------+--------------+---------------+---------------+
| NULL | 1 | exog_a | 31.414947903 | user_provided |
| NULL | 2 | exog_b | 0 | user_provided |
+--------+------+--------------+---------------+---------------+
Solução de problemas¶
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 qual série temporal falhou e por quê, chame o método <nome_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-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-06'), 10.0, 'B'), -- the same timestamp used again and again
(TO_TIMESTAMP_NTZ('2020-01-06'), 13.0, 'B'),
(TO_TIMESTAMP_NTZ('2020-01-06'), 12.0, 'B'),
(TO_TIMESTAMP_NTZ('2020-01-06'), 15.0, 'B'),
(TO_TIMESTAMP_NTZ('2020-01-06'), 14.0, 'B'),
(TO_TIMESTAMP_NTZ('2020-01-06'), 18.0, 'B'),
(TO_TIMESTAMP_NTZ('2020-01-06'), 12.0, 'B');
CREATE SNOWFLAKE.ML.FORECAST error_model(
INPUT_DATA => TABLE(SELECT date, sales, series FROM t_error),
SERIES_COLNAME => 'series',
TIMESTAMP_COLNAME => 'date',
TARGET_COLNAME => 'sales',
CONFIG_OBJECT => {'ON_ERROR': 'SKIP'}
);
CALL error_model!SHOW_TRAINING_LOGS();
Saída
+--------+--------------------------------------------------------------------------+
| SERIES | LOGS |
+--------+--------------------------------------------------------------------------+
| "B" | { "Errors": [ "At least two unique timestamps are required." ] } |
| "A" | NULL |
+--------+--------------------------------------------------------------------------+
Gerenciamento de modelos¶
Para visualizar uma lista dos seus modelos, use o comando SHOW SNOWFLAKE.ML.FORECAST:
SHOW SNOWFLAKE.ML.FORECAST;
Para excluir um modelo, use o comando DROP SNOWFLAKE.ML.FORECAST:
DROP SNOWFLAKE.ML.FORECAST my_model;
Os modelos são imutáveis e não podem ser atualizados no local. Em vez disso, treine um novo modelo.
Seleção do warehouse¶
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.
Há dois fatores chave a ter em mente ao escolher um warehouse:
O número de linhas e colunas que seus dados contêm.
O número de séries distintas que seus dados contêm.
Você pode usar as seguintes regras básicas para escolher seu warehouse:
Se você estiver treinando em uma série temporal mais longa (> 5 milhões de linhas) ou em muitas colunas (muitos recursos), considere atualizar para Warehouses otimizados para Snowpark.
Se você estiver treinando muitas séries, escolha um tamanho maior. A função de previsão distribui o treinamento do modelo entre todos os nós disponíveis no seu warehouse quando você está treinando várias séries ao mesmo tempo.
A tabela a seguir fornece a mesma orientação:
Tipo de série |
< 5 milhões de linhas |
> 5 milhões de linhas e ≤ 100 milhões de linhas |
> 100 milhões de linhas |
|---|---|---|---|
Uma série |
Warehouse padrão; XS |
Warehouse otimizado para Snowpark; XS |
Considere agregar a um intervalo de carimbo de data/hora menos frequente (por exemplo, de hora em hora para diário) |
Séries múltiplas |
Warehouse padrão; aumentar tamanho |
Warehouse otimizado para Snowpark; aumentar o tamanho |
Considere agrupar o treinamento por série em vários trabalhos |
Como estimativa aproximada, o tempo de treinamento é proporcional ao número de linhas na sua série temporal. Por exemplo, em um warehouse padrão XS, com a avaliação desativada (CONFIG_OBJECT => {'evaluate': False}), o treinamento em um conjunto de dados de 100.000 linha leva cerca de 400 segundos. O treinamento em um conjunto de dados de 1.000.000 linhas leva cerca de 850 segundos. Com a avaliação ativada, o tempo de treinamento aumenta de forma aproximadamente linear pelo número de divisões usadas.
Detalhes do algoritmo¶
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 meta e de carimbo de data/hora, ou pode incluir recursos (colunas extras) que possam ter influenciado o valor da meta. 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 seu modelo incorporar recursos, ao gerar uma previsão, você deverá fornecer valores para esses recursos em cada carimbo de data/hora do horizonte de previsão completo. Recursos apropriados 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, a Snowflake pode refinar o algoritmo de previsão. Essas melhorias são implementadas por meio do processo de lançamento regular do Snowflake. Não é possível reverter para uma versão anterior do recurso, mas os modelos criados com uma versão anterior continuam a usar essa versão para previsões até a depreciação por meio do processo de liberação de mudança de comportamento.
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.
A função de previsão não fornece parâmetros para substituir tendências, 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.)
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.
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 DATABASE admin_db TO ROLE analyst;
GRANT USAGE ON SCHEMA admin_schema TO ROLE analyst;
GRANT CREATE SNOWFLAKE.ML.FORECAST 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 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 analyst_db.analyst_schema;
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;
Considerações sobre custo¶
Para obter detalhes sobre os custos de utilização das funções ML, consulte Considerações sobre custo na visão geral das funções ML.
Avisos legais¶
Importante
Aviso legal. Esta função de ML Snowflake é 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 de ML Snowflake Cortex serão tratadas como qualquer outra consulta SQL e poderão ser consideradas metadados.
Metadados. Quando você usa funções de ML Snowflake Cortex, o Snowflake registra mensagens de erro genéricas retornadas por uma função baseada em ML. 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.