Selvstudium: Opret, evaluer og scor en model til registrering af svindel

  • Artikel

I dette selvstudium præsenteres et eksempel fra ende til anden på en Synapse Data Science-arbejdsproces i Microsoft Fabric. Scenariet bygger en model til registrering af svindel med algoritmer til maskinel indlæring, der er oplært i historiske data. Den bruger derefter modellen til at registrere fremtidige falske transaktioner.

I dette selvstudium beskrives disse trin:

  • Installér brugerdefinerede biblioteker
  • Indlæs dataene
  • Forstå og behandl dataene via udforskning af dataanalyser
  • Brug scikit-learn til at oplære en model til maskinel indlæring og spore eksperimenter med funktionerne MLflow og Fabric Autologging
  • Gem og registrer den model til maskinel indlæring, der har den højeste ydeevne
  • Indlæs modellen til maskinel indlæring for at få point og foretage forudsigelser

Forudsætninger

  • Få et Microsoft Fabric-abonnement. Du kan også tilmelde dig en gratis Prøveversion af Microsoft Fabric.

  • Log på Microsoft Fabric.

  • Brug oplevelsesskifteren i venstre side af startsiden til at skifte til Synapse Data Science-oplevelsen.

    Screenshot of the experience switcher menu, showing where to select Data Science.

Følg med i en notesbog

Du kan vælge en af disse indstillinger for at følge med i en notesbog:

  • Åbn og kør den indbyggede notesbog i datavidenskabsoplevelsen
  • Upload din notesbog fra GitHub til datavidenskabsoplevelsen

Åbn den indbyggede notesbog

Notesbogen til registrering af svindeleksempel følger med dette selvstudium.

Sådan åbner du selvstudiets indbyggede eksempelnotesbog i Synapse Data Science-oplevelsen:

  1. Gå til startsiden Synapse Data Science.

  2. Vælg Brug et eksempel.

  3. Vælg det tilsvarende eksempel:

    • Fra standardfanen End-to-end-arbejdsprocesser (Python), hvis eksemplet er til et Python-selvstudium.
    • Fra fanen Komplette arbejdsprocesser (R), hvis eksemplet er til et R-selvstudium.
    • Fra fanen Hurtige selvstudier , hvis eksemplet er til et hurtigt selvstudium.

  4. Vedhæft et lakehouse til notesbogen , før du begynder at køre kode.

Importér notesbogen fra GitHub

Notesbogen AIsample – Fraud Detection.ipynb følger med dette selvstudium.

Hvis du vil åbne den medfølgende notesbog til dette selvstudium, skal du følge vejledningen i Forbered dit system til selvstudier om datavidenskab for at importere notesbogen til dit arbejdsområde.

Hvis du hellere vil kopiere og indsætte koden fra denne side, kan du oprette en ny notesbog.

Sørg for at vedhæfte et lakehouse til notesbogen , før du begynder at køre kode.

Trin 1: Installér brugerdefinerede biblioteker

I forbindelse med udvikling af modeller til maskinel indlæring eller ad hoc-dataanalyse skal du muligvis hurtigt installere et brugerdefineret bibliotek til din Apache Spark-session. Du har to muligheder for at installere biblioteker.

  • Brug funktionerne til indbygget installation (%pip eller %conda) i notesbogen til at installere et bibliotek, kun i din aktuelle notesbog.
  • Du kan også oprette et Fabric-miljø, installere biblioteker fra offentlige kilder eller uploade brugerdefinerede biblioteker til det, og derefter kan administratoren af arbejdsområdet vedhæfte miljøet som standard for arbejdsområdet. Alle biblioteker i miljøet bliver derefter tilgængelige til brug i alle notesbøger og Spark-jobdefinitioner i arbejdsområdet. Du kan få flere oplysninger om miljøer under Opret, konfigurer og brug et miljø i Microsoft Fabric.

I dette selvstudium skal du bruge %pip install til at installere imblearn biblioteket i din notesbog.

Bemærk

PySpark-kernen genstartes efter %pip install kørsler. Installer de nødvendige biblioteker, før du kører andre celler.

# Use pip to install imblearn
%pip install imblearn

Trin 2: Indlæs dataene

