Opetusohjelma: Petosten havaitsemismallin luominen, arvioiminen ja pisteytys

Tämä opas esittelee kokonaisvaltaisen esimerkin Synapse Data Science -työnkulusta Microsoft Fabric -tilassa. Skenaario rakentaa petosten tunnistusmallin, jossa machine learning algoritmit on koulutettu historiallisten tietojen pohjalta. Se käyttää sitten mallia tulevien vilpillisten tapahtumien tunnistamiseen.

Tässä opetusohjelmassa käsitellään seuraavat vaiheet:

Edellytykset

• Hanki Microsoft Fabric-tilaus. Tai tilaa ilmainen Microsoft Fabric kokeilujakso.

• Kirjaudu sisään Microsoft Fabric.

• Vaihda Fabric-tilaan käyttämällä etusivun vasemmassa alakulmassa olevaa kokemuskytkintä.

  

• Tarvittaessa luo Microsoft Fabric järvimajoitus kuten Luo järvenrakennus Microsoft Fabric:ssa.

Seuraa mukana muistikirjassa

Jos haluat seurata vihkossa, valitse jokin näistä vaihtoehdoista:

• Avaa ja suorita sisäinen muistikirja.
• Lataa muistikirjasi GitHubista.

Avaa sisäinen muistikirja

Tämän opetusohjelman mukana on malli Petosten havaitseminen muistikirja.

1. Avaa tätä opetusohjelmaa varten näytemuistikirja noudattamalla ohjeita kohdassa Järjestelmän valmisteleminen datatieteen opetusohjelmia varten.

2. Varmista, että liittää lakehouse- ennen kuin aloitat koodin suorittamisen.

Tuo muistikirja GitHub:sta

Tämän tutoriaalin yhteydessä on AIsample - Fraud Detection.ipynb -muistikirja.

• Jos haluat avata tämän opetusohjelman liitteenä olevan muistikirjan, noudata ohjeita kohdassa Valmistele järjestelmäsi datatiedeopetusohjelmia varten muistikirjan tuomiseksi työtilaasi.

• Jos haluat kopioida ja liittää koodin tältä sivulta, voit luoda uuden muistikirjan.

• Muista liittää muistikirjaan lakehouse- ennen kuin aloitat koodin suorittamisen.

Vaihe 1: Mukautettujen kirjastojen asentaminen

Machine learning-mallien kehitykseen tai ad hoc -data-analyysiin saatat joutua asentamaan nopeasti oman kirjaston Apache Spark -istuntoasi varten. Sinulla on kaksi vaihtoehtoa kirjastojen asentamiseen.

• Asenna kirjasto nykyiseen muistikirjaasi käyttämällä muistikirjasi sisäiset asennusominaisuudet (%pip tai %conda).
• Vaihtoehtoisesti voit luoda Fabric-ympäristön, asentaa kirjastoja julkisista lähteistä tai ladata mukautettuja kirjastoja siihen, jonka jälkeen työtilan järjestelmänvalvoja voi liittää ympäristön työtilan oletusarvoksi. Kaikki ympäristön kirjastot ovat käytettävissä kaikissa muistikirjoissa ja Spark-työtehtävien määrittelyissä työtilassa. Lisätietoja ympäristöistä löytyy kohdasta luo, konfiguroi ja käytä ympäristöä Microsoft Fabric.

Tässä opetusohjelmassa asenna %pip install-kirjasto muistikirjaasi imblearn avulla.

# Use pip to install imblearn
%pip install imblearn

Vaihe 2: Lataa tiedot

Petosten tunnistusaineisto sisältää syyskuun 2013 luottokorttitapahtumia, joita eurooppalaiset kortinhaltijat tekivät kahden päivän aikana. Tietojoukko sisältää vain numeerisia ominaisuuksia, koska alkuperäisissä ominaisuuksissa käytetään PÄÄkomponenttianalyysia (PCA). PCA muunsi kaikki ominaisuudet lukuun ottamatta Time ja Amount. Luottamuksellisuuden suojaamiseksi aineiston alkuperäisiä ominaisuuksia tai muuta taustatietoa ei ole saatavilla.

Nämä tiedot kuvaavat tietojoukkoa:

• , V1V2, V3, ..., V28 ominaisuudet ovat pääkomponentteja, jotka saadaan PCA:lla.
• Ominaisuus Time sisältää sekunnit transaktion ja ensimmäisen transaktion välillä aineistossa.
• Amount ominaisuus on tapahtuman summa. Voit käyttää tätä ominaisuutta esimerkiksi riippuvaisessa, kustannusherkässä oppimisessa.
• Class sarake on vastausmuuttuja (kohde). Sillä on arvoa 1 petoksena ja 0 muuhun.

