Partager via

Détection d’anomalie multivariée

  • Article

Pour obtenir des informations générales sur la détection d’anomalies multivariées dans Real-Time Intelligence, consultez La détection d'anomalie multivariée dans Microsoft Fabric - Vue d'ensemble. Dans ce tutoriel, vous allez utiliser des exemples de données pour entraîner un modèle de détection d’anomalie multivariée à l’aide du moteur Spark dans un notebook Python. Vous prédirez ensuite les anomalies en appliquant le modèle entraîné aux nouvelles données à l’aide du moteur Eventhouse. Les premières étapes configurent vos environnements et les étapes suivantes entraînent le modèle et prédisent les anomalies.

Prérequis

  • Un espace de travail avec une capacité compatible Microsoft Fabric
  • Un rôle Administrateur, Contributeur, ou Membre dans un espace de travail. Ce niveau d’autorisation est nécessaire pour créer des éléments tels qu’un environnement.
  • Un eventhouse dans votre espace de travail avec une base de données.
  • Téléchargez l’exemple de données à partir du référentiel GitHub
  • Téléchargez le notebook à partir du référentiel GitHub

Partie 1 - Activer la disponibilité de OneLake

La disponibilité de OneLake doit être activée avant d’obtenir des données dans Eventhouse. Cette étape est importante, car elle permet aux données que vous ingérez de devenir disponibles dans OneLake. Dans une étape ultérieure, vous accédez à ces mêmes données à partir de votre notebook Spark pour entraîner le modèle.

  1. Accédez à la page d’accueil de votre espace de travail dans Real-Time Intelligence.

  2. Sélectionnez l’Eventhouse que vous avez créé dans les composants requis. Choisissez la base de données vers lequel vous souhaitez charger vos données.

  3. À côté de la vignette détails de la base de données, sélectionnez l’icône crayon à côté de Disponibilité OneLake

  4. Dans le volet droit, basculez le bouton sur Actif.

  5. Cliquez sur Terminé.

    Capture d’écran de l’activation de la disponibilité de OneLake dans votre Eventhouse.

Partie 2 - Activer le plug-in Python KQL

Dans cette étape, vous activez le plug-in Python dans votre Eventhouse. Cette étape est nécessaire pour exécuter le code Python des anomalies prédites dans l’ensemble de requêtes KQL. Il est important de choisir le package approprié qui contient le package time-series-anomaly-detector.

  1. Dans l’écran Eventhouse, sélectionnez votre base de données, puis sélectionnez Gérer les>plug-ins dans le ruban..

  2. Dans le volet Plug-ins, basculez l’extension du langage Python sur Activé.

  3. Sélectionnez Python 3.11.7 DL (préversion).

  4. Cliquez sur Terminé.

    Capture d’écran montrant comment activer le package Python 3.11.7 DL dans Eventhouse.

Partie 3 - Créer un environnement Spark

Dans cette étape, vous créez un environnement Spark pour exécuter le notebook Python qui entraîne le modèle de détection d'anomalie multivariée à l’aide du moteur Spark. Pour plus d’informations sur la création d’environnements, voir Créer et gérer des environnements.

  1. Dans le sélecteur d'expérience, choisissez Ingénieurs de données. Si vous êtes déjà dans l’expérience Ingénieurs Données, accédez à Accueil.

  2. Dans Éléments recommandés pour créer, sélectionnez Environnements, puis entrez le nom MVAD_ENV de l’environnement.

    Capture d’écran de la création d’un environnement dans Ingénieurs Données.

  3. Sous Bibliothèques, sélectionnez Bibliothèques publiques.

  4. Sélectionnez Ajouter à partir de PyPI.

  5. Dans la zone de recherche, entrez time-series-anomaly-detector. La version remplit automatiquement la version la plus récente. Ce tutoriel a été créé à l’aide de la version 0.2.7, qui est la version incluse dans le Kusto Python 3.11.7 DL.

  6. Cliquez sur Enregistrer.

    Capture d’écran de l’ajout du package PyPI à l’environnement Spark.

  7. Sélectionnez l’onglet Accueil dans l’environnement.

  8. Dans le ruban en haut, cliquez sur l’icône Publier.

  9. Sélectionnez Publier tous. Cette étape peut prendre plusieurs minutes.

    Capture d’écran de la publication de l’environnement.

Partie 4 - Obtenir des données dans eventhouse

  1. Pointez sur la base de données KQL où vous souhaitez stocker vos données. Sélectionnez le menu Plus [...]>Obtenir les données>Fichier.

    Capture d’écran de l’obtention de données à partir du fichier local.

  2. Sélectionnez + Nouvelle table et entrez demo_stocks_change comme nom de table.

  3. Dans la boîte de dialogue Charger des données, sélectionnez Rechercher des fichiers et chargez l’exemple de fichier de données téléchargé dans les conditions préalables

  4. Cliquez sur Suivant.

  5. Dans la section Inspecter les données, basculez La première ligne est l’en-tête de colonne sur Activé.

  6. Sélectionnez Terminer.

  7. Une fois que les données sont chargées, cliquez sur Fermer.

