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

Einschränkungen¶

• Sie können den Algorithmus zur Anomalieerkennung weder auswählen noch anpassen. Insbesondere bietet der Algorithmus keine Parameter, um Trend, Saisonalität oder saisonale Amplituden zu überschreiben; diese werden aus den Daten abgeleitet.

• Die Mindestanzahl von Zeilen für den Hauptalgorithmus zur Anomalieerkennung beträgt 12 pro Zeitreihe. Bei Zeitreihen mit 2 bis 11 Beobachtungen führt die Anomalieerkennung zu einem „naiven“ Ergebnis, bei dem alle vorhergesagten Werte gleich dem letzten beobachteten Zielwert sind. Bei der beschrifteten Anomalieerkennung entspricht die Anzahl der verwendeten Beobachtungen der Anzahl der Zeilen, in denen die Beschriftungsspalte „false“ ist.

• 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 Anomalieerkennungsmodelle 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. Im Allgemeinen sollten Sie das Modell in regelmäßigen Abständen neu trainieren, z. B. einmal pro Woche oder einmal pro Monat, je nachdem, wie häufig Sie neue Daten erhalten, damit das Modell mit den sich ändernden Trends Schritt halten kann.

• Dieses Feature erkennt nur Anomalien in den Testdaten in Bezug zu den Trainingsdaten. Es kann keine Anomalien in den Trainingsdaten erkennen. Da die Trainingsdaten die Quelle des Modells sind, haben diese per Definition keine Ausreißer in Bezug auf sich selbst. Stellen Sie sicher, dass die Trainingsdaten einen typischen Zeitraum ohne tatsächliche Ausreißer abdecken, oder kennzeichnen (beschriften) Sie bekannte Ausreißer mithilfe einer Boolean-Spalte.

• 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 ANOMALY_DETECTION-Klasse nicht replizieren.

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 der optimalen Größe und des passenden Warehouse-Typs für diesen Zweck. Der Schwerpunkt liegt dabei auf dem Trainingsschritt (dem zeit- und speicherintensivsten Teil des Prozesses).

Erteilen von Berechtigungen zum Erstellen von Anomalieerkennungsobjekten¶

Das Training eines Anomalieerkennungsmodells führt zu einem Objekt auf Schemaebene. Daher muss die Rolle, mit der Sie Modelle erstellen, über die Berechtigung CREATE SNOWFLAKE.ML.ANOMALY_DETECTION 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 Erkennen von Anomalien 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.ANOMALY_DETECTION ON SCHEMA admin_db.admin_schema TO ROLE analyst;

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

USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;

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 Anomalieerkennungsmodelle erstellen:

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

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

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

Erkennen von Anomalien in einer einzelnen Zeitreihe (nicht überwacht)¶

So können Sie Anomalien in Ihren Daten erkennen:

1. Trainieren Sie ein Anomalieerkennungsmodell mithilfe historischer Daten.

2. Verwenden Sie das trainierte Anomalieerkennungsmodell, um Anomalien in historischen oder projizierten Daten zu erkennen. Die Zeitstempel in den Testdaten müssen chronologisch den Zeitstempeln in den Trainingsdaten folgen. Sie benötigen mindestens 2 Datenpunkte, um ein Modell zu trainieren, mindestens 12 Datenpunkte für nicht naive Ergebnisse und mindestens 60 Datenpunkte für nichtlineare Ergebnisse.

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

BEGIN
  CALL basic_model!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
     TIMESTAMP_COLNAME =>'date',
     TARGET_COLNAME => 'sales'
  );
  LET x := SQLID;
  CREATE TABLE my_anomalies AS SELECT * FROM TABLE(RESULT_SCAN(:x));
END;

SELECT * FROM my_anomalies;

Trainieren eines Anomalieerkennungsmodells mit beschrifteten Daten¶

Das Ergebnis aus dem Modell im vorherigen Beispiel scheint ungenau zu sein. Mögliche Gründe sind:

