Freigeben über

Multivariate Anomalieerkennung

  • Artikel

Allgemeine Informationen zur Erkennung von multivariaten Anomalien in Real-Time Intelligence finden Sie unter Erkennung von multivariaten Anomalien in Microsoft Fabric – Überblick. In diesem Tutorial trainieren Sie anhand von Beispieldaten ein Modell zur Erkennung von multivariaten Anomalien mit der Spark-Engine in einem Python-Notebook. Anschließend sagen Sie Anomalien vorher, indem Sie das trainierte Modell mit der Eventhouse-Engine auf neue Daten anwenden. In den ersten Schritten werden Ihre Umgebungen eingerichtet, und in den folgenden Schritten wird das Modell trainiert und Anomalien werden vorhergesagt.

Voraussetzungen

  • Ein Arbeitsbereich mit einer Microsoft Fabric-fähigen Kapazität
  • Admin-, Mitglieds- oder Contributor-Rolle in einem Arbeitsbereich. Diese Berechtigungsstufe ist erforderlich, um Objekte wie z. B. eine Umgebung zu erstellen.
  • Ein Eventhouse in Ihrem Arbeitsbereich mit einer Datenbank.
  • Laden Sie die Beispieldaten aus dem GitHub Repo herunter
  • Laden Sie das Notebook von der GitHub-Website herunter

Teil 1: Aktivieren der OneLake-Verfügbarkeit

Die Verfügbarkeit von OneLake muss aktiviert sein, bevor Sie Daten im Eventhouse abrufen. Dieser Schritt ist wichtig, da er dafür sorgt, dass die Daten, die Sie importieren, in OneLake verfügbar werden. In einem späteren Schritt greifen Sie auf dieselben Daten in Ihrem Spark Notebook zu, um das Modell zu trainieren.

  1. Navigieren Sie in Echtzeitsintelligenz zur Homepage Ihres Arbeitsbereichs.

  2. Wählen Sie das Eventhouse aus, das Sie in den Voraussetzungen erstellt haben. Wählen Sie die Datenbank, in der Sie Ihre Daten speichern möchten.

  3. Wählen Sie in der Kachel Datenbankdetails das Stiftsymbol neben der Verfügbarkeit von OneLake

  4. Schalten Sie im rechten Fensterbereich die Schaltfläche auf Aktiv um.

  5. Wählen Sie Fertig aus.

    Screenshot der Aktivierung der Verfügbarkeit von OneLake in Ihrem Eventhouse.

Teil 2: Aktivieren des KQL Python-Plug-Ins

In diesem Schritt aktivieren Sie das Python-Plug-In in Ihrem Eventhouse. Dieser Schritt ist erforderlich, um den Python-Code zur Vorhersage von Anomalien im KQL-Abfragesatz auszuführen. Es ist wichtig, das richtige Paket auszuwählen, das das time-series-anomaly-detector-Paket enthält.

  1. Wählen Sie auf dem Bildschirm Eventhouse Ihre Datenbank aus und wählen Sie dann Plugins>verwalten aus dem Menüband.

  2. Schalten Sie im Plug-In-Bereich die Python-Spracherweiterung auf Ein um.

  3. Wählen Sie Python 3.11.7 DL (Vorschau) aus.

  4. Wählen Sie Fertig aus.

    Screenshot zur Aktivierung des Python-Pakets 3.11.7 DL im Eventhouse.

Teil 3: Erstellen einer Spark-Umgebung

