Dela via

Multivariatavvikelseidentifiering

  • Artikel

Allmän information om multivariatavvikelseidentifiering i realtidsinformation finns i Multivariate anomaly detection in Microsoft Fabric – overview (Multivariate anomaly detection in Microsoft Fabric – overview). I den här självstudien använder du exempeldata för att träna en modell för avvikelseidentifiering med flera avvikelseidentifieringar med Spark-motorn i en Python-notebook-fil. Sedan förutsäger du avvikelser genom att tillämpa den tränade modellen på nya data med hjälp av Eventhouse-motorn. De första stegen konfigurerar dina miljöer och följande steg tränar modellen och förutsäger avvikelser.

Förutsättningar

  • En arbetsyta med en Microsoft Fabric-aktiverad kapacitet
  • Rollen administratör, deltagare eller medlem i arbetsytan. Den här behörighetsnivån krävs för att skapa objekt som en miljö.
  • Ett eventhouse på din arbetsyta med en databas.
  • Ladda ned exempeldata från GitHub-lagringsplatsen
  • Ladda ned anteckningsboken från GitHub-lagringsplatsen

Del 1 – Aktivera OneLake-tillgänglighet

OneLake-tillgänglighet måste vara aktiverat innan du hämtar data i Eventhouse. Det här steget är viktigt eftersom det gör att de data du matar in blir tillgängliga i OneLake. I ett senare steg får du åtkomst till samma data från din Spark Notebook för att träna modellen.

  1. Bläddra till arbetsytans startsida i Realtidsinformation.

  2. Välj det Eventhouse som du skapade i förhandskraven. Välj den databas där du vill lagra dina data.

  3. I panelen Databasinformation väljer du pennikonen bredvid OneLake-tillgänglighet

  4. Växla knappen till Aktiv i den högra rutan.

  5. Välj Klar.

    Skärmbild av aktivering av OneLake-tillgänglighet i ditt Eventhouse.

Del 2 – Aktivera KQL Python-plugin-program

I det här steget aktiverar du python-plugin-programmet i Eventhouse. Det här steget krävs för att köra Python-koden predict anomalies i KQL-frågeuppsättningen. Det är viktigt att välja rätt paket som innehåller paketet time-series-anomaly-detector .

  1. På skärmen Eventhouse väljer du din databas och sedan Hantera>plugin-program i menyfliksområdet..

  2. I fönstret Plugin-program växlar du Python-språktillägget till På.

  3. Välj Python 3.11.7 DL (förhandsversion).

  4. Välj Klar.

    Skärmbild för hur du aktiverar Python-paket 3.11.7 DL i Eventhouse.

Del 3 – Skapa en Spark-miljö

I det här steget skapar du en Spark-miljö för att köra Python-notebook-filen som tränar modellen för multivariatavvikelseidentifiering med Spark-motorn. Mer information om hur du skapar miljöer finns i Skapa och hantera miljöer.

  1. I upplevelseväxlaren väljer du Dataingenjör ing. Om du redan befinner dig i Dataingenjör funktionen bläddrar du till Start.

  2. Från Rekommenderade objekt för att skapa väljer du Miljöer och anger namnet MVAD_ENV för miljön.

    Skärmbild av hur du skapar en miljö i Dataingenjör ing.

  3. Under Bibliotek väljer du Offentliga bibliotek.

  4. Välj Lägg till från PyPI.

  5. I sökrutan anger du time-series-anomaly-detector. Versionen fylls automatiskt i med den senaste versionen. Den här självstudien skapades med version 0.2.7, som är den version som ingår i Kusto Python 3.11.7 DL.

  6. Välj Spara.

    Skärmbild av hur du lägger till PyPI-paketet i Spark-miljön.

  7. Välj fliken Start i miljön.

  8. Välj ikonen Publicera i menyfliksområdet.

  9. Markera Publicera alla. Det här steget kan ta flera minuter att slutföra.

    Skärmbild av publicering av miljön.

Del 4 – Hämta data till Eventhouse

  1. Hovra över den KQL-databas där du vill lagra dina data. Välj menyn Mer [...]>Hämta data>Lokal fil.

    Skärmbild av hämta data från en lokal fil.

  2. Välj + Ny tabell och ange demo_stocks_change som tabellnamn.

  3. I dialogrutan ladda upp data väljer du Bläddra efter filer och laddar upp exempeldatafilen som laddades ned i förutsättningar

  4. Välj Nästa.

  5. I avsnittet Inspektera data växlar du Första raden är kolumnrubrik till På.

  6. Välj Slutför.

  7. När data laddas upp väljer du Stäng.

