Prévision des séries temporelles (fonctions Snowflake ML)¶

Conditions préalables¶

Pour commencer, vous devez procéder comme suit :

• Sélectionnez une base de données, un schéma et un entrepôt virtuel.

• Confirmez que vous possédez votre schéma ou que vous avez les privilèges CREATE SNOWFLAKE.ML.FORECAST dans le schéma que vous avez choisi.

• Avoir une table ou une vue avec au moins deux colonnes : une colonne d’horodatage et une colonne numérique. Assurez-vous que votre colonne d’horodatage comporte des horodatages à intervalle fixe et qu’il ne manque pas trop d’horodatages. L’exemple suivant montre un ensemble de données avec des intervalles d’horodatage d’un jour :

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

  Copy

Créer des prévisions¶

Une fois que vous avez les prérequis, vous pouvez utiliser le Studio AI & ML dans Snowsight pour vous guider dans la configuration ou vous pouvez utiliser les commandes SQL suivantes pour entraîner un modèle et commencer à créer des prévisions :

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

Pour plus de détails sur la syntaxe et les méthodes disponibles, consultez la référence FORECAST (SNOWFLAKE.ML).

Configurer des exemples de données¶

L’exemple ci-dessous crée deux tables. Des vues de ces tables sont incluses dans les exemples plus loin dans cette rubrique.

La table sales_data contient des données sur les ventes. Chaque vente comprend un ID de magasin, un identificateur d’article, un horodatage et le montant de la vente. Des colonnes supplémentaires, qui sont des fonctionnalités supplémentaires (température, humidité et vacances), sont également incluses.

La table future_features contient les valeurs futures des colonnes de fonctionnalités, qui sont nécessaires lors de la prévision à l’aide de fonctionnalités dans le cadre de votre processus de prédiction.

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

Prévision sur une série unique¶

Cet exemple utilise une seule série temporelle (c’est-à-dire que toutes les lignes font partie d’une seule série) qui comporte deux colonnes, une colonne d’horodatage et une colonne de valeur cible, sans fonctions supplémentaires.

Tout d’abord, préparez l’exemple de jeu de données pour entraîner le modèle :

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

L’instruction SELECT affiche :

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

Maintenant, entraînez un modèle de prévision en utilisant cette vue :

