Delen via

Zelfstudie: Een fraudedetectiemodel maken, evalueren en beoordelen

  • Artikel

In deze zelfstudie ziet u een end-to-end-voorbeeld van een Synapse-werkstroom Datawetenschap, in Microsoft Fabric. In het scenario wordt een fraudedetectiemodel gebouwd met machine learning-algoritmen die zijn getraind op historische gegevens. Vervolgens wordt het model gebruikt om toekomstige frauduleuze transacties te detecteren.

In deze zelfstudie worden de volgende stappen behandeld:

  • Aangepaste bibliotheken installeren
  • De gegevens laden
  • De gegevens begrijpen en verwerken via experimentele gegevensanalyse
  • Scikit-learn gebruiken om een machine learning-model te trainen en experimenten bij te houden met de functies MLflow en Fabric Autologging
  • Sla het machine learning-model op en registreer dit met de hoogste prestaties
  • Het machine learning-model laden om te scoren en voorspellingen te doen

Vereisten

Volgen in een notitieblok

U kunt een van deze opties kiezen om mee te doen in een notitieblok:

  • Open en voer het ingebouwde notebook uit in de Datawetenschap-ervaring
  • Uw notebook uploaden vanuit GitHub naar de Datawetenschap-ervaring

Het ingebouwde notebook openen

Het voorbeeldnotitieblok voor fraudedetectie begeleidt deze zelfstudie.

Ga als volgt te werk om het ingebouwde voorbeeldnotebook van de zelfstudie te openen in de Synapse-Datawetenschap-ervaring:

  1. Ga naar de startpagina van Synapse Datawetenschap.

  2. Selecteer Een voorbeeld gebruiken.

  3. Selecteer het bijbehorende voorbeeld:

    • Op het standaardtabblad End-to-endwerkstromen (Python) als het voorbeeld voor een Python-zelfstudie is.
    • Van het tabblad End-to-endwerkstromen (R) als het voorbeeld voor een R-zelfstudie is.
    • Ga naar het tabblad Snelle zelfstudies , als het voorbeeld voor een snelle zelfstudie is.

  4. Koppel een lakehouse aan het notebook voordat u begint met het uitvoeren van code.

Het notebook importeren vanuit GitHub

Het AIsample - Fraud Detection.ipynb-notebook begeleidt deze zelfstudie.

Als u het bijbehorende notitieblok voor deze zelfstudie wilt openen, volgt u de instructies in Uw systeem voorbereiden voor zelfstudies voor gegevenswetenschap om het notebook te importeren in uw werkruimte.

Als u liever de code van deze pagina kopieert en plakt, kunt u een nieuw notitieblok maken.

Zorg ervoor dat u een lakehouse aan het notebook koppelt voordat u begint met het uitvoeren van code.

Stap 1: Aangepaste bibliotheken installeren

Voor het ontwikkelen van machine learning-modellen of ad-hocgegevensanalyse moet u mogelijk snel een aangepaste bibliotheek voor uw Apache Spark-sessie installeren. U hebt twee opties om bibliotheken te installeren.

  • Gebruik de inline-installatiemogelijkheden (%pip of %conda) van uw notitieblok om alleen een bibliotheek te installeren in uw huidige notitieblok.
  • U kunt ook een Fabric-omgeving maken, bibliotheken installeren uit openbare bronnen of aangepaste bibliotheken ernaar uploaden. Vervolgens kan uw werkruimtebeheerder de omgeving als standaard voor de werkruimte koppelen. Alle bibliotheken in de omgeving zijn vervolgens beschikbaar voor gebruik in notebooks en Spark-taakdefinities in de werkruimte. Zie een omgeving maken, configureren en gebruiken in Microsoft Fabric voor meer informatie over omgevingen.

Voor deze zelfstudie gebruikt %pip install u om de imblearn bibliotheek in uw notebook te installeren.

Notitie

De PySpark-kernel wordt opnieuw opgestart na %pip install uitvoering. Installeer de benodigde bibliotheken voordat u andere cellen uitvoert.

# Use pip to install imblearn
%pip install imblearn

Stap 2: de gegevens laden

De gegevensset voor fraudedetectie bevat creditcardtransacties, van september 2013, die Europese kaarthouders in de loop van twee dagen hebben gemaakt. De gegevensset bevat alleen numerieke functies vanwege een PCA-transformatie (Principal Component Analysis) die is toegepast op de oorspronkelijke functies. PCA heeft alle functies getransformeerd, met uitzondering van Time en Amount. Om vertrouwelijkheid te beschermen, kunnen we de oorspronkelijke functies of meer achtergrondinformatie over de gegevensset niet opgeven.