In diesem Schritt erstellen Sie eine Spark-Umgebung, um das Python-Notebook auszuführen, das das Modell zur Erkennung von multivariaten Anomalien mit der Spark-Engine trainiert. Weitere Informationen zum Erstellen von Umgebungen finden Sie unter Erstellen und Verwalten von Umgebungen.

  1. Wählen Sie im Umschalter für die Benutzeroberfläche Datentechnik aus. Wenn Sie sich bereits im Bereich Data Engineering befinden, gehen Sie zu Start.

  2. Wählen Sie unter Empfohlene zu erstellende Elemente die Option Umgebungen aus, und geben Sie den Namen MVAD_ENV für die Umgebung ein.

    Screenshot der Erstellung einer Umgebung in Datentechnik.

  3. Wählen Sie unter Bibliotheken die Option Öffentliche Bibliotheken aus.

  4. Wählen Sie Hinzufügen aus PyPI aus.

  5. Geben Sie im Suchfeld time-series-anomaly-detector ein. Die Version wird automatisch mit der neuesten Version aufgefüllt. Dieses Lernprogramm wurde mit Version 0.2.7 erstellt, die in der Kusto Python 3.11.7 DL enthalten ist.

  6. Wählen Sie Speichern.

    Screenshot des Hinzufügens des PyPI-Pakets zur Spark-Umgebung.

  7. Wählen Sie in der Umgebung die Registerkarte Start.

  8. Wählen Sie Veröffentlichen im Menüband aus.

  9. Wählen Sie Alle veröffentlichen aus. Dieser Schritt kann mehrere Minuten dauern.

    Screenshot der Veröffentlichung der Umgebung.

Teil 4: Abrufen von Daten in das Eventhouse

  1. Bewegen Sie den Mauszeiger über die KQL-Datenbank, in der Sie Ihre Daten speichern möchten. Wählen Sie das Menü "Weitere" [...]aus>Daten abrufen>Lokale Datei.

    Screenshot des Abrufens von Daten aus der lokalen Datei.

  2. Wählen Sie + Neue Tabelle aus, und geben Sie demo_stocks_change als Tabellennamen ein.

  3. Wählen Sie im Dialogfeld Daten hochladen die Option Nach Dateien suchen und laden Sie die Beispieldatendatei hoch, die Sie im Abschnitt Voraussetzungen heruntergeladen haben

  4. Wählen Sie Weiter aus.

  5. Schalten Sie im Abschnitt Daten prüfen die Option Erste Zeile ist Spaltenüberschrift auf Ein.

  6. Wählen Sie Fertig stellen aus.

  7. Wenn die Daten hochgeladen sind, wählen Sie Schließen.

Teil 5: Kopieren des OneLake-Pfads in die Tabelle

Stellen Sie sicher, dass Sie die Tabelle demo_stocks_change auswählen. Wählen Sie in der Kachel Tabellendetails die Option Pfad kopieren, um den OneLake-Pfad in Ihre Zwischenablage zu kopieren. Speichern Sie den kopierten Text in einem Texteditor, um ihn in einem späteren Schritt zu verwenden.

Screenshot des Kopierens des OneLake-Pfads.

Teil 6: Vorbereiten des Notebooks

  1. Wählen Sie im Umschalter für die Benutzeroberfläche Entwickeln und dann Ihren Arbeitsbereich aus.

  2. Wählen Sie Import, Notebook und dann Von diesem Computer aus.

  3. Wählen Sie Hochladen und wählen Sie das Notebook, das Sie unter den Voraussetzungen heruntergeladen haben, aus.

  4. Nachdem das Notebook hochgeladen wurde, können Sie es in Ihrem Arbeitsbereich suchen und öffnen.

  5. Wählen Sie in der oberen Multifunktionsleiste das Dropdown-Menü Arbeitsbereichs-Standard und wählen Sie die Umgebung, die Sie im vorherigen Schritt erstellt haben.

    Screenshot der Auswahl der Umgebung im Notebook.

Teil 7: Ausführen des Notebooks

  1. Importieren Sie Standardpakete.

    import numpy as np
import pandas as pd

  2. Spark benötigt eine ABFSS-URI, um sich sicher mit dem OneLake-Speicher zu verbinden. Daher wird im nächsten Schritt diese Funktion definiert, um die OneLake-URI in eine ABFSS-URI zu konvertieren.

    def convert_onelake_to_abfss(onelake_uri):
if not onelake_uri.startswith('https://'):
    raise ValueError("Invalid OneLake URI. It should start with 'https://'.")
uri_without_scheme = onelake_uri[8:]
parts = uri_without_scheme.split('/')
if len(parts) < 3:
    raise ValueError("Invalid OneLake URI format.")
account_name = parts[0].split('.')[0]
container_name = parts[1]
path = '/'.join(parts[2:])
abfss_uri = f"abfss://{container_name}@{parts[0]}/{path}"
return abfss_uri

  3. Geben Sie Ihre OneLake-URI ein, die Sie in Teil 5: Kopieren des OneLake-Pfads in die Tabelle kopiert haben, um die Tabelle demo_stocks_change in einen Pandas-Dataframe zu laden.

    onelake_uri = "OneLakeTableURI" # Replace with your OneLake table URI 
