Multivariat avvikelseidentifiering

Den här självstudien visar hur du tränar en modell för multivariatavvikelseidentifiering i en Fabric notebook-fil med hjälp av exempeldata som lagras i ett händelsehus. Sedan använder du den tränade modellen i en KQL-frågeuppsättning för att poängsätta nya data och visualisera avvikelser.

Bakgrundsinformation finns i Multivariat avvikelseidentifiering i Microsoft Fabric – översikt.

Förutsättningar

Del 1: Aktivera OneLake-tillgänglighet

Aktivera OneLake-tillgänglighet innan du läser in data i händelsehuset. Den här inställningen gör inmatade data tillgängliga i OneLake så att du kan komma åt samma tabell från en notebook-fil senare i självstudien.

  1. På din arbetsyta öppnar du det händelsehus som du skapade i förhandskraven och väljer sedan den databas där du vill lagra dina data.

  2. I fönstret Databasinformation anger du OneLake-tillgänglighet till På.

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

Del 2: Aktivera KQL-Python plugin-programmet

I det här steget aktiverar du plugin-programmet Python i händelsehuset. Det här steget krävs för att köra Python koden i KQL-frågeuppsättningen i del 9: Förutsäga avvikelser i en KQL-frågeuppsättning. Välj den Python bild som innehåller paketet time-series-anomaly-detector.

  1. I Eventhouse väljer du Eventhouse>Plugins på menyfliksområdet.

  2. I panelen Insticksprogram ställer du in språktillägget Python på På.

  3. Välj Python 3.11.7 DL.

  4. Välj Klar.

    Skärmbild som visar hur du aktiverar Python 3.11.7 DL-paketet i händelsehuset.

Del 3: Skapa en Spark-miljö

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

  1. Välj + Nytt objekt på arbetsytan och välj sedan Miljö.

    Skärmbild av miljöpanelen i fönstret Nytt objekt.

  2. Ange MVAD_ENV som miljönamn och välj sedan Skapa.

  3. Under Bibliotek väljer du Offentliga bibliotek.

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

  5. Skriv time-series-anomaly-detector i sökrutan. I rutan Version anger du 0.3.9.

  6. Välj Spara.

    Skärmbild av att lägga 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 miljöpublicering.

Del 4: Läsa in data i händelsehuset

  1. Hovra över KQL-databasen i händelsehuset där du vill lagra dina data och välj sedan 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 uppladdningsdialogrutan väljer du Bläddra efter filer och laddar upp exempeldatafilen som du laddade ned i Krav.

  4. Välj Nästa.

  5. I avsnittet Inspektera data säkerställer du att Första raden är kolumnrubrik är inställt på På.

  6. Välj Slutför.

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

Del 5: Kopiera OneLake-sökvägen

Välj tabellen demo_stocks_change . I fönstret Tabellinformation väljer du OneLake-mapp för att kopiera OneLake-sökvägen till urklipp. Spara sökvägen i en textredigerare för senare användning.

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

Del 6: Förbered anteckningsboken

  1. Välj din arbetsyta.

  2. Välj Importera>anteckningsbok>från den här datorn.

  3. Välj Ladda upp och välj den anteckningsbok som du laddade ned i Förutsättningar.

  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 sedan den miljö som du skapade i föregående steg.

    Skärmbild av valet av miljö i anteckningsboken.

Del 7: Kör anteckningsboken

  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 Storage, så definiera en hjälpfunktion som konverterar OneLake-URI:n till en ABFSS-URI.

    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

  3. Ersätt OneLakeTableURI med OneLake-URI:n som du kopierade i del 5: Kopiera OneLake-sökvägen och läs sedan in demo_stocks_change tabellen 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()
df['Date'] = pd.to_datetime(df['Date'])
df = df.set_index('Date').sort_index()
print(df.shape)
df.head(3)

  4. Kör följande celler för att förbereda dataramarna för träning och förutsägelse.

    Anteckning

    De faktiska förutsägelserna körs i Eventhouse i Del 9: Förutsäg avvikelser i en KQL-fråga. I ett produktionsscenario får du vanligtvis nya strömmande data. I den här handledningen delas datamängden upp efter datum i intervall för träning och prediktion för att simulera historiska och nya data.

    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')

  5. Kör cellerna för att träna modellen och spara den i Fabric MLflow-modellregistret.

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

  6. Kör följande cell för att hämta sökvägen till den registrerade modellen som du senare använder för prediktion i KQL-Python-sandboxen.

    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)

  7. Kopiera modellens URI från utdata i den sista cellen. Du använder den i del 9.

Del 8: Skapa en KQL-frågeuppsättning

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

  1. På din arbetsyta väljer du + Nytt objekt>KQL-frågeuppsättning.
  2. Ange MultivariateAnomalyDetectionTutorialoch välj sedan Skapa.
  3. I fönstret OneLake-katalog väljer du den KQL-databas där du lagrade data.
  4. Välj Anslut.

Del 9: Förutsäga avvikelser i en KQL-frågeuppsättning

  1. Kör följande .create-or-alter function 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
        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)
}

  2. Kör följande förutsägelsefråga. Ersätt enter your model URI here med den URI som du kopierade i slutet av del 7: Kör notebook-filen.

    Frågan identifierar multivarierade avvikelser mellan de fem lagren med hjälp av den tränade modellen och renderar sedan resultatet som en anomalychart. De avvikande punkterna visas på den första aktien (AAPL), men de representerar avvikelser i det gemensamma beteendet för alla fem aktierna vid ett visst 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 changes in % with anomalies')

Det resulterande avvikelsediagrammet liknar följande bild:

Skärmbild av multivariatavvikelseutdata.

Rensa resurser

När du är klar med självstudien tar du bort de resurser som du skapade för att undvika onödiga kostnader:

  1. Gå till arbetsytans startsida.
  2. Ta bort miljön som skapades i den här handledningen.
  3. Ta bort anteckningsboken som skapades i denna handledning.
  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 handledningen.

Relaterat innehåll

  • Last updated on