Deze details beschrijven de gegevensset:

  • De V1functies , V2, , V3... V28 zijn de belangrijkste onderdelen die zijn verkregen met PCA
  • De Time functie bevat de verstreken seconden tussen een transactie en de eerste transactie in de gegevensset
  • De Amount functie is het transactiebedrag. U kunt deze functie gebruiken voor voorbeeldafhankelijke, kostengevoelige training
  • De Class kolom is de responsvariabele (doelvariabele). Het heeft de waarde 1 voor fraude en 0 anderszins

Slechts 492 transacties, van de 284.807 transacties, zijn frauduleus. De gegevensset is zeer onevenwichtig, omdat de minderheidsklasse (frauduleuze) slechts ongeveer 0,172% van de gegevens uitmaakt.

In deze tabel ziet u een voorbeeld van de creditcard.csv gegevens:

Tijd 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 Aantal Klasse
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"

De gegevensset downloaden en uploaden naar het lakehouse

Definieer deze parameters, zodat u dit notebook kunt gebruiken met verschillende gegevenssets:

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

Met deze code wordt een openbaar beschikbare versie van de gegevensset gedownload en vervolgens opgeslagen in een Fabric Lakehouse.

Belangrijk

Zorg ervoor dat u een lakehouse toevoegt aan het notebook voordat u het uitvoert. Anders krijgt u een foutmelding.

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.")

MLflow-experimenttracking instellen

In het proces voor het bijhouden van experimenten worden alle relevante experimentgerelateerde informatie opgeslagen voor elk experiment dat u uitvoert. Soms hebt u geen manier om betere resultaten te verkrijgen wanneer u een specifiek experiment uitvoert. In die gevallen moet u het experiment stoppen en een nieuw experiment proberen.

De Synapse-Datawetenschap-ervaring in Microsoft Fabric bevat een functie voor automatisch aanmelden. Deze functie vermindert de hoeveelheid code die nodig is om de parameters, metrische gegevens en items van een machine learning-model automatisch te registreren tijdens de training. De functie breidt de mogelijkheden voor automatische aanmelding van MLflow uit. Het heeft een diepgaande integratie in de Datawetenschap ervaring.

Met automatische logboekregistratie kunt u eenvoudig de prestaties van verschillende modellen en experimenten bijhouden en vergelijken, zonder dat u handmatig hoeft bij te houden. Zie Autologging in Microsoft Fabric voor meer informatie.

Als u automatische aanmelding van Microsoft Fabric in een notebooksessie wilt uitschakelen, roept mlflow.autolog() u het volgende aan en stelt u deze in disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Onbewerkte gegevens lezen uit lakehouse

Met deze code worden onbewerkte gegevens uit lakehouse gelezen:

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

Stap 3: Verkennende gegevensanalyse uitvoeren

In deze sectie verkent u eerst de onbewerkte gegevens en statistieken op hoog niveau. Als u de gegevens vervolgens wilt transformeren, cast u de kolommen naar de juiste typen en converteert u deze vanuit het Spark DataFrame naar een pandas DataFrame voor eenvoudigere visualisatie. Ten slotte verkent en visualiseert u de klassedistributies in de gegevens.

De onbewerkte gegevens weergeven

  1. Verken de onbewerkte gegevens en bekijk statistieken op hoog niveau met de display opdracht. Zie Notebook-visualisatie in Microsoft Fabric voor meer informatie over gegevensvisualisatie.

    display(df)

  2. Enkele basisinformatie over de gegevensset afdrukken:

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

De gegevens transformeren

  1. Cast de kolommen van de gegevensset naar de juiste typen:

    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)

  2. Converteer het Spark DataFrame naar een Pandas DataFrame voor eenvoudigere visualisatie en verwerking:

    df_pd = df.toPandas()

De klassedistributie in de gegevensset verkennen

  1. Geef de klassedistributie weer in de gegevensset:

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

    De code retourneert deze distributie van gegevenssetklassen: 99,83% No Frauds en 0,17% Frauds. Deze klassedistributie toont aan dat de meeste transacties niet-audulent zijn. Daarom is gegevensvoorverwerking vereist voordat het model wordt getraind, om overfitting te voorkomen.

  2. Gebruik een plot om de onbalans van de klasse in de gegevensset weer te geven door de distributie van frauduleuze versus niet-frauduleuze transacties weer te geven:

    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)

  3. De samenvatting van vijf getallen (minimumscore, eerste kwartiel, mediaan, derde kwartiel en maximumscore) weergeven voor het transactiebedrag, met boxplots:

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

    Voor zeer onevenwichtige gegevens tonen boxplots mogelijk geen nauwkeurige inzichten. U kunt echter eerst het Class onevenwichtige probleem oplossen en vervolgens dezelfde plots maken voor nauwkeurigere inzichten.

