Tutoriel : créer, évaluer et noter un modèle de détection des fraudes

Article
02/12/2024

Ce tutoriel présente un exemple de bout en bout d’un flux de travail science des données Synapse, dans Microsoft Fabric. Le scénario crée un modèle de détection des fraudes avec des algorithmes d’apprentissage automatique entraînés sur des données historiques. Il utilise ensuite le modèle pour détecter les futures transactions frauduleuses.

Ce didacticiel couvre ces étapes :

Installer des bibliothèques personnalisées
Chargement des données
Comprendre et traiter les données par le biais d’une analyse exploratoire des données
Utilisez scikit-learn pour former un modèle Machine Learning, et suivez les expériences avec les fonctionnalités MLflow et Fabric Autologging
Enregistrer et inscrire le modèle Machine Learning le plus performant
Charger le modèle Machine Learning pour le scoring et pour faire des prédictions

Prérequis

Obtenir un abonnement Microsoft Fabric. Ou, inscrivez-vous pour un essai gratuit de Microsoft Fabric.
Connectez-vous à Microsoft Fabric.
Utilisez le sélecteur d’expérience sur le côté gauche de votre page d’accueil pour passer à l’expérience science des données Synapse.

Si nécessaire, créez un lakehouse Microsoft Fabric comme décrit dans Créer une lakehouse dans Microsoft Fabric.

Suivez l’évolution dans un notebook

Vous pouvez choisir l’une de ces options pour suivre l’évolution de la situation dans un notebook :

Ouvrez et exécutez le notebook intégré dans l’expérience Science des données
Chargez votre notebook à partir de GitHub vers l’expérience Science des données

Ouvrir le notebook intégré

L’exemple de notebook détection des fraudes accompagne ce tutoriel.

Pour ouvrir l’exemple de notebook intégré au tutoriel dans l’expérience science des données Synapse :

Accédez à la page d’accueil science des données Synapse.
Sélectionnez Utiliser un échantillon.
Sélectionnez l’échantillon correspondant :
- À partir de l’onglet par défaut Workflows de bout en bout (Python), si l’exemple concerne un tutoriel Python.
- À partir de l’onglet Workflows de bout en bout (R), si l’exemple concerne un tutoriel R.
- À partir de l’onglet Tutoriels rapides, si l’exemple concerne un tutoriel rapide.
Attachez un lakehouse au notebook avant de commencer à exécuter le code.

Importer le notebook à partir de GitHub

Le notebook AIsample - Détection des fraudes.ipynb accompagne ce tutoriel.

Pour ouvrir le notebook d’accompagnement de ce tutoriel, suivez les instructions fournies dans Préparer votre système pour la science des données afin d’importer le notebook dans votre espace de travail.

Si vous préférez copier et coller le code de cette page, vous pouvez créer un nouveau notebook.

Assurez-vous d’attacher un lakehouse au notebook avant de commencer à exécuter du code.

Étape 1 : Installer des bibliothèques personnalisées

Pour le développement de modèle Machine Learning ou l’analyse de données ad hoc, vous pourriez avoir besoin d’installer rapidement une bibliothèque personnalisée pour votre session Apache Spark. Vous avez deux options d’installation des bibliothèques.

Utilisez les capacités d’installation en ligne (%pip ou %conda) de votre notebook pour installer une bibliothèque, dans votre notebook actuel uniquement
Vous pouvez également créer un environnement Fabric, installer des bibliothèques à partir de sources publiques ou y charger des bibliothèques personnalisées. Ensuite, l’administrateur de votre espace de travail peut attacher l’environnement en tant qu’environnement par défaut pour l’espace de travail. Toutes les bibliothèques de l’environnement seront ensuite disponibles pour être utilisées dans les notebooks et les définitions de travail Spark dans l’espace de travail. Pour plus d’informations sur les environnements, consultez Créer, configurer et utiliser un environnement dans Microsoft Fabric.

Pour ce tutoriel, utilisez %pip install pour installer imblearn la bibliothèque dans votre notebook.

Remarque

Le noyau PySpark redémarre après l’exécution de %pip install. Installez les bibliothèques nécessaires avant d’exécuter d’autres cellules.