Datasættet til registrering af svindel indeholder kreditkorttransaktioner fra september 2013, som europæiske kortholdere foretog i løbet af to dage. Datasættet indeholder kun numeriske funktioner på grund af en PCA-transformation (Principal Component Analysis), der er anvendt på de oprindelige funktioner. PCA transformerede alle funktioner undtagen og TimeAmount. For at beskytte fortroligheden kan vi ikke levere de oprindelige funktioner eller flere baggrundsoplysninger om datasættet.

Disse oplysninger beskriver datasættet:

  • Funktionerne V1, V2, V3, , er de vigtigste komponenter, V28 der er hentet med PCA
  • Funktionen Time indeholder de forløbne sekunder mellem en transaktion og den første transaktion i datasættet
  • Funktionen Amount er transaktionsbeløbet. Du kan bruge denne funktion til eksempelafhængig, omkostningsfølsom læring
  • Kolonnen Class er variablen svar (mål). Det har værdien 1 for svindel, og 0 ellers

Kun 492 transaktioner ud af 284.807 transaktioner i alt er falske. Datasættet er meget ubalanceret, fordi minoritetsklassen (falsk) kun tegner sig for ca. 0,172 % af dataene.

I denne tabel vises et eksempel på de creditcard.csv data:

Tid 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 Beløb 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"

Download datasættet, og upload det til lakehouse

Definer disse parametre, så du kan bruge denne notesbog med forskellige datasæt:

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

Denne kode downloader en offentligt tilgængelig version af datasættet og gemmer den derefter i et Fabric lakehouse.

Vigtigt

Sørg for at føje et lakehouse til notesbogen, før du kører den. Ellers får du vist en fejl.

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

Konfigurer sporing af MLflow-eksperiment

Eksperimentsporingsprocessen gemmer alle relevante eksperimentrelaterede oplysninger for hvert eksperiment, du kører. Nogle gange kan du ikke opnå bedre resultater, når du kører et bestemt eksperiment. I disse tilfælde skal du stoppe eksperimentet og prøve et nyt.

Synapse Data Science-oplevelsen i Microsoft Fabric indeholder en funktion til automatisklogning. Denne funktion reducerer den mængde kode, der skal bruges til automatisk at logføre parametre, målepunkter og elementer i en model til maskinel indlæring under træningen. Funktionen udvider funktionerne til automatisk logning af MLflow. Det har dyb integration i datavidenskabsoplevelsen.

Med autologging kan du nemt spore og sammenligne ydeevnen for forskellige modeller og eksperimenter uden behov for manuel sporing. Du kan få flere oplysninger under Automatisk logning i Microsoft Fabric.

Hvis du vil deaktivere automatisk logning af Microsoft Fabric i en notesbogsession, skal du ringe mlflow.autolog() og angive disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Læs rådata fra lakehouse

Denne kode læser rådata fra lakehouse:

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

Trin 3: Udfør udforskning af dataanalyse

I dette afsnit skal du først udforske rådata og statistikker på højt niveau. Hvis du derefter vil transformere dataene, skal du omdanne kolonnerne til de korrekte typer og konvertere dem fra Spark DataFrame til en pandas DataFrame for at gøre det nemmere at visualisere dem. Endelig kan du udforske og visualisere klassedistributionerne i dataene.

Vis rådata

  1. Udforsk rådata, og få vist statistikker på højt niveau med display kommandoen . Du kan få flere oplysninger om datavisualisering under Visualisering af notesbog i Microsoft Fabric.

    display(df)

  2. Udskriv nogle grundlæggende oplysninger om datasættet:

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

Transformér dataene

  1. Cast datasætkolonnerne til de korrekte typer:

    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. Konvertér Spark DataFrame til en pandas DataFrame for at gøre det nemmere at visualisere og behandle:

    df_pd = df.toPandas()