Partie 5 - Copier le chemin OneLake dans la table

Veillez à sélectionner la table demo_stocks_change. Dans la vignette Détails du tableau, sélectionnez Copier le chemin d'accès pour copier le chemin OneLake dans votre Presse-papiers. Enregistrez ce texte copié dans un éditeur de texte quelque part pour être utilisé dans une étape ultérieure.

Capture d’écran de la copie du chemin d'accès OneLake.

Partie 6 - Préparer le notebook

  1. Dans le sélecteur d’expérience, choisissez Développer et sélectionnez votre espace de travail.

  2. Sélectionnez Importer, Notebook, puis À partir de cet ordinateur.

  3. Sélectionnez Télécharger, puis choisissez le notebook que vous avez téléchargé dans les conditions préalables.

  4. Une fois le notebook chargé, vous pouvez rechercher et ouvrir votre notebook à partir de votre espace de travail.

  5. Dans le ruban supérieur, sélectionnez la liste déroulante Espace de travail par défaut, puis sélectionnez l’environnement que vous avez créé à l’étape précédente.

    Capture d’écran de la sélection de l’environnement dans le notebook.

Partie 7 - Exécuter le notebook

  1. Importer des packages standard.

    import numpy as np
import pandas as pd

  2. Spark a besoin d’un URI ABFSS pour se connecter en toute sécurité au stockage OneLake. L’étape suivante définit cette fonction pour convertir l’URI OneLake en URI ABFSS.

    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. Entrez votre URI OneLake copié à partir de la Partie 5 - Copiez le chemin d'accès OneLake vers la table pour charger la table demo_stocks_change dans un dataframe pandas.

    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. Exécutez les cellules suivantes pour préparer les trames de données d’entraînement et de prédiction.

    Remarque

    Les prédictions réelles seront exécutées sur les données par l’Eventhouse dans la Partie 9 - Predict-anomalies-in-the-kql-queryset. Dans un scénario de production, si vous diffusez des données dans la maison d’événements, les prédictions seront effectuées sur les nouvelles données de diffusion en continu. Dans le cadre du didacticiel, le jeu de données a été divisé par date en deux sections pour l’entraînement et la prédiction. Il s’agit de simuler des données historiques et de nouvelles données de streaming.

    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. Exécutez les cellules pour entraîner le modèle et l’enregistrer dans le registre des modèles Fabric MLflow.

    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. Copiez l’URI du modèle à partir de la dernière sortie de cellule. Vous utiliserez cela plus tard.

Partie 8 - Configurer votre ensemble de requêtes KQL

Pour obtenir des informations générales, consultez Créer un ensemble de requêtes KQL.

  1. Dans le sélecteur d’expérience, choisissez Real-Time Intelligence.
  2. Sélectionnez votre espace de travail.
  3. Sélectionnez +Nouvel élement>Ensemble de requêtes KQL. Entrez le nom MultivariateAnomalyDetectionTutorial.
  4. Sélectionnez Créer.
  5. Dans la fenêtre du hub de données OneLake, sélectionnez la base de données KQL dans laquelle vous avez stocké les données.
  6. Sélectionnez Connecter.

Partie 9 - Prédire les anomalies dans l’ensemble de requêtes KQL

  1. Copiez/collez et exécutez la requête suivante « .create-or-alter function » pour définir la fonction stockée predict_fabric_mvad_fl() :

    .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. Copiez/collez la requête de prédiction suivante.

    1. Remplacez l’URI du modèle de sortie copié à la fin de l’étape 7.
    2. Exécutez la requête. Il détecte les anomalies multivariées sur les cinq actions, en fonction du modèle entraîné et affiche les résultats sous la forme anomalychart. Les points anormaux sont rendus sur le premier stock (AAPL), bien qu’ils représentent des anomalies multivariées (en d’autres termes, des anomalies des modifications conjointes des cinq actions dans la date spécifique).
    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')

Le graphique d'anomalie obtenu devrait ressembler à l'image suivante :

Capture d’écran de la sortie d’anomalie multivariée.

Nettoyer les ressources

Lorsque vous avez terminé le tutoriel, vous pouvez supprimer les ressources que vous avez créées pour éviter les coûts supplémentaires. Pour supprimer les ressources, suivez ces étapes :

  1. Accédez à la page d’accueil de votre espace de travail.
  2. Supprimez l’environnement que vous avez créé dans ce tutoriel.
  3. Supprimez le notebook que vous avez créé dans ce tutoriel.
  4. Supprimez l’Eventhouse ou la base de données utilisée dans ce tutoriel.
  5. Supprimez l’ensemble de requêtes KQL que vous avez créé dans ce tutoriel.