# Use pip to install imblearn
%pip install imblearn

Étape 2 : Chargement des données

Le jeu de données de détection des fraudes contient des transactions par carte de crédit, datant de septembre 2013, que les titulaires de cartes européens ont effectuées au cours de deux jours. Le jeu de données contient uniquement des fonctionnalités numériques en raison d’une transformation par analyse en composantes principales (ACP) appliquée aux caractéristiques d’origine. PCA a transformé toutes les fonctionnalités à l’exception de Time et Amount. Pour protéger la confidentialité, nous ne pouvons pas fournir les fonctionnalités d’origine ou plus d’informations générales sur le jeu de données.

Ces détails décrivent le jeu de données :

Les fonctionnalités V1, V2, V3, …, V28 sont les principaux composants obtenus avec PCA
La fonctionnalité Time contient les secondes écoulées entre une transaction et la première transaction du jeu de données
La fonctionnalité Amount est le montant de la transaction. Vous pouvez utiliser cette fonctionnalité pour l’apprentissage sensible aux coûts, dépendant des exemples
La colonne Class est la variable de réponse (cible). Il a la valeur 1 en cas de fraude, et 0 dans le cas contraire

Seules 492 transactions, sur un total de 284 807, sont frauduleuses. Le jeu de données est fortement déséquilibré, car la classe minoritaire (frauduleuse) ne représente qu’environ 0,172 % des données.

Ce tableau présente un aperçu des données de creditcard.csv :

Temps	V1	V2	V3	V4	V5	V6	V7	V8	V9	V10	V11	Version 12 (V12)	V13	V14	V15	V16	V17	V18	V19	V20	V21	V22	V23	V24	V25	V26	V27	V28	Montant	Classe
0	-1.3598071336738	-0.0727811733098497	2.53634673796914	1.37815522427443	-0.338320769942518	0.462387777762292	0.239598554061257	0.0986979012610507	0.363786969611213	0.0907941719789316	-0.551599533260813	-0.617800855762348	-0.991389847235408	-0.311169353699879	1.46817697209427	-0.470400525259478	0.207971241929242	0.0257905801985591	0.403992960255733	0.251412098239705	-0.018306777944153	0.277837575558899	-0.110473910188767	0.0669280749146731	0.128539358273528	-0.189114843888824	0.133558376740387	-0.0210530534538215	149.62	"0"
0	1.19185711131486	0.26615071205963	0.16648011335321	0.448154078460911	0.0600176492822243	-0.0823608088155687	-0.0788029833323113	0.0851016549148104	-0.255425128109186	-0.166974414004614	1.61272666105479	1.06523531137287	0.48909501589608	-0.143772296441519	0.635558093258208	0.463917041022171	-0.114804663102346	-0.183361270123994	-0.145783041325259	-0.0690831352230203	-0.225775248033138	-0.638671952771851	0.101288021253234	-0.339846475529127	0.167170404418143	0.125894532368176	-0.00898309914322813	0.0147241691924927	2.69	"0"

Télécharger le jeu de données et le charger dans le lakehouse

Définissez ces paramètres pour pouvoir utiliser ce notebook avec différents jeux de données :

IS_CUSTOM_DATA = False  # If True, the dataset has to be uploaded manually

TARGET_COL = "Class"  # Target column name
IS_SAMPLE = False  # If True, use only <SAMPLE_ROWS> rows of data for training; otherwise, use all data
SAMPLE_ROWS = 5000  # If IS_SAMPLE is True, use only this number of rows for training

DATA_FOLDER = "Files/fraud-detection/"  # Folder with data files
DATA_FILE = "creditcard.csv"  # Data file name

EXPERIMENT_NAME = "aisample-fraud"  # MLflow experiment name

Ce code télécharge une version du jeu de données accessible au public, puis la stocke dans un lakehouse Fabric.

Important

Assurez-vous d’ajouter un lakehouse au notebook avant de l’exécuter. Sinon, une erreur s’affiche.

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/default"):
        raise FileNotFoundError("Default lakehouse not found, please add a lakehouse and restart the session.")
    os.makedirs(download_path, exist_ok=True)
    if not os.path.exists(f"{download_path}/{fname}"):
        r = requests.get(f"{remote_url}/{fname}", timeout=30)
        with open(f"{download_path}/{fname}", "wb") as f:
            f.write(r.content)
    print("Downloaded demo data files into lakehouse.")