Del 5 – Kopiera OneLake-sökväg till tabellen

Kontrollera att du väljer tabellen demo_stocks_change . I panelen Tabellinformation väljer du Kopiera sökväg för att kopiera OneLake-sökvägen till Urklipp. Spara den kopierade texten i en textredigerare någonstans som ska användas i ett senare steg.

Skärmbild av kopiering av OneLake-sökvägen.

Del 6 – Förbereda anteckningsboken

  1. I upplevelseväxlaren väljer du Utveckla och väljer din arbetsyta.

  2. Välj Importera, Notebook och sedan Från den här datorn.

  3. Välj Ladda upp och välj den notebook-fil som du laddade ned i förutsättningarna.

  4. När anteckningsboken har laddats upp kan du hitta och öppna anteckningsboken från arbetsytan.

  5. I det övre menyfliksområdet väljer du listrutan Arbetsyta som standard och väljer den miljö som du skapade i föregående steg.

    Skärmbild av att välja miljön i notebook-filen.

Del 7 – Kör notebook-filen

  1. Importera standardpaket.

    import numpy as np
import pandas as pd

  2. Spark behöver en ABFSS-URI för att ansluta säkert till OneLake-lagring, så nästa steg definierar den här funktionen för att konvertera OneLake-URI:n till ABFSS-URI:n.

    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. Ange din OneLake-URI som kopierats från del 5 – Kopiera OneLake-sökvägen till tabellen för att läsa in demo_stocks_change tabell i en Pandas-dataram.

    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. Kör följande celler för att förbereda dataramarna för träning och förutsägelse.

    Kommentar

    De faktiska förutsägelserna körs på data av Eventhouse i del 9– Predict-anomalies-in-the-kql-queryset. I ett produktionsscenario, om du strömmade data till händelsehuset, skulle förutsägelserna göras på nya strömmande data. I självstudien har datamängden delats upp efter datum i två avsnitt för träning och förutsägelse. Detta är för att simulera historiska data och nya strömmande data.

    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. Kör cellerna för att träna modellen och spara den i fabric MLflow-modellregistret.

    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. Kopiera modell-URI:n från den senaste cellens utdata. Du använder detta i ett senare nästa steg.

Del 8 – Konfigurera din KQL-frågeuppsättning

Allmän information finns i Skapa en KQL-frågeuppsättning.

  1. I upplevelseväxlaren väljer du Realtidsinformation.
  2. Välj din arbetsyta.
  3. Välj +Nytt objekt>KQL-frågeuppsättning. Ange namnet MultivariateAnomalyDetectionTutorial.
  4. Välj Skapa.
  5. I fönstret OneLake-datahubben väljer du den KQL-databas där du lagrade data.
  6. Välj Anslut.

Del 9 – Förutsäga avvikelser i KQL-frågeuppsättningen

  1. Kopiera/klistra in och kör följande ".create-or-alter-funktion"-fråga för att definiera den predict_fabric_mvad_fl() lagrade funktionen:

    .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. Kopiera/klistra in följande förutsägelsefråga.

    1. Ersätt utdatamodellens URI som kopierats i slutet av steg 7.
    2. Köra frågan. Den identifierar multivarierade avvikelser på de fem lagren, baserat på den tränade modellen, och renderar resultatet som anomalychart. De avvikande punkterna återges på det första beståndet (AAPL), även om de representerar avvikelser med flera avvikelser (med andra ord avvikelser i de gemensamma ändringarna av de fem lagren under det specifika datumet).
    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')

Det resulterande avvikelsediagrammet bör se ut som följande bild:

Skärmbild av multivariatavvikelseutdata.

Rensa resurser

När du är klar med självstudien kan du ta bort resurserna, som du har skapat för att undvika andra kostnader. Följ dessa steg för att ta bort resurserna:

  1. Bläddra till arbetsytans startsida.
  2. Ta bort miljön som skapades i den här självstudien.
  3. Ta bort anteckningsboken som skapades i den här självstudien.
  4. Ta bort händelsehuset eller databasen som används i den här självstudien.
  5. Ta bort KQL-frågeuppsättningen som skapades i den här självstudien.