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

Article
01/31/2025

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

Ce tutoriel décrit les étapes suivantes :

Installer des bibliothèques personnalisées
Charger les données
Comprendre et traiter les données par le biais d’une analyse exploratoire des données
Utiliser scikit-learn pour effectuer l’apprentissage d’un modèle Machine Learning et suivre les expériences avec les fonctionnalités MLflow et Fabric Autologging
Enregistrer et inscrire le modèle Machine Learning avec les performances les plus élevées
Charger le modèle Machine Learning pour le scoring et effectuer des prédictions

Conditions préalables

Souscrire à un abonnement à Microsoft Fabric . Vous pouvez également vous inscrire à une version d’évaluation gratuite de Microsoft Fabric .
Connectez-vous à Microsoft Fabric.
Utilisez le sélecteur d’expérience en bas à gauche de votre page d’accueil pour basculer vers Fabric.

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

Suivre dans un notebook

Vous pouvez choisir l’une de ces options à suivre dans un bloc-notes :

Ouvrez et exécutez le notebook intégré.
Chargez votre bloc-notes à partir de GitHub.

Ouvrir le notebook intégré

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

Pour ouvrir le cahier d'exemple pour ce tutoriel, suivez les instructions de Préparer votre système pour les tutoriels de sciences des données.
Assurez-vous d’attacher un lakehouse au notebook avant de commencer à exécuter du code.

Importer le notebook à partir de GitHub

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

Pour ouvrir le bloc-notes associé pour ce didacticiel, suivez les instructions de Préparer votre système pour les didacticiels de science des données pour importer le bloc-notes dans votre espace de travail.
Si vous préférez copier et coller le code à partir de cette page, vous pouvez créer un bloc-notes.
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èles Machine Learning ou l’analyse des données ad hoc, vous devrez peut-être installer rapidement une bibliothèque personnalisée pour votre session Apache Spark. Vous avez deux options d’installation des bibliothèques.

Utilisez les fonctionnalités d’installation inline (%pip ou %conda) de votre notebook pour installer une bibliothèque, dans votre bloc-notes actuel uniquement.
Vous pouvez également créer un environnement Fabric, installer des bibliothèques à partir de sources publiques ou charger des bibliothèques personnalisées vers celui-ci, puis l’administrateur de votre espace de travail peut attacher l’environnement comme valeur par défaut pour l’espace de travail. Toutes les bibliothèques de l’environnement seront ensuite disponibles pour être utilisées dans les blocs-notes et les définitions de travaux 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 la bibliothèque de imblearn dans votre notebook.

Note

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 : Charger les données

Le jeu de données de détection des fraudes contient des transactions de carte de crédit, depuis septembre 2013, que les titulaires de carte européens ont effectué au cours des deux jours. Le jeu de données contient uniquement des fonctionnalités numériques en raison d’une transformation d’analyse des composants principaux (PCA) appliquée aux fonctionnalités d’origine. PCA a transformé toutes les fonctionnalités à l’exception de Time et de Amount. Pour protéger la confidentialité, nous ne pouvons pas fournir les fonctionnalités d’origine ni 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 dans le jeu de données
La fonctionnalité Amount correspond au montant de la transaction. Vous pouvez utiliser cette fonctionnalité pour un apprentissage dépendant de l’exemple, sensible aux coûts
La colonne Class correspond à la variable de réponse (cible). Il a la valeur 1 pour la fraude, et 0 sinon

Seules 492 transactions, sur 284 807 transactions totales, sont frauduleuses. Le jeu de données est très déséquilibré, car la classe minoritaire (frauduleuse) représente seulement environ 0,172% du total des données.

Ce tableau affiche un aperçu des données creditcard.csv :

Heure	V1	V2	V3	V4	V5	V6	V7	V8	V9	V10	V11	V12	V13	V14	V15	V16	V17	V18	V19	V20	V21	V22	V23	V24	V25	V26	V27	V28	Quantité	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échargez le jeu de données et chargez-le 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 publiquement disponible du jeu de données, puis la stocke dans un lakehouse Fabric.

Important

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

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 relatives aux expériences pour chaque expérience que vous exécutez. 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 Synapse Data Science dans Microsoft Fabric inclut une fonctionnalité de mise en service automatique. Cette fonctionnalité réduit la quantité de code nécessaire pour journaliser automatiquement les paramètres, les métriques et les éléments d’un modèle Machine Learning pendant l’entraînement. La fonctionnalité étend les capacités de journalisation automatique de MLflow. Il a une intégration approfondie dans l’expérience de science des données.

Avec la journalisation automatique, vous pouvez facilement suivre et comparer les performances de différents modèles et expériences, sans avoir à effectuer de suivi manuel. Pour plus d’informations, consultez Autologging dans Microsoft Fabric.

Pour désactiver la journalisation automatique de Microsoft Fabric dans une session de notebook, utilisez 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 allez d’abord explorer les données brutes et les statistiques de haut niveau. Ensuite, pour transformer les données, convertir les colonnes en types corrects et les convertir à partir du DataFrame Spark en dataFrame pandas pour faciliter la visualisation. Enfin, vous explorez et visualisez les distributions de classes dans les données.

Afficher les données brutes

Explorez les données brutes et affichez les statistiques de haut niveau, avec 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