Configurer le suivi des expériences MLflow

Le processus de suivi des expériences enregistre toutes les informations pertinentes liées à l’expérience pour chaque expérience que vous réalisez. Parfois, vous n’avez aucun moyen d’obtenir de meilleurs résultats lorsque vous exécutez une expérience spécifique. Dans ces cas, vous devez arrêter l’expérience et essayer une nouvelle.

L’expérience de science des données Synapse dans Microsoft Fabric comprend une fonctionnalité d’autologging. Cette fonctionnalité réduit la quantité de code nécessaire pour consigner automatiquement les paramètres, les métriques et les éléments d’un modèle Machine Learning pendant la formation. La fonctionnalité étend les fonctionnalités de mise en service automatique MLflow. Il a une intégration approfondie dans l’expérience Science des données.

Grâce à l’autologging, vous pouvez facilement suivre et comparer les performances de différents modèles et expériences, sans avoir besoin d’un suivi manuel. Pour plus d’informations, consultez Autologging dans Microsoft Fabric.

Pour désactiver l’autologging de Microsoft Fabric dans une session notebook, appelez mlflow.autolog() et définissez disable=True :

# Set up MLflow for experiment tracking
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Lire des données brutes à partir du lakehouse

Ce code lit les données brutes du lakehouse :

df = (
    spark.read.format("csv")
    .option("header", "true")
    .option("inferSchema", True)
    .load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
    .cache()
)

Étape 3 : Effectuer une analyse exploratoire des données

Dans cette section, vous commencez par explorer les données brutes et les statistiques de haut niveau. Ensuite, pour transformer les données, convertir les colonnes dans les types corrects, et les convertir du DataFrame Spark en un DataFrame pandas pour une visualisation plus facile. Enfin, vous explorez et visualisez les distributions de classes dans les données.

Afficher les données brutes

Explorez les données brutes et visualisez les statistiques de haut niveau à l’aide de la commande display. Pour plus d’informations sur la visualisation des données, consultez Visualisation des notebooks dans Microsoft Fabric.
```
display(df)
```

Imprimez des informations de base sur le jeu de données :

# Print dataset basic information
print("records read: " + str(df.count()))
print("Schema: ")
df.printSchema()

Transformer les données

Convertir les colonnes du jeu de données dans les types corrects :

import pyspark.sql.functions as F

df_columns = df.columns
df_columns.remove(TARGET_COL)

# Ensure that TARGET_COL is the last column
df = df.select(df_columns + [TARGET_COL]).withColumn(TARGET_COL, F.col(TARGET_COL).cast("int"))

if IS_SAMPLE:
    df = df.limit(SAMPLE_ROWS)

Convertissez le DataFrame Spark en DataFrame pandas pour faciliter la visualisation et le traitement :
```
df_pd = df.toPandas()
```

Explorer la distribution de classes dans le jeu de données

Affichez la distribution de classes dans le jeu de données :
```
# The distribution of classes in the dataset
print('No Frauds', round(df_pd['Class'].value_counts()[0]/len(df_pd) * 100,2), '% of the dataset')
print('Frauds', round(df_pd['Class'].value_counts()[1]/len(df_pd) * 100,2), '% of the dataset')
```
Le code renvoie la distribution des classes de ce jeu de données : 99,83 % No Frauds et 0,17 % Frauds. Cette distribution de classe montre que la plupart des transactions sont non frauduleuses. Par conséquent, le prétraitement des données est nécessaire avant l’entraînement du modèle afin d’éviter le surajustement.

Utilisez un tracé pour afficher le déséquilibre de classe dans le jeu de données, en affichant la distribution des transactions frauduleuses par rapport aux transactions non frauduleuses :

import seaborn as sns
import matplotlib.pyplot as plt

colors = ["#0101DF", "#DF0101"]
sns.countplot(x='Class', data=df_pd, palette=colors) 
plt.title('Class Distributions \n (0: No Fraud || 1: Fraud)', fontsize=10)