Udforsk klassedistributionen i datasættet

  1. Vis klassedistributionen i datasættet:

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

    Koden returnerer denne datasætklassedistribution: 99,83 % No Frauds og 0,17 % Frauds. Denne klassedistribution viser, at de fleste af transaktionerne ikke er bedrageriske. Derfor er dataforbehandling påkrævet før modeltræning for at undgå overfitting.

  2. Brug en afbildning til at få vist klasseubalancen i datasættet ved at få vist fordelingen af falske transaktioner i forhold til ikke-bedrageriske transaktioner:

    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. Vis femtalsoversigten (minimumresultat, første kvartil, median, tredje kvartil og maksimumscore) for transaktionsbeløbet med feltafbildninger:

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

    I forbindelse med data med høj ubalance viser feltafbildninger muligvis ikke nøjagtig indsigt. Du kan dog først løse problemet med Class ubalancen og derefter oprette de samme afbildninger for at få mere nøjagtig indsigt.

Trin 4: Oplær og evaluer modellerne

Her kan du oplære en LightGBM-model til at klassificere svindeltransaktionerne. Du oplærer en LightGBM-model på både det ubalancerede datasæt og det balancerede datasæt. Derefter skal du sammenligne ydeevnen for begge modeller.

Forbered oplærings- og testdatasæt

Før oplæringen skal du opdele dataene i trænings- og testdatasættene:

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

Anvend SMOTE på træningsdatasættet

Biblioteket imblearn bruger SMOTE-tilgangen (Synthetic Minority Oversampling Technique) til at løse problemet med ubalanceret klassificering. Ubalanceret klassificering sker, når der er for få eksempler på mindretalsklassen tilgængelige, så en model effektivt kan lære beslutningsgrænsen. SMOTE er den mest anvendte metode til at syntetisere nye prøver for minoritetsklassen.

Anvend kun SMOTE på træningsdatasættet i stedet for testdatasættet. Når du scorer modellen med testdataene, skal du have en tilnærmelse af modellens ydeevne for usete data i produktionen. For at opnå en gyldig tilnærmelse er dine testdata baseret på den oprindelige ubalancerede distribution for at repræsentere produktionsdata så tæt som muligt.

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

Du kan finde flere oplysninger om SMOTE på referencesiden for scikit-learn for SMOTE-metoden og brugervejledningen til scikit-learn om oversampling af ressourcer.

Oplær modeller til maskinel indlæring, og kør eksperimenter

Apache Spark i Microsoft Fabric muliggør maskinel indlæring med big data. Med Apache Spark kan du få værdifuld indsigt fra store mængder strukturerede, ustrukturerede og hurtigt bevægende data.

Du har flere tilgængelige muligheder for at oplære modeller til maskinel indlæring med Apache Spark i Microsoft Fabric: Apache Spark MLlib, SynapseML og andre biblioteker med åben kildekode. Du kan få flere oplysninger under Oplær modeller til maskinel indlæring i Microsoft Fabric.

Et maskinel indlæringseksperiment fungerer som den primære enhed i organisationen og styringen for alle relaterede machine learning-kørsler. En kørsel svarer til en enkelt udførelse af modelkoden. Sporing af eksperimenter med maskinel indlæring omfatter administration af alle eksperimenter og deres komponenter, f.eks. parametre, målepunkter, modeller og andre artefakter.

I forbindelse med sporing af eksperimenter kan du organisere alle de påkrævede komponenter i et bestemt machine learning-eksperiment. Derudover kan du nemt genskabe tidligere resultater med gemte eksperimenter. Du kan få flere oplysninger om eksperimenter med maskinel indlæring under Eksperimenter med maskinel indlæring i Microsoft Fabric.

  1. Hvis du vil spore flere målepunkter, parametre og filer, skal du indstille exclusive=False til at opdatere konfigurationen for automatisk logning af MLflow:

    mlflow.autolog(exclusive=False)

  2. Oplær to modeller med LightGBM. Den ene model håndterer det ubalancerede datasæt, og den anden model håndterer det balancerede datasæt (via SMOTE). Sammenlign derefter ydeevnen for de to modeller.

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

Fastlæg vigtigheden af funktioner til oplæring

  1. Bestem vigtigheden af funktioner for den model, du oplærte i det ubalancerede datasæt:

    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. Fastlæg vigtigheden af funktioner for den model, du har oplært i balancerede data. SMOTE genererede de balancerede data:

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

For at oplære en model med det ubalancerede datasæt har de vigtige funktioner betydelige forskelle sammenlignet med en model, der er oplært med det balancerede datasæt.

Evaluer modellerne

Her evaluerer du de to oplærte modeller:

  • model oplært i rå, ubalancerede data
  • smote_model oplært i balancerede data

