Poikkeamien tunnistaminen monivariaatiolla

Tämä opas näyttää, miten koulutetaan monimuuttujaisten poikkeamien tunnistusmalli Fabric-muistikirjassa käyttämällä näytedataa, joka on tallennettu tapahtumahuoneeseen. Sitten käytät koulutettua mallia KQL-kyselyjoukossa pisteyttääksesi uutta dataa ja visualisoimaan poikkeavuuksia.

Taustatietoa löytyy osoitteesta Multivariate anomaly detection in Microsoft Fabric - overview.

Edellytykset

  • työtila, jossa on Microsoft Fabricia käyttävä -.
  • Ylläpitäjä-, avustaja- tai jäsenroolityötilassa. Tarvitset tämän käyttöoikeustason luodaksesi kohteita, kuten ympäristön.
  • Tapahtumatalo työtilassasi, jossa on tietokanta.
  • Näytedatatiedosto.
  • Näytevihko.

Osa 1: Käynnistä OneLaken saatavuus

Laita OneLaken saatavuus päälle ennen kuin lataat dataa tapahtumataloon. Tämä asetus tekee vastaanotetun datan saataville OneLakessa, jotta voit käyttää samaa taulukkoa muistikirjasta myöhemmin tutoriaalissa.

  1. Avaa työtilassasi tapahtumatalo, jonka loit ennakkovaatimuksissa, ja valitse sitten tietokanta, johon haluat tallentaa tietosi.

  2. Tietokannan yksityiskohdissa aseta OneLaken saatavuusarvoksiPäällä.

    Kuvakaappaus OneLaken saatavuuden sallimisesta tapahtumatalossasi.

Osa 2: Käynnistä KQL Python -lisäosa

Tässä vaiheessa käynnistät Python-lisäosan tapahtumahuoneessasi. Tämä vaihe vaaditaan Python-koodin ajamiseksi KQL-kyselyjoukossa osassa 9: Ennusta anomaliat KQL-kyselyjoukossa. Valitse Python-kuva, joka sisältää aikasarja-anomalia-ilmaisin-paketin.

  1. Tapahtumatalossa valitse nauhasta Eventhouse>Plugins .

  2. Plugins-paneelissa aseta Python-kielen laajennukseksiOn.

  3. Valitse Python 3.11.7 DL.

  4. Valitse Valmis.

    Kuvakaappaus, joka näyttää, miten Python 3.11.7 DL-paketti otetaan käyttöön tapahtumatalossa.

Osa 3: Luo Spark-ympäristö

Tässä vaiheessa luot Spark-ympäristön, joka ajaa muistikirjaa, joka kouluttaa monimuuttujaisten poikkeamien tunnistusmallia. Lisätietoja löytyy kohdasta Ympäristöjen luominen ja hallinta.

  1. Valitse työtilastasi + Uusi kohde ja sitten Ympäristö.

    Kuvakaappaus Ympäristö-laatasta Uuden esineen ikkunassa.

  2. Syötä MVAD_ENV ympäristön nimi ja valitse sitten Luo.

  3. Valitse Kirjastot-kohdasta Julkiset kirjastot.

  4. Valitse Lisää PyPI:stä.

  5. Hakukenttään kirjoita time-series-anomaly-detector. Versio-laatikkoon kirjoita .0.3.9

  6. Valitse Tallenna.

    Kuvakaappaus PyPI-paketin lisäämisestä Spark-ympäristöön.

  7. Valitse ympäristön Aloitus-välilehti .

  8. Valitse valintanauhasta Julkaise-kuvake .

  9. Valitse Julkaise kaikki. Tämän vaiheen suorittaminen voi kestää useita minuutteja.

    Näyttökuva ympäristön julkaisemisesta.

Osa 4: Lataa dataa tapahtumataloon

  1. Tapahtumatalossa vie hiiri KQL-tietokannan päälle, johon haluat tallentaa tietosi, ja valitse sitten Lisää valikko [...]>Hae dataa>Paikallinen tiedosto.

    Näyttökuva Nouda tiedot -kohdasta paikallisesta tiedostosta.

  2. Valitse + Uusi taulukko ja syötä demo_stocks_change taulun nimeksi.

  3. Latausvalikossa valitse Selaa tiedostoja ja lataa Prerequisites-tiedostosta lataamasi näytedatatiedosto.

  4. Valitse Seuraava.

  5. Tarkista datan tarkastelu-osiossa varmista, että ensimmäisen rivin sarakkeen otsikko on asetettu Päällä.

  6. Valitse Valmis.

  7. Kun tiedot ladataan, valitse Sulje.

