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

  • Luo tarvittaessa Microsoft Fabric Lakehouse kohdan Lakehouse luominen Microsoft Fabricissa ohjeiden mukaan.

Seuraa mukana muistikirjassa

Voit valita jonkin seuraavista vaihtoehdoista, joita voit seurata muistikirjassa:

  • Avaa ja suorita sisäinen muistikirja Data Science -kokemuksessa
  • Lataa muistikirjasi GitHubista Data Science -kokemukseen

Avaa sisäinen muistikirja

Petosten tunnistamisen muistikirjamalli on tämän opetusohjelman mukana.

Opetusohjelman sisäinen näytemuistikirja avataan Synapse Data Science -kokemuksesta seuraavasti:

  1. Siirry Synapse Data Science -aloitussivulle.

  2. Valitse Käytä mallia.

  3. Valitse vastaava malli:

    • Oletusarvoisen Päästä päähän -työnkulkujen (Python) välilehdestä, jos malli on tarkoitettu Python-opetusohjelmaa varten.
    • Jos malli on R-opetusohjelmassa, päästä päähän -työnkulut (R) -välilehdeltä.
    • Pikaopetusohjelmat-välilehdessä, jos malli on pikaopetusohjelmaa varten.

  4. Liitä muistikirjaan lakehouse, ennen kuin aloitat koodin suorittamisen.

Tuo muistikirja GitHubista

AIsample - Fraud Detection.ipynb -muistikirja on tämän opetusohjelman mukana.

Jos haluat avata tämän opetusohjelman liitteenä olevan muistikirjan, tuo muistikirja työtilaasi noudattamalla ohjeita kohdassa Järjestelmän valmisteleminen datatieteen opetusohjelmia varten.

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

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

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 muistikirjasi sisäiset asennusominaisuudet (%pip tai %conda) kirjastoon, vain senhetkiseen muistikirjaasi.
  • 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. Katso lisätietoja ympäristöistä kohdasta Ympäristön luominen, määrittäminen ja käyttäminen Microsoft Fabricissa.

Tätä opetusohjelmaa varten %pip install voit asentaa kirjaston imblearn muistikirjaasi.

Muistiinpano

PySpark-ydin käynnistyy uudelleen suoritusten jälkeen %pip install . 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 paitsi ja Time Amount. Luottamuksellisuuden turvaamiseksi emme voi antaa alkuperäisiä ominaisuuksia tai lisätietoja tietojoukosta.

Nämä tiedot kuvaavat tietojoukkoa:

  • Ominaisuudet V1, , V3V2, ..., V28 ovat PCA:n avulla hankitut pääkomponentit
  • Ominaisuus Time sisältää kuluneet sekunnit tapahtuman ja tietojoukon ensimmäisen tapahtuman välillä
  • Ominaisuus Amount on tapahtuman summa. Voit käyttää tätä ominaisuutta esimerkiksi riippuvaiseen, kustannussidonnaiseen oppimiseen
  • Sarake Class on vastausmuuttuja (tavoite). Sillä on petosten arvo 1 , ja 0 muussa tapauksessa se

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 näkyy creditcard.csv tietojen esikatselu:

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 Summa 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 kuin suoritat sen. 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. Saat lisätietoja ohjeartikkelista Automaattinen lokiloggaus Microsoft Fabricissa.

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 komennolla display . Lisätietoja tietojen visualisoinnista on kohdassa Muistikirjavisualisointi Microsoft Fabricissa.

    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 tietojoukon luokan 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 korjata epätasapainoongelman Class ensin 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

Kirjasto imblearn käyttää synteettisen vähemmistön ylimyyntitekniikkaa (SMOTE) epätasapainoisen luokituksen ongelman korjaamiseen. 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-metodin scikit-learn-viitesivulta ja scikit-learn-käyttöoppaasta, joka käsittelee 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. Lisätietoja on artikkelissa Koneoppimismallien harjoittaminen Microsoft Fabricissa.

Koneoppimiskokeilu toimii organisaation ensisijaisena yksikkönä ja kaikkien siihen liittyvien koneoppimisten suoritusten ensisijaisena yksikkönä. Suoritus vastaa mallikoodin yksittäistä suoritusta. Koneoppimisen kokeilujen seuranta edellyttää kaikkien kokeilujen ja niiden osien, kuten parametrien, mittareiden, mallien ja muiden artefaktien, hallintaa.

Kokeilujen seurantaa varten voit järjestää kaikki tietyn koneoppimiskokeilun vaaditut komponentit. Lisäksi voit helposti toistaa aiemmat tulokset tallennettujen kokeilujen avulla. Lisätietoja koneoppimiskokeiluista on artikkelissa Microsoft Fabricin koneoppimiskokeilut.

  1. Jos haluat seurata enemmän mittareita, parametreja ja tiedostoja, määritä exclusive=False päivittämään MLflow-automaattianalyysipalveluiden määritys:

    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 tieto
  • smote_model harjoitettu tasapainotetetuilla tiedoilla

Käsittelymallin mittarit

  1. prediction_to_spark Määritä funktio, joka suorittaa ennusteita, ja muuntaa ennustetulokset Spark DataFrame -funktioksi. Voit sitten laskea mallitilastot ennustetuloksista SynapseML:n avulla.

    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ä funktiota prediction_to_spark ennusteiden tekemiseen 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

Sekaannusmatriisi näyttää :n määrän

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

mallin tuottama, kun se on pisteytetty testitiedoilla. Binaariluokitusta varten malli palauttaa sekaannusmatriisin 2x2 . Moniluokkaista luokitusta varten malli palauttaa nxn sekaannusmatriisin, 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 kohteen ennusteita smote_model 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 ennusteita model 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 toimintaominaisuutena oleva alue (AUC-ROC) arvioi binaariluokittajien suorituskyvyn. AUC-ROC-kaavio visualisoi todellisen positiivisen koron (TPR) ja epätosi-positiivisen koron (FPR) välisen kompromissin.

Joissakin tapauksissa on tarkoituksenmukaisempaa arvioida luokittelutoimintosi Precision-Recall Curve (AUPRC) -mittarin alla olevan alueen 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 AUC-ROC- ja AUPRC-mittarit mallille, jonka harjoitit epätasapainoisten tietojen perusteella:

    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 AUC-ROC- ja AUPRC-mittarit mallille, jonka harjoitit tasapainoisilla tiedoilla:

    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.

Screenshot of the tracked experiment.

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

Screenshot of logged model performance metrics and model parameters.

Voit valita version 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 muodossa 0, ja ennustamaan 1 luokat muodossa 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 PREDICT skaalattavan toiminnon 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 aiheesta PREDICTon artikkelissa Mallin pisteytys PREDICT-parametrilla Microsoft Fabricissa.

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

Liittyvä sisältö