abfss_uri = convert_onelake_to_abfss(onelake_uri)
print(abfss_uri)

    df = spark.read.format('delta').load(abfss_uri)
df = df.toPandas().set_index('Date')
print(df.shape)
df[:3]

  4. Führen Sie die folgenden Zellen aus, um die Trainings- und Vorhersagedatenrahmen vorzubereiten.

    Hinweis

    Die eigentlichen Vorhersagen werden mit den Daten des Eventhouse in Teil 9: Vorhersage von Anomalien im KQL-Abfrageset durchgeführt. In einem Produktionsszenario, wenn Sie Daten in das Eventhouse streamen, würden die Vorhersagen auf der Grundlage der neuen Streaming-Daten erstellt. Für den Zweck des Lernprogramms wurde der Datensatz nach Datum in zwei Abschnitte für Training und Vorhersage aufgeteilt. Dies dient der Simulation von historischen Daten und neuen Streaming-Daten.

    features_cols = ['AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY']
cutoff_date = pd.to_datetime('2023-01-01')

    train_df = df[df.Date < cutoff_date]
print(train_df.shape)
train_df[:3]

    train_len = len(train_df)
predict_len = len(df) - train_len
print(f'Total samples: {len(df)}. Split to {train_len} for training, {predict_len} for testing')

  5. Führen Sie die Zellen aus, um das Modell zu trainieren und speichern Sie es in der Fabric MLflow-Modell-Registrierung.

    import mlflow
from anomaly_detector import MultivariateAnomalyDetector
model = MultivariateAnomalyDetector()

    sliding_window = 200
param   s = {"sliding_window": sliding_window}

    model.fit(train_df, params=params)

    with mlflow.start_run():
    mlflow.log_params(params)
    mlflow.set_tag("Training Info", "MVAD on 5 Stocks Dataset")

    model_info = mlflow.pyfunc.log_model(
        python_model=model,
        artifact_path="mvad_artifacts",
        registered_model_name="mvad_5_stocks_model",
    )

    # Extract the registered model path to be used for prediction using Kusto Python sandbox

mi = mlflow.search_registered_models(filter_string="name='mvad_5_stocks_model'")[0]
model_abfss = mi.latest_versions[0].source
print(model_abfss)

  6. Kopieren Sie den Modell-URI aus der letzten Zellenausgabe. Sie werden diese in einem späteren Schritt benötigen.

Teil 8: Einrichten des KQL-Abfragesets

Allgemeine Informationen finden Sie unter Erstellen eines KQL-Abfragesets.

  1. Wählen Sie im Experience Switcher die Option Real-Time Intelligence aus.
  2. Wählen Sie Ihren Arbeitsbereich aus.
  3. Wählen Sie +Neues Element>KQL-Abfrageset aus. Geben Sie den Namen MultivariateAnomalyDetectionTutorial ein.
  4. Klicken Sie auf Erstellen.
  5. Wählen Sie im OneLake Data Hub-Fenster die KQL-Datenbank aus, in der Sie die Daten gespeichert haben.
  6. Wählen Sie Verbinden.

Teil 9: Vorhersagen von Anomalien im KQL-Abfrageset

  1. Kopieren Sie bzw. fügen Sie die folgende Abfrage '.create-or-alter function' ein und führen Sie sie aus, um die gespeicherte predict_fabric_mvad_fl()-Funktion zu definieren:

    .create-or-alter function with (folder = "Packages\\ML", docstring = "Predict MVAD model in Microsoft Fabric")
