Erkennung multivariater Anomalien

In diesem Lernprogramm erfahren Sie, wie Sie ein multivariates Anomalieerkennungsmodell in einem Fabric Notizbuch mithilfe von Beispieldaten trainieren, die in einem Eventhouse gespeichert sind. Anschließend verwenden Sie das trainierte Modell in einem KQL-Abfrageset, um neue Daten zu scoren und Anomalien zu visualisieren.

Hintergrundinformationen finden Sie unter Multivariate Anomaly Detection in Microsoft Fabric – Übersicht.

Voraussetzungen

Ein Arbeitsbereich mit einer Microsoft Fabric-fähigen Kapazität.
Eine Administrator-, Mitwirkender- oder MitgliedArbeitsbereichsrolle. Sie benötigen diese Berechtigungsstufe, um Elemente wie eine Umgebung zu erstellen.
Ein Eventhouse in Ihrem Arbeitsbereich mit einer Datenbank.
Die Beispieldatendatei.
Das Beispiel-Notebook.

Teil 1: Aktivieren der OneLake-Verfügbarkeit

Aktivieren Sie die Verfügbarkeit von OneLake , bevor Sie Daten in das Eventhouse laden. Diese Einstellung macht die aufgenommenen Daten in OneLake verfügbar, sodass Sie später im Lernprogramm auf dieselbe Tabelle aus einem Notizbuch zugreifen können.

Öffnen Sie in Ihrem Arbeitsbereich das Eventhouse, das Sie in den Voraussetzungen erstellt haben, und wählen Sie dann die Datenbank aus, in der Sie Ihre Daten speichern möchten.
Legen Sie im Bereich "Datenbankdetails " die Verfügbarkeit von OneLake auf "Ein" fest.

Teil 2: Aktivieren des KQL-Python-Plug-Ins

In diesem Schritt aktivieren Sie das Python Plugin in Ihrem Eventhouse. Dieser Schritt ist erforderlich, um den Python Code im KQL-Abfrageset in Teil 9 auszuführen: Vorhersagen von Anomalien in einem KQL-Abfrageset. Wählen Sie das Python-Image aus, das das Paket time-series-anomaly-detector enthält.

Wählen Sie im Eventhouse im Menüband Eventhouse>Plugins aus.
Legen Sie im Plug-In-BereichPython Spracherweiterung auf "Ein" fest.
Wählen Sie Python 3.11.7 DL aus.
Wählen Sie Fertig aus.

Teil 3: Erstellen einer Spark-Umgebung

In diesem Schritt erstellen Sie eine Spark-Umgebung zum Ausführen des Notizbuchs, das das multivariate Anomalieerkennungsmodell trainiert. Weitere Informationen finden Sie unter Erstellen und Verwalten von Umgebungen.

Wählen Sie in Ihrem Arbeitsbereich +Neues Element aus, und wählen Sie dann "Umgebung" aus.
Geben Sie MVAD_ENV den Namen der Umgebung ein, und wählen Sie dann "Erstellen" aus.
Wählen Sie unter Bibliotheken die Option Öffentliche Bibliotheken aus.
Wählen Sie Hinzufügen aus PyPI aus.
Geben Sie im Suchfeld time-series-anomaly-detectorein. Geben Sie im Feld Version0.3.9 ein.
Wählen Sie Speichern.
Wählen Sie in der Umgebung die Registerkarte Start.
Wählen Sie Veröffentlichen im Menüband aus.
Wählen Sie Alle veröffentlichen aus. Dieser Schritt kann mehrere Minuten dauern.

Teil 4: Laden von Daten in das Eventhouse

Zeigen Sie im Eventhouse auf die KQL-Datenbank, in der Sie Ihre Daten speichern möchten, und wählen Sie dann das Menü "Weitere" aus [...]>Abrufen von Daten>Lokale Datei.
Wählen Sie +Neue Tabelle aus, und geben Sie demo_stocks_change ihn als Tabellennamen ein.
Wählen Sie im Dialogfeld "Hochladen" die Option " Nach Dateien suchen" aus, und laden Sie die Beispieldatendatei hoch, die Sie in "Voraussetzungen" heruntergeladen haben.
Wählen Sie Weiter aus.
Überprüfen Sie im Abschnitt "Daten untersuchen", ob "Erste Zeile ist Spaltenüberschrift" auf "Ein" steht.
Wählen Sie Fertig stellen aus.
Wenn die Daten hochgeladen sind, wählen Sie Schließen.

Teil 5: Kopieren des OneLake-Pfads

Wählen Sie die Tabelle „demo_stocks_change“ aus. Wählen Sie im Bereich Tabellendetails den OrdnerOneLake aus, um den OneLake-Pfad in die Zwischenablage zu kopieren. Speichern Sie den Pfad in einem Text-Editor zur späteren Verwendung.

Screenshot des Kopierens des OneLake-Pfads.

Teil 6: Vorbereiten des Notizbuchs

Wählen Sie Ihren Arbeitsbereich aus.
Wählen Sie "Notizbuch>von diesem Computer>" aus.
Wählen Sie "Hochladen" und dann das Notizbuch aus, das Sie unter "Voraussetzungen" heruntergeladen haben.
Nachdem das Notebook hochgeladen wurde, können Sie es in Ihrem Arbeitsbereich suchen und öffnen.
Wählen Sie im oberen Menüband die Standardmäßige Dropdownliste "Arbeitsbereich" und dann die Umgebung aus, die Sie im vorherigen Schritt erstellt haben.