Osa 5: Kopioi OneLake-polku

Valitse demo_stocks_change taulukko. Valitse Taulukon yksityiskohdistaOneLake-kansio kopioidaksesi OneLake-polun leikepöydällesi. Tallenna polku tekstieditoriin myöhempää käyttöä varten.

Näyttökuva OneLake-polun kopioimisesta.

Osa 6: Valmistele muistikirja

  1. Valitse työtilasi.

  2. Valitse Tuo>muistikirja>tältä tietokoneelta.

  3. Valitse Lataa ja lataamasi muistikirja Prerequisites-osiosta.

  4. Kun muistikirja on ladattu, voit etsiä ja avata muistikirjasi työtilastasi.

  5. Valitse yläreunalta Workspace-oletusvalikko ja valitse sitten edellisessä vaiheessa luomasi ympäristö.

    Näyttökuva ympäristön valitsemisesta muistikirjassa.

Osa 7: Suorita muistikirja

  1. Tuo vakiopaketit.

    import numpy as np
import pandas as pd

  2. Spark tarvitsee ABFSS URI:n yhdistääkseen turvallisesti OneLake-tallennustilaan, joten määrittele aputoiminto, joka muuntaa OneLake-URI:n ABFSS-URI:ksi.

    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. Korvaa OneLakeTableURI se OneLake-URI:lla, jonka kopioit osassa 5: Kopioi OneLake-polku ja lataa demo_stocks_change taulu pandas-dataframeen.

    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. Valmistele harjoitus- ja ennustetietokehykset suorittamalla seuraavat solut.

    Muistiinpano

    Varsinaiset ennusteet pyörivät tapahtumatalossa osassa 9: Ennusta poikkeamat KQL-kyselyjoukossa. Tuotantotilanteessa saat yleensä uutta suoratoistodataa. Tässä opetusohjelmassa aineisto jaetaan päivämäärän mukaan harjoitus- ja ennustealueisiin, jotta voidaan simuloida historiallista ja saapuvaa dataa.

    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. Aja solut kouluttamaan malli ja tallenna se Fabric MLflow -mallirekisteriin.

    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. Suorita seuraava solu saadaksesi rekisteröidyn mallipolun, jota käytät myöhemmin ennustamiseen KQL Python -hiekkalaatikossa.

    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. Kopioi mallin URI viimeisen solun ulostulosta. Käytät sitä osassa 9.

Osa 8: Luo KQL-kyselyjoukko

Yleisiä tietoja on kohdassa KQL-kyselyjoukon luominen.

  1. Valitse työtilassasi + Uusi kohde>KQL Queryset.
  2. Syötä MultivariateAnomalyDetectionTutorial, ja valitse sitten Luo.
  3. OneLake-katalogi-ikkunasta valitse KQL-tietokanta, johon tallennit tiedot.
  4. Valitse Yhdistä.

Osa 9: Anomalioiden ennustaminen KQL-kyselyjoukossa

  1. Suorita seuraava .create-or-alter function kysely määrittääksesi tallennettu predict_fabric_mvad_fl() funktio:

    .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. Suorita seuraava ennustuskysely. Korvaa enter your model URI here se URI:lla, jonka kopioit osan 7 lopussa: Aja muistikirja.

    Kysely havaitsee monimuuttujapoikkeamat viiden osakkeen välillä käyttämällä koulutettua mallia ja renderöi tulokset muodossa anomalychart. Anomaliat pisteet näkyvät ensimmäisellä varastolla (AAPL), mutta ne edustavat poikkeavuuksia kaikkien viiden varaston yhteisessä käyttäytymisessä tiettynä päivänä.

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

Tuloksena oleva poikkeamakartta muistuttaa seuraavaa kuvaa:

Kuvakaappaus monimuuttujaanomalian tuloksesta.

Resurssien puhdistaminen

Kun olet suorittanut tutoriaalin, poista luomasi resurssit välttääksesi tarpeettomat kustannukset:

  1. Siirry työtilan aloitussivulle.
  2. Poista tässä opetusohjelmassa luotu ympäristö.
  3. Poista tässä opetusohjelmassa luotu muistikirja.
  4. Poista tapahtumatalo tai tietokanta, jota käytettiin tässä opastusohjelmassa.
  5. Poista tässä opetusohjelmassa luotu KQL-kyselyjoukko.

Liittyvä sisältö

  • Last updated on