Vain 492 tapahtumaa 284 807 tapahtumasta on vilpillisiä. Tietojoukko on epätasapainoinen, koska vähemmistön (vilpillinen) luokan osuus tiedoista on vain noin 0,172%.

Tässä taulukossa on esiversio creditcard.csv tiedoista:

Lataa tietojoukko ja lataa se Lakehouse-palveluun

Määrittele nämä parametrit niin, että voit käyttää tätä muistikirjaa eri tietoaineistojen kanssa:

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

Tämä koodi lataa tietojoukosta julkisesti saatavilla olevan version ja tallentaa sen Fabric Lakehouse -järjestelmään.

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.z13.web.core.windows.net/data/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/default"):
        raise FileNotFoundError("Default lakehouse not found, please add a lakehouse and restart the session.")
    os.makedirs(download_path, exist_ok=True)
    if not os.path.exists(f"{download_path}/{fname}"):
        r = requests.get(f"{remote_url}/{fname}", timeout=30)
        with open(f"{download_path}/{fname}", "wb") as f:
            f.write(r.content)
    print("Downloaded demo data files into lakehouse.")

MLflow-kokeilujen seurannan määrittäminen

Kokeilujen seurantaprosessi tallentaa kaikki olennaiset kokeiluihin liittyvät tiedot jokaisesta suorittamastasi kokeesta. Joskus et saa parempia tuloksia, kun teet tietyn kokeen. Näissä tapauksissa lopeta koe ja kokeile uutta.

Synapse Data Science -kokemukseen Microsoft Fabric sisältää automaattisen lokitusominaisuuden. Tämä ominaisuus vähentää koodin määrää, joka vaaditaan automaattisesti parametrien, mittareiden ja machine learning-mallin kohteiden kirjaamiseen koulutuksen aikana. Ominaisuus laajentaa MLflow'n automaattisen lokeroinnin ominaisuuksia. Se on integroitu syvästi datatieteen kokemukseen.

Autologgauksen avulla voit helposti seurata ja vertailla eri mallien ja kokeiden suorituskykyä ilman manuaalista seurantaa. Lisätietoja löytyy osoitteesta Autologging Microsoft Fabric.

Poistaaksesi Microsoft Fabric automaattisen kirjautumisen muistikirjan istunnossa, soita mlflow.autolog() ja aseta disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Raakadata Lakehousesta

Tässä koodissa lukee raakadataa Lakehousesta:

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

Vaihe 3: Suorita valmisteleva tietoanalyysi

Tässä osiossa tutustut ensin raakatietoihin ja korkean tason tilastotietoihin. Muunna sitten sarakkeet oikeantyyppisiksi ja muunna ne Spark DataFrame -kehyksestä pandas DataFrame -kehykseksi visualisoinnin helpottamiseksi. Lopuksi voit tutkia ja visualisoida tiedoissa olevia luokan jakaumia.

Raakatietojen näyttäminen

1. Tutki raakadataa ja katso korkean tason tilastoja käyttämällä komentoa display . Lisätietoja datavisualisoinnista löytyy Notebook-visualisointi Microsoft Fabric:ssa.

   display(df)
   

2. Tulosta joitakin tietojoukon perustietoja:

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

Tietojen muuntaminen

1. Muunna tietojoukon sarakkeet oikeisiin tyyppeihin:

   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. Muunna Spark DataFrame pandas DataFrame -kehykseksi visualisoinnin ja käsittelyn helpottamiseksi:

   df_pd = df.toPandas()
   

Tutustu luokan jakaumaan tietojoukossa

1. Näytä luokan jakauma tietojoukossa:

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

   Koodi palauttaa tämän tietojoukkoluokan jakauman: 99,83% No Frauds ja 0,17% Frauds. Tämä luokkajakauma näyttää, että suurin osa tapahtumista ei ole ole sitovaa. Siksi datan esikäsittely on välttämätöntä ennen mallin koulutusta ylisovituksen välttämiseksi.

2. Käytä kaaviota luokan epätasapainon osoittamiseksi tietojoukossa tarkastelemalla vilpillisten ja ei-maksuttomien tapahtumien jakaumaa:

   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. Näytä tapahtuman summan viiden numeron yhteenveto (vähimmäispistemäärä, ensimmäinen louhos, mediaani, kolmas kvartile ja enimmäispistemäärä) ruututuloksilla:

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

   Jos tiedot ovat epätasapainoisia, ruutukaavioissa ei välttämättä näy tarkkoja merkityksellisiä tietoja. Voit kuitenkin ratkaista ensin Class epätasapainoongelman ja luoda sitten samat kaaviot tarkempien merkityksellisten tietojen luomiseksi.