predict_fabric_mvad_fl(samples:(*), features_cols:dynamic, artifacts_uri:string, trim_result:bool=false)
{
    let s = artifacts_uri;
    let artifacts = bag_pack('MLmodel', strcat(s, '/MLmodel;impersonate'), 'conda.yaml', strcat(s, '/conda.yaml;impersonate'),
                             'requirements.txt', strcat(s, '/requirements.txt;impersonate'), 'python_env.yaml', strcat(s, '/python_env.yaml;impersonate'),
                             'python_model.pkl', strcat(s, '/python_model.pkl;impersonate'));
    let kwargs = bag_pack('features_cols', features_cols, 'trim_result', trim_result);
    let code = ```if 1:
        import os
        import shutil
        import mlflow
        model_dir = 'C:/Temp/mvad_model'
        model_data_dir = model_dir + '/data'
        os.mkdir(model_dir)
        shutil.move('C:/Temp/MLmodel', model_dir)
        shutil.move('C:/Temp/conda.yaml', model_dir)
        shutil.move('C:/Temp/requirements.txt', model_dir)
        shutil.move('C:/Temp/python_env.yaml', model_dir)
        shutil.move('C:/Temp/python_model.pkl', model_dir)
        features_cols = kargs["features_cols"]
        trim_result = kargs["trim_result"]
        test_data = df[features_cols]
        model = mlflow.pyfunc.load_model(model_dir)
        predictions = model.predict(test_data)
        predict_result = pd.DataFrame(predictions)
        samples_offset = len(df) - len(predict_result)        # this model doesn't output predictions for the first sliding_window-1 samples
        if trim_result:                                       # trim the prefix samples
            result = df[samples_offset:]
            result.iloc[:,-4:] = predict_result.iloc[:, 1:]   # no need to copy 1st column which is the timestamp index
        else:
            result = df                                       # output all samples
            result.iloc[samples_offset:,-4:] = predict_result.iloc[:, 1:]
        ```;
    samples
    | evaluate python(typeof(*), code, kwargs, external_artifacts=artifacts)
}

  2. Kopieren Sie bzw. fügen Sie die folgende Vorhersageabfrage ein.

    1. Ersetzen Sie den am Ende von Schritt 7 kopierten Output-Modell-URI.
    2. Abfrage ausführen. Er erkennt multivariate Anomalien bei den fünf Aktien auf der Grundlage des trainierten Modells und gibt die Ergebnisse als anomalychart aus. Die anomalen Punkte werden auf der ersten Aktie (AAPL) dargestellt, obwohl sie multivariate Anomalien darstellen (mit anderen Worten, Anomalien der gemeinsamen Veränderungen der fünf Aktien an einem bestimmten Datum).
    let cutoff_date=datetime(2023-01-01);
let num_predictions=toscalar(demo_stocks_change | where Date >= cutoff_date | count);   //  number of latest points to predict
let sliding_window=200;                                                                 //  should match the window that was set for model training
let prefix_score_len = sliding_window/2+min_of(sliding_window/2, 200)-1;
let num_samples = prefix_score_len + num_predictions;
demo_stocks_change
| top num_samples by Date desc 
| order by Date asc
| extend is_anomaly=bool(false), score=real(null), severity=real(null), interpretation=dynamic(null)
| invoke predict_fabric_mvad_fl(pack_array('AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY'),
            // NOTE: Update artifacts_uri to model path
            artifacts_uri='enter your model URI here',
            trim_result=true)
| summarize Date=make_list(Date), AAPL=make_list(AAPL), AMZN=make_list(AMZN), GOOG=make_list(GOOG), MSFT=make_list(MSFT), SPY=make_list(SPY), anomaly=make_list(toint(is_anomaly))
| render anomalychart with(anomalycolumns=anomaly, title='Stock Price Changest in % with Anomalies')

Das resultierende Anomalie-Diagramm sollte wie das folgende Bild aussehen:

Screenshot der multivariablen Anomalieausgabe.

Bereinigen von Ressourcen

Wenn Sie das Löschen abgeschlossen haben, können Sie die Ressourcen löschen, die Sie erstellt haben, um andere Kosten zu vermeiden. Um die Ressourcen zu löschen, gehen Sie wie folgt vor:

  1. Navigieren Sie zu Ihrer Arbeitsbereichs-Homepage.
  2. Löschen Sie die in diesem Lernprogramm erstellte Umgebung.
  3. Löschen Sie den Notebook, den Sie in diesem Tutorial erstellt haben.
  4. Löschen Sie das in diesem Tutorial verwendete Eventhouse oder Datenbank.
  5. Löschen Sie das in diesem Lernprogramm erstellte KQL-Queryset.