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

Bemerkung

Die Prognoseerstellung ist Teil von Snowflake Cortex, dem intelligenten, vollständig verwalteten KI- und ML-Dienst von Snowflake. Dieses Feature ist Teil der ML-gestützten Funktionssuite Snowflake Cortex.

Bei der Prognoseerstellung (Forecasting) wird ein Algorithmus des maschinellen Lernens eingesetzt, um anhand historischer Zeitreihendaten zukünftige Daten vorherzusagen. Die Zeitreihenprognose erstellt univariate Vorhersagen zukünftiger Daten auf Grundlage historischer Eingabedaten. Ein häufiger Anwendungsfall ist die Prognose von Verkäufen auf der Grundlage von Saisonalität und anderen Faktoren.

Die historischen Daten müssen Folgendes enthalten:

  • Eine Zeitstempelspalte, die eine feste Frequenz haben sollte (z. B. stündlich, alle 5 Minuten usw.).

  • Eine Zielspalte, die zu jedem Zeitstempel eine relevante Messgröße repräsentiert.

Die historischen Daten können auch weitere Spalten enthalten, die das Ziel beeinflusst haben könnten (exogene Variablen). Diese Spalten können entweder numerische Daten oder Zeichendaten sein.

Die historischen Daten werden verwendet, um ein Machine Learning-Modell zu trainieren, das eine Prognose der Zielwerte zu zukünftigen Zeitpunkten erstellt. Das Modell ist ein Objekt auf Schemaebene und kann für mehrere Prognosen verwendet werden, nachdem es trainiert wurde. (Das Modell kann nicht verwendet werden, um Prognosen im gleichen Bereich wie die historischen Daten zu erstellen).

Die Prognoseerstellung funktioniert mit Daten entweder aus einzelnen Zeitreihen oder mehreren Zeitreihen. Daten mehrerer Zeitreihen repräsentieren mehrere unterschiedliche Ereignisstränge. Wenn Sie z. B. Verkaufsdaten für mehrere Filialen haben, können die Verkäufe jeder Filiale separat mit einem einzigen Modell auf Grundlage des Bezeichners der Filiale prognostiziert werden.

Um Prognosen für Zeitreihendaten zu erstellen, verwenden Sie die in Snowflake integrierte Klasse FORECAST. Gehen Sie dabei wie folgt vor:

  1. Erstellen Sie ein Prognosemodellobjekt, indem Sie eine Referenz auf die Trainingsdaten übergeben. Dieses Objekt passt (trainiert) ein Modell an die von Ihnen bereitgestellten Trainingsdaten an. Das Modell ist ein Objekt auf Schemaebene.

  2. Rufen Sie mit diesem Prognosemodellobjekt die Prognosemethode auf, um eine Prognose des Ziels für künftige Zeitpunkte zu erstellen, wobei Sie entweder die Anzahl der Zeitschritte oder, bei Verwendung exogener Variablen, die zukunftsbezogene exogenen Daten angeben.

Wichtig

Rechtlicher Hinweis Diese ML-basierte Snowflake Cortex-Funktion wird durch Machine Learning-Technologie unterstützt. Die Machine Learning-Technologie und die bereitgestellten Ergebnisse können ungenau, unangemessen oder verzerrt sein. Entscheidungen auf der Grundlage von Ergebnissen aus Prozessen des maschinellen Lernens, einschließlich solcher, die in automatische Pipelines integriert sind, erfordern eine von Menschen durchgeführte Überwachung und Überprüfung, um sicherzustellen, dass die vom Modell generierten Inhalte korrekt sind. Die von ML-basierten Snowflake Cortex-Funktionen ausgeführten Abfragen werden wie alle anderen SQL-Abfragen behandelt, deren Metadaten untersucht werden können.

Metadaten. Wenn Sie ML-basierte Snowflake Cortex-Funktionen verwenden, protokolliert Snowflake allgemeine Fehlermeldungen, die von einer ML-Funktion zurückgegeben werden, zusätzlich zu dem, was in Metadatenfeldern erwähnt wird. Diese Fehlerprotokolle helfen uns, auftretende Probleme zu beheben und diese Funktionen zu verbessern, um unser Angebot für Sie zu optimieren.

Weitere Informationen dazu finden Sie unter Snowflake AI Trust and Safety FAQ.

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.

Wichtig