Affichez le résumé en cinq chiffres (score minimum, premier quartile, médiane, troisième quartile et score maximum) pour le montant de la transaction, avec des diagrammes en boîte :
```
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,5))
s = sns.boxplot(ax = ax1, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=True) # Remove outliers from the plot
s = sns.boxplot(ax = ax2, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=False) # Keep outliers from the plot
plt.show()
```
Pour les données fortement déséquilibrées, les diagrammes en boîte peuvent ne pas donner d’insights précis. Toutefois, vous pouvez commencer par résoudre le problème du déséquilibre des Class, puis créer les mêmes graphiques pour obtenir des insights plus précis.

Étape 4 : former et évaluer les modèles

Ici, vous formez un modèle LightGBM pour classer les transactions frauduleuses. Vous entraînez un modèle LightGBM sur les jeux de données déséquilibrés et sur les jeux de données équilibrés. Ensuite, vous comparez les performances des deux modèles.

Préparation de jeux de données d’apprentissage et de test

Avant l’entraînement, fractionnez les données en jeux de données d’entraînement et de test :

# Split the dataset into training and testing sets
from sklearn.model_selection import train_test_split

train, test = train_test_split(df_pd, test_size=0.15)
feature_cols = [c for c in df_pd.columns.tolist() if c not in [TARGET_COL]]

Appliquons la technique SMOTE aux données d’apprentissage

La bibliothèque imblearn utilise l’approche SMOTE (Synthetic Minority Oversampling Technique) pour résoudre le problème de la classification déséquilibrée. La classification déséquilibrée se produit lorsque trop peu d’exemples de la classe minoritaire sont disponibles pour qu’un modèle puisse apprendre efficacement la délimitation de décision. La SMOTE est l’approche la plus largement utilisée pour synthétiser de nouveaux échantillons pour la classe minoritaire.

Appliquez SMOTE uniquement au jeu de données d’entraînement, plutôt qu’au jeu de données de test. Lorsque vous évaluez le modèle avec les données de test, vous avez besoin d’une approximation de la performance du modèle sur des données non vues en production. Pour que cette approximation soit valide, vos données de test s’appuient sur la distribution déséquilibrée d’origine pour représenter les données de production aussi fidèlement que possible.

# Apply SMOTE to the training data
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE

X = train[feature_cols]
y = train[TARGET_COL]
print("Original dataset shape %s" % Counter(y))

sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X, y)
print("Resampled dataset shape %s" % Counter(y_res))

new_train = pd.concat([X_res, y_res], axis=1)

Pour plus d’informations sur SMOTE, consultez les ressources référence scikit-learn pour la méthode SMOTE et le guide de l’utilisateur scikit-learn sur les ressources de suréchantillonnage.

Entraîner des modèles Machine Learning et exécuter des expériences

Apache Spark dans Microsoft Fabric permet l’apprentissage automatique avec Big Data. Avec Apache Spark, vous pouvez obtenir des insights précieux à partir de grandes quantités de données structurées, non structurées et en évolution rapide.

Vous disposez de plusieurs options disponibles pour former des modèles Machine Learning avec Apache Spark dans Microsoft Fabric : Apache Spark MLlib, SynapseML et d’autres bibliothèques open source. Si vous souhaitez obtenir plus d’informations, consultez Effectuer l’apprentissage de modèles Machine Learning dans Microsoft Fabric.

Une expérience d’apprentissage automatique sert d’unité principale d’organisation et de contrôle pour toutes les exécutions d’apprentissage automatique connexes. Une exécution correspond à une seule exécution de code de modèle. Le suivi des expériences d’apprentissage automatique implique la gestion de toutes les expériences et de leurs composants, tels que les paramètres, les métriques, les modèles et autres artefacts.

Pour le suivi des expériences, vous pouvez organiser tous les composants requis d’une expérience d’apprentissage automatique spécifique. En outre, vous pouvez facilement reproduire des résultats antérieurs grâce aux expériences sauvegardées. Pour plus d’informations sur les expériences d’apprentissage automatique, consultez Expériences d’apprentissage automatique dans Microsoft Fabric.