CREATE SNOWFLAKE.ML.FORECAST model1(
  INPUT_DATA => TABLE(v1),
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

Le message suivant apparaît après l’entraînement du modèle :

Instance MODEL1 successfully created.

Ensuite, utilisez le modèle de prévision pour prévoir les trois prochains horodatages :

call model1!FORECAST(FORECASTING_PERIODS => 3);

Sortie

Notez que le modèle a déduit l’intervalle entre les horodatages à partir des données d’entraînement.

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

Dans cet exemple, étant donné que la prévision est parfaitement linéaire et que les erreurs par rapport aux valeurs réelles sont nulles, l’intervalle de prévision (LOWER_BOUND, UPPER_BOUND) est identique à la valeur FORECAST.

Pour personnaliser la taille de l’intervalle de prédiction, transmettez prediction_interval dans un objet de configuration :

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

Pour enregistrer vos résultats directement dans une table, utilisez CREATE TABLE … AS SELECT … et appelez la méthode FORECAST dans la clause FROM :

CREATE TABLE my_forecasts AS
  SELECT * FROM TABLE(model1!FORECAST(FORECASTING_PERIODS => 3));

Comme le montre l’exemple ci-dessus, lors de l’appel de la méthode, omettez la commande CALL. Au lieu de cela, mettez l’appel entre parenthèses, précédé du mot-clé TABLE.

Prévision sur des séries multiples¶

Pour créer un modèle de prévision pour plusieurs séries à la fois, utilisez le paramètre series_colname.

Dans cet exemple, les données contiennent des colonnes store_id et item. Pour prévoir les ventes séparément pour chaque combinaison magasin/article dans l’ensemble de données, créez une nouvelle colonne qui combine ces valeurs et la spécifier comme colonne de la série.

Par exemple, la requête suivante crée une nouvelle vue combinant store_id et item dans une nouvelle colonne nommée store_item :

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

Sortie

Les cinq premières lignes de chaque série de l’ensemble de données obtenu sont les suivantes :

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

Utilisez maintenant la fonction de prévision pour former un modèle pour chaque série, le tout en une seule étape. Notez que le paramètre series_colname est défini sur store_item :

CREATE SNOWFLAKE.ML.FORECAST model2(
  INPUT_DATA => TABLE(v3),
  SERIES_COLNAME => 'store_item',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

Ensuite, utilisez ce modèle pour prévoir les deux prochains horodatages pour toutes les séries :

CALL model2!FORECAST(FORECASTING_PERIODS => 2);

Sortie

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

Vous pouvez également prévoir une série spécifique avec :

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

Sortie

Le résultat ne montre que les deux incréments suivants pour les ventes de parapluies du magasin 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          |
+-------------------+-------------------------+-----------+-------------+-------------+

Prévision avec fonctionnalités¶

Si vous souhaitez que des fonctionnalités supplémentaires (par exemple, les vacances ou la météo) influencent vos prévisions, vous devez inclure ces fonctionnalités dans vos données d’entraînement. Vous créez ici une vue contenant les champs de la table 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;

Sortie

Il s’agit des cinq premières lignes du résultat de la requête 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     |
+-------------------------+--------+-------------+----------+----------+

Vous pouvez maintenant utiliser cette vue pour entraîner un modèle. Vous devez uniquement spécifier l’horodatage et les noms des colonnes cibles ; les colonnes supplémentaires dans les données d’entrée sont supposées être des fonctionnalités à utiliser pour l’entraînement.

CREATE SNOWFLAKE.ML.FORECAST model3(
  INPUT_DATA => TABLE(v2),
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

Pour générer des prévisions avec ce modèle, vous devez fournir des valeurs futures pour les fonctionnalités au modèle : dans ce cas, TEMPERATURE, HUMIDITY et HOLIDAY. Cela permet au modèle d’ajuster ses prévisions de ventes en fonction de la température, de l’humidité et des prévisions de vacances.

À présent, créez une vue à partir de la table future_features contenant ces données pour des horodatages futurs.

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;

Sortie

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

Vous pouvez maintenant générer une prévision à partir de ces données :

CALL model3!FORECAST(
  INPUT_DATA => TABLE(v2_forecast),
  TIMESTAMP_COLNAME =>'date'
);

Dans cette variante de la méthode FORECAST, vous ne spécifiez pas le nombre d’horodatages à prédire. Au lieu de cela, les horodatages des prévisions proviennent de la vue 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           |
+--------+-------------------------+-----------+--------------+--------------+

Mesures d’évaluation¶

Pour obtenir les mesures d’évaluation de votre modèle, appelez la méthode <nom_du_modèle>!SHOW_EVALUATION_METRICS. Par défaut, la fonction de prévision évalue tous les modèles qu’elle entraîne à l’aide d’une méthode appelée validation croisée. Cela signifie que sous le capot, en plus d’entraîner le modèle final sur toutes les données d’entraînement que vous fournissez, la fonction forme également des modèles sur des sous-ensembles de vos données d’entraînement. Ces modèles sont ensuite utilisés pour prédire votre métrique cible sur les données retenues, permettant à la fonction de comparer ces prédictions aux valeurs réelles de vos données historiques.

Si vous n’avez pas besoin de ces mesures d’évaluation, vous pouvez définir evaluate sur FALSE. Si vous souhaitez contrôler la manière dont la validation croisée est exécutée, vous pouvez utiliser les paramètres suivants :

• n_splits : représente le nombre de divisions dans vos données pour la validation croisée. La valeur par défaut est 1.

• max_train_size : représente le nombre maximal de lignes pour un seul ensemble d’entraînement.

• test_size : limite le nombre de lignes incluses dans chaque ensemble de tests.

• écart : représente l’écart entre la fin de chaque ensemble d’entraînement et le début de l’ensemble de test.

Pour plus de détails sur les paramètres d’évaluation, consultez Configuration de l’évaluation.

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

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

Importance des fonctionnalités¶

Pour comprendre l’importance relative des fonctionnalités utilisées dans votre modèle, utilisez la méthode <nom_du_modèle>!EXPLAIN_FEATURE_IMPORTANCE.

Lorsque vous entraînez un modèle de prévision, votre modèle utilise les données fournies, telles que les horodatages, votre métrique cible, les colonnes supplémentaires que vous fournissez (fonctionnalités) et les fonctionnalités générées automatiquement pour améliorer les performances de vos prévisions, afin d’apprendre des modèles dans vos données. L’entraînement détecte l’importance de chacun de ces éléments pour faire des prédictions précises par rapport aux autres. Comprendre l’importance relative de ces caractéristiques sur une échelle de 0 à 1 est le but de cette fonction d’aide.

Sous le capot, cette fonction d’assistance compte le nombre de fois que le modèle a utilisé chaque fonctionnalité pour prendre une décision. Ces scores d’importance des fonctions sont ensuite normalisés à des valeurs comprises entre 0 et 1, de sorte que leur somme soit égale à 1. Les scores obtenus représentent un classement approximatif des fonctions de votre modèle entraîné.

CALL model!EXPLAIN_FEATURE_IMPORTANCE();

+--------+------+--------------+---------------+---------------+
| SERIES | RANK | FEATURE_NAME | SCORE         | FEATURE_TYPE  |
+--------+------+--------------+---------------+---------------+
| NULL   |    1 | exog_a       |  31.414947903 | user_provided |
| NULL   |    2 | exog_b       |             0 | user_provided |
+--------+------+--------------+---------------+---------------+

Résolution des problèmes¶

Lorsque vous entraînez plusieurs séries avec CONFIG_OBJECT => 'ON_ERROR': 'SKIP', les modèles de séries temporelles individuels peuvent échouer sans que le processus d’entraînement global n’échoue. Pour comprendre quelle série temporelle a échoué et pourquoi, appelez la méthode <nom_du_modèle>!SHOW_TRAINING_LOGS.

Exemple¶

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

Sortie

+--------+--------------------------------------------------------------------------+
| SERIES | LOGS                                                                     |
+--------+--------------------------------------------------------------------------+
| "B"    | {   "Errors": [     "At least two unique timestamps are required."   ] } |
| "A"    | NULL                                                                     |
+--------+--------------------------------------------------------------------------+

Limites actuelles¶

La version actuelle présente les limitations suivantes :

• Vous ne pouvez pas choisir ni ajuster l’algorithme de prévision.

• Le nombre minimum de lignes pour l’algorithme de prévision principal est de 12 par série temporelle. Pour les séries temporelles comportant entre 2 et 11 observations, la prévision produit une prévision « naïve » dans laquelle toutes les valeurs prédites sont égales à la dernière valeur cible observée.

• La fonction de prévision ne fournissent pas de paramètres permettant de remplacer la tendance, la saisonnalité ou les amplitudes saisonnières ; ces paramètres sont déduits des données.

• La granularité minimale acceptable des données est d’une seconde. (Les horodatages ne doivent pas être espacés de moins d’une seconde.)

• La granularité minimale des composantes saisonnières est d’une minute. (La fonction ne peut pas détecter de modèles cycliques à des deltas temporels plus petits.)

• La « longueur de la saison » des fonctions autorégressives est liée à la fréquence d’entrée (24 pour des données horaires, 7 pour des données journalières, et ainsi de suite).

• Les modèles de prévision, une fois entraînés, sont immuables. Vous ne pouvez pas mettre à jour les modèles existants avec de nouvelles données ; vous devez entraîner un modèle entièrement nouveau.

• Les modèles ne prennent pas en charge la gestion des versions. Snowflake recommande d’entraîner à nouveau un modèle à intervalles réguliers, par exemple une fois par jour, par semaine ou par mois, en fonction de la fréquence à laquelle vous recevez de nouvelles données, afin de permettre au modèle de s’adapter à l’évolution des modèles et des tendances.

• Vous ne pouvez pas cloner de modèles ni les partager entre rôles ou comptes. Lors du clonage d’un schéma ou d’une base de données, les objets du modèle sont ignorés.

• Vous ne pouvez pas répliquer une instance de la classe FORECAST.