Von Zeit zu Zeit wird Snowflake den Algorithmus zur Prognoseerstellung verfeinern und solche Verbesserungen im Rahmen des regulären Snowflake-Release-Prozesses bereitstellen. Sie können nicht zu einer früheren Version des Features zurückkehren, aber Modelle, die Sie mit einer früheren Version erstellt haben, verwenden weiterhin diese Version für die Vorhersagen.

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 Zeitstempel in Ihren Daten müssen feste Zeitintervalle repräsentieren. Wenn Ihre Eingabedaten unregelmäßig sind, versuchen Sie beim Training des Modells die Funktionen DATE_TRUNC oder TIME_SLICE auf Ihrer Zeitstempelspalte anzuwenden.

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

Vorbereiten der Prognoseerstellung

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

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

Auswählen eines virtuellen Warehouses

Ein virtuelles Snowflake-Warehouse stellt die Computeressourcen für Training und Nutzung der Machine Learning-Modelle für dieses Feature zur Verfügung. In diesem Abschnitt finden Sie allgemeine Hinweise zur Auswahl des optimalen Typs und der optimalen Größe des Warehouses für diesen Zweck. Der Schwerpunkt liegt dabei auf dem Trainingsschritt, dem zeit- und speicherintensivsten Teil des Prozesses.

Training mit Daten einer einzelnen Zeitreihe

Bei Modellen, die mit Daten einzelner Zeitreihen trainiert werden, wählen Sie den Warehouse-Typ auf Grundlage des Umfangs Ihrer Trainingsdaten aus. Standard-Warehouses unterliegen einer niedrigeren Snowpark-Grenze für Arbeitsspeicher und eignen sich besser für Trainingsjobs mit weniger Zeilen und exogenen Variablen.

Wenn Ihre Trainingsdaten keine exogenen Variablen enthalten und das Datenset höchstens 5 Millionen Zeilen umfasst, können Sie zum Trainieren ein Standard-Warehouse verwenden. Wenn Ihre Trainingsdaten fünf oder mehr exogene Variablen verwenden, ist die maximale Zeilenanzahl niedriger. Andernfalls empfiehlt Snowflake für größere Trainingsjobs die Verwendung eines Snowpark-optimierten Warehouses.

Im Allgemeinen führt bei Daten einer einzelnen Zeitreihe eine größere Warehouse-Größe nicht zu schnelleren Trainingszeiten oder höheren Speichergrenzen. Als grobe Faustregel kann gelten, dass die Trainingszeit proportional zur Anzahl der Zeilen in der Zeitreihe ist. Bei einem Standard-Warehouse der Größe XS dauert das Training auf einem Datenset mit 100.000 Zeilen beispielsweise etwa 30 Sekunden. Das Training auf einem Datenset mit 1.000.000 Zeilen dauert etwa 140 Sekunden.

Um optimale Performance zu erzielen, empfiehlt Snowflake die Verwendung eines dedizierten Warehouses, mit dem Sie Ihr Modell trainieren können, ohne dass parallel andere Workloads ausgeführt werden.

Training mit Daten aus mehreren Zeitreihen

Wie bei Daten aus einzelnen Zeitreihen empfiehlt Snowflake, den Warehouse-Typ auf Grundlage der Anzahl der Zeilen Ihrer größten Zeitreihe zu wählen. Wenn Ihre größte Zeitreihe mehr als 5 Millionen Zeilen enthält, wird der Trainingsjob wahrscheinlich die Speichergrenzen eines Standard-Warehouses überschreiten.

Im Gegensatz zu Daten einzelner Zeitreihen werden Daten mehrere Zeitreihen bei größeren Warehouse-Größen wesentlich schneller verarbeitet. Die folgenden Datenpunkte können Sie bei Ihrer Auswahl unterstützen.

Warehouse-Typ

Anzahl der Zeitreihen

Anzahl der Zeilen pro Zeitreihe

Warehouse-Größe

Trainingszeit

Standard

1

100,000

XS

38 Sekunden

10

100,000

XS

112 Sekunden

100

100,000

XS

594 Sekunden

10

100,000

XL

34 Sekunden

100

100,000

XL

114 Sekunden

1000

100,000

XL

572 Sekunden

Snowpark-optimiert

10

100,000

XL

74 Sekunden

100

100,000

XL

215 Sekunden

1000

100,000

XL

1.429 Sekunden

Erteilen von Berechtigungen zum Erstellen von Prognoseobjekten

Das Training eines Prognosemodells führt zu einem Objekt auf Schemaebene. Daher muss die Rolle, mit der Sie Modelle erstellen, über die Berechtigung CREATE SNOWFLAKE.ML.FORECAST für das Schema verfügen, in dem das Modell erstellt wird, damit das Modell dort gespeichert werden kann. Diese Berechtigung ist vergleichbar mit anderen Schemaberechtigungen wie CREATE TABLE oder CREATE VIEW.