Målepunkter for beregningsmodel

  1. Definer en prediction_to_spark funktion, der udfører forudsigelser, og konverterer forudsigelsesresultaterne til en Spark DataFrame. Du kan derefter beregne modelstatistikken for forudsigelsesresultaterne med 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. Brug funktionen prediction_to_spark til at udføre forudsigelser med de to modeller og modelsmote_model:

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

  3. Beregningsdata for de to modeller:

    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)

Evaluer modellens ydeevne med en forvirringsmatrix

En forvirringsmatrix viser antallet af

  • true positiver (TP)
  • true negativer (TN)
  • falske positiver (FP)
  • falske negativer (FN)

som en model producerer, når den scores med testdata. I forbindelse med binær klassificering returnerer modellen en 2x2 forvirringsmatrix. I forbindelse med klassificering af flere klasser returnerer modellen en nxn forvirringsmatrix, hvor n er antallet af klasser.

  1. Brug en forvirringsmatrix til at opsummere ydeevnen for de oplærte modeller til maskinel indlæring på testdataene:

    # 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. Afbildning af forvirringsmatrixen for forudsigelserne af smote_model (oplært i balancerede data):

    # 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. Afbildning af forvirringsmatrixen for forudsigelserne af model (oplært i rådata, ubalancerede data):

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

Evaluer modellens ydeevne med AUC-ROC- og AUPRC-målinger

Målingen Area Under the Curve Receiver Operating Characteristic (AUC-ROC) vurderer ydeevnen for binære klassificeringer. Diagrammet AUC-ROC visualiserer afvejning mellem den sande positive rente (TPR) og den falske positive rente (FPR).

I nogle tilfælde er det mere hensigtsmæssigt at evaluere din klassificering baseret på målingen Area Under the Precision-Recall Curve (AUPRC). AUPRC-kurven kombinerer disse satser:

  • Præcisionen eller den positive forudsigende værdi (PPV)
  • Tilbagekaldelsen eller TPR

Sådan evaluerer du ydeevnen med målingerne AUC-ROC og AUPRC:

  1. Definer en funktion, der returnerer målingerne AUC-ROC og 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

  2. Logfør målepunkterne AUC-ROC og AUPRC for den model, du oplærte på ubalancerede data:

    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. Logfør målepunkterne AUC-ROC og AUPRC for den model, du oplærte på balancerede data:

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

Den model, der er oplært i balancerede data, returnerer højere AUC-ROC- og AUPRC-værdier sammenlignet med den model, der er oplært i ubalancerede data. Baseret på disse målinger virker SMOTE som en effektiv teknik til at forbedre modellens ydeevne, når du arbejder med data med meget ubalancerede data.

Som det næste billede viser, logføres alle eksperimenter med deres respektive navn. Du kan spore eksperimentparametrene og målepunkterne for ydeevnen i dit arbejdsområde.

Screenshot of the tracked experiment.

Dette billede viser metrikværdierne for ydeevnen for den model, der er oplært i det balancerede datasæt (i version 2):

Screenshot of logged model performance metrics and model parameters.

Du kan vælge Version 1 for at se målepunkterne for den model, der er oplært i det ubalancerede datasæt. Når du sammenligner målepunkterne, er AUROC højere for den model, der er oplært med det balancerede datasæt. Disse resultater angiver, at denne model er bedre til korrekt at 0 forudsige klasser som 0og forudsige 1 klasser som 1.

Trin 5: Registrer modellerne

Brug MLflow til at registrere de to modeller:

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

Trin 6: Gem forudsigelsesresultaterne

Microsoft Fabric giver brugerne mulighed for at anvende modeller til maskinel indlæring med den PREDICT skalerbare funktion. Denne funktion understøtter batchscore (eller batchafledning) i et hvilket som helst beregningsprogram.

Du kan generere batchforudsigelser direkte fra Microsoft Fabric-notesbogen eller fra en models elementside. Du kan få flere oplysninger om PREDICTunder Modelscore med PREDICT i Microsoft Fabric.

  1. Indlæs modellen med bedre ydeevne (version 2) for batchscore, og generér forudsigelsesresultaterne:

    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. Gem forudsigelser i lakehouse:

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

Relateret indhold