Vaihe 4: Mallien harjoittaminen ja arvioiminen

Tässä vaiheessa koulutat LightGBM-mallin luokittelemaan petostapahtumat. Voit harjoittaa LightGBM-mallin sekä epätasapainoisen tietojoukon että tasapainotetun tietojoukon perusteella. Sen jälkeen voit verrata molempien mallien suorituskykyä.

Koulutuksen ja testitietojoukkojen valmistelu

Ennen koulutusta tiedot jaetaan harjoittamisen ja testin tietojoukkoihin:

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

Sovella SMOTE:a koulutustietojoukkoon

imblearn kirjasto käyttää synteettisen vähemmistön ylimyyntitekniikkaa (SMOTE) ratkaistakseen epätasapainoisen luokituksen ongelman. Epätasapainoinen luokitus tapahtuu, kun vähemmistöluokasta on saatavilla liian vähän esimerkkejä, jotta malli oppisi tehokkaasti päätösrajan. SMOTE on yleisin tapa syntetisoida uusia näytteitä vähemmistöluokalle.

Käytä SMOTE-arvoa vain koulutuksen tietojoukkoon testitietojoukon sijaan. Kun annat mallille testitiedot, tarvitset arvion mallin suorituskyvystä, kun et näe tietoja tuotannossa. Kelvollisen arvioitaessa testitiedot perustuvat alkuperäiseen epätasapainoon jakaumaan ja edustavat tuotantotietoja mahdollisimman tarkasti.

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

Saat lisätietoja SMOTE:sta smote- scikit-learn-viitesivulta sekä scikit-learn-käyttöoppaasta resurssien ylimyyntiä.

Kouluta machine learning malleja ja suorita kokeita

Apache Spark mahdollistaa Microsoft Fabric machine learning big datan avulla. Apache Sparkin avulla voit saada arvokkaita oivalluksia suurista määristä jäsenneltyä, jäsentämätöntä ja nopeasti liikkuvaa dataa.

Sinulla on useita vaihtoehtoja kouluttaa machine learning-malleja Apache Sparkilla Microsoft Fabric -tilassa: Apache Spark MLlib, SynapseML ja muita avoimen lähdekoodin kirjastoja. Lisätietoja löytyy Train machine learning -malleista Microsoft Fabric.

machine learning-koe toimii ensisijaisena organisoinnin ja kontrollin yksikkönä kaikille toisiinsa liittyville machine learning-ajoille. suoritus vastaa mallikoodin yksittäistä suoritusta. Machine learning kokeen seuranta sisältää kaikkien kokeiden ja niiden komponenttien, kuten parametrien, mittareiden, mallien ja muiden artifacts, hallinnan.

Kokeiden seurantaa varten voit järjestää kaikki tietyn machine learning-kokeen vaaditut komponentit. Lisäksi voit helposti toistaa aiemmat tulokset tallennettujen kokeilujen avulla. Lisätietoja machine learning kokeista löytyy Machine learning kokeista Microsoft Fabric.

1. Jos haluat seurata enemmän mittareita, parametreja ja tiedostoja, määritä exclusive=False MLflow-automaattisen lokeroinnin määrityksen päivittämiseksi:

   mlflow.autolog(exclusive=False)
   

2. Harjoita kaksi mallia LightGBM:n avulla. Yksi malli käsittelee epätasapainon olevan tietojoukon ja toinen käsittelee tasapainotettua tietojoukkoa (SMOTE:n kautta). Vertaa sitten kahden mallin suorituskykyä.

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

Määritä ominaisuuksien tärkeys koulutuksessa

1. Selvitä epätasapainoisen tietojoukon harjoittamasi mallin ominaisuuden tärkeys:

   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. Määritä toiminnon tärkeys mallille, jonka harjoitit tasapainoisille tiedoille. SMOTE loi tasapainotetut tiedot:

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

Kun koulutat mallia epätasapainoisella aineistolla, tärkeät ominaisuudet osoittavat merkittäviä eroja verrattuna tasapainotetulla aineistolla koulutettuun malliin.

Mallien arvioiminen

Tässä arvioidaan kahta harjoitettua mallia:

• model harjoitettu raakana, epätasapainoinen tietona
• smote_model harjoitettu tasapainotetetuilla tiedoilla

Käsittelymallin mittarit

1. Määrittele prediction_to_spark funktio, joka tekee ennusteita ja muuntaa ennustetulokset Spark DataFrameksi. Voit sitten laskea mallitilastoja ennustetuloksista käyttämällä 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. Käytä prediction_to_spark funktiota model ennusteiden tekemiseen kahdella mallilla, ja smote_model:

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

