Opplæring: Opprette, evaluere og få en modell for svindelregistrering
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
Forutsetning
Få et Microsoft Fabric-abonnement. Eller registrer deg for en gratis prøveversjon av Microsoft Fabric.
Logg på Microsoft Fabric.
Bruk opplevelsesbryteren til venstre på hjemmesiden for å bytte til Synapse Data Science-opplevelsen.
- Opprett om nødvendig et Microsoft Fabric lakehouse som beskrevet i Create a lakehouse i Microsoft Fabric.
Følg med i en notatblokk
Du kan velge ett av disse alternativene for å følge med i en notatblokk:
- Åpne og kjøre den innebygde notatblokken i datavitenskapsopplevelsen
- Last opp notatblokken fra GitHub til Data Science-opplevelsen
Åpne den innebygde notatblokken
Notatblokken for gjenkjenning av svindel følger med denne opplæringen.
Slik åpner du opplæringens innebygde eksempelnotatblokk i Synapse Data Science-opplevelsen:
Gå til hjemmesiden for Synapse Data Science.
Velg Bruk et eksempel.
Velg det tilsvarende eksemplet:
- Hvis eksemplet er for en Python-opplæring, fra standard fanen Ende-til-ende-arbeidsflyter (Python ).
- Hvis eksemplet er for en R-opplæring fra R-fanen fra ende til ende-til-ende-arbeidsflyter (R).
- Hvis eksemplet er for en rask opplæring fra fanen Hurtigopplæringer .
Legg ved et lakehouse i notatblokken før du begynner å kjøre kode.
Importere notatblokken fra GitHub
Notatblokken AIsample – Fraud Detection.ipynb følger med denne opplæringen.
Hvis du vil åpne den medfølgende notatblokken for denne opplæringen, følger du instruksjonene i Klargjør systemet for opplæring for datavitenskap, for å importere notatblokken til arbeidsområdet.
Hvis du heller vil kopiere og lime inn koden fra denne siden, kan du opprette en ny notatblokk.
Pass på at du fester et lakehouse til notatblokken før du begynner å kjøre kode.
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.
Merk
PySpark-kjernen starter på nytt etter %pip install
kjøringer. 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 Time
fra og Amount
. For å beskytte konfidensialiteten kan vi ikke oppgi de opprinnelige funksjonene eller mer bakgrunnsinformasjon om datasettet.
Disse detaljene beskriver datasettet:
- Funksjonene
V1
, ,V3
V2
... ,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 verdien1
for svindel, og0
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 mlflow.autolog()
du 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
Utforsk rådataene, og vis statistikk på høyt nivå med
display
kommandoen. Hvis du vil ha mer informasjon om datavisualisering, kan du se Visualisering av notatblokker i Microsoft Fabric.display(df)
Skriv ut grunnleggende informasjon om datasettet:
# Print dataset basic information print("records read: " + str(df.count())) print("Schema: ") df.printSchema()
Transformere dataene
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)
Konverter Spark DataFrame til en pandas DataFrame for enklere visualisering og behandling:
df_pd = df.toPandas()
Utforske klassedistribusjonen i datasettet
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 distribusjonen av datasettklassen: 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.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)
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
Class
ubalanseproblemet 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 den syntetiske minoritetsoversamplingsteknikken (SMOTE) 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 brukerveiledningen for scikit-learn om oversampling av 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 for organisering og kontroll for alle relaterte maskinlæringskjøringer. En kjøring tilsvarer en enkelt kjøring av modellkode. Sporing av maskinlæringseksperimenter innebærer administrasjon av alle eksperimentene og komponentene, 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.
Hvis du vil spore flere måledata, parametere og filer, må
exclusive=False
du oppdatere konfigurasjonen for automatisk tillogging av MLflow:mlflow.autolog(exclusive=False)
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
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")
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 datasmote_model
opplært på balanserte data
Måledata for databehandlingsmodell
Definer en
prediction_to_spark
funksjon som utfører prognoser, og konverterer prognoseresultatene til en Spark DataFrame. Deretter kan du 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
prediction_to_spark
Bruk funksjonen til å utføre prognoser med de to modellene,model
ogsmote_model
:predictions = prediction_to_spark(model, test) smote_predictions = prediction_to_spark(smote_model, test) predictions.limit(10).toPandas()
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 forvirringsmatrise 2x2
. For flerklasseklassifisering returnerer modellen en forvirringsmatrise nxn
, hvor n
er antall klasser.
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)
Tegn inn forvirringsmatrisen for prognosene
smote_model
for (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")
Tegn inn forvirringsmatrisen for prognosene
model
til (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
Area Under the Curve Receiver Operating Characteristic (AUC-ROC) måler ytelsen til binære klassifikatorer. AUC-ROC-diagrammet visualiserer avveiningen mellom den sanne positive kursen (TPR) og den falske positive satsen (FPR).
I noen tilfeller er det mer hensiktsmessig å evaluere klassifisereren basert på målet Område under Presisjonstilbakekallingskurven (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ålene:
Definer en funksjon som returnerer AUC-ROC- og AUPRC-målene:
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
Logg AUC-ROC- og AUPRC-måledataene 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})
Logg AUC-ROC- og AUPRC-måledataene for modellen 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 på 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.
Dette bildet viser ytelsesmåledataene for modellen som er opplært i det balanserte datasettet (i versjon 2):
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
klassene riktig 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 skalerbar PREDICT
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, PREDICT
kan du se Modellpoengberegning med PREDICT i Microsoft Fabric.
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)
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
Tilbakemeldinger
https://aka.ms/ContentUserFeedback.
Kommer snart: Gjennom 2024 faser vi ut GitHub Issues som tilbakemeldingsmekanisme for innhold, og erstatter det med et nytt system for tilbakemeldinger. Hvis du vil ha mer informasjon, kan du se:Send inn og vis tilbakemelding for