Multidimensionale anomaliedetectie

In deze zelfstudie leert u hoe u een multivariate anomaliedetectiemodel traint in een Fabric notebook met behulp van voorbeeldgegevens die zijn opgeslagen in een eventhouse. Vervolgens gebruikt u het getrainde model in een KQL-queryset om nieuwe gegevens te scoren en afwijkingen te visualiseren.

Zie Overzicht van multivariate anomaliedetectie in Microsoft Fabric voor achtergrondinformatie.

Prerequisites

Deel 1: Beschikbaarheid van OneLake inschakelen

Schakel OneLake-beschikbaarheid in voordat u gegevens in het eventhouse laadt. Met deze instelling zijn de opgenomen gegevens beschikbaar in OneLake, zodat u later in de zelfstudie toegang hebt tot dezelfde tabel vanuit een notebook.

  1. Open in uw werkruimte het eventhouse dat u hebt gemaakt in de vereisten en selecteer vervolgens de database waarin u uw gegevens wilt opslaan.

  2. Stel in het deelvenster Databasegegevensde beschikbaarheid van OneLake in op Aan.

    Schermopname van het inschakelen van de beschikbaarheid van OneLake in uw eventhouse.

Deel 2: De KQL-Python-invoegtoepassing inschakelen

In deze stap schakelt u de Python-invoegtoepassing in uw eventhouse in. Deze stap is vereist om de Python code uit te voeren in de KQL-queryset in deel 9: Afwijkingen voorspellen in een KQL-queryset. Selecteer de Python afbeelding die het pakket time-series-anomaly-detector bevat.

  1. Selecteer in het eventhouse Eventhouse>Invoegtoepassingen op het lint.

  2. Stel in het deelvenster InvoegtoepassingenPython taalextensie in op Aan.

  3. Selecteer Python 3.11.7 DL.

  4. Kies Gereed.

    Schermopname van het inschakelen van het Python 3.11.7 DL-pakket in het eventhouse.

Deel 3: Een Spark-omgeving maken

In deze stap maakt u een Spark-omgeving om het notebook uit te voeren waarmee het multivariate anomaliedetectiemodel wordt getraind. Zie Omgevingen maken en beheren voor meer informatie.

  1. Selecteer + Nieuw item in uw werkruimte en selecteer vervolgens Omgeving.

    Schermopname van de tegel Omgeving in het venster Nieuw item.

  2. Voer MVAD_ENV in voor de naam van de omgeving en selecteer vervolgens Maken.

  3. Selecteer openbare bibliotheken onder Bibliotheken.

  4. Selecteer Toevoegen in PyPI.

  5. Typ time-series-anomaly-detector in het zoekvak. Voer in het vak Versie de tekst in 0.3.9.

  6. Selecteer Opslaan.

    schermopname van het toevoegen van het PyPI-pakket aan de Spark-omgeving.

  7. Selecteer het tabblad Start in de omgeving.

  8. Selecteer het pictogram Publiceren op het lint.

  9. Selecteer Alles publiceren. Het kan enkele minuten duren voordat deze stap is voltooid.

    Schermopname van het publiceren van de omgeving.

Deel 4: Gegevens in het eventhouse laden

  1. Beweeg in het eventhouse de aanwijzer over de KQL-database waar u uw gegevens wilt opslaan en selecteer vervolgens Meer menu [...]>Gegevens ophalen>Lokaal bestand.

    Schermopname van het ophalen van gegevens uit een lokaal bestand.

  2. Selecteer + Nieuwe tabel en voer de tabelnaam in demo_stocks_change .

  3. Selecteer Bladeren naar bestanden in het dialoogvenster Uploaden en upload het voorbeeldgegevensbestand dat u hebt gedownload in Vereisten.

  4. Klik op Volgende.

  5. Controleer in de sectie De gegevens inspecteren of Eerste rij is kolomkop is ingesteld op Aan.

  6. Selecteer en voltooi.

  7. Wanneer de gegevens worden geüpload, selecteert u Sluiten.

Deel 5: Het OneLake-pad kopiëren

