Zeitreihenprognose (ML-gestützte Snowflake Cortex-Funktionen)¶

Allgemeine Informationen zum Prognosealgorithmus¶

Der Prognosealgorithmus wird von einem Gradient-Boosting-Modul (GBM) unterstützt. Wie ein ARIMA-basiertes Modell verwendet es eine Transformation aus Differenzbildung (Differenzierung), um Daten mit einem nichtstationären Trend zu modellieren, und verwendet autoregressive Lags der historischen Zieldaten als Modellvariablen.

Darüber hinaus verwendet der Algorithmus gleitende Durchschnitte historischer Zieldaten, um Trends vorherzusagen, und erstellt aus den Zeitstempeldaten automatisch zyklische Kalendervariablen (z. B. Wochentag und Woche des Jahres).

Sie können Modelle nur mit historischen Ziel- und Zeitstempeldaten anpassen, oder Sie können exogene Daten (Variablen) einbeziehen, die den Zielwert beeinflusst haben könnten. Die exogenen Variablen können numerisch oder kategorisch sein, und sie können möglicherweise auch NULL sein (Zeilen, die für exogene Variablen NULL-Werte enthalten, werden nicht gelöscht).

Der Algorithmus verlässt sich beim Training auf kategorialen Variablen nicht auf One-Hot-Codierung, sodass Sie kategoriale Daten mit vielen Dimensionen (hohe Kardinalität) verwenden können.

Wenn Ihr Modell exogene Variablen enthält, müssen Sie beim Erstellen einer Prognose Werte für diese Variablen zu Zeitpunkten für den gesamten Prognosehorizont angeben. Geeignete exogene Variablen könnten Wetterinformationen (Temperatur, Niederschlag), unternehmensspezifische Informationen (historische und geplante Betriebsferien, Werbekampagnen, Veranstaltungstermine) oder andere externe Faktoren sein, von denen Sie glauben, dass sie zur Vorhersage Ihrer Zielvariablen beitragen können.

Der Algorithmus generiert zusätzlich zu den Prognosen auch Vorhersageintervalle. Ein Vorhersageintervall ist ein geschätzter Wertebereich innerhalb einer Ober- und einer Untergrenze, in den ein bestimmter Prozentsatz der Daten wahrscheinlich fallen wird. Ein Wert von 0,95 bedeutet zum Beispiel, dass 95 % der Daten wahrscheinlich innerhalb des Intervalls liegen. Sie können einen Prozentsatz für das Vorhersageintervall angeben oder den Standardwert von 0,95 verwenden. Die untere und obere Grenze des Vorhersageintervalls werden als Teil der Prognoseausgabe zurückgegeben.

Vorbereiten der Prognoseerstellung¶

Bevor Sie die Prognoseerstellung nutzen können, müssen Sie Folgendes tun:

• Wählen Sie ein virtuelles Warehouse aus, in dem Sie Ihre Modelle trainieren und ausführen können.

• Erteilen Sie die Berechtigungen zum Erstellen von Prognoseobjekten.

Sie können auch Ihren Suchpfad ändern, um SNOWFLAKE.ML einzuschließen.

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

USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;

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

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

Einrichten der Daten für die Beispiele¶

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. Exogene oder externe Variablen (Temperatur, Luftfeuchtigkeit und Feiertage) werden ebenfalls berücksichtigt.

Die Tabelle future_features enthält die zukünftigen Werte der exogenen Variablen, die für die Prognoseerstellung mit solchen Variablen 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 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);

Trainieren, Verwenden, Anzeigen, Löschen und Aktualisieren von Modellen¶

Verwenden Sie CREATE SNOWFLAKE.ML.FORECAST, um ein Modell zu erstellen und zu trainieren. Das Modell wird mit dem von Ihnen bereitgestellten Datenset trainiert.

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

Umfassende Informationen zum Konstruktor SNOWFLAKE.ML.FORECAST finden Sie unter FORECAST. Beispiele für das Erstellen eines Modells finden Sie unter Beispiele.