Pour suivre davantage de métriques, de paramètres et de fichiers, définissez exclusive=False pour mettre à jour la configuration d’Autologging de MLflow :
```
mlflow.autolog(exclusive=False)
```

Former deux modèles avec LightGBM. Un modèle gère le jeu de données déséquilibré, et l’autre modèle gère le jeu de données équilibré (via SMOTE). Comparez ensuite les performances des deux modèles.

import lightgbm as lgb

model = lgb.LGBMClassifier(objective="binary") # Imbalanced dataset
smote_model = lgb.LGBMClassifier(objective="binary") # Balanced dataset

# Train LightGBM for both imbalanced and balanced datasets and define the evaluation metrics
print("Start training with imbalanced data:\n")
with mlflow.start_run(run_name="raw_data") as raw_run:
    model = model.fit(
        train[feature_cols],
        train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

print(f"\n\nStart training with balanced data:\n")
with mlflow.start_run(run_name="smote_data") as smote_run:
    smote_model = smote_model.fit(
        new_train[feature_cols],
        new_train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

Déterminer l’importance des fonctionnalités pour l’entraînement

Déterminez l’importance des fonctionnalités pour le modèle que vous avez entraîné sur le jeu de données déséquilibré :

with mlflow.start_run(run_id=raw_run.info.run_id):
    importance = lgb.plot_importance(
        model, title="Feature importance for imbalanced data"
    )
    importance.figure.savefig("feauture_importance.png")
    mlflow.log_figure(importance.figure, "feature_importance.png")

Déterminez l’importance d’une caractéristique pour le modèle que vous avez formé sur des données équilibrées. SMOTE a généré les données équilibrées :

with mlflow.start_run(run_id=smote_run.info.run_id):
    smote_importance = lgb.plot_importance(
        smote_model, title="Feature importance for balanced (via SMOTE) data"
    )
    smote_importance.figure.savefig("feauture_importance_smote.png")
    mlflow.log_figure(smote_importance.figure, "feauture_importance_smote.png")

Pour entraîner un modèle avec le jeu de données déséquilibré, les fonctionnalités importantes présentent des différences significatives par rapport à un modèle entraîné avec le jeu de données équilibré.

Évaluer les modèles

Ici, vous évaluez les deux modèles formés :

model entraîné sur des données déséquilibrées brutes
smote_model entraîné sur des données équilibrées

Métriques du modèle de calcul

Définissez une fonction prediction_to_spark qui effectue des prédictions et convertit les résultats de la prédiction en Dataframe Spark. Vous pouvez ensuite calculer les statistiques du modèle sur les résultats de la prédiction avec SynapseML.

from pyspark.sql.functions import col
from pyspark.sql.types import IntegerType, DoubleType

def prediction_to_spark(model, test):
    predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_)
    predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist()))
    dataColumns = [TARGET_COL, "prediction"]
    predictions = (
        spark.createDataFrame(data=predictions, schema=dataColumns)
        .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType()))
        .withColumn("prediction", col("prediction").cast(DoubleType()))
    )

    return predictions

Utilisez la fonction prediction_to_spark pour effectuer des prédictions avec les deux modèles model et smote_model :

predictions = prediction_to_spark(model, test)
smote_predictions = prediction_to_spark(smote_model, test)
predictions.limit(10).toPandas()

Calculez les métriques pour les deux modèles :

from synapse.ml.train import ComputeModelStatistics

metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(predictions)

smote_metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(smote_predictions)
display(metrics)

Évaluer les performances du modèle avec une matrice de confusion

Une matrice de confusion affiche le nombre de

vrais positifs (TP)
vrais négatifs (TN)
faux positifs (FP)
faux négatifs (FN)

qu’un modèle produit lorsqu’il est marqué avec des données de test. Pour la classification binaire, le modèle renvoie une matrice de confusion 2x2. Pour la classification multiclasse, le modèle renvoie une matrice de confusion nxn, où n est le nombre de classes.

Utilisez une matrice de confusion pour résumer les performances des modèles Machine Learning entraînés sur les données de test :

# Collect confusion matrix values
cm = metrics.select("confusion_matrix").collect()[0][0].toArray()
smote_cm = smote_metrics.select("confusion_matrix").collect()[0][0].toArray()
print(cm)

