Del via

Opplæring: Opprette, evaluere og få en modell for svindelregistrering

  • Artikkel

Denne opplæringen presenterer et ende-til-ende-eksempel på en Synapse Data Science-arbeidsflyt i Microsoft Fabric. Scenarioet bygger en svindelregistreringsmodell med maskinlæringsalgoritmer som er opplært i historiske data. Den bruker deretter modellen til å oppdage fremtidige falske transaksjoner.

Denne opplæringen dekker disse trinnene:

  • Installere egendefinerte biblioteker
  • Laste inn dataene
  • Forstå og behandle dataene gjennom utforskende dataanalyse
  • Bruk scikit-learn til å lære opp en maskinlæringsmodell, og spor eksperimenter med MLflow- og Fabric Autologging-funksjonene
  • Lagre og registrer maskinlæringsmodellen som har høyest ytelse
  • Last inn maskinlæringsmodellen for scoring og for å lage prognoser

Forutsetninger

Følg med i en notatblokk

Du kan velge ett av disse alternativene for å følge med i en notatblokk:

  • Åpne og kjør den innebygde notatblokken.
  • Last opp notatblokken fra GitHub.

Åpne den innebygde notatblokken

Eksemplet Svindelregistrering notatblokk følger med denne opplæringen.

  1. Hvis du vil åpne eksempelnotatblokken for denne opplæringen, følger du instruksjonene i Klargjør systemet for.

  2. Pass på å feste et lakehouse til notatblokken før du begynner å kjøre kode.

Importere notatblokken fra GitHub

AIsample – Fraud Detection.ipynb notatblokk følger med denne opplæringen.

Trinn 1: Installere egendefinerte biblioteker

For utvikling av maskinlæringsmodeller eller ad hoc-dataanalyse, må du kanskje raskt installere et egendefinert bibliotek for Apache Spark-økten. Du har to alternativer for å installere biblioteker.

  • Bruk de innebygde installasjonsfunksjonene (%pip eller %conda) i notatblokken til å installere et bibliotek, bare i gjeldende notatblokk.
  • Alternativt kan du opprette et stoffmiljø, installere biblioteker fra offentlige kilder eller laste opp egendefinerte biblioteker til det, og deretter kan administratoren for arbeidsområdet legge ved miljøet som standard for arbeidsområdet. Alle bibliotekene i miljøet blir da tilgjengelige for bruk i alle notatblokker og Spark-jobbdefinisjoner i arbeidsområdet. Hvis du vil ha mer informasjon om miljøer, kan du se opprette, konfigurere og bruke et miljø i Microsoft Fabric.

For denne opplæringen kan du bruke %pip install til å installere imblearn biblioteket i notatblokken.

Notat

PySpark-kjernen starter på nytt etter at %pip install kjører. Installer de nødvendige bibliotekene før du kjører andre celler.

# Use pip to install imblearn
%pip install imblearn

Trinn 2: Laste inn dataene

Datasettet for svindelregistrering inneholder kredittkorttransaksjoner, fra september 2013, som europeiske kortholdere har gjort i løpet av to dager. Datasettet inneholder bare numeriske funksjoner på grunn av en PCA-transformasjon (Principal Component Analysis) som brukes på de opprinnelige funksjonene. PCA transformerte alle funksjoner bortsett fra Time og Amount. For å beskytte konfidensialiteten kan vi ikke oppgi de opprinnelige funksjonene eller mer bakgrunnsinformasjon om datasettet.

Disse detaljene beskriver datasettet:

  • Funksjonene V1, V2, V3, ..., V28 er hovedkomponentene som hentes med PCA
  • Funksjonen Time inneholder de forløpte sekundene mellom en transaksjon og den første transaksjonen i datasettet
  • Funksjonen Amount er transaksjonsbeløpet. Du kan bruke denne funksjonen for eksempel avhengig, kostnadssensitiv læring
  • Kolonnen Class er svarvariabelen (mål). Den har verdien 1 for svindel, og 0 ellers