Um eine Prognose zu erstellen, rufen Sie die Methode <name>!FORECAST des Modells auf:

CALL <name>!FORECAST(...)

Um eine Liste Ihrer Modelle anzuzeigen, verwenden Sie den Befehl SHOW SNOWFLAKE.ML.FORECAST:

SHOW SNOWFLAKE.ML.FORECAST;

Um ein Modell zu entfernen, verwenden Sie den Befehl DROP SNOWFLAKE.ML.FORECAST:

DROP SNOWFLAKE.ML.FORECAST <name>;

Um ein Modell zu aktualisieren, löschen Sie es und trainieren ein neues Modell. Modelle sind unveränderlich und können nicht direkt aktualisiert werden.

Erstellen von Prognosen¶

Nachdem Sie Ihr Modell erstellt haben, können Sie mit name!FORECAST(...) eine Prognose erstellen. Sie können Prognosen aus mehreren Datensets mit demselben Modell erstellen.

In den folgenden Beispielen wird gezeigt, wie Sie Modelle erstellen und daraus Prognosen generieren können. Details zu den einzelnen Parametern finden Sie unter <name>!FORECAST.

Weitere Informationen zu den Parametern, die beim Erstellen und Verwenden eines Modells verwendet werden, finden Sie unter FORECAST.

Beispiele¶

Die folgenden Beispiele zeigen die Verwendung von Zeitreihenprognosen für verschiedene Anwendungsfälle.

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

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

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

Instance MODEL1 successfully created.

call model1!FORECAST(FORECASTING_PERIODS => 3);

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

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

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

SELECT * FROM my_forecasts;

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

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

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

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

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

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

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

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

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

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

CALL model3!FORECAST(FORECASTING_PERIODS => 2);

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

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

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

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

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

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

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

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

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

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

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

Visualisieren von Prognosen¶

Um eine Prognose zu visualisieren, verwenden Sie das Diagramm-Feature von Snowsight. Nachdem Sie eine Prognose erstellt haben, klicken Sie über der Ergebnistabelle der Abfrage auf Charts.

Sie können Ihre Prognosen mit Ihrem Original-Datenset verknüpfen, indem Sie UNION ALL verwenden, um SELECTs auf den Originaldaten und den Prognoseergebnissen zu kombinieren, sodass Sie beide zusammen visualisieren können. Beispiel:

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

Benennen Sie die Spalten mit Zeitstempel und exogener Variable bei Bedarf um, damit sie im Original-Datenset und in der Prognose übereinstimmen. Verwenden Sie NULL, um den prognostizierten Zielwert in den Trainingsdaten zu repräsentieren, und umgekehrt, um den historischen Zielwert in den Prognoseergebnissen darzustellen. Im obigen Beispiel wird die Spalte für das tatsächliche (historische) Ziel in actual und die Spalte für das prognostizierte Ziel in forecast umbenannt.

Nachdem Sie Ihre Daten auf diese Weise vorbereitet haben, führen Sie die folgenden Schritte im Abschnitt Data auf der rechten Seite des Diagramms aus:

1. Wählen Sie die Spalte ACTUAL aus, und wählen Sie dann unter Aggregation die Option None aus.

2. Wählen Sie die Spalte TS aus, und wählen Sie dann unter Bucketing die Option None aus.

3. Fügen Sie die Spalte FORECAST hinzu, indem Sie Use as Line auswählen, und wählen Sie dann unter Aggregation die Option None aus.

4. Fügen Sie die Spalten LOWER_BOUND und UPPER_BOUND auf die gleiche Weise hinzu.

Das resultierende Diagramm sollte in etwa wie folgt aussehen:

Erläuterungen zur Feature Importance¶

Ein Prognosemodell kann die relative Bedeutung aller in Ihrem Modell verwendeten Features erklären, einschließlich der von Ihnen gewählten exogenen Variablen, der automatisch generierten zeitlichen Features (wie z. B. Wochentag oder Woche des Jahres) sowie der Transformationen Ihrer Zielvariablen (wie z. B. gleitende Durchschnitte und autoregressive Lags). Diese Informationen sind nützlich, um zu verstehen, welche Faktoren Ihre Daten wirklich beeinflussen.

