Zeitreihen-Prognose (Snowflake ML-Funktionen)¶

Voraussetzungen¶

Um loszulegen, müssen Sie Folgendes tun:

• Wählen Sie eine Datenbank, ein Schema und ein virtuelles Warehouse aus.

• Vergewissern Sie sich, dass Sie Eigentümer des Schemas sind oder über CREATE SNOWFLAKE.ML.FORECAST-Berechtigungen in dem von Ihnen gewählten Schema verfügen.

• Sie haben eine Tabelle oder Ansicht mit mindestens zwei Spalten: eine Zeitstempelspalte und eine numerische Spalte. Stellen Sie sicher, dass Ihre Zeitstempelspalte Zeitstempel in einem festen Intervall enthält und nicht zu viele Zeitstempel fehlen. Das folgende Beispiel zeigt einen Datensatz mit Zeitstempelintervallen von einem Tag:

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

Prognosen erstellen¶

Sobald Sie über die Voraussetzungen verfügen, können Sie das AI & ML-Studio in Snowsight verwenden, das Sie durch das Setup führt, oder Sie können die folgenden SQL Befehle verwenden, um ein Modell zu trainieren und mit der Erstellung von Prognosen zu beginnen:

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

Weitere Einzelheiten zur Syntax und den verfügbaren Methoden finden Sie in der Referenz FORECAST (SNOWFLAKE.ML).

Beispieldaten einrichten¶

Im folgenden Beispiel werden zwei Tabellen erstellt. Ansichten zu diesen Tabellen sind unten in den Beispielen zu diesem Thema enthalten.

Die Tabelle sales_data enthält Verkaufsdaten. Jeder Verkauf umfasst eine Filial-ID, einen Bezeichner für den Artikel, einen Zeitstempel und den Verkaufsbetrag. Weitere Spalten, die zusätzliche Features (Temperatur, Luftfeuchtigkeit und Feiertage) enthalten, werden ebenfalls berücksichtigt

Die Tabelle future_features enthält die zukünftigen Werte der Feature-Spalten, die für die Prognoseerstellung mithilfe von Features als Teil Ihres Vorhersageprozesses erforderlich sind.

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

Prognoseerstellung für eine einzelne Zeitreihen¶

Dieses Beispiel verwendet eine einzelne Zeitreihe (d. h. alle Zeilen sind Teil einer einzigen Zeitreihe), die zwei Spalten hat, eine Zeitstempelspalte und eine Zielwertspalte, ohne zusätzliche Features.

Bereiten Sie zunächst das Beispieldatenset vor, um das Modell zu trainieren:

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

Die SELECT-Anweisung gibt Folgendes zurück:

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

Trainieren Sie nun ein Prognosemodell mit dieser Ansicht:

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

Nachdem das Modell trainiert wurde, wird die folgende Meldung angezeigt:

Instance MODEL1 successfully created.

Als Nächstes verwenden Sie das Prognosemodell, um die nächsten drei Zeitstempel zu prognostizieren:

call model1!FORECAST(FORECASTING_PERIODS => 3);

Ausgabe

Beachten Sie, dass das Modell das Intervall zwischen den Zeitstempeln aus den Trainingsdaten abgeleitet hat.

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

In diesem Beispiel ist das Vorhersageintervall (LOWER_BOUND, UPPER_BOUND) gleich dem FORECAST-Wert, da die Prognose eine perfekte lineare Vorhersage ergibt, die im Vergleich zu den tatsächlichen Werten keinen Fehler aufweist.

Um die Größe des Vorhersageintervalls anzupassen, übergeben Sie prediction_interval als Teil eines Konfigurationsobjekts:

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

Um Ihre Ergebnisse direkt in einer Tabelle zu speichern, verwenden Sie CREATE TABLE … AS SELECT … und rufen Sie die Methode FORECAST in der FROM-Klausel auf:

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

Wie im obigen Beispiel gezeigt, lassen Sie beim Aufruf der Methode den Befehl CALL weg. Stattdessen setzen Sie den Aufruf in Klammern, denen das Schlüsselwort TABLE vorangestellt ist.

Prognoseerstellung für mehrere Zeitreihen¶

Um ein Prognosemodell für mehrere Serien auf einmal zu erstellen, verwenden Sie den Parameter series_colname.