3. Kahden mallin käsittelymittarit:

   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)
   

Arvioi mallin suorituskyky sekaannusmatriisin avulla

sekaannusmatriisin näyttää

• true-positiiviset (TP)
• true-negatiiviset (TN)
• false-positiiviset (FP)
• false-negatiiviset (FN)

mallin tuottama, kun se on pisteytetty testitiedoilla. Binaariluokitusta varten malli palauttaa 2x2 sekaannusmatriisin. Moniluokkaista luokitusta varten malli palauttaa nxn virhematriisin, jossa n on luokkien määrä.

1. Käytä sekaannusmatriisia tiivistääksesi koulutettujen machine learning -mallien suorituskyvyt testidatassa:

   # 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. Piirtää sekaannusmatriisin smote_model ennusteita varten (harjoitettu tasapainotettuihin tietoihin):

   # 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. Piirtää sekaannusmatriisin model ennusteita varten (harjoitettu raakaan, epätasapainoisiin tietoihin):

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

Mallin suorituskyvyn arvioiminen AUC-ROC- ja AUPRC-mittareilla

Käyrän vastaanottimen toimintaominaisuuden (AUC-ROC) alapuolella oleva alue arvioi binaariluokittajien suorituskyvyn. AUC-ROC-kaavio visualisoi todellisen positiivisen kurssin (TPR) ja väärän positiivisen prosenttiprosentin (FPR) välisen kompromissin.

Joissakin tapauksissa on tarkoituksenmukaisempaa arvioida luokittelutoimintosi Precision-Recall käyrän alla olevan alueen (AUPRC) mittarin perusteella. AUPRC-käyrä yhdistää nämä hinnat:

• Tarkkuus tai positiivinen ennustearvo (PPV)
• Paikannus eli TPR

Suorituskyvyn arvioiminen AUC-ROC- ja AUPRC-mittareilla:

1. Määritä funktio, joka palauttaa AUC-ROC- ja AUPRC-mittarit:

   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. Kirjaa epätasapainoisiin tietoihin harjoittamasi mallin AUC-ROC- ja AUPRC-mittarit:

   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. Kirjaa tasapainoisella tiedolla harjoitetun mallin AUC-ROC ja AUPRC-mittarit:

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

Tasapainotetuilla tiedoilla harjoitettu malli palauttaa suuremmat AUC-ROC ja AUPRC-arvot verrattuna epätasapainoisilla tiedoilla harjoitettuun malliin. Näiden mittareiden perusteella SMOTE vaikuttaa tehokkaalta tekniikalta parantaa mallin suorituskykyä käsiteltäessä erittäin epätasapainoisten tietojen kanssa.

Kuten seuraava kuva osoittaa, järjestelmä kirjaa jokaisen kokeen niiden nimellä. Voit seurata kokeiluparametreja ja suorituskykymittareita työtilassasi.

Seuraava kuva näyttää mallin suorituskykymittarit, jotka on koulutettu tasapainotetulla aineistolla (versiossa 2):

Valitse versio 1 nähdäksesi mallin mittarit, jotka on koulutettu epätasapainoisella aineistolla. Kun vertaat mittareita, näet, että AUROC on korkeampi mallissa, joka on koulutettu tasapainoisella aineistolla. Nämä tulokset osoittavat, että tämä malli pystyy paremmin ennustamaan 0 luokat oikein 0, ja ennustamaan 1 luokat 1.

Vaihe 5: Mallien rekisteröinti

MLflow-funktiolla voit rekisteröidä kaksi mallia:

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

Vaihe 6: Tallenna ennustetulokset

Microsoft Fabric käyttäjät voivat operationalisoida machine learning-mallit käyttämällä PREDICT skaalautuvaa toimintoa. Tämä funktio tukee erän pisteytystä (tai erän päätelyä) missä tahansa laskentamoduulissa.

Voit generoida eräennusteita suoraan Microsoft Fabric -muistikirjasta tai mallin tuotesivulta. Lisätietoja PREDICT:sta löytyy Mallin pisteytyksestä PREDICT-menetelmällä Microsoft Fabric.

1. Lataa paremmin toimiva malli (versio 2) erän pisteytystä varten ja luo ennustetulokset:

   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. Tallenna ennusteet Lakehouse-järjestelmään:

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

Aiheeseen liittyvä sisältö

• Kuinka käyttää Microsoft Fabric-muistikirjoja
• Machine learning malli Microsoft Fabric
• Train machine learning mallit
• Machine learning kokeet Microsoft Fabric