Die Methode <name>!EXPLAIN_FEATURE_IMPORTANCE zählt, wie oft die Modellbäume die jeweiligen Features für eine Entscheidung verwendet haben. 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.

Features, deren Punktzahlen nahe beieinander liegen, sind ähnlich wichtig. Bei extrem einfachen Zeitreihen (z. B. wenn die Zielspalte einen konstanten Wert hat) können alle Feature Importance-Bewertungen null sein.

Die Verwendung mehrerer Features, die einander sehr ähnlich sind, kann dazu führen, dass die Importance-Bewertung dieser Features sinkt. Wenn beispielweise ein Feature die Menge der verkauften Artikel und ein anderes die Menge der Artikel im Bestand ist, können die Werte korrelieren, da Sie nicht mehr verkaufen können, als Sie haben, und weil Sie versuchen, den Bestand so zu verwalten, dass Sie nicht mehr auf Lager haben, als Sie verkaufen werden. Wenn zwei Features exakt identisch sind, kann es sein, dass das Modell sie bei der Entscheidungsfindung als austauschbar behandelt. Dies führt zu einer Feature Importance-Bewertung, die nur halb so hoch ist, wie wenn nur eines der identischen Features berücksichtigt würde.

Die Feature Importance zeigt auch Lag-Features an. Während des Trainings schließt das Modell auf die Häufigkeit (stündlich, täglich oder wöchentlich) Ihrer Trainingsdaten. Das Feature lagx (z. B. lag24) ist der Wert der Zielvariablen bei x Zeiteinheiten zuvor. Wenn Ihre Daten zum Beispiel stündlich erhoben werden, steht lag24 für den Wert der Zielvariablen vor 24 Stunden.

Alle anderen Transformationen der Zielvariablen (gleitende Durchschnitte usw.) werden als aggregated_endogenous_features in der Ergebnistabelle zusammengefasst.

CREATE OR REPLACE VIEW v_random_data AS SELECT
  DATEADD('minute', ROW_NUMBER() over (ORDER BY 1), '2023-12-01')::TIMESTAMP_NTZ ts,
  MOD(SEQ1(),10) y,
  UNIFORM(1, 100, RANDOM(0)) exog_a
FROM TABLE(GENERATOR(ROWCOUNT => 500));

CREATE OR REPLACE SNOWFLAKE.ML.FORECAST forecast_feature_importance_demo(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v_random_data'),
  TIMESTAMP_COLNAME => 'ts',
  TARGET_COLNAME => 'y'
);

CALL forecast_feature_importance_demo!EXPLAIN_FEATURE_IMPORTANCE();

+------+--------------------------------------+-------+-------------------------+
| RANK | FEATURE_NAME                         | SCORE | FEATURE_TYPE            |
+------+--------------------------------------+-------+-------------------------+
|    1 | aggregated_endogenous_trend_features |  0.36 | derived_from_endogenous |
|    2 | exog_a                               |  0.22 | user_provided           |
|    3 | epoch_time                           |  0.15 | derived_from_timestamp  |
|    4 | minute                               |  0.13 | derived_from_timestamp  |
|    5 | lag60                                |  0.07 | derived_from_endogenous |
|    6 | lag120                               |  0.06 | derived_from_endogenous |
|    7 | hour                                 |  0.01 | derived_from_timestamp  |
+------+--------------------------------------+-------+-------------------------+

Erläuterungen zu Bewertungskennzahlen¶

Standardmäßig wird jedes Prognosemodell einer Kreuzvalidierung unterzogen. Zusätzlich zum Training eines Modells auf allen bereitgestellten Trainingsdaten werden ein oder mehrere Modelle auf Teilmengen der Trainingsdaten trainiert und dann zur „Vorhersage“ der zurückgehaltenen Daten verwendet. Die vorhergesagten Zielwerte werden dann mit den tatsächlichen Zielwerten verglichen. Wenn Sie keine Bewertungskennzahlen benötigen oder keine Computeressourcen dafür aufwenden möchten, setzen Sie evaluate bei der Instanziierung des Modells auf FALSE.