In diesem Beispiel enthalten die Daten die Spalten store_id und item. Um die Verkäufe für jede Kombination aus Filiale und Artikel im Datenset separat zu prognostizieren, können Sie eine neue Spalte erstellen, die diese Werte kombiniert, und diese dann als Zeitreihenspalte angeben.

Die folgende Abfrage erstellt eine neue Ansicht, die store_id und item in einer neuen Spalte mit dem Namen store_item kombiniert:

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

Ausgabe

Die ersten fünf Zeilen für jede Zeitreihe des resultierenden Datensets sind:

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

Verwenden Sie nun die Prognosefunktion, um ein Modell für jede Serie zu trainieren, alles in einem Schritt. Beachten Sie, dass der Parameter series_colname auf store_item festgelegt ist:

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

Als Nächstes verwenden Sie dieses Modell, um die nächsten beiden Zeitpunkte für alle Serien zu prognostizieren:

CALL model2!FORECAST(FORECASTING_PERIODS => 2);

Ausgabe

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

Sie können auch eine bestimmte Serie prognostizieren mit:

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

Ausgabe

Das Ergebnis zeigt nur die nächsten beiden Schritte für den Verkauf von Regenschirmen in Filiale 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          |
+-------------------+-------------------------+-----------+-------------+-------------+

Prognosen mit Features¶

Wenn Sie möchten, dass zusätzliche Features (z. B. Feiertage oder Wetter) die Prognose beeinflussen, müssen Sie diese Features in Ihre Trainingsdaten aufnehmen. Hier erstellen Sie eine Ansicht, die diese Felder aus der Tabelle sales_data enthält:

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;

Ausgabe

Dies sind die ersten fünf Zeilen aus dem Ergebnis der SELECT-Abfrage.

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

Jetzt können Sie diese Ansicht verwenden, um ein Modell zu trainieren. Sie müssen nur die Namen der Zeitstempel- und Zielspalten angeben. Zusätzliche Spalten in den Eingabedaten werden als Features für die Verwendung beim Training betrachtet.

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

Um mit diesem Modell Prognosen zu erstellen, müssen Sie dem Modell Zukunftswerte für die Features zur Verfügung stellen: in diesem Fall TEMPERATURE, HUMIDITY und HOLIDAY. So kann das Modell seine Umsatzprognosen auf der Grundlage von Temperatur-, Luftfeuchtigkeits- und Feiertagsprognosen anpassen.

Erstellen Sie nun eine Ansicht aus der Tabelle future_features, die diese Daten für zukünftige Zeitstempel enthält:

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;

Ausgabe

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

Jetzt können Sie mithilfe dieser Daten eine Prognose generieren:

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

Bei dieser Variante der FORECAST-Methode geben Sie nicht die Anzahl der Zeitstempel an, die vorhergesagt werden sollen. Stattdessen stammen die Zeitstempel der Prognosen aus der Ansicht 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           |
+--------+-------------------------+-----------+--------------+--------------+

Bewertungskennzahlen¶

Um die Bewertungskennzahlen für Ihr Modell zu erhalten, rufen Sie die Methode <Name_des_Modells>!SHOW_EVALUATION_METRICS auf. Standardmäßig bewertet die Prognosefunktion alle Modelle, die sie trainiert, mit einer Methode Kreuzvalidierung genannten Methode. Das bedeutet, dass die Funktion nicht nur das endgültige Modell auf der Grundlage aller von Ihnen bereitgestellten Trainingsdaten trainiert, sondern auch Modelle basierend auf Teilmengen Ihrer Trainingsdaten trainiert. Diese Modelle werden dann zur Vorhersage Ihrer Zielmetrik auf den zurückgehaltenen Daten verwendet, sodass die Funktion diese Vorhersagen mit den tatsächlichen Werten in Ihren historischen Daten vergleichen kann.

Wenn Sie diese Bewertungskennzahlen nicht benötigen, können Sie evaluate auf FALSE festlegen. Wenn Sie die Art und Weise, wie die Kreuzvalidierung durchgeführt wird, steuern möchten, können Sie die folgenden Parameter verwenden:

• n_splits: Gibt die Anzahl der Aufteilungen in Ihren Daten für die Kreuzvalidierung an. Der Standardwert ist 1.