Snowflake empfiehlt, eine Rolle mit dem Namen analyst zu erstellen, die von Personen verwendet wird, deren Aufgabe das Erstellen von Prognosen ist.

Im folgenden Beispiel ist die Rolle admin der Eigentümer des Schemas admin_db.admin_schema. Die Rolle analyst muss in der Lage sein, Modelle in diesem Schema zu erstellen.

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

Um dieses Schema verwenden zu können, wird einem Benutzer die Rolle analyst zugewiesen:

USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;
Copy

Wenn die Rolle analyst über die Berechtigung CREATE SCHEMA in der Datenbank analyst_db verfügt, kann die Rolle ein neues Schema analyst_db.analyst_schema erstellen und in diesem Schema Prognosemodelle erstellen:

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

Um einer Rolle die Berechtigung zum Erstellen eines Prognosemodells für das Schema zu entziehen, verwenden Sie REVOKE <Berechtigungen>:

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

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

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

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

Bemerkung

SNOWFLAKE.ML.FORECAST wird mit eingeschränkten Berechtigungen ausgeführt, sodass der Konstruktor standardmäßig keinen Zugriff auf Ihre Daten hat. Sie müssen daher Tabellen und Ansichten als Referenzen übergeben, mit denen auch die Berechtigungen des Aufrufers weitergeben werden. Sie können anstelle eines Verweises auf eine Tabelle oder Ansicht auch eine Abfragereferenz angeben.

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

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

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

SHOW SNOWFLAKE.ML.FORECAST;
Copy

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

DROP SNOWFLAKE.ML.FORECAST <name>;
Copy

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.

Tipp

Wenn Sie ein Modell mit einem Datenset verwenden möchten, dessen Spaltennamen sich von denen des Datensets unterscheiden, mit dem das Modell trainiert wurde, erstellen Sie eine Ansicht oder eine Abfrage, die die Spalten (mit AS) in die Namen umbenennt, die das Modell erwartet. Verwenden Sie diese Ansicht oder Abfrage als Eingabe für die FORECAST-Methode.

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.

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 Datenset von sales_data vor, um das Modell zu trainieren. Mit dem folgenden Code wird ein Ansicht namens v1 erstellt:

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

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

Mit der folgenden Anweisung wird ein Prognosemodell unter Verwendung des obigen Datensets trainiert:

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

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

Instance MODEL1 successfully created.

Das Prognosemodell ist jetzt als model1 verfügbar. So führen Sie die Prognose für die nächsten drei Zeitstempel aus:

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

Ausgabe

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

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

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

Um Ihre Ergebnisse direkt in einer Tabelle zu speichern, verwenden Sie den folgenden Code:

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

SELECT * FROM my_forecasts;
Copy

Obwohl der obige Code RESULT_SCAN verwendet, unterliegt er keinen Racebedingungen, auch wenn mehrere Prozesse gleichzeitig ausgeführt werden. Die Ergebnisse des obigen Modellaufrufs werden deterministisch in der Tabelle my_forecasts gespeichert.

Prognoseerstellung einer einzelnen Zeitreihe mit exogenen Variablen

Wenn Sie möchten, dass zusätzliche Features (z. B. Feiertage oder Wetter) die Prognoseerstellung 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;
Copy

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 exogene Variablen betrachtet.

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

Das neue Modell trägt den Namen model2. Um die Prognoseerstellung für zukünftige Zeitstempel auszuführen, müssen Sie zukünftige Werte für die exogenen Variablen in Ihrem Modell angeben: in diesem Fall TEMPERATURE, HUMIDITY und HOLIDAY. So können Sie „Was-wäre-wenn“-Fragen beantworten, z. B.: „Was wäre, wenn die Temperaturen kühler wären als normal?“ 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;
Copy

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 model2!FORECAST(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v2_forecast'),
  TIMESTAMP_COLNAME =>'date'
);
Copy

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.

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

Prognoseerstellung für mehrere Zeitreihen

Die vorangegangenen Prognosen bezogen sich auf eine einzige Zeitreihe: Alle Zeilen in den Trainingsdaten stellten eine einzelne Sequenz von Werten dar. Sie können auch ein Prognosemodell für mehrere Zeitreihen auf einmal erstellen.

Die Beispieldaten enthalten 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.

Mit der folgenden Abfrage wird beispielsweise eine neue Ansicht erstellt, 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;
Copy

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

