Multivariat avviksregistrering

Denne veiledningen viser deg hvordan du trener en multivariat anomalideteksjonsmodell i en Fabric-notebook ved å bruke eksempeldata lagret i et eventhouse. Deretter bruker du den trente modellen i et KQL-spørringssett for å score nye data og visualisere anomalier.

For bakgrunnsinformasjon, se Multivariate anomalideteksjon i Microsoft Fabric – oversikt.

Forutsetning

Del 1: Slå på tilgjengeligheten av OneLake

Slå på OneLake-tilgjengelighet før du laster inn data i eventhuset. Denne innstillingen gjør de innsamlede dataene tilgjengelige i OneLake slik at du kan få tilgang til den samme tabellen fra en notatbok senere i veiledningen.

  1. I arbeidsområdet ditt, åpne eventhouse-programmet du opprettet i forutsetningene, og velg deretter databasen hvor du vil lagre dataene dine.

  2. I panelet for databasedetaljer , sett OneLake-tilgjengelighet til På.

    Skjermbilde av aktivering av OneLake-tilgjengelighet i eventhuset ditt.

Del 2: Slå på KQL Python-pluginen

I dette steget slår du på Python-pluginen i eventhuset ditt. Dette steget kreves for å kjøre Python-koden i KQL-spørringssettet i del 9: Forutsi anomalier i et KQL-spørringssett. Velg Python-bildet som inkluderer time-series-anomaly-detector-pakken.

  1. I eventhouse, velg Eventhouse>Plugins på båndet.

  2. I Plugins-panelet, sett Python-språkutvidelsen til På.

  3. Velg Python 3.11.7 DL.

  4. Velg Ferdig.

    Skjermbilde som viser hvordan man aktiverer Python 3.11.7 DL-pakken i eventhouse.

Del 3: Skap et Spark-miljø

I dette steget lager du et Spark-miljø for å kjøre notatboken som trener multivariate anomali-deteksjonsmodellen. For mer informasjon, se Opprett og administrer miljøer.

  1. Fra arbeidsområdet ditt, velg + Nytt element, og velg deretter Miljø.

    Skjermbilde av miljøflisen i vinduet Nytt element.

  2. Skriv inn MVAD_ENV for miljønavnet, og velg deretter Opprett.

  3. Velg Folkebiblioteker under Biblioteker.

  4. Velg Legg til fra PyPI.

  5. I søkefeltet, skriv time-series-anomaly-detectorinn . I versjonsboksen, skriv inn .0.3.9

  6. Velg Lagre.

    Skjermbilde av å legge til PyPI-pakken i Spark-miljøet.

  7. Velg Hjem-fanen i miljøet.

  8. Velg Publiser-ikonet på båndet.

  9. Velg Publiser alle. Dette trinnet kan ta flere minutter å fullføre.

    Skjermbilde av publisering av miljøet.

Del 4: Last inn data i eventhuset

  1. I eventhouse, hold musepekeren over KQL-databasen der du vil lagre dataene dine, og velg deretter Mer meny [...]>Hent data>Lokal fil.

    Skjermbilde av hent data fra lokal fil.

  2. Velg + Ny tabell, og skriv demo_stocks_change inn som tabellnavn.

  3. I opplastingsdialogen velger du Bla etter filer, og last opp eksempeldatafilen du lastet ned i Prerequisites.

  4. Velg Neste.

  5. Kontroller at Første rad er kolonneoverskrift er satt til Påi delen Undersøk dataene .

  6. Velg Fullfør.

  7. Når dataene lastes opp, velger du Lukk.

Del 5: Kopier OneLake-stien

Velg demo_stocks_change tabellen. Velg OneLake-mappen for å kopiere OneLake-banen til utklippstavlen i Tabelldetaljer-ruten. Lagre stien i en teksteditor for senere bruk.

Skjermbilde av kopiering av OneLake-banen.

Del 6: Gjør klar notatboken

  1. Velg arbeidsområdet.

  2. Velg Importer>notatbok>fra denne datamaskinen.

  3. Velg Last opp, og velg notatboken du lastet ned i Prerequisites.

  4. Når notatblokken er lastet opp, kan du finne og åpne notatblokken fra arbeidsområdet.

  5. På øverste bånd velger du nedtrekkslisten for standard arbeidsområde , og deretter miljøet du opprettet i forrige steg.

    Skjermbilde av å velge miljøet i notatblokken.

Del 7: Kjør notatboken

  1. Importer standardpakker.

    import numpy as np
import pandas as pd

  2. Spark trenger en ABFSS-URI for å koble sikkert til OneLake-lagring, så definer en hjelpefunksjon som konverterer OneLake-URI-en til 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. Erstatt OneLakeTableURI ut med OneLake-URI-en du kopierte i del 5: Kopier OneLake-stien, og last demo_stocks_change deretter tabellen inn i en pandas-dataramme.

    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. Kjør følgende celler for å klargjøre datarammene for opplæring og prognoser.

    Merk

    De faktiske prediksjonene kjøres i eventhuset i del 9: Forutsi anomalier i et KQL-spørringssett. I et produksjonsscenario scorer du vanligvis nye strømmedata. I denne veiledningen deles datasettet opp etter dato i trenings- og prediksjonsområder for å simulere historiske og innkommende 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. Kjør cellene for å trene modellen og lagre den i Fabric MLflow-modellregisteret.

    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. Kjør følgende celle for å få den registrerte modellstien som du senere bruker for prediksjon i 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. Kopier modell-URI-en fra utgangen i forrige celle. Du bruker det i del 9.

Del 8: Opprett et KQL-spørringssett

Hvis du vil ha generell informasjon, kan du se Opprette et KQL-spørringssett.

  1. I arbeidsområdet ditt, velg + Nytt element>KQL Queryset.
  2. Skriv inn MultivariateAnomalyDetectionTutorial, og velg deretter Opprette.
  3. I OneLake-katalogvinduet , velg KQL-databasen der du lagret dataene.
  4. Velg Koble til.

Del 9: Forutsi avvik i et KQL-spørringssett

  1. Kjør følgende .create-or-alter function spørring for å definere den predict_fabric_mvad_fl() lagrede funksjonen:

    .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. Kjør følgende prediksjonsspørring. Erstatt enter your model URI here med URI-en du kopierte på slutten av del 7: Kjør notatboken.

    Spørringen oppdager multivariate anomalier på tvers av de fem aksjene ved å bruke den trente modellen, og gjengir deretter resultatene som en anomalychart. De anomale punktene vises på den første stokken (AAPL), men de representerer anomalier i felles oppførsel for alle fem stokkene på en gitt dato.

    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 resulterende anomalidiagrammet ligner følgende bilde:

Skjermbilde av multivariate avviksutdata.

Fjerning av ressurser

Når du er ferdig med opplæringen, slett ressursene du har laget for å unngå unødvendige kostnader:

  1. Bla til hjemmesiden for arbeidsområdet.
  2. Slett miljøet som er opprettet i denne opplæringen.
  3. Slett notatblokken som er opprettet i denne opplæringen.
  4. Slett eventhuset eller databasen som ble brukt i denne veiledningen.
  5. Slett KQL-spørringssettet som er opprettet i denne opplæringen.

Relatert innhold

  • Last updated on