Tracez la matrice de confusion pour les prédictions de smote_model (entraînées sur des données équilibrées) :

# Plot the confusion matrix
import seaborn as sns

def plot(cm):
    """
    Plot the confusion matrix.
    """
    sns.set(rc={"figure.figsize": (5, 3.5)})
    ax = sns.heatmap(cm, annot=True, fmt=".20g")
    ax.set_title("Confusion Matrix")
    ax.set_xlabel("Predicted label")
    ax.set_ylabel("True label")
    return ax

with mlflow.start_run(run_id=smote_run.info.run_id):
    ax = plot(smote_cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

Tracez la matrice de confusion pour les prédictions de model (entraînées sur des données déséquilibrées brutes) :

with mlflow.start_run(run_id=raw_run.info.run_id):
    ax = plot(cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

Évaluer les performances du modèle avec les mesures AUC-ROC et AUPRC

La mesure de la zone sous la courbe de la caractéristique d’exploitation du récepteur (AUC-ROC) évalue la performance des classifieurs binaires. Le graphique AUC-ROC permet de visualiser le compromis entre le taux de vrais positifs (TPR) et le taux de faux positifs (FPR).

Dans certains cas, il est plus approprié d’évaluer votre classifieur en fonction de la mesure Zone sous la courbe de rappel de précision (Area Under the Precision-Recall Curve, ou AUPRC). La courbe AUPRC combine ces taux :

La précision, ou la valeur prédictive positive (VPP)
Le rappel, ou TPR

Évaluer les performances à l’aide des mesures AUC-ROC et AUPRC :

Définissez une fonction qui retourne les mesures AUC-ROC et AUPRC :

from pyspark.ml.evaluation import BinaryClassificationEvaluator

def evaluate(predictions):
    """
    Evaluate the model by computing AUROC and AUPRC with the predictions.
    """

    # Initialize the binary evaluator
    evaluator = BinaryClassificationEvaluator(rawPredictionCol="prediction", labelCol=TARGET_COL)

    _evaluator = lambda metric: evaluator.setMetricName(metric).evaluate(predictions)

    # Calculate AUROC, baseline 0.5
    auroc = _evaluator("areaUnderROC")
    print(f"The AUROC is: {auroc:.4f}")

    # Calculate AUPRC, baseline positive rate (0.172% in the data)
    auprc = _evaluator("areaUnderPR")
    print(f"The AUPRC is: {auprc:.4f}")

    return auroc, auprc

Enregistrez les métriques AUC-ROC et AUPRC pour le modèle que vous avez formé sur des données déséquilibrées :

with mlflow.start_run(run_id=raw_run.info.run_id):
    auroc, auprc = evaluate(predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "None", "DATA_FILE": DATA_FILE})

Enregistrez les métriques AUC-ROC et AUPRC pour le modèle que vous avez formé sur des données équilibrées :

with mlflow.start_run(run_id=smote_run.info.run_id):
    auroc, auprc = evaluate(smote_predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "SMOTE", "DATA_FILE": DATA_FILE})

Le modèle formé sur les données équilibrées renvoie des valeurs AUC-ROC et AUPRC plus élevées que le modèle formé sur les données déséquilibrées. Sur la base de ces mesures, SMOTE semble être une technique efficace pour améliorer la performance des modèles lorsque l’on travaille avec des données fortement déséquilibrées.

Comme le montre l’image suivante, chaque expérience est enregistrée avec son nom. Vous pouvez suivre les paramètres de l’expérience et les métriques de performance dans votre espace de travail.

Cette image montre les métriques de performance pour le modèle entraîné sur le jeu de données équilibré (dans la Version 2) :

Vous pouvez sélectionner la Version 1 pour afficher les métriques du modèle entraîné sur le jeu de données déséquilibré. Lorsque vous comparez les métriques, l’AUROC est plus élevé pour le modèle formé avec le jeu de données équilibré. Ces résultats indiquent que ce modèle est meilleur pour prédire correctement les classes 0 en tant que 0 et pour prédire les classes 1 en tant que 1.

Étape 5 : Inscrire les modèles