CREATE OR REPLACE VIEW v_random_data AS SELECT
  DATEADD('minute', ROW_NUMBER() over (ORDER BY 1), '2023-12-01')::TIMESTAMP_NTZ ts,
  MOD(SEQ1(),10) y,
  UNIFORM(1, 100, RANDOM(0)) exog_a
FROM TABLE(GENERATOR(ROWCOUNT => 500));

CREATE OR REPLACE SNOWFLAKE.ML.FORECAST model(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v_random_data'),
  TIMESTAMP_COLNAME => 'ts',
  TARGET_COLNAME => 'y'
);

CALL model!SHOW_EVALUATION_METRICS();

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

Überprüfen der Trainingsprotokolle¶

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 <model_instance>!SHOW_TRAINING_LOGS auf.

CREATE TABLE t_error(date TIMESTAMP_NTZ, sales FLOAT, series VARCHAR);
INSERT INTO t_error VALUES
  (TO_TIMESTAMP_NTZ('2019-12-20'), 1.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-21'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-22'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-23'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-24'), 1.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-25'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-26'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-27'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-28'), 1.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-29'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-30'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2019-12-31'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-01'), 2.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-02'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-03'), 3.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-04'), 7.0, 'A'),
  (TO_TIMESTAMP_NTZ('2020-01-05'), 10.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-06'), 13.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-06'), 12.0, 'B'), -- duplicate timestamp
  (TO_TIMESTAMP_NTZ('2020-01-07'), 15.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-08'), 14.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-09'), 18.0, 'B'),
  (TO_TIMESTAMP_NTZ('2020-01-10'), 12.0, 'B');

CREATE SNOWFLAKE.ML.FORECAST model(
  INPUT_DATA => SYSTEM$QUERY_REFERENCE('SELECT date, sales, series FROM t_error'),
  SERIES_COLNAME => 'series',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales',
  CONFIG_OBJECT => {'ON_ERROR': 'SKIP'}
);

CALL model!SHOW_TRAINING_LOGS();

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

Hinweise zu Kosten¶

Das Trainieren und Verwenden von Prognosemodellen verursacht Kosten für Speicherung und Computing.

Wie unter Auswählen eines virtuellen Warehouses beschrieben, verbraucht das Training mehr Computeleistung als die Prognoseerstellung mit einem trainierten Modell. Allerdings können sich die Kosten für die Prognoseerstellung bei wiederholter Nutzung des Modells summieren. Allgemeine Informationen zu den Snowflake-Computekosten finden Sie unter Erläuterungen zu den Computekosten.

Die Speicherkosten entstehen bei der Speicherung der ML-Modellinstanzen, die während des Trainingsprozesses erstellt wurden. Um die mit Ihrer Modellinstanz verknüpften Objekte anzuzeigen, navigieren Sie zu den Account Usage-Ansichten (z. B. ACCOUNT_USAGE.TABLES und ACCOUNT_USAGE.STAGES). Diese Objekte werden mit NULL-Datenbankspalten und -Schemaspalten angezeigt. Die Spalte instance_id wird jedoch gefüllt und zeigt an, dass diese Objekte in einer Modellinstanz enthalten sind. Diese Objekte werden vollständig von der Modellinstanz verwaltet. Sie können nicht separat auf sie zugreifen, und sie können sie auch nicht löschen. Um die mit Ihren Modellen verbundenen Speicherkosten zu reduzieren, löschen Sie unbenutzte oder veraltete Modelle.

Verwenden von Prognosen in Snowpark¶

session.call ist noch nicht mit Prognosemodellen kompatibel. Zum Aufrufen eines Prognosemodells in Snowpark verwenden Sie stattdessen session.sql, wie hier gezeigt.

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