• Das Anomalieerkennungsmodell wurde mit sehr wenigen Eingabedaten trainiert.

• Eine größere Anzahl von Jacken (30) wurde am „2020-01-03“ verkauft. Dadurch wurden die Vorhersagen nach oben verzerrt und das Vorhersageintervall vergrößert.

Um die Genauigkeit des Anomalieerkennungsmodells zu verbessern, können Sie entweder mehr Trainingsdaten einbeziehen oder die Trainingsdaten beschriften (überwachtes Training). Beschriftete Trainingsdaten haben eine zusätzliche boolesche Spalte, die angibt, ob es sich bei jeder Zeile um eine bekannte Anomalie handelt. Das Beschriften kann dem Anomalieerkennungsmodell helfen, eine Überanpassung an bekannte Anomalien in den Trainingsdaten zu vermeiden.

Um beschriftete Daten in die Trainingsdaten aufzunehmen, geben Sie die Spalte mit der Beschriftung im Konstruktorargument LABEL_COLNAME des Befehls CREATE SNOWFLAKE.ML.ANOMALY_DETECTION an. Beispiel:

1. Erstellen Sie eine Ansicht, oder entwerfen Sie eine Abfrage, die die Beschriftungen mit den Trainingsdaten zurückgibt.

   Führen Sie für dieses Beispiel den Befehl CREATE VIEW aus, um eine Ansicht namens view_with_labeled_data zu erstellen, die in der Spalte label die Beschriftungen enthält:

   CREATE OR REPLACE VIEW view_with_labeled_data_for_training
     AS SELECT date, sales, label FROM historical_sales_data
       WHERE store_id=1 and item='jacket';
   

   Copy

2. Erstellen Sie ein Objekt für das Anomalieerkennungsmodell, und trainieren Sie das Modell anhand der Daten in dieser Ansicht.

   Führen Sie für dieses Beispiel den Befehl CREATE SNOWFLAKE.ML.ANOMALY_DETECTION aus, um ein Anomalieerkennungsobjekt namens model_trained_with_labeled_data zu erstellen. Mit der folgenden Anweisung wird das Anomalieerkennungsobjekt erstellt:

   CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_trained_with_labeled_data(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_labeled_data_for_training'),
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     LABEL_COLNAME => 'label'
   );
   

   Copy

3. Rufen Sie mit diesem neuen Anomalieerkennungsmodell die Methode <name>!DETECT_ANOMALIES auf, und übergeben Sie dabei dieselben Argumente, die Sie unter Erkennen von Anomalien in einer einzelnen Zeitreihe (nicht überwacht) verwendet haben:

   CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
     TIMESTAMP_COLNAME =>'date',
     TARGET_COLNAME => 'sales'
   );
   

   Copy

   Die Methode gibt eine Tabelle zurück, die Zeilen für die Daten enthält, die sich derzeit in der Ansicht view_with_data_to_analyze befinden, sowie die Vorhersage aus der Anomalieerkennung. Eine Beschreibung der Spalten in dieser Tabelle finden Sie unter Ausgabe.

Ausgabe

Die Ergebnisse wurden zur besseren Lesbarkeit gerundet.

+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+
| TS                      |  Y | FORECAST |   LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |   PERCENTILE |   DISTANCE |
|-------------------------+----+----------+---------------+--------------+------------+--------------+------------|
| 2020-01-16 00:00:00.000 |  6 |        6 |  0.82         | 11.18        | False      | 0.5          | 0          |
| 2020-01-17 00:00:00.000 | 20 |        6 | -0.39         | 12.33        | True       | 0.99         | 5.70       |
+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+

Festlegen des Vorhersageintervalls für die Anomalieerkennung¶

Beim Erkennen von Anomalien können unterschiedliche Empfindlichkeitsstufen verwendet werden. Um den Prozentsatz der Beobachtungen anzugeben, die als Anomalien eingestuft werden sollen, erstellen Sie ein OBJECT, das Konfigurationseinstellungen für <name>!DETECT_ANOMALIES enthält, und setzen Sie dann den Schlüssel prediction_interval auf den Prozentsatz der Beobachtungen, die als Anomalien markiert werden sollen.