Bare 492 transaksjoner, av totalt 284 807 transaksjoner, er falske. Datasettet er svært ubalansert, fordi minoritetsklassen (uredelig) står for bare om lag 0,172% av dataene.

Denne tabellen viser en forhåndsvisning av 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øp 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"

Last ned datasettet og last opp til lakehouse

Definer disse parameterne, slik at du kan bruke denne notatblokken med forskjellige datasett:

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 koden laster ned en offentlig tilgjengelig versjon av datasettet, og lagrer den deretter i et Fabric Lakehouse.

Viktig

Pass på å legge til et lakehouse- i notatblokken før du kjører den. Ellers får du en feilmelding.

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

Konfigurere sporing av MLflow-eksperimenter

Eksperimentsporingsprosessen lagrer all relevant eksperimentrelatert informasjon for hvert eksperiment du kjører. Noen ganger kan du ikke oppnå bedre resultater når du kjører et bestemt eksperiment. I slike tilfeller bør du stoppe eksperimentet og prøve en ny.

Synapse Data Science-opplevelsen i Microsoft Fabric inkluderer en autologgingsfunksjon. Denne funksjonen reduserer hvor mye kode som kreves for å logge parameterne, måledataene og elementene i en maskinlæringsmodell automatisk under opplæring. Funksjonen utvider egenskapene for automatisk tillogging av MLflow. Den har dyp integrering i datavitenskapsopplevelsen.

Med autologging kan du enkelt spore og sammenligne ytelsen til ulike modeller og eksperimenter, uten behov for manuell sporing. Hvis du vil ha mer informasjon, kan du se Autologging i Microsoft Fabric.

Hvis du vil deaktivere Automatisk tillogging av Microsoft Fabric i en notatblokkøkt, ringer du mlflow.autolog() og angir disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Les rådata fra lakehouse

Denne koden leser rådata fra lakehouse:

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

Trinn 3: Utfør utforskende dataanalyse

I denne delen utforsker du først rådata og statistikk på høyt nivå. Hvis du deretter vil transformere dataene, kaster du kolonnene til de riktige typene og konverterer dem fra Spark DataFrame til en pandas DataFrame for enklere visualisering. Til slutt utforsker og visualiserer du klassefordelingene i dataene.

Vise rådataene

  1. Utforsk rådataene, og vis statistikk på høyt nivå med kommandoen display. Hvis du vil ha mer informasjon om datavisualisering, kan du se visualisering av notatblokker i Microsoft Fabric.

    display(df)

  2. Skriv ut grunnleggende informasjon om datasettet:

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

Transformere dataene

  1. Kast datasettkolonnene til de riktige typene:

    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. Konverter Spark DataFrame til en pandas DataFrame for enklere visualisering og behandling:

    df_pd = df.toPandas()

Utforske klassedistribusjonen i datasettet

  1. Vis klassedistribusjonen i datasettet:

    # 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 datasettklassefordelingen: 99,83% No Frauds og 0,17% Frauds. Denne klassedistribusjonen viser at de fleste transaksjonene ikke er bindende. Derfor kreves forhåndsbehandling av data før modellopplæring, for å unngå overtilpasset.

  2. Bruk et plott for å vise klasseubalansen i datasettet ved å vise fordelingen av falske kontra ikke-krenkende transaksjoner:

    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 sammendrag med fem tall (minimumspoengsum, første kvartil, median, tredje kvartil og maksimal poengsum) for transaksjonsbeløpet, med boksplott:

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

    For svært ubalanserte data kan det hende at bokstegninger ikke viser nøyaktig innsikt. Du kan imidlertid løse problemet med Class ubalanse først, og deretter opprette de samme plottene for mer nøyaktig innsikt.

Trinn 4: Lære opp og evaluere modellene