Mit der folgenden Anweisung wird ein Prognosemodell unter Verwendung des vorherigen Datensets trainiert. Achten Sie darauf, dass Sie den Spaltennamen der Zeitreihe store_item angeben:

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

Nach dem Training können Sie für alle Zeitreihen gleichzeitig zwei Schritte vorwärts prognostizieren (d. h. zwei Schritte pro Zeitreihe) mit:

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

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 nur eine bestimmte Zeitreihe prognostizieren. Verwenden Sie dafür:

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

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-15 00:00:00.000 | 15        | 15          | 15          |
+-------------------+-------------------------+-----------+-------------+-------------+

Tipp

Die Angabe einer Zeitreihe mit der Methode FORECAST ist effizienter als das Filtern der Ergebnisse einer Multizeitreihen-Prognose, um nur die Zeitreihen einzuschließen, an der Sie interessiert sind, denn es wird nur die Prognose für eine Zeitreihe erstellt.

Prognoseerstellung für mehrere Zeitreihen mit exogenen Variablen

Um mehrere Zeitreihen parallel mit exogenen Variablen zu trainieren und zu prognostizieren, also im Wesentlichen die beiden vorherigen Beispiele zu kombinieren, bereiten Sie Ihre Daten auf folgende Weise vor, wobei Sie sowohl eine Zeitreihenspalte (in diesem Fall store_item) als auch mindestens eine exogene Spalte (hier temperature) einbeziehen:

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

Ausgabe

Die ersten fünf Zeilen jeder Zeitreihe des resultierenden Datensets sehen wie folgt aus:

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

Mit der folgenden Anweisung wird ein Prognosemodell unter Verwendung des vorherigen Datensets trainiert. Achten Sie darauf, dass Sie den Spaltennamen der Zeitreihe store_item angeben:

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

Tipp

Sie können eine Abfragereferenz für input_data übergeben, anstatt eine Zwischenansicht zu erstellen. Mit der folgenden Anweisung wird ein Modell mit denselben Eingabedaten erstellt, die mit der vorherigen Anweisung erstellt wurden:

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

Wie zuvor müssen Sie auch bei der Prognoseerstellung die zukünftigen Werte für die exogenen Variablen übergeben, aber diesmal für jede Zeitreihe. Bereiten Sie den zukünftigen Wert der exogenen Variablen wie folgt vor:

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

Ausgabe

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

Jetzt können Sie die vorherigen Zeitstempel prognostizieren:

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

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

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

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:

Beispiel für das Erstellen eines Diagramms aus einer Zeitreihenprognose

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.

Einschränkungen

  • Sie können das zur Berechnung der Feature Importance verwendete Verfahren nicht frei wählen.

  • Die Feature Importance-Bewertung kann hilfreich sein, um ein Gefühl dafür zu bekommen, welche Features für die Genauigkeit Ihres Modells wichtig sind, aber die tatsächlichen Werte müssen als Schätzung angesehen werden.

Beispiel

Um die relative Bedeutung Ihrer Features für Ihr Modell zu verstehen, trainieren Sie ein Modell, und rufen Sie dann <name>!EXPLAIN_FEATURE_IMPORTANCE auf. In diesem Beispiel erstellen Sie zunächst Zufallsdaten mit zwei exogenen Variablen, von denen eine zufällig ist und daher wahrscheinlich keine große Bedeutung für Ihr Modell hat, während die andere eine Kopie Ihrer Zielvariablen ist und daher wahrscheinlich eine größere Bedeutung für Ihr Modell hat.

Führen Sie die folgenden Anweisungen aus, um die Daten zu generieren, dann darauf ein Modell zu trainieren und schließlich die Feature Importance zu ermitteln:

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

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

CALL forecast_feature_importance_demo!EXPLAIN_FEATURE_IMPORTANCE();
Copy

Ausgabe

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

Einschränkungen

  • Der Parameter n_splits muss mindestens auf 2 gesetzt werden.

  • Kleine Datensets enthalten möglicherweise nicht genügend Daten, um eine Bewertung durchzuführen. Die Gesamtzahl der Trainingszeilen muss gleich oder größer als (n_splits * test_size) + gap sein. Wenn nicht genügend Daten zur Verfügung stehen, um Bewertungskennzahlen zu trainieren, sind keine Bewertungskennzahlen verfügbar, selbst wenn evaluate den Wert TRUE hat.

Beispiel

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

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

CALL model!SHOW_EVALUATION_METRICS();
Copy

Ausgabe

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

Beispiel

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

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

CALL model!SHOW_TRAINING_LOGS();
Copy

Ausgabe

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