Um dieses Objekt zu erstellen, können Sie entweder eine Objektkonstante oder die Funktion OBJECT_CONSTRUCT verwenden.

Wenn Sie dann die Methode <name>!DETECT_ANOMALIES aufrufen, geben Sie dieses Objekt als CONFIG_OBJECT-Argument an.

Standardmäßig ist der mit dem Schlüssel „prediction_interval“ verknüpfte Wert auf 0,99 eingestellt, was bedeutet, dass etwa 1 % der Daten als Anomalien markiert werden. Sie können einen Wert zwischen 0 und 1 angeben:

• Um weniger Beobachtungen als Anomalien zu markieren, geben Sie einen höheren Wert für prediction_interval an.

• Um mehr Beobachtungen als Anomalien zu markieren, reduzieren Sie den Wert für prediction_interval.

Im folgenden Beispiel wird die Anomalieerkennung strenger konfiguriert, indem prediction_interval auf 0,995 gesetzt wird. In dem Beispiel wird auch das auf beschrifteten Daten trainierte Modell (das Sie unter Trainieren eines Anomalieerkennungsmodells mit beschrifteten Daten eingerichtet haben) mit der Ansicht verwendet, die die zu analysierenden Daten enthält (die Sie unter Erkennen von Anomalien in einer einzelnen Zeitreihe (nicht überwacht) eingerichtet haben).

CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales',
  CONFIG_OBJECT => {'prediction_interval':0.995}
);

Mit dieser Anweisung wird eine Tabelle erstellt, die Zeilen für die Daten enthält, die sich derzeit in der Ansicht view_with_data_to_analyze befinden. Jede Zeile enthält eine Spalte mit der Vorhersage aus der Anomalieerkennung. Es zeigt sich, dass das Ergebnis dieses Modells genauer ist als das Beispiel ohne Beschriftung.

Ausgabe

Die Ergebnisse wurden zur besseren Lesbarkeit gerundet.

+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+
| TS                      |  Y | FORECAST |   LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |   PERCENTILE |   DISTANCE |
|-------------------------+----+----------+---------------+--------------+------------+--------------+------------|
| 2020-01-16 00:00:00.000 |  6 |        6 |  0.36         | 11.64        | False      | 0.5          | 0          |
| 2020-01-17 00:00:00.000 | 20 |        6 | -0.90         | 12.90        | True       | 0.99         | 5.70       |
+-------------------------+----+----------+---------------+--------------+------------+--------------+------------+

Einbeziehen zusätzlicher Spalten in die Analyse¶

Sie können zusätzliche Spalten in die Daten für Training und Analyse aufnehmen (z. B. temperature, weather, is_black_friday), wenn diese Spalten Ihnen helfen können, das Identifizieren echter Anomalien zu verbessern.

So beziehen Sie neue Spalten in die Analyse ein:

1. Erstellen Sie für die Trainingsdaten eine Ansicht, oder entwerfen Sie eine Abfrage, die die neuen Spalten enthält, und erstellen Sie ein neues Anomalieerkennungsobjekt, indem Sie eine Referenz auf diese Ansicht bzw. Abfrage übergeben.

2. Erstellen Sie für die zu analysierenden Daten eine Ansicht, oder entwerfen Sie eine Abfrage, die die neuen Spalten enthält, und übergeben Sie der Methode <name>!DETECT_ANOMALIES eine Referenz auf diese Ansicht bzw. Abfrage.

Das Anomalieerkennungsobjekt erkennt und verwendet die zusätzlichen Spalten automatisch.

Angenommen, Sie möchten die Spalten temperature, humidity und holiday hinzufügen:

1. Erstellen Sie eine Ansicht, oder entwerfen Sie eine Abfrage, die die Trainingsdaten mit diesen zusätzlichen Spalten zurückgibt.

   Führen Sie für dieses Beispiel den Befehl CREATE VIEW aus, um eine Ansicht namens view_with_training_data_extra_columns zu erstellen:

   CREATE OR REPLACE VIEW view_with_training_data_extra_columns
     AS SELECT date, sales, label, temperature, humidity, holiday
       FROM historical_sales_data
       WHERE store_id=1 AND item='jacket';
   

   Copy

2. Erstellen Sie ein Objekt für das Anomalieerkennungsmodell, und trainieren Sie das Modell anhand der Daten in dieser Ansicht.

   Führen Sie für dieses Beispiel den Befehl CREATE SNOWFLAKE.ML.ANOMALY_DETECTION aus, um ein Anomalieerkennungsobjekt namens model_with_additional_columns zu erstellen, und übergeben Sie dabei eine Referenz auf die neue Ansicht:

   CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_with_additional_columns(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_training_data_extra_columns'),
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     LABEL_COLNAME => 'label'
   );
   

   Copy

3. Erstellen Sie eine Ansicht, oder entwerfen Sie eine Abfrage, die die zu analysierenden Daten mit diesen zusätzlichen Spalten zurückgibt.

   Führen Sie für dieses Beispiel den Befehl CREATE VIEW aus, um eine Ansicht namens view_with_data_for_analysis_extra_columns zu erstellen:

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

   Copy

4. Rufen Sie mit diesem neuen Anomalieerkennungsobjekt die Methode <name>!DETECT_ANOMALIES auf, und übergeben Sie dabei die neue Ansicht:

   CALL model_with_additional_columns!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_for_analysis_extra_columns'),
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     CONFIG_OBJECT => {'prediction_interval':0.93}
   );
   

   Copy

   Mit dieser Anweisung wird eine Tabelle erstellt, die Zeilen für die Daten enthält, die sich derzeit in der Ansicht view_with_data_for_analysis_extra_columns befinden, sowie die Vorhersage aus der Anomalieerkennung. Das Ausgabeformat ist dasselbe wie bei den Befehlen, die Sie zuvor ausgeführt haben.

Ausgabe

Die Ergebnisse wurden zur besseren Lesbarkeit gerundet.

+-------------------------+----+----------+-------------+--------------+------------+--------------+------------+
| TS                      |  Y | FORECAST | LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |   PERCENTILE |   DISTANCE |
|-------------------------+----+----------+-------------+--------------+------------+--------------+------------|
| 2020-01-16 00:00:00.000 |  6 |        6 | 2.34        |  9.64        | False      | 0.5          | 0          |
| 2020-01-17 00:00:00.000 | 20 |        6 | 1.56        | 10.451       | True       | 0.99         | 5.70       |
+-------------------------+----+----------+-------------+--------------+------------+--------------+------------+

Erkennen von Anomalien in mehreren Zeitreihen¶

In den vorangegangenen Abschnitten wurden Beispiele für das Erkennen von Anomalien in einer einzelnen Zeitreihe bereitgestellt. In diesen Beispielen wurden Anomalien für den Verkauf eines Typs von Artikel (Jacken) in einer Filiale (Filial-ID 1) markiert. So erkennen Sie Anomalien für mehrere Zeitreihen gleichzeitig (z. B. für mehrere Kombinationen von Artikeln und Filialen):

1. Erstellen Sie für die Trainingsdaten eine Ansicht, oder entwerfen Sie eine Abfrage, die eine Spalte enthält, die die Zeitreihe identifiziert, und erstellen Sie dann ein neues Anomalieerkennungsobjekt, indem Sie eine Referenz auf diese Ansicht bzw. Abfrage übergeben und den Namen der Zeitreihenspalte für das Argument SERIES_COLNAME angeben.