Transformez les colonnes du jeu de données en 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 retourne cette distribution de classes de jeu de données : 99.83% No Frauds et 0.17% Frauds. Cette distribution de classes indique que la plupart des transactions ne sont pasfraudulent. Par conséquent, le prétraitement des données est requis 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 consultant la distribution de transactions frauduleuses ou nonfraudulentes :

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é à cinq nombres (score minimal, premier quartile, médiane, troisième quartile et score maximal) 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 hautement déséquilibrées, les diagrammes à surfaces peuvent ne pas afficher d’insights précis. Toutefois, vous pouvez d’abord résoudre le problème de déséquilibre Class, puis créer les mêmes tracés pour obtenir des insights plus précis.

Étape 4 : Entraîner et évaluer les modèles

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

Préparer des jeux de données d’entraînement 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]]

Appliquer SMOTE au jeu de données d’entraînement

La bibliothèque imblearn utilise l’approche SMOTE (Synthetic Minority Oversampling Technique) pour résoudre le problème de 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 apprenne efficacement la limite de décision. SMOTE est l’approche la plus couramment utilisée pour synthétiser de nouveaux échantillons pour la classe minoritaire.

Appliquez SMOTE uniquement au jeu de données d’entraînement, au lieu du jeu de données de test. Lorsque vous notez le modèle avec les données de test, vous avez besoin d’une approximation des performances du modèle sur des données invisibles en production. Pour une approximation 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 étroitement 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 la page de référence scikit-learn pour la méthode SMOTE et le guide utilisateur scikit-learn sur le suréchantillonnage des ressources.

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

Apache Spark, dans Microsoft Fabric, permet le Machine Learning avec le 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 mobiles.

Vous disposez de plusieurs options disponibles pour entraîner des modèles Machine Learning avec Apache Spark dans Microsoft Fabric : Apache Spark MLlib, SynapseML et d’autres bibliothèques open source. Pour plus d’informations, consultez Entraîner des modèles Machine Learning dans Microsoft Fabric.

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

Pour le suivi des expériences, vous pouvez organiser tous les composants requis d’une expérience machine learning spécifique. En outre, vous pouvez facilement reproduire les résultats passés avec des expériences enregistrées. Pour plus d’informations sur les expériences de Machine Learning, consultez expériences Machine Learning dans Microsoft Fabric.

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

Entraîner 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 des fonctionnalités pour le modèle que vous avez entraîné 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 entraîné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 de modèle de calcul

Définissez une fonction prediction_to_spark qui effectue des prédictions et convertit les résultats de prédiction en dataFrame Spark. Vous pouvez ensuite calculer des statistiques de modèle sur les résultats de 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()

Calcul des 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 génère lorsqu’il est évalué avec des données de test. Pour la classification binaire, le modèle retourne une matrice de confusion 2x2. Pour la classification multiclasse, le modèle retourne 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 brutes et déséquilibrées) :

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 des mesures AUC-ROC et AUPRC

La mesure Zone sous la courbe caractéristique de fonctionnement du récepteur (Area Under the Curve Receiver Operating Characteristic, ou AUC-ROC) évalue les performances des classifieurs binaires. Le graphique AUC-ROC visualise le compromis entre le taux positif réel (TPR) et le taux faux positif (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 :

Précision ou valeur prédictive positive (PPV)
Le rappel, ou TPR

Pour évaluer les performances avec les 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

Consignez les métriques AUC-ROC et AUPRC pour le modèle que vous avez entraîné sur les 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})

Consignez les métriques AUC-ROC et AUPRC pour le modèle que vous avez entraîné 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 entraîné sur les données équilibrées retourne des valeurs plus élevées AUC-ROC et AUPRC par rapport au modèle entraîné sur les données déséquilibrées. En fonction de ces mesures, SMOTE semble être une technique efficace pour améliorer les performances du modèle lors de l’utilisation de données hautement déséquilibrées.

Comme l’illustre l’image suivante, toute expérience est enregistrée avec son nom respectif. Vous pouvez suivre les paramètres d’expérience et les métriques de performances dans votre espace de travail.

Cette image montre les métriques de performances du modèle entraîné sur le jeu de données équilibré (dans version 2) :

Vous pouvez sélectionner 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 entraîné avec le jeu de données équilibré. Ces résultats indiquent que ce modèle est préférable pour prédire correctement les classes 0 en tant que 0et prédire les classes 1 comme 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 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 bloc-notes Microsoft Fabric ou à partir 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 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")

Comment utiliser des notebooks Microsoft Fabric
modèle Machine Learning dans Microsoft Fabric
Entraîner des modèles Machine Learning
expériences Machine Learning dans Microsoft Fabric

Partager via

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

Conditions préalables

Suivre dans un notebook

Ouvrir le notebook intégré

Importer le notebook à partir de GitHub

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

Étape 2 : Charger les données

Téléchargez le jeu de données et chargez-le 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 : Entraîner et évaluer les modèles

Préparer des jeux de données d’entraînement et de test

Appliquer SMOTE au jeu de données d’entraînement

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 de modèle de calcul

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

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

Étape 5 : Inscrire les modèles

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

Commentaires

Ressources supplémentaires

Partager via

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

Conditions préalables

Suivre dans un notebook

Ouvrir le notebook intégré

Importer le notebook à partir de GitHub

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

Étape 2 : Charger les données

Téléchargez le jeu de données et chargez-le 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 : Entraîner et évaluer les modèles

Préparer des jeux de données d’entraînement et de test

Appliquer SMOTE au jeu de données d’entraînement

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 de modèle de calcul

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

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

Étape 5 : Inscrire les modèles

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

Contenu connexe

Commentaires

Ressources supplémentaires