Delen via

Zelfstudie: Een fraudedetectiemodel maken, evalueren en beoordelen

  • Artikel

In deze zelfstudie vindt u een end-to-end-voorbeeld van een Synapse Data Science-werkstroom 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

Voorwaarden

Volg mee in een notitieblok

U kunt een van deze opties kiezen om te volgen in een notitieboek.

  • Open en voer het ingebouwde notebook uit.
  • Upload uw notebook vanuit GitHub.

Het ingebouwde notebook openen

Het voorbeeld Fraudedetectie notitieboek begeleidt deze zelfstudie.

  1. Als u het voorbeeldnotitieblok voor deze zelfstudie wilt openen, volgt u de instructies in Uw systeem voorbereiden op zelfstudies voor gegevenswetenschap.

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

Het notebook importeren vanuit GitHub

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

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 in uw huidige notitieblok te installeren.
  • 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 Fabricvoor meer informatie over omgevingen.

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

Notitie

De PySpark-kernel wordt opnieuw opgestart nadat %pip install wordt uitgevoerd. 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 V1, V2, V3, ..., V28 functies 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 kolom Class is de antwoordvariabele (doelvariabele). Het heeft de waarde 1 voor fraude en 0 anders

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

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 Klas
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- aan het notebook toevoegt 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-experiment-tracking 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 Data Science-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 Data Science-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 Fabricvoor meer informatie.

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

# Set up MLflow for experiment tracking
import mlflow

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

Ruwe gegevens lezen uit het 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 opdracht display. Voor meer informatie over gegevensvisualisatie, zie Notebook-visualisatie in Microsoft Fabric.

    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. Zet de kolommen van de gegevensset om 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 dat de meeste transacties niet-frauduleus 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 onevenwichtsprobleem oplossen en vervolgens dezelfde grafieken 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 Synthetic Minority Oversampling Technique (SMOTE) methode 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 beoordeelt, hebt u een benadering van de modelprestaties nodig voor niet-gezien gegevens in de productieomgeving. 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)

Voor meer informatie over SMOTE, zie de scikit-learn referentiepagina voor de SMOTE-methode en de scikit-learn-gebruikershandleiding voor oversampling-bronnen .

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 Fabricvoor meer informatie.

Een machine learning-experiment fungeert als de primaire eenheid van de organisatie en controle voor alle gerelateerde machine learning-uitvoeringen. Een run komt overeen met een enkele uitvoering van de modelcode. Machine learning experimenttracking 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 Fabricvoor meer informatie over machine learning-experimenten.

  1. Als u meer metrische gegevens, parameters en bestanden wilt bijhouden, stelt u exclusive=False in 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. Vervolgens kunt u modelstatistieken 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 functie prediction_to_spark om voorspellingen uit te voeren met de twee modellen, model en 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

  • true positives (TP)
  • terechte negatieven (TN)
  • vals-positieven (FP)
  • vals-negatieven (FN)

dat een model produceert wanneer het beoordeeld wordt 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 gebalanceerde 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. Plot 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 maatstaaf Area Under the Curve Receiver Operating Characteristic (AUC-ROC) beoordeelt de prestaties van binaire classificatiesystemen. De AUC-ROC-grafiek visualiseert de afweging tussen het positief percentage (TPR) en het vals positief percentage (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 terugroeping, 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 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 onbalansgegevens. 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.

Schermopname van het bijgehouden experiment.

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

schermopname van vastgelegde metrische gegevens over modelprestaties en modelparameters.

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 0en 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 batchverwerking (of batchinferentie) op elke rekenmachine.

U kunt batchvoorspellingen rechtstreeks genereren vanuit het Microsoft Fabric-notebook of op de itempagina van een model. Voor meer informatie over PREDICT, zie Modellen beoordelen 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")

Verwante inhoud