Delen via

Multivariate Anomaliedetectie

  • Artikel

Zie het overzicht van multivariate anomaliedetectie in Realtime Intelligence voor algemene informatie over multivariate anomaliedetectie in Microsoft Fabric. In deze zelfstudie gebruikt u voorbeeldgegevens om een multivariate anomaliedetectiemodel te trainen met behulp van de Spark-engine in een Python-notebook. Vervolgens voorspelt u afwijkingen door het getrainde model toe te passen op nieuwe gegevens met behulp van de Eventhouse-engine. Met de eerste paar stappen stelt u uw omgevingen in en met de volgende stappen traint u het model en voorspelt u afwijkingen.

Vereisten

Deel 1: Beschikbaarheid van OneLake inschakelen

De beschikbaarheid van OneLake moet zijn ingeschakeld voordat u gegevens in Eventhouse krijgt. Deze stap is belangrijk, omdat hiermee de gegevens die u opneemt, beschikbaar zijn in OneLake. In een latere stap opent u dezelfde gegevens uit uw Spark Notebook om het model te trainen.

  1. Blader naar de startpagina van uw werkruimte in Realtime Intelligence.

  2. Selecteer het Eventhouse dat u hebt gemaakt in de vereisten. Kies de database waarin u uw gegevens wilt opslaan.

  3. Selecteer in de tegel Databasedetails het potloodpictogram naast de beschikbaarheid van OneLake

  4. Schakel in het rechterdeelvenster de knop in op Actief.

  5. Selecteer Gereed.

    Schermopname van het inschakelen van oneLake-beschikbaarheid in uw Eventhouse.

Deel 2: KQL Python-invoegtoepassing inschakelen

In deze stap schakelt u de Python-invoegtoepassing in uw Eventhouse in. Deze stap is vereist om de Python-code voor afwijkingen voorspellen uit te voeren in de KQL-queryset. Het is belangrijk om het juiste pakket te kiezen dat het pakket time-series-anomaly-detector bevat.

  1. Selecteer uw database in het eventhouse-scherm en selecteer vervolgens Invoegtoepassingen beheren>op het lint.

  2. Schakel in het deelvenster Invoegtoepassingen de python-taalextensie in op Aan.

  3. Selecteer Python 3.11.7 DL (preview).

  4. Selecteer Gereed.

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

Deel 3: Een Spark-omgeving maken

In deze stap maakt u een Spark-omgeving om het Python-notebook uit te voeren waarmee het multivariate anomaliedetectiemodel wordt getraind met behulp van de Spark-engine. Zie Omgevingen maken en beheren voor meer informatie over het maken van omgevingen.

  1. Kies in de ervaringswisselaar Data-engineer ing. Als u al in de Data-engineer ervaring bent, gaat u naar Start.

  2. Van aanbevolen items die u wilt maken, omgevingen selecteren en de naam MVAD_ENV voor de omgeving invoeren.

    Schermopname van het maken van een omgeving in Data-engineer ing.

  3. Selecteer openbare bibliotheken onder Bibliotheken.

  4. Selecteer Toevoegen in PyPI.

  5. Voer in het zoekvak tijdreeks-anomaliedetector in. De versie wordt automatisch gevuld met de meest recente versie. Deze zelfstudie is gemaakt met versie 0.2.7. Dit is de versie die is opgenomen in de Kusto Python 3.11.7 DL.

  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 ophalen in eventhouse

  1. Beweeg de muisaanwijzer over de KQL-database waar u uw gegevens wilt opslaan. Selecteer het menu Meer [...]>>Gegevens lokaal bestand ophalen.

    Schermopname van het ophalen van gegevens uit een lokaal bestand.

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

  3. Selecteer Bladeren naar bestanden in het dialoogvenster Gegevens uploaden en upload het voorbeeldgegevensbestand dat is gedownload in de vereisten

  4. Selecteer Volgende.

  5. Schakel in de sectie Gegevens controleren de kolomkop Eerste rij in op Aan.

  6. Selecteer Voltooien.

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

Deel 5: OneLake-pad naar de tabel kopiëren

Zorg ervoor dat u de demo_stocks_change tabel selecteert. Selecteer in de tegel Tabeldetails het pad kopiëren om het OneLake-pad naar het Klembord te kopiëren. Sla deze gekopieerde tekst op in een teksteditor die in een latere stap moet worden gebruikt.

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

Deel 6: Het notitieblok voorbereiden

  1. Kies in de ervaringswisselaar ontwikkelen en selecteer uw werkruimte.

  2. Selecteer Importeren, Notitieblok en vervolgens vanaf deze computer.

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

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

  5. Selecteer in het bovenste lint de standaard vervolgkeuzelijst Werkruimte en selecteer 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. In de volgende stap wordt deze functie gedefinieerd om de OneLake-URI te converteren naar de 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.")
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. Voer uw OneLake-URI in die u hebt gekopieerd uit deel 5: Kopieer het OneLake-pad naar de tabel om demo_stocks_change tabel in een pandas-dataframe te 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. Voer de volgende cellen uit om de trainings- en voorspellingsgegevensframes voor te bereiden.

    Notitie

    De werkelijke voorspellingen worden uitgevoerd op gegevens door eventhouse in deel 9: Predict-anomalies-in-the-kql-queryset. Als u in een productiescenario gegevens naar het eventhouse streamt, worden de voorspellingen gedaan op de nieuwe streaminggegevens. Voor de zelfstudie is de gegevensset gesplitst op datum in twee secties voor training en voorspelling. Dit is om historische gegevens en nieuwe streaminggegevens te simuleren.

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

    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. Kopieer de model-URI uit de laatste celuitvoer. U gebruikt dit in een latere volgende stap.

Deel 8: Uw KQL-queryset instellen

Zie Een KQL-queryset maken voor algemene informatie.

  1. Kies real-time intelligence in de ervaringswisselaar.
  2. Selecteer uw werkruimte.
  3. Selecteer +Nieuw item>KQL-queryset. Voer de naam MultivariateAnomalyDetectionTutorial in.
  4. Selecteer Maken.
  5. Selecteer in het venster van de OneLake-gegevenshub de KQL-database waarin u de gegevens hebt opgeslagen.
  6. Selecteer Verbinding maken.

Deel 9: Afwijkingen voorspellen in de KQL-queryset

  1. Kopieer/plak en voer de volgende query '.create-or-alter function' 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
        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. Kopieer/plak de volgende voorspellingsquery.

    1. Vervang de URI van het uitvoermodel die in stap 7 is gekopieerd.
    2. Voer de query uit. Het detecteert multivariate afwijkingen op de vijf voorraden, op basis van het getrainde model, en geeft de resultaten weer als anomalychart. De afwijkende punten worden weergegeven op het eerste aandeel (AAPL), hoewel ze multivariate anomalieën vertegenwoordigen (met andere woorden, afwijkingen van de gezamenlijke wijzigingen van de vijf voorraden op de specifieke 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')

Het resulterende anomaliediagram moet eruitzien als de volgende afbeelding:

Schermopname van multivariate anomalie-uitvoer.

Resources opschonen

Wanneer u klaar bent met de zelfstudie, kunt u de resources verwijderen die u hebt gemaakt om andere kosten te voorkomen. Voer de volgende stappen uit om de resources te verwijderen:

  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 de Eventhouse- of database die in deze zelfstudie wordt gebruikt.
  5. Verwijder de KQL-queryset die in deze zelfstudie is gemaakt.