Utilisez MLflow pour inscrire les deux modèles :

# Register the model
registered_model_name = f"{EXPERIMENT_NAME}-lightgbm"

raw_model_uri = "runs:/{}/model".format(raw_run.info.run_id)
mlflow.register_model(raw_model_uri, registered_model_name)

smote_model_uri = "runs:/{}/model".format(smote_run.info.run_id)
mlflow.register_model(smote_model_uri, registered_model_name)

Étape 6 : Enregistrer les résultats de la prédiction

Microsoft Fabric permet aux utilisateurs d’opérationnaliser des modèles Machine Learning avec la fonction évolutive PREDICT. Cette fonction prend en charge le scoring par lots (ou l’inférence par lot) dans n’importe quel moteur de calcul.

Vous pouvez générer des prédictions par lots directement à partir du notebook Microsoft Fabric ou de la page d’élément d’un modèle. Pour plus d’informations sur PREDICT, consultez Scoring de modèle avec PREDICT dans Microsoft Fabric.

Chargez le modèle le plus performant (Version 2) pour le scoring par lots et générez les résultats de prédiction :

from synapse.ml.predict import MLFlowTransformer

spark.conf.set("spark.synapse.ml.predict.enabled", "true")

model = MLFlowTransformer(
    inputCols=feature_cols,
    outputCol="prediction",
    modelName=f"{EXPERIMENT_NAME}-lightgbm",
    modelVersion=2,
)

test_spark = spark.createDataFrame(data=test, schema=test.columns.to_list())

batch_predictions = model.transform(test_spark)

Enregistrer les prédictions dans le lakehouse :

# Save the predictions to the lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")

Partager via

Tutoriel : créer, évaluer et noter un modèle de détection des fraudes

Prérequis

Suivez l’évolution dans un notebook

Ouvrir le notebook intégré

Importer le notebook à partir de GitHub

Étape 1 : Installer des bibliothèques personnalisées

Étape 2 : Chargement des données

Télécharger le jeu de données et le charger dans le lakehouse

Configurer le suivi des expériences MLflow

Lire des données brutes à partir du lakehouse

Étape 3 : Effectuer une analyse exploratoire des données

Afficher les données brutes

Transformer les données

Explorer la distribution de classes dans le jeu de données

Étape 4 : former et évaluer les modèles

Préparation de jeux de données d’apprentissage et de test

Appliquons la technique SMOTE aux données d’apprentissage

Entraîner des modèles Machine Learning et exécuter des expériences

Déterminer l’importance des fonctionnalités pour l’entraînement

Évaluer les modèles

Métriques du modèle de calcul

Évaluer les performances du modèle avec une matrice de confusion

Évaluer les performances du modèle avec les mesures AUC-ROC et AUPRC

Étape 5 : Inscrire les modèles

Étape 6 : Enregistrer les résultats de la prédiction

Commentaires

Ressources supplémentaires

Partager via

Tutoriel : créer, évaluer et noter un modèle de détection des fraudes

Prérequis

Suivez l’évolution dans un notebook

Ouvrir le notebook intégré

Importer le notebook à partir de GitHub

Étape 1 : Installer des bibliothèques personnalisées

Étape 2 : Chargement des données

Télécharger le jeu de données et le charger dans le lakehouse

Configurer le suivi des expériences MLflow

Lire des données brutes à partir du lakehouse

Étape 3 : Effectuer une analyse exploratoire des données

Afficher les données brutes

Transformer les données

Explorer la distribution de classes dans le jeu de données

Étape 4 : former et évaluer les modèles

Préparation de jeux de données d’apprentissage et de test

Appliquons la technique SMOTE aux données d’apprentissage

Entraîner des modèles Machine Learning et exécuter des expériences

Déterminer l’importance des fonctionnalités pour l’entraînement

Évaluer les modèles

Métriques du modèle de calcul

Évaluer les performances du modèle avec une matrice de confusion

Évaluer les performances du modèle avec les mesures AUC-ROC et AUPRC

Étape 5 : Inscrire les modèles

Étape 6 : Enregistrer les résultats de la prédiction

Contenu connexe

Commentaires

Ressources supplémentaires