Jaa

Opetusohjelma: Petosten havaitsemismallin luominen, arvioiminen ja pisteytys

  • Artikkeli

Tässä opetusohjelmassa esitellään päästä päähän -esimerkki Synapse Data Science -työnkulusta Microsoft Fabricissa. Skenaario luo petosten havaitsemismallin historiallisten tietojen pohjalta harjoitetuilla koneoppimisalgoritmeilla. Se käyttää sitten mallia tulevien vilpillisten tapahtumien tunnistamiseen.

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

  • Mukautettujen kirjastojen asentaminen
  • Lataa tiedot
  • Tietojen ymmärtäminen ja käsitteleminen valmistelevan tietoanalyysin avulla
  • Scikit-learnin käyttäminen koneoppimismallin harjoittamiseen ja MLflow- ja Fabric-automaattianalyysiominaisuuksien kokeilujen seuraaminen
  • Parhaan suorituskyvyn omaavan koneoppimismallin tallentaminen ja rekisteröiminen
  • Lataa koneoppimismalli pisteytystä varten ja tee ennusteita

Edellytykset

  • Hanki Microsoft Fabric -tilaus. Voit myös rekisteröityä microsoft fabric -kokeiluversion maksuttomaan .

  • Kirjaudu sisään Microsoft Fabric .

  • Vaihda Fabriciin aloitussivun vasemmassa alakulmassa olevan käyttökokemuksen vaihtajan avulla.

    Näyttökuva käyttökokemuksen vaihtajavalikosta, jossa näkyy, missä datatiede valitaan.

Seuraa mukana muistikirjassa

Voit valita jonkin seuraavista vaihtoehdoista, joita voit seurata muistikirjassa:

  • Avaa ja suorita sisäinen muistikirja.
  • Lataa muistikirja 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 GitHubista

Tämän opetusohjelman mukana on AIsample - Fraud Detection.ipynb notebook.

Vaihe 1: Mukautettujen kirjastojen asentaminen

Koneoppimismallin kehittämistä tai ad-hoc-tietojen analysointia varten sinun on ehkä asennettava nopeasti mukautettu kirjasto Apache Spark -istuntoa 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 sitten käytettävissä missä tahansa muistikirjoissa ja Spark-työmääritelmissä työtilassa. Lisätietoja ympäristöistä on artikkelissa Ympäristön luominen, määrittäminen ja käyttäminen Microsoft Fabric -.

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

Muistiinpano

PySpark-ydin käynnistyy uudelleen %pip install suoritusten jälkeen. Asenna tarvittavat kirjastot, ennen kuin suoritat muita soluja.

# Use pip to install imblearn
%pip install imblearn

Vaihe 2: Lataa tiedot

Petosten tunnistamisen tietojoukko sisältää syyskuussa 2013 tehtyjä luottokorttitapahtumia, joita eurooppalaiset kortinhaltijat ovat tehneet 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 turvaamiseksi emme voi antaa alkuperäisiä ominaisuuksia tai lisätietoja tietojoukosta.

Nämä tiedot kuvaavat tietojoukkoa:

  • pcA:n avulla hankitut pääkomponentit ovat V1, V2, V3, ..., V28 ominaisuudet.
  • Time -ominaisuus sisältää kuluneet sekunnit tapahtuman ja tietojoukon ensimmäisen tapahtuman välillä
  • Amount ominaisuus on tapahtuman summa. Voit käyttää tätä ominaisuutta esimerkiksi riippuvaiseen, kustannussidonnaiseen oppimiseen
  • Class sarake on vastausmuuttuja (kohde). Sillä on 1 arvo petoksille, ja muutoin 0

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:

Aika 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 Määrä Luokka
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"

Lataa tietojoukko ja lataa se Lakehouse-palveluun

Määritä nämä parametrit niin, että voit käyttää tätä muistikirjaa eri tietojoukkojen 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.

Tärkeä

Muista lisätä muistikirjaan lakehouse- ennen sen suorittamista. Muussa tapauksessa saat virheilmoituksen.

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

MLflow-kokeilujen seurannan määrittäminen

Kokeilujen seurantaprosessi tallentaa kaikki olennaiset kokeiluihin liittyvät tiedot jokaisesta suorittamastasi kokeesta. Joskus et voi saada parempia tuloksia, kun suoritat tietyn kokeen. Näissä tapauksissa sinun tulee lopettaa kokeilu ja kokeilla uutta.