Her lærer du opp en LightGBM-modell for å klassifisere svindeltransaksjonene. Du lærer opp en LightGBM-modell både på det ubalanserte datasettet og det balanserte datasettet. Deretter sammenligner du ytelsen til begge modellene.

Klargjøre opplærings- og testdatasett

Før opplæring deler du dataene inn i opplærings- og testdatasettene:

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

Bruk SMOTE på opplæringsdatasettet

Biblioteket imblearn bruker SMOTE-tilnærmingen (Synthetic Minority Oversampling Technique) til å løse problemet med ubalansert klassifisering. Ubalansert klassifisering skjer når for få eksempler på minoritetsklassen er tilgjengelige, for en modell for effektivt å lære beslutningsgrensen. SMOTE er den mest brukte tilnærmingen til å syntetisere nye eksempler for minoritetsklassen.

Bruk SMOTE bare på opplæringsdatasettet i stedet for testdatasettet. Når du scorer modellen med testdataene, trenger du en tilnærming av modellytelsen på usynlige data i produksjon. For en gyldig tilnærming er testdataene avhengig av den opprinnelige ubalanserte fordelingen for å representere produksjonsdata så nært som mulig.

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

Hvis du vil ha mer informasjon om SMOTE, kan du se referansesiden for scikit-learn for SMOTE-metoden og scikit-learn-brukerveiledning om oversampling ressurser.

Lære opp maskinlæringsmodeller og kjøre eksperimenter

Apache Spark, i Microsoft Fabric, muliggjør maskinlæring med store data. Med Apache Spark kan du få verdifull innsikt fra store mengder strukturerte, ustrukturerte og raske data.

Du har flere tilgjengelige alternativer for å lære opp maskinlæringsmodeller med Apache Spark i Microsoft Fabric: Apache Spark MLlib, SynapseML og andre biblioteker med åpen kildekode. Hvis du vil ha mer informasjon, kan du se Lære opp maskinlæringsmodeller i Microsoft Fabric.

Et maskinlæringseksperiment fungerer som den primære enheten i organisasjonen og kontroll for alle relaterte maskinlæringskjøringer. En kjøre tilsvarer en enkelt kjøring av modellkode. Maskinlæring eksperimentsporing innebærer administrasjon av alle eksperimenter og komponenter, for eksempel parametere, måledata, modeller og andre artefakter.

For eksperimentsporing kan du organisere alle nødvendige komponenter i et bestemt maskinlæringseksperiment. I tillegg kan du enkelt gjenskape tidligere resultater med lagrede eksperimenter. Hvis du vil ha mer informasjon om maskinlæringseksperimenter, kan du se maskinlæringseksperimenter i Microsoft Fabric.

  1. Hvis du vil spore flere måledata, parametere og filer, angir du exclusive=False for å oppdatere konfigurasjonen for automatisk tillogging av MLflow:

    mlflow.autolog(exclusive=False)

  2. Lær opp to modeller med LightGBM. Én modell håndterer det ubalanserte datasettet, og den andre modellen håndterer det balanserte datasettet (via SMOTE). Sammenlign deretter ytelsen til de to modellene.

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

Fastslå viktighet for funksjoner for opplæring

  1. Bestem funksjonsbetydning for modellen du har opplært på det ubalanserte datasettet:

    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. Bestem funksjonsbetydning for modellen du har kalibrert på balanserte data. SMOTE genererte de balanserte dataene:

    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 å lære opp en modell med det ubalanserte datasettet, har de viktige funksjonene betydelige forskjeller sammenlignet med en modell som er opplært med det balanserte datasettet.

Evaluer modellene

Her evaluerer du de to opplærte modellene:

  • model opplært på rå, ubalanserte data
  • smote_model opplært på balanserte data