2. Erstellen Sie für die zu analysierenden Daten eine Ansicht, oder entwerfen Sie eine Abfrage, die die Spalte enthält, mit der die Zeitreihe identifiziert wird. Rufen Sie die Methode <name>!DETECT_ANOMALIES auf, wobei Sie eine Referenz auf diese Ansicht oder Abfrage übergeben und den Namen der Zeitreihenspalte für das Argument SERIES_COLNAME angeben.

Angenommen, Sie möchten die Kombination der Spalten store_id und item verwenden, um die Zeitreihe zu identifizieren:

1. Erstellen Sie eine Ansicht, oder entwerfen Sie eine Abfrage, die die Trainingsdaten mithilfe der Zeitreihenspalte zurückgibt.

   Führen Sie für dieses Beispiel den Befehl CREATE VIEW aus, um eine Ansicht mit dem Namen view_with_training_data_multiple_series zu erstellen, die eine Spalte mit dem Namen store_item enthält, mit der die Zeitreihe als Kombination aus Filial-ID und Artikel identifiziert wird:

   CREATE OR REPLACE VIEW view_with_training_data_multiple_series
     AS SELECT
       [store_id, item] AS store_item,
       date,
       sales,
       label,
       temperature,
       humidity,
       holiday
     FROM historical_sales_data;
   

   Copy

2. Erstellen Sie ein Objekt für die Anomalieerkennung, und trainieren Sie das Modell anhand der Daten in dieser Ansicht.

   Führen Sie für dieses Beispiel den Befehl CREATE SNOWFLAKE.ML.ANOMALY_DETECTION aus, um ein Anomalieerkennungsobjekt namens model_for_multiple_series zu erstellen, und übergeben Sie dabei eine Referenz auf die neue Ansicht, wobei Sie für das Argument SERIES_COLNAME den Wert store_item angeben:

   CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_for_multiple_series(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_training_data_multiple_series'),
     SERIES_COLNAME => 'store_item',
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     LABEL_COLNAME => 'label'
   );
   

   Copy

3. Erstellen Sie eine Ansicht, oder entwerfen Sie eine Abfrage, die die zu analysierenden Daten mit der Zeitreihenspalte zurückgibt.

   In diesem Beispiel führen Sie den Befehl CREATE VIEW aus, um eine Ansicht namens view_with_data_for_analysis_multiple_series zu erstellen, die eine Spalte namens store_item für die Zeitreihe enthält:

   CREATE OR REPLACE VIEW view_with_data_for_analysis_multiple_series
     AS SELECT
       [store_id, item] AS store_item,
       date,
       sales,
       temperature,
       humidity,
       holiday
     FROM new_sales_data;
   

   Copy

4. Rufen Sie mit diesem neuen Anomalieerkennungsobjekt die Methode <name>!DETECT_ANOMALIES auf, und übergeben Sie die neue Ansicht, wobei Sie store_item als SERIES_COLNAME-Argument angeben.

   CALL model_for_multiple_series!DETECT_ANOMALIES(
     INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_for_analysis_multiple_series'),
     SERIES_COLNAME => 'store_item',
     TIMESTAMP_COLNAME => 'date',
     TARGET_COLNAME => 'sales',
     CONFIG_OBJECT => {'prediction_interval':0.995}
   );
   

   Copy

   Mit dieser Anweisung wird eine Tabelle erstellt, die Zeilen für die Daten enthält, die sich derzeit in der Ansicht view_with_data_for_analysis_multiple_series befinden, sowie die Vorhersage aus der Anomalieerkennung. Die Ausgabe enthält die Spalte, mit der die Zeitreihe identifiziert wird.

Ausgabe

Die Ergebnisse wurden zur besseren Lesbarkeit gerundet.