Microsoft Fabricin Synapse Data Science -käyttökokemus sisältää automaattisen lokerauksen. Tämä ominaisuus vähentää koodimäärää, jota tarvitaan koneoppimismallin parametrien, mittarien ja kohteiden automaattiseen kirjaamiseen harjoittamisen aikana. Ominaisuus laajentaa MLflow'n automaattisen lokeroinnin ominaisuuksia. Se on integroitu syvästi datatieteen kokemukseen.

Automaattisen lokeroinnin avulla voit helposti seurata ja vertailla eri mallien ja kokeilujen suorituskykyä ilman manuaalista seurantaa. Jos haluat lisätietoja, katso Automaattinen lokeraatio Microsoft Fabric.

Jos haluat poistaa Microsoft Fabric -automaattianalyysin käytöstä muistikirjaistunnossa, kutsu mlflow.autolog() ja määritä 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. Tutustu raakatietoihin ja tarkastele korkean tason tilastotietoja display-komennolla. Lisätietoja tietojen visualisoinnista on Notebook -visualisoinnissa Microsoft Fabric.

    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. Tämän vuoksi tietojen esikäsittely vaaditaan ennen mallin harjoittamista ylikuormittelun 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äällä voit harjoittaa LightGBM-mallin petostapahtumien luokittelemiseksi. 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ä.

Koneoppimismallien harjoittaminen ja kokeilujen suorittaminen

Microsoft Fabricin Apache Spark mahdollistaa massadatan koneoppimisen. Apache Sparkin avulla saat arvokkaita merkityksellisiä tietoja suurista määristä jäsennettyjä, jäsentämättömiä ja nopeasti eteneviä tietoja.

Sinulla on useita vaihtoehtoja koneoppimismallien kouluttamiseen Apache Sparkillä Microsoft Fabricissa: Apache Spark MLlib, SynapseML ja muut avoimen lähdekoodin kirjastot. Katso lisätietoja artikkelista Koneoppimismallien harjoittaminen Microsoft Fabricissa.

koneoppimiskokeilut toimii kaikkien niihin liittyvien koneoppimissuosikeiden ensisijaisena organisaationa ja hallintayksikkönä. suoritus vastaa mallikoodin yksittäistä suoritusta. Koneoppimisen kokeilla seurantaa sisältää kaikkien kokeilujen ja niiden osien, kuten parametrien, mittareiden, mallien ja muiden artefaktien, hallinnan.

Kokeilujen seurantaa varten voit järjestää kaikki tietyn koneoppimiskokeilun vaaditut komponentit. Lisäksi voit helposti toistaa aiemmat tulokset tallennettujen kokeilujen avulla. Katso lisätietoja koneoppimiskokeiluista artikkelista 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")

Jos haluat harjoittaa mallin epätasapainoisen tietojoukon kanssa, tärkeillä ominaisuuksilla on merkittäviä eroja verrattuna malliin, joka on harjoitettu tasapainotetulla tietojoukolla.

Mallien arvioiminen

Tässä arvioidaan kahta harjoitettua mallia:

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

Käsittelymallin mittarit

  1. Määritä prediction_to_spark funktio, joka tekee ennusteita, ja muuntaa ennustetulokset Spark DataFrame -funktioksi. Voit sitten laskea mallitilastot ennustetuloksista 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. prediction_to_spark-funktion avulla voit tehdä ennusteita kahdelle mallille, model 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. Sekaannusmatriisin avulla voit tehdä yhteenvedon harjoitetun koneoppimisen mallien suoritussuorituksesta testitiedoissa:

    # 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 seuraavassa kuvassa näytetään, kaikki kokeilut kirjataan niiden nimellä. Voit seurata kokeiluparametreja ja suorituskykymittareita työtilassasi.

Näyttökuva jäljitetystä kokeilusta.

Tässä kuvassa näkyvät tasapainotettuun tietojoukkoon harjoitetun mallin suorituskykymittarit (versiossa 2):

Näyttökuva kirjatun mallin suorituskyvyn mittareista ja mallin parametreista.

Voit valita versiosta 1, jos haluat tarkastella epätasapainoiselle tietojoukolle harjoitetun mallin mittareita. Kun vertaat mittareita, AUROC on korkeampi mallille, joka on harjoitettu tasapainoisella tietojoukolla. 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 Fabricin avulla käyttäjät voivat operationalisoida koneoppimismalleja skaalattavan PREDICT avulla. Tämä funktio tukee erän pisteytystä (tai erän päätelyä) missä tahansa laskentamoduulissa.

Eräennusteita voi luoda suoraan Microsoft Fabric -muistikirjasta tai mallin kohdesivulta. Lisätietoja PREDICTon artikkelissa Mallin pisteytys PREDICT-parametrilla 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ö