Måledata for databehandlingsmodell

  1. Definer en prediction_to_spark funksjon som utfører prognoser, og konverterer prognoseresultatene til en Spark DataFrame. Du kan deretter beregne modellstatistikk på prognoseresultatene 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. Bruk prediction_to_spark-funksjonen til å utføre prognoser med de to modellene, model og smote_model:

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

  3. Beregningsdata for de to modellene:

    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 modellytelse med en forvirringsmatrise

En forvirringsmatrise viser antall

  • sanne positiver (TP)
  • sanne negativer (TN)
  • falske positiver (FP)
  • usann negativer (FN)

som en modell produserer når den blir scoret med testdata. For binær klassifisering returnerer modellen en 2x2 forvirringsmatrise. For flerklasseklassifisering returnerer modellen en nxn forvirringsmatrise, der n er antall klasser.

  1. Bruk en forvirringsmatrise til å oppsummere forestillingene til de opplærte maskinlæringsmodellene 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. Tegn inn forvirringsmatrisen for prognosene for smote_model (opplært på balanserte 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. Tegn inn forvirringsmatrisen for prognosene til model (opplært på rå, ubalanserte data):

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

Evaluer modellytelse med AUC-ROC- og AUPRC-mål

Målet Area Under the Curve Receiver Operating Characteristic (AUC-ROC) vurderer ytelsen til binære klassifikatorer. Diagrammet AUC-ROC visualiserer avveiningen mellom den sanne positive satsen (TPR) og den falske positive kursen (FPR).

I noen tilfeller er det mer hensiktsmessig å evaluere klassifisereren basert på målet Område under Precision-Recall Kurve (AUPRC). AUPRC-kurven kombinerer disse satsene:

  • Presisjonen eller den positive prediktive verdien (PPV)
  • Tilbakekallingen, eller TPR

Slik evaluerer du ytelsen med AUC-ROC- og AUPRC-mål:

  1. Definer en funksjon som returnerer AUC-ROC- og AUPRC-mål:

    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. Logg AUC-ROC og AUPRC-måledata for modellen som du har kalibrert på ubalanserte 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. Logg AUC-ROC og AUPRC-måledata for modellen som du har kalibrert på balanserte 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})

Modellen som er opplært på de balanserte dataene, returnerer høyere AUC-ROC- og AUPRC-verdier sammenlignet med modellen som er opplært i ubalanserte data. Basert på disse tiltakene virker SMOTE som en effektiv teknikk for å forbedre modellytelsen når du arbeider med svært ubalanserte data.

Som det neste bildet viser, logges ethvert eksperiment med sitt respektive navn. Du kan spore eksperimentparametere og ytelsesmåledata i arbeidsområdet.

Skjermbilde av det sporede eksperimentet.

Dette bildet viser ytelsesmåledataene for modellen som er opplært i det balanserte datasettet (i versjon 2):

Skjermbilde av ytelsesmåledata for loggført modell og modellparametere.

Du kan velge versjon 1 for å se måledataene for modellen som er opplært i det ubalanserte datasettet. Når du sammenligner måledataene, er AUROC høyere for modellen som er opplært med det balanserte datasettet. Disse resultatene indikerer at denne modellen er bedre til å forutsi 0 klasser som 0, og forutsi 1 klasser som 1.

Trinn 5: Registrere modellene

Bruk MLflow til å registrere de to modellene:

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

Trinn 6: Lagre prognoseresultatene

Microsoft Fabric gjør det mulig for brukere å operasjonalisere maskinlæringsmodeller med PREDICT skalerbar funksjon. Denne funksjonen støtter satsvis poengsum (eller satsvis inferencing) i en hvilken som helst databehandlingsmotor.

Du kan generere satsvise prognoser direkte fra Microsoft Fabric-notatblokken eller fra en modells elementside. Hvis du vil ha mer informasjon om PREDICT, kan du se Model scoring med PREDICT i Microsoft Fabric.

  1. Last inn modellen med bedre ytelse (versjon 2) for satsvis poengsum, og generer prognoseresultatene:

    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. Lagre prognoser til lakehouse:

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

Relatert innhold