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

Artikel
01/14/2025

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 Microsoft Fabric-prøveversion.
Log på Microsoft Fabric.
Brug oplevelsesskifteren nederst til venstre på startsiden til at skifte til Fabric.

Opret om nødvendigt et Microsoft Fabric lakehouse som beskrevet i Opret et lakehouse i Microsoft Fabric.

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.
Upload din notesbog fra GitHub.

Åbn den indbyggede notesbog

Eksemplet Registrering af svindel notesbog følger med dette selvstudium.

Hvis du vil åbne eksempelnotesbogen til dette selvstudium, skal du følge vejledningen i Forbered dit system til selvstudier om datavidenskab.
Sørg for at vedhæfte et lakehouse til notesbogen, før du begynder at køre kode.

Importér notesbogen fra GitHub

Den AIsample – Fraud Detection.ipynb notesbog 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 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 de indbyggede installationsegenskaber (%pip eller %conda) i notesbogen til kun at installere et bibliotek 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 oprette, konfigurere og bruge et miljø i Microsoft Fabric.

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

Seddel

PySpark-kernen genstartes, når %pip install har kørt. 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 Time og Amount. 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, ..., V28 er de vigtigste komponenter, 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:

Tidspunkt	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.

Vigtig

Sørg for at føje en 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 til 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

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

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

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)

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

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.

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)

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 ubalance 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-metoden (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 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 for organisation og kontrol for alle relaterede machine learning-kørsler. En kørsel svarer til en enkelt udførelse af modelkoden. Machine learning eksperimentsporing involverer 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.

Hvis du vil spore flere målepunkter, parametre og filer, skal du angive exclusive=False for at opdatere konfigurationen for automatisk logning af MLflow:
```
mlflow.autolog(exclusive=False)
```

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

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

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ådata, ubalancerede data
smote_model oplært i balancerede data

Målepunkter for beregningsmodel

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

Brug funktionen prediction_to_spark til at udføre forudsigelser med de to modeller, model og smote_model:

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

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.

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)

Afbildning af forvirringsmatrixen for forudsigelserne for 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")

Afbildning af forvirringsmatrixen for forudsigelserne for 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 afvejninger 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:

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

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

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 oplæres 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.

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

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 forudsige 0 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 Model scoring med PREDICT i Microsoft Fabric.

Indlæs modellen med en 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)

Gem forudsigelser i lakehouse:

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

Del via

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

Forudsætninger

Følg med i en notesbog

Åbn den indbyggede notesbog

Importér notesbogen fra GitHub

Trin 1: Installér brugerdefinerede biblioteker

Trin 2: Indlæs dataene

Download datasættet, og upload det til lakehouse

Konfigurer sporing af MLflow-eksperiment

Læs rådata fra lakehouse

Trin 3: Udfør udforskning af dataanalyse

Vis rådata

Transformér dataene

Udforsk klassedistributionen i datasættet

Trin 4: Oplær og evaluer modellerne

Forbered oplærings- og testdatasæt

Anvend SMOTE på træningsdatasættet

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

Fastlæg vigtigheden af funktioner til oplæring

Evaluer modellerne

Målepunkter for beregningsmodel

Evaluer modellens ydeevne med en forvirringsmatrix

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

Trin 5: Registrer modellerne

Trin 6: Gem forudsigelsesresultaterne

Feedback

Yderligere ressourcer

Del via

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

Forudsætninger

Følg med i en notesbog

Åbn den indbyggede notesbog

Importér notesbogen fra GitHub

Trin 1: Installér brugerdefinerede biblioteker

Trin 2: Indlæs dataene

Download datasættet, og upload det til lakehouse

Konfigurer sporing af MLflow-eksperiment

Læs rådata fra lakehouse

Trin 3: Udfør udforskning af dataanalyse

Vis rådata

Transformér dataene

Udforsk klassedistributionen i datasættet

Trin 4: Oplær og evaluer modellerne

Forbered oplærings- og testdatasæt

Anvend SMOTE på træningsdatasættet

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

Fastlæg vigtigheden af funktioner til oplæring

Evaluer modellerne

Målepunkter for beregningsmodel

Evaluer modellens ydeevne med en forvirringsmatrix

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

Trin 5: Registrer modellerne

Trin 6: Gem forudsigelsesresultaterne

Relateret indhold

Feedback

Yderligere ressourcer