• max_train_size: Stellt die maximale Anzahl von Zeilen für ein einzelnes Trainingsset dar.

• test_size: Beschränkt die Anzahl der Zeilen, die in jedem Testset enthalten sind.

• Lücke: Stellt die Lücke zwischen dem Ende jedes Trainingssatzes und dem Beginn des Testsatzes dar.

Ausführliche Informationen zu den Evaluierungsparametern finden Sie unter Konfiguration der Bewertung.

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

Bedeutung des Features¶

Um die relative Bedeutung der in Ihrem Modell verwendeten Features zu verstehen, verwenden Sie die Methode <Name_des_Modells>!EXPLAIN_FEATURE_IMPORTANCE.

Wenn Sie ein Prognosemodell trainieren, verwendet Ihr Modell bereitgestellte Daten, wie z. B. Zeitstempel, Ihre Zielmetrik, zusätzliche Spalten, die Sie bereitstellen (Features), und Features, die automatisch generiert werden, um die Performance Ihrer Prognosen zu verbessern, um Muster in Ihren Daten zu lernen. Durch das Training wird ermittelt, wie wichtig jedes dieser Elemente für eine genaue Vorhersage ist. Der Zweck dieser Funktion ist es, die relative Bedeutung dieser Features auf einer Skala von 0 bis 1 zu verstehen.

Im Hintergrund zählt diese Funktion, wie oft das Modell jedes Feature verwendet hat, um eine Entscheidung zu treffen. Diese Feature Importance-Bewertungen werden dann auf Werte zwischen 0 und 1 normalisiert, sodass sie in der Summe 1 ergeben. Die sich daraus resultierenden Punktzahlen ergeben eine ungefähre Rangliste der Features in Ihrem trainierten Modell.

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

Problembehandlung¶

Wenn Sie mehrere Zeitreihen mit CONFIG_OBJECT => 'ON_ERROR': 'SKIP' trainieren, können einzelne Zeitreihenmodelle fehlschlagen, ohne dass der gesamte Trainingsprozess fehlschlägt. Um zu verstehen, welche Zeitreihen fehlgeschlagen sind und warum, rufen Sie die Methode <Name_des_Modells>!SHOW_TRAINING_LOGS auf.

Beispiel¶

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

Ausgabe

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

Aktuelle Einschränkungen¶

Das aktuelle Release hat die folgenden Einschränkungen:

• Sie können den Prognosealgorithmus weder auswählen noch anpassen.

• Die Mindestanzahl von Zeilen für den Prognose-Hauptalgorithmus beträgt 12 pro Zeitreihe. Bei Zeitreihen mit 2 bis 11 Beobachtungen führt die Prognoseerstellung zu einer „naiven“ Prognose, bei der alle prognostizierten Werte gleich dem zuletzt beobachteten Zielwert sind.

• Die Prognosefunktionen stellen keine Parameter bereit, um Trend, Saisonalität oder saisonale Amplituden zu überschreiben; diese werden aus den Daten abgeleitet.

• Die minimal akzeptable Granularität der Daten ist eine Sekunde. (Die Zeitstempel dürfen nicht weniger als eine Sekunde auseinanderliegen.)

• Die Mindestgranularität der saisonalen Komponenten beträgt eine Minute. (Die Funktion kann keine zyklischen Muster bei kleineren Zeitdeltas erkennen.)

• Die „Saisonlänge“ der autoregressiven Features ist an die Eingabefrequenz gebunden (24 für stündliche Daten, 7 für tägliche Daten usw.).

• Einmal trainierte Prognosemodelle sind unveränderlich. Sie können bestehende Modelle nicht mit neuen Daten aktualisieren, sondern Sie müssen ein völlig neues Modell trainieren.

• Modelle unterstützen keine Versionierung. Snowflake empfiehlt, ein Modell in regelmäßigen Abständen neu zu trainieren, z. B. täglich, wöchentlich oder monatlich, je nachdem, wie häufig Sie neue Daten erhalten, damit sich das Modell an veränderte Muster und Trends anpassen kann.

• Sie können Modelle weder klonen noch über Rollen oder Konten hinweg freigeben. Beim Klonen eines Schemas oder einer Datenbank werden Modellobjekte übersprungen.

• Sie können Instanzen der FORECAST-Klasse nicht replizieren.