Teil 7: Notebook ausführen

Importieren Sie Standardpakete.
```
import numpy as np
import pandas as pd
```

Spark benötigt einen ABFSS-URI, um eine sichere Verbindung mit OneLake-Speicher herzustellen. Definieren Sie daher eine Hilfsfunktion, die den OneLake-URI in einen ABFSS-URI konvertiert.

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.")
    container_name = parts[1]
    path = '/'.join(parts[2:])
    abfss_uri = f"abfss://{container_name}@{parts[0]}/{path}"
    return abfss_uri

Ersetzen Sie OneLakeTableURI durch den OneLake-URI, den Sie in Teil 5: Kopieren des OneLake-Pfads kopiert haben, und laden Sie dann die Tabelle demo_stocks_change in einen pandas-DataFrame.

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()
df['Date'] = pd.to_datetime(df['Date'])
df = df.set_index('Date').sort_index()
print(df.shape)
df.head(3)

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

Hinweis

Die tatsächlichen Vorhersagen werden im Ereignishaus in Teil 9 ausgeführt: Vorhersagen von Anomalien in einem KQL-Abfrageset. In einem Produktionsszenario bewertet man in der Regel neue Streamingdaten. In diesem Lernprogramm wird das Dataset nach Datum in Schulungs- und Vorhersagebereiche aufgeteilt, um historische und eingehende Daten zu simulieren.
```
features_cols = ['AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY']
cutoff_date = pd.Timestamp('2023-01-01')
```
```
train_df = df.loc[df.index < cutoff_date, features_cols]
print(train_df.shape)
train_df.head(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')
```

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

from anomaly_detector import MultivariateAnomalyDetector
model = MultivariateAnomalyDetector()

sliding_window = 200
params = {"sliding_window": sliding_window}

model.fit(train_df, params=params)

model_name = "mvad_5_stocks_model"

import mlflow

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=model_name,
    )

Führen Sie die folgende Zelle aus, um den registrierten Modellpfad abzurufen, den Sie später für die Vorhersage im KQL-Python-Sandkasten verwenden.

from mlflow.tracking import MlflowClient

client = MlflowClient()
mvs = client.search_model_versions(f"name='{model_name}'")
latest = max(mvs, key=lambda v: v.creation_timestamp)
model_abfss = latest.source
print(model_abfss)

Kopieren Sie den Modell-URI aus der Ausgabe der letzten Zelle. Sie verwenden es in Teil 9.

Teil 8: Erstellen eines KQL-Abfragesets

Allgemeine Informationen finden Sie unter Erstellen eines KQL-Abfragesets.

Wählen Sie in Ihrem Arbeitsbereich +Neues Element>KQL Queryset aus.
Geben Sie MultivariateAnomalyDetectionTutorialdie Eingabetaste ein, und wählen Sie dann "Erstellen" aus.
Wählen Sie im OneLake-Katalogfenster die KQL-Datenbank aus, in der Sie die Daten gespeichert haben.
Wählen Sie Verbinden.

Teil 9: Vorhersagen von Anomalien in einem KQL-Abfrageset

Führen Sie die folgende .create-or-alter function Abfrage aus, um die predict_fabric_mvad_fl() gespeicherte 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
        work_dir = os.environ.get("UPLOAD_PATH")
        model_dir = work_dir + '/mvad_model'
        model_data_dir = model_dir + '/data'
        os.mkdir(model_dir)
        shutil.move(work_dir + '/MLmodel', model_dir)
        shutil.move(work_dir + '/conda.yaml', model_dir)
        shutil.move(work_dir + '/requirements.txt', model_dir)
        shutil.move(work_dir + '/python_env.yaml', model_dir)
        shutil.move(work_dir + '/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)
}

Führen Sie die folgende Vorhersageabfrage aus. Ersetzen Sie enter your model URI here durch die URI, die Sie am Ende von Teil 7: Ausführen des Notebooks kopiert haben.

Die Abfrage erkennt multivariate Anomalien in den fünf Aktien mithilfe des trainierten Modells und rendert dann die Ergebnisse als .anomalychart Die anomalen Punkte werden auf der ersten Aktie (AAPL) angezeigt, aber sie stellen Anomalien im gemeinsamen Verhalten aller fünf Aktien an einem bestimmten Datum dar.

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 changes in % with anomalies')

Das resultierende Anomaliediagramm ähnelt der folgenden Abbildung:

Bereinigen von Ressourcen

Wenn Sie das Lernprogramm abgeschlossen haben, löschen Sie die von Ihnen erstellten Ressourcen, um unnötige Kosten zu vermeiden:

Navigieren Sie zu Ihrer Arbeitsbereichs-Homepage.
Löschen Sie die in diesem Lernprogramm erstellte Umgebung.
Löschen Sie das Notebook, das Sie in diesem Tutorial erstellt haben.
Löschen Sie das Eventhouse oder die Datenbank, die in diesem Tutorial verwendet wurden.
Löschen Sie das in diesem Tutorial erstellte KQL-Queryset.

Feedback

War diese Seite hilfreich?

Last updated on 2026-06-18