+--------------+-------------------------+----+----------+---------------+--------------+------------+---------------+--------------+
| SERIES       | TS                      |  Y | FORECAST |   LOWER_BOUND |  UPPER_BOUND | IS_ANOMALY |    PERCENTILE |     DISTANCE |
|--------------+-------------------------+----+----------+---------------+--------------+------------+---------------+--------------|
| [            | 2020-01-16 00:00:00.000 |  3 |      6.3 |  2.07         | 10.53        | False      | 0.01          | -2.19         |
|   2,         |                         |    |          |               |              |            |               |              |
|   "umbrella" |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
| [            | 2020-01-17 00:00:00.000 | 70 |      2.9 | -1.33         |  7.13        | True       | 1             | 44.54         |
|   2,         |                         |    |          |               |              |            |               |              |
|   "umbrella" |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
| [            | 2020-01-16 00:00:00.000 |  6 |      6   |  0.36         | 11.64        | False      | 0.5           |  0           |
|   1,         |                         |    |          |               |              |            |               |              |
|   "jacket"   |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
| [            | 2020-01-17 00:00:00.000 | 20 |      6   | -0.90         | 12.90        | True       | 0.99          |  5.70         |
|   1,         |                         |    |          |               |              |            |               |              |
|   "jacket"   |                         |    |          |               |              |            |               |              |
| ]            |                         |    |          |               |              |            |               |              |
+--------------+-------------------------+----+----------+---------------+--------------+------------+---------------+--------------+

Wiederkehrendes Training mit Snowflake-Aufgaben¶

Sie können Ihr Modell mithilfe von Snowflake-Aufgaben trainieren, damit es die aktuellen Daten widerspiegelt.

Um eine Aufgabe zu erstellen, die das Anomalieerkennungsobjekt stündlich aktualisiert, führen Sie die folgende Anweisung aus, wobei Sie your_warehouse_name durch den Namen Ihres Warehouses ersetzen:

CREATE OR REPLACE TASK ad_model_retrain_task
WAREHOUSE = <your_warehouse_name>
SCHEDULE = '60 MINUTE'
AS
EXECUTE IMMEDIATE
$$
BEGIN
  CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION model_trained_with_labeled_data(
    INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_labeled_data_for_training'),
    TIMESTAMP_COLNAME => 'date',
    TARGET_COLNAME => 'sales',
    LABEL_COLNAME => 'label'
  );
END;
$$;

Standardmäßig sind neu erstellte Aufgaben im Modus „Angehalten“.

Um die Aufgabe fortzusetzen, führen Sie den Befehl ALTER TASK … RESUME aus:

ALTER TASK ad_model_retrain_task RESUME;

Um die Aufgabe anzuhalten, führen Sie den Befehl ALTER TASK … SUSPEND aus:

ALTER TASK ad_model_retrain_task SUSPEND;

Überwachen mit Snowflake-Aufgaben¶

Sie können Snowflake-Aufgaben auch verwenden, um Ihre Daten in regelmäßigen Abständen zu überwachen.

Erstellen Sie zuerst eine Tabelle, in der die Ergebnisse der Anomalieerkennung gespeichert werden:

CREATE OR REPLACE TABLE anomaly_res_table (
  ts TIMESTAMP_NTZ, y FLOAT, forecast FLOAT, lower_bound FLOAT, upper_bound FLOAT,
  is_anomaly BOOLEAN, percentile FLOAT, distance FLOAT);

Erstellen Sie eine Aufgabe, mit der die Ergebnisse einer sich wiederholenden Anomalieerkennungsoperation in der Tabelle gespeichert werden: In diesem Beispiel wird der Parameter WAREHOUSE auf snowhouse gesetzt. Sie können diesen Wert durch Ihr eigenes Warehouse ersetzen:

CREATE OR REPLACE TASK ad_model_monitoring_task
WAREHOUSE = snowhouse
SCHEDULE = '1 minute'
AS
EXECUTE IMMEDIATE
$$
BEGIN
  CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
    INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
    TIMESTAMP_COLNAME => 'date',
    TARGET_COLNAME => 'sales',
    CONFIG_OBJECT => {'prediction_interval':0.99}
  );

  INSERT INTO anomaly_res_table (ts, y, forecast, lower_bound, upper_bound, is_anomaly, percentile, distance)
    SELECT * FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));