Stap 4: De modellen trainen en evalueren

Hier traint u een LightGBM-model om de fraudetransacties te classificeren. U traint een LightGBM-model op zowel de onevenwichtige gegevensset als de evenwichtige gegevensset. Vervolgens vergelijkt u de prestaties van beide modellen.

Trainings- en testgegevenssets voorbereiden

Voordat u gaat trainen, splitst u de gegevens op in de trainings- en testgegevenssets:

# 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]]

SMOTE toepassen op de trainingsgegevensset

De imblearn bibliotheek maakt gebruik van de synthetische minderheid oversampling technique (SMOTE) benadering om het probleem van onevenwichtige classificatie aan te pakken. Onevenwichtige classificatie treedt op wanneer er te weinig voorbeelden van de minderheidsklasse beschikbaar zijn, zodat een model de beslissingsgrens effectief kan leren. SMOTE is de meest gebruikte benadering om nieuwe steekproeven voor de minderheidsklasse te synthetiseren.

Pas SMOTE alleen toe op de trainingsgegevensset in plaats van de testgegevensset. Wanneer u het model met de testgegevens scoren, hebt u een benadering van de modelprestaties nodig voor ongelezen gegevens in productie. Voor een geldige benadering zijn uw testgegevens afhankelijk van de oorspronkelijke onevenwichtige verdeling om productiegegevens zo dicht mogelijk weer te geven.

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

Zie de referentiepagina scikit-learn voor de SMOTE-methode en de scikit-learn-gebruikershandleiding voor oversampling-resources voor meer informatie over SMOTE.

Machine Learning-modellen trainen en experimenten uitvoeren

Apache Spark, in Microsoft Fabric, maakt machine learning mogelijk met big data. Met Apache Spark kunt u waardevolle inzichten verkrijgen uit grote hoeveelheden gestructureerde, ongestructureerde en snel veranderende gegevens.

U hebt verschillende beschikbare opties voor het trainen van machine learning-modellen met Apache Spark in Microsoft Fabric: Apache Spark MLlib, SynapseML en andere opensourcebibliotheken. Zie Machine Learning-modellen trainen in Microsoft Fabric voor meer informatie.

Een machine learning-experiment fungeert als de primaire eenheid van de organisatie en controle voor alle gerelateerde machine learning-uitvoeringen. Een uitvoering komt overeen met één uitvoering van modelcode. Het bijhouden van machine learning-experimenten omvat het beheer van alle experimenten en hun onderdelen, zoals parameters, metrische gegevens, modellen en andere artefacten.

Voor het bijhouden van experimenten kunt u alle vereiste onderdelen van een specifiek machine learning-experiment organiseren. Daarnaast kunt u eenvoudig eerdere resultaten reproduceren met opgeslagen experimenten. Zie Machine Learning-experimenten in Microsoft Fabric voor meer informatie over machine learning-experimenten.

  1. Als u meer metrische gegevens, parameters en bestanden wilt bijhouden, stelt u deze in exclusive=False om de configuratie voor automatische aanmelding van MLflow bij te werken:

    mlflow.autolog(exclusive=False)

  2. Train twee modellen met LightGBM. Het ene model verwerkt de onevenwichtige gegevensset en het andere model verwerkt de evenwichtige gegevensset (via SMOTE). Vergelijk vervolgens de prestaties van de twee modellen.

    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),
        ],
    )

Het belang van functies voor training bepalen

  1. Bepaal het belang van functies voor het model dat u hebt getraind op de onevenwichtige gegevensset:

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

  2. Bepaal het belang van functies voor het model dat u hebt getraind op evenwichtige gegevens. SMOTE heeft de evenwichtige gegevens gegenereerd:

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

Als u een model wilt trainen met de onevenwichtige gegevensset, hebben de belangrijke functies aanzienlijke verschillen in vergelijking met een model dat is getraind met de evenwichtige gegevensset.

De modellen evalueren

Hier evalueert u de twee getrainde modellen:

  • model getraind op onbewerkte, onevenwichtige gegevens
  • smote_model getraind op evenwichtige gegevens