Selecteer de demo_stocks_change tabel. Selecteer in het deelvenster Tabeldetailsde map OneLake om het OneLake-pad naar het Klembord te kopiëren. Sla het pad op in een teksteditor voor later gebruik.

Schermopname van het kopiëren van het OneLake-pad.

Deel 6: Het notitieblok voorbereiden

  1. Selecteer uw werkruimte.

  2. Selecteer Importeren>Notebook>vanaf deze computer.

  3. Selecteer Uploaden en kies het notitieblok dat u hebt gedownload in Vereisten.

  4. Nadat het notitieblok is geüpload, kunt u uw notitieblok zoeken en openen vanuit uw werkruimte.

  5. Selecteer op het bovenste lint de standaard vervolgkeuzelijst Werkruimte en selecteer vervolgens de omgeving die u in de vorige stap hebt gemaakt.

    Schermopname van het selecteren van de omgeving in het notebook.

Deel 7: Het notebook uitvoeren

  1. Standaardpakketten importeren.

    import numpy as np
import pandas as pd

  2. Spark heeft een ABFSS-URI nodig om veilig verbinding te maken met OneLake-opslag. Definieer daarom een helperfunctie waarmee de OneLake-URI wordt geconverteerd naar een 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. Vervang OneLakeTableURI door de OneLake-URI die u hebt gekopieerd in deel 5: Kopieer het OneLake-pad en laad de demo_stocks_change tabel in een 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)

  4. Voer de volgende cellen uit om de trainings- en voorspellingsdataframes voor te bereiden.

    Notitie

    De werkelijke voorspellingen worden uitgevoerd in het eventhouse in Deel 9: Anomalieën voorspellen in een KQL-queryset. In een productiescenario past u doorgaans een score toe op nieuwe streaminggegevens. In deze tutorial wordt de gegevensset op basis van datum opgesplitst in trainings- en voorspellingsperioden om historische en binnenkomende gegevens te simuleren.

    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. Voer de cellen uit om het model te trainen en op te slaan in het Fabric MLflow-modelregister.

    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. Voer de volgende cel uit om het geregistreerde modelpad op te halen dat u later gebruikt voor voorspelling in de KQL-Python sandbox.

    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. Kopieer de model-URI uit de uitvoer van de laatste cel. U gebruikt het in deel 9.

Deel 8: Een KQL-queryset maken

Zie Een KQL-queryset maken voor algemene informatie.

  1. Selecteer + Nieuw item>KQL Queryset in uw werkruimte.
  2. Voer MultivariateAnomalyDetectionTutorial in en selecteer vervolgens Maken.
  3. Selecteer in het oneLake-catalogusvenster de KQL-database waarin u de gegevens hebt opgeslagen.
  4. Selecteer Verbinding maken.

Deel 9: Afwijkingen voorspellen in een KQL-queryset

  1. Voer de volgende .create-or-alter function query uit om de predict_fabric_mvad_fl() opgeslagen functie te definiëren:

    .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. Voer de volgende voorspellingsquery uit. Vervang enter your model URI here door de URI die u aan het einde van Deel 7: Het notebook uitvoeren hebt gekopieerd.

    De query detecteert afwijkingen met meerdere variabelen voor de vijf aandelen met behulp van het getrainde model en geeft vervolgens de resultaten weer als een anomalychart. De afwijkende punten worden weergegeven op het eerste aandeel (AAPL), maar ze vertegenwoordigen afwijkingen in het gezamenlijke gedrag van alle vijf de voorraden op een bepaalde 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')

Het resulterende anomaliediagram lijkt op de volgende afbeelding:

Schermopname van multivariate anomalie-uitvoer.

Hulpmiddelen opschonen

Wanneer u klaar bent met de zelfstudie, verwijdert u de resources die u hebt gemaakt om onnodige kosten te voorkomen:

  1. Blader naar de startpagina van uw werkruimte.
  2. Verwijder de omgeving die u in deze zelfstudie hebt gemaakt.
  3. Verwijder het notitieblok dat u in deze zelfstudie hebt gemaakt.
  4. Verwijder het eventhouse of de database die in deze tutorial is gebruikt.
  5. Verwijder de KQL-queryset die in deze handleiding is gemaakt.

Verwante inhoud

  • Last updated on