END;
$$;

Um die Aufgabe fortzusetzen, führen Sie den Befehl ALTER TASK … RESUME aus:

ALTER TASK ad_model_monitoring_task RESUME;

anomaly_res_table enthält dann alle Ergebnisse für jede Aufgabenausführung.

Um die Aufgabe anzuhalten, führen Sie den Befehl ALTER TASK … SUSPEND aus:

ALTER TASK ad_model_monitoring_task SUSPEND;

Überwachen mit Snowflake-Alerts¶

Sie können auch Snowflake-Alerts verwenden, um Ihre Daten in regelmäßigen Abständen zu überwachen und Ihnen E-Mails bei Erkennen von Anomalien zu senden. Mit den folgenden Anweisungen wird ein Alert erstellt, der jede Minute auf erkannte Anomalien prüft. Zuerst definieren Sie eine gespeicherte Prozedur, um Anomalien zu erkennen, und erstellen dann einen Alert, der diese gespeicherte Prozedur verwendet.

CREATE OR REPLACE PROCEDURE extract_anomalies()
  RETURNS TABLE()
  LANGUAGE SQL
  AS
  $$
    BEGIN
      CALL model_trained_with_labeled_data!DETECT_ANOMALIES(
        INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'view_with_data_to_analyze'),
        TIMESTAMP_COLNAME => 'date',
        TARGET_COLNAME => 'sales',
        CONFIG_OBJECT => {'prediction_interval':0.99}
      );

      DECLARE
        res RESULTSET DEFAULT (SELECT * FROM TABLE(RESULT_SCAN(-1)) WHERE is_anomaly = TRUE);
      BEGIN
        RETURN TABLE(res);
      END;
    END;
  $$
  ;

CREATE OR REPLACE ALERT sample_sales_alert
WAREHOUSE = <your_warehouse_name>
SCHEDULE = '1 MINUTE'
IF (EXISTS (CALL extract_anomalies()))
THEN
CALL SYSTEM$SEND_EMAIL(
  'sales_email_alert',
  'your_email@snowflake.com',
  'Anomalous Sales Data Detected in data stream',
  CONCAT(
    'Anomalous Sales Data Detected in data stream \n',
    'Value outside of prediction interval detected in the most recent run at ',
    current_timestamp(1)
  ));

Um den Alert zu starten oder fortzusetzen, führen Sie den Befehl ALTER ALERT … RESUME aus:

ALTER ALERT sample_sales_alert RESUME;

Um den Alert anzuhalten, führen Sie den Befehl ALTER ALERT … SUSPEND aus:

ALTER ALERT sample_sales_alert SUSPEND;

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 VIEW v_feature_importance_demo AS SELECT
  ts,
  y,
  exog_a
FROM v_random_data;

SELECT * FROM v_feature_importance_demo;

CREATE OR REPLACE SNOWFLAKE.ML.ANOMALY_DETECTION anomaly_model_feature_importance_demo(
  INPUT_DATA => SYSTEM$REFERENCE('VIEW', 'v_feature_importance_demo'),
  TIMESTAMP_COLNAME => 'ts',
  TARGET_COLNAME => 'y',
  LABEL_COLNAME => ''
);

CALL anomaly_model_feature_importance_demo!EXPLAIN_FEATURE_IMPORTANCE();

Ausgabe

Da in diesem Beispiel zufällige Daten verwendet werden, dürfen Sie nicht erwarten, dass Ihre Ausgabe genau mit dieser Beispielausgabe übereinstimmt.

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

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.ANOMALY_DETECTION model(
  INPUT_DATA => SYSTEM$QUERY_REFERENCE('SELECT date, sales, series FROM t_error'),
  SERIES_COLNAME => 'series',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales',
  LABEL_COLNAME => '',
  CONFIG_OBJECT => {'ON_ERROR': 'SKIP'}
);

CALL model!SHOW_TRAINING_LOGS();

Ausgabe

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