Metrische gegevens van rekenmodel

  1. Definieer een prediction_to_spark functie die voorspellingen uitvoert en converteert de voorspellingsresultaten naar een Spark DataFrame. U kunt vervolgens statistieken van het model berekenen voor de voorspellingsresultaten met 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

  2. Gebruik de prediction_to_spark functie om voorspellingen uit te voeren met de twee modellen en model smote_model:

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

  3. Reken metrische gegevens voor de twee modellen:

    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)

Modelprestaties evalueren met een verwarringsmatrix

Een verwarringsmatrix geeft het aantal weer

  • terecht-positieven (TP)
  • terechte negatieven (TN)
  • fout-positieven (FP)
  • fout-negatieven (FN)

dat een model produceert bij het scoren met testgegevens. Voor binaire classificatie retourneert het model een 2x2 verwarringsmatrix. Voor classificatie met meerdere klassen retourneert het model een nxn verwarringsmatrix, waarbij n het aantal klassen is.

  1. Gebruik een verwarringsmatrix om de prestaties van de getrainde machine learning-modellen op de testgegevens samen te vatten:

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

  2. Teken de verwarringsmatrix voor de voorspellingen van smote_model (getraind op evenwichtige gegevens):

    # 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")

  3. Teken de verwarringsmatrix voor de voorspellingen van model (getraind op onbewerkte, onevenwichtige gegevens):

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

Modelprestaties evalueren met AUC-ROC- en AUPRC-metingen

De meting Area Under the Curve Receiver Operating Characteristic (AUC-ROC) beoordeelt de prestaties van binaire classificaties. De AUC-ROC-grafiek visualiseert de afweging tussen de werkelijke positieve rente (TPR) en de fout-positieve rente (FPR).

In sommige gevallen is het beter om uw classificatie te evalueren op basis van de meting Area Under the Precision-Recall Curve (AUPRC). De AUPRC-curve combineert deze tarieven:

  • De precisie of de positieve voorspellende waarde (PPV)
  • De relevante overeenkomsten of TPR

Prestaties evalueren met de AUC-ROC- en AUPRC-metingen:

  1. Definieer een functie die de AUC-ROC- en AUPRC-metingen retourneert:

    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

  2. Registreer de metrische gegevens van AUC-ROC en AUPRC voor het model dat u hebt getraind op onevenwichtige gegevens:

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

  3. Registreer de metrische gegevens van AUC-ROC en AUPRC voor het model dat u hebt getraind op evenwichtige gegevens:

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

Het model dat is getraind op de evenwichtige gegevens retourneert hogere AUC-ROC- en AUPRC-waarden vergeleken met het model dat is getraind op de onevenwichtige gegevens. Op basis van deze maatregelen lijkt SMOTE een effectieve techniek om de modelprestaties te verbeteren bij het werken met zeer onevenwichtige gegevens.

Zoals in de volgende afbeelding wordt weergegeven, wordt elk experiment geregistreerd met de bijbehorende naam. U kunt de experimentparameters en metrische prestatiegegevens in uw werkruimte bijhouden.

Screenshot of the tracked experiment.

In deze afbeelding ziet u de metrische prestatiegegevens voor het model dat is getraind op de evenwichtige gegevensset (in versie 2):

Screenshot of logged model performance metrics and model parameters.

U kunt versie 1 selecteren om de metrische gegevens voor het model te zien dat is getraind op de onevenwichtige gegevensset. Wanneer u de metrische gegevens vergelijkt, is de AUROC hoger voor het model dat is getraind met de evenwichtige gegevensset. Deze resultaten geven aan dat dit model beter is bij het correct voorspellen van 0 klassen als 0, en het voorspellen van 1 klassen als 1.

Stap 5: De modellen registreren

Gebruik MLflow om de twee modellen te registreren:

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

Stap 6: de voorspellingsresultaten opslaan

Met Microsoft Fabric kunnen gebruikers machine learning-modellen operationeel maken met de PREDICT schaalbare functie. Deze functie ondersteunt batchgewijs scoren (of batchdeductie) in elke rekenengine.

U kunt batchvoorspellingen rechtstreeks genereren vanuit het Microsoft Fabric-notebook of op de itempagina van een model. Zie Voor meer informatie over PREDICThet scoren van modellen met PREDICT in Microsoft Fabric.

  1. Laad het beter presterende model (versie 2) voor batchgewijs scoren en genereer de voorspellingsresultaten:

    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)

  2. Voorspellingen opslaan in lakehouse:

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

Gerelateerde inhoud