Oktatóanyag: Csalásészlelési modell létrehozása, értékelése és pontszáma

Cikk
01/23/2024

Ez az oktatóanyag a Synapse Adattudomány munkafolyamatának végpontok közötti példáját mutatja be a Microsoft Fabricben. A forgatókönyv egy csalásészlelési modellt hoz létre az előzményadatokra betanított gépi tanulási algoritmusokkal. Ezt követően a modell használatával észleli a jövőbeli csalárd tranzakciókat.

Ez az oktatóanyag az alábbi lépéseket ismerteti:

Egyéni kódtárak telepítése
Az adatok betöltése
Az adatok megismerése és feldolgozása feltáró adatelemzéssel
A scikit-learn használatával betaníthat egy gépi tanulási modellt, és nyomon követheti az MLflow és a Fabric autologging funkcióival végzett kísérleteket
Mentse és regisztrálja a legnagyobb teljesítményű gépi tanulási modellt
A gépi tanulási modell betöltése pontozáshoz és előrejelzések készítéséhez

Előfeltételek

Microsoft Fabric-előfizetés lekérése. Vagy regisztráljon egy ingyenes Microsoft Fabric-próbaverzióra.
Jelentkezzen be a Microsoft Fabricbe.
A kezdőlap bal oldalán található élménykapcsolóval válthat a Synapse Adattudomány felületre.

Szükség esetén hozzon létre egy Microsoft Fabric-tóházat a Microsoft Fabricben a Tóház létrehozása című cikkben leírtak szerint.

Követés jegyzetfüzetben

A jegyzetfüzetben az alábbi lehetőségek közül választhat:

Nyissa meg és futtassa a beépített jegyzetfüzetet a Adattudomány felületen
Jegyzetfüzet feltöltése a GitHubról a Adattudomány felületre

A beépített jegyzetfüzet megnyitása

Az oktatóanyaghoz a csalásészlelési mintajegyzetfüzet is hozzá van kísérve.

Az oktatóanyag beépített mintajegyzetfüzetének megnyitása a Synapse Adattudomány felületén:

Nyissa meg a Synapse Adattudomány kezdőlapját.
Válassza a Minta használata lehetőséget.
Válassza ki a megfelelő mintát:
- Ha a minta Python-oktatóanyaghoz készült, az alapértelmezett Végpontok közötti munkafolyamatok (Python) lapon.
- A végpontok közötti munkafolyamatok (R) lapról, ha a minta R-oktatóanyaghoz készült.
- A Gyors oktatóanyagok lapon, ha a minta egy gyors oktatóanyaghoz készült.
A kód futtatása előtt csatoljon egy lakehouse-t a jegyzetfüzethez .

A jegyzetfüzet importálása a GitHubról

Az AIsample – Fraud Detection.ipynb jegyzetfüzet ezt az oktatóanyagot kíséri.

Az oktatóanyaghoz mellékelt jegyzetfüzet megnyitásához kövesse a Rendszer előkészítése adatelemzési oktatóanyagokhoz című témakör utasításait, és importálja a jegyzetfüzetet a munkaterületre.

Ha inkább erről a lapról másolja és illessze be a kódot, létrehozhat egy új jegyzetfüzetet.

A kód futtatása előtt mindenképpen csatoljon egy lakehouse-t a jegyzetfüzethez .

1. lépés: Egyéni kódtárak telepítése

A gépi tanulási modell fejlesztéséhez vagy az alkalmi adatelemzéshez előfordulhat, hogy gyorsan telepítenie kell egy egyéni kódtárat az Apache Spark-munkamenethez. A kódtárak telepítéséhez két lehetőség közül választhat.

A jegyzetfüzet beágyazott telepítési képességeivel (%pip vagy %conda) csak az aktuális jegyzetfüzetben telepíthet tárat.
Másik lehetőségként létrehozhat egy Fabric-környezetet, telepíthet nyilvános forrásokból származó kódtárakat, vagy feltölthet hozzá egyéni kódtárakat, majd a munkaterület rendszergazdája alapértelmezettként csatolhatja a környezetet a munkaterülethez. Ezután a környezet összes kódtára elérhetővé válik a munkaterület bármely jegyzetfüzetében és Spark-feladatdefiníciójában. A környezetekkel kapcsolatos további információkért tekintse meg a Környezetek létrehozását, konfigurálását és használatát a Microsoft Fabricben.

Ebben az oktatóanyagban %pip install a tárat telepítheti imblearn a jegyzetfüzetbe.

Feljegyzés

A PySpark-kernel futás után %pip install újraindul. Telepítse a szükséges kódtárakat, mielőtt bármilyen más cellát futtatna.

# Use pip to install imblearn
%pip install imblearn

2. lépés: Az adatok betöltése

A csalásészlelési adatkészlet 2013 szeptemberétől tartalmazza azokat a hitelkártya-tranzakciókat, amelyeket az európai kártyatulajdonosok két nap alatt hajtottak végre. Az adathalmaz csak numerikus szolgáltatásokat tartalmaz az eredeti funkciókra alkalmazott fő összetevő-elemzési (PCA) átalakítás miatt. A PCA az összes funkciót átalakította, kivéve az és Amounta Time . A bizalmasság védelme érdekében nem tudjuk megadni az eredeti szolgáltatásokat vagy az adathalmazsal kapcsolatos további háttérinformációkat.

Ezek a részletek az adathalmazt írják le:

A V1, V2, ... V3V28 jellemzők a PCA-val beszerzett fő összetevők
A Time szolgáltatás tartalmazza a tranzakció és az adathalmaz első tranzakciója közötti eltelt másodperceket
A Amount szolgáltatás a tranzakció összege. Ezt a funkciót használhatja például függő, költségérzékeny tanuláshoz
Az Class oszlop a válasz (cél) változó. A csalás értékével 1 rendelkezik, és 0 egyébként

A 284 807 tranzakcióból csak 492 tranzakció hamis. Az adathalmaz rendkívül kiegyensúlyozatlan, mivel a kisebbségi (csalárd) osztály az adatoknak csak körülbelül 0,172%-át teszi ki.

Ez a táblázat a creditcard.csv adatainak előnézetét mutatja be:

Idő	1. verzió	2. verzió	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	Összeg	Osztály
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"

Töltse le az adathalmazt, és töltse fel a lakehouse-ba

Adja meg ezeket a paramétereket, hogy ezt a jegyzetfüzetet különböző adatkészletekkel használhassa:

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

Ez a kód letölti az adathalmaz nyilvánosan elérhető verzióját, majd egy Fabric lakehouse-ban tárolja.

Fontos

A futtatás előtt mindenképpen vegyen fel egy lakehouse-t a jegyzetfüzetbe. Ellenkező esetben hibaüzenet jelenik meg.

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-kísérletkövetés beállítása

A kísérletkövetési folyamat minden futtatott kísérlethez menti a kísérlettel kapcsolatos összes információt. Néha nincs mód arra, hogy jobb eredményeket érjen el egy adott kísérlet futtatásakor. Ezekben az esetekben le kell állítania a kísérletet, és ki kell próbálnia egy újat.

A Microsoft Fabric Synapse Adattudomány felülete tartalmaz egy automatikus naplózási funkciót. Ez a funkció csökkenti a gépi tanulási modell paramétereinek, metrikáinak és elemeinek automatikus naplózásához szükséges kód mennyiségét a betanítás során. A funkció kibővíti az MLflow automatikus kitöltési képességeit. Mély integrációval rendelkezik a Adattudomány élményben.

Az automatikus címkézéssel egyszerűen nyomon követheti és összehasonlíthatja a különböző modellek és kísérletek teljesítményét anélkül, hogy manuális nyomon követést kellene végeznie. További információ: Automatikus keresés a Microsoft Fabricben.

Ha le szeretné tiltani a Microsoft Fabric automatikus használatát egy jegyzetfüzet-munkamenetben, hívja meg mlflow.autolog() és állítsa be a következőt disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Nyers adatok olvasása a lakehouse-ból

Ez a kód nyers adatokat olvas be a lakehouse-ból:

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

3. lépés: Feltáró adatelemzés végrehajtása

Ebben a szakaszban először a nyers adatokat és a magas szintű statisztikákat ismerheti meg. Ezután az adatok átalakításához adja át az oszlopokat a megfelelő típusokká, és alakítsa át őket a Spark DataFrame-ből pandas DataFrame-be a könnyebb vizualizáció érdekében. Végül megismerheti és megjelenítheti az osztályeloszlásokat az adatokban.

A nyers adatok megjelenítése

Fedezze fel a nyers adatokat, és tekintse meg a magas szintű statisztikákat a display paranccsal. Az adatvizualizációval kapcsolatos további információkért tekintse meg a Jegyzetfüzet-vizualizációt a Microsoft Fabricben.
```
display(df)
```

Az adathalmaz néhány alapvető információjának nyomtatása:

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

Az adatok átalakítása

Az adathalmaz oszlopait a megfelelő típusok szerint alakítsa ki:

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)

Konvertálja a Spark DataFrame-et pandas DataFrame-gé a könnyebb vizualizáció és feldolgozás érdekében:
```
df_pd = df.toPandas()
```

Az osztályeloszlás megismerése az adathalmazban

Az osztályeloszlás megjelenítése az adathalmazban:
```
# 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')
```
A kód ezt az adathalmazosztály-eloszlást adja vissza: 99,83% No Frauds és 0,17% Frauds. Ez az osztályeloszlás azt mutatja, hogy a tranzakciók többsége nem jogsértő. Ezért a túlillesztés elkerülése érdekében a modell betanítása előtt adatelőfeldolgozásra van szükség.

Az adathalmaz osztályegyensúlytalanságának megjelenítéséhez használjon diagramot a csalárd és a nem jogsértő tranzakciók eloszlásának megtekintésével:

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)

A tranzakció összegéhez tartozó ötszámos összegzés (minimális pontszám, első kvartilis, medián, harmadik kvartilis és maximális pontszám) megjelenítése dobozdiagramokkal:
```
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()
```
A nagymértékben kiegyensúlyozatlan adatok esetében előfordulhat, hogy a dobozdiagramok nem mutatnak pontos megállapításokat. Először azonban megoldhatja az Class egyensúlyhiány problémáját, majd ugyanazokat a diagramokat hozhatja létre a pontosabb elemzésekhez.

4. lépés: A modellek betanítása és kiértékelése

Itt betanít egy LightGBM-modellt a csalási tranzakciók besorolásához. Betanított egy LightGBM-modellt a kiegyensúlyozatlan adathalmazra és a kiegyensúlyozott adatkészletre is. Ezután összehasonlítja mindkét modell teljesítményét.

Adathalmazok betanítása és tesztelése

A betanítás előtt ossza fel az adatokat a betanítási és tesztelési adatkészletekre:

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

SMOTE alkalmazása a betanítási adatkészletre

A imblearn könyvtár a szintetikus kisebbségi túlmintavételi technika (SMOTE) módszerével kezeli az egyensúlyhiányos besorolás problémáját. A kiegyensúlyozatlan besorolás akkor fordul elő, ha túl kevés példa áll rendelkezésre a kisebbségi osztályra, hogy egy modell hatékonyan tanulhassa meg a döntési határt. Az SMOTE a legelszántabb módszer a kisebbségi osztály új mintáinak szintetizálására.

Az SMOTE-t csak a betanítási adatkészletre alkalmazza a tesztadatkészlet helyett. Amikor a tesztadatokkal pontozza a modellt, közelítenie kell a modell teljesítményét az éles környezetben nem látott adatokon. Az érvényes közelítés érdekében a tesztadatok az eredeti kiegyensúlyozatlan eloszlásra támaszkodnak, hogy a lehető legszorosabban képviseljék az éles adatokat.

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

Az SMOTE-ról további információt az SMOTE-metódus scikit-learn referenciaoldalán, valamint az erőforrások túlbélyegzéséről szóló scikit-learn felhasználói útmutatóban talál.

Gépi tanulási modellek betanítása és kísérletek futtatása

Az Apache Spark a Microsoft Fabricben lehetővé teszi a big data-alapú gépi tanulást. Az Apache Spark segítségével értékes megállapításokat kaphat nagy mennyiségű strukturált, strukturálatlan és gyorsan mozgó adatból.

A Gépi tanulási modellek betanítása a Microsoft Fabricben futó Apache Spark használatával számos lehetőség közül választhat: Apache Spark MLlib, SynapseML és más nyílt forráskódú kódtárak. További információ: Gépi tanulási modellek betanítása a Microsoft Fabricben.

A gépi tanulási kísérlet az összes kapcsolódó gépi tanulási futtatás szervezetének és vezérlésének elsődleges egysége. A futtatás a modellkód egyetlen végrehajtásának felel meg. A gépi tanulási kísérletek nyomon követése magában foglalja az összes kísérlet és összetevő kezelését, például paramétereket, metrikákat, modelleket és egyéb összetevőket.

A kísérletkövetéshez rendszerezheti egy adott gépi tanulási kísérlet összes szükséges összetevőjét. Emellett a mentett kísérletekkel egyszerűen reprodukálhatja a múltbeli eredményeket. A gépi tanulási kísérletekről további információt a Gépi tanulási kísérletek a Microsoft Fabricben című témakörben talál.

További metrikák, paraméterek és fájlok nyomon követéséhez állítsa be exclusive=False az MLflow automatikus naplózási konfigurációjának frissítését:
```
mlflow.autolog(exclusive=False)
```

Két modell betanítása a LightGBM használatával. Az egyik modell kezeli a kiegyensúlyozatlan adathalmazt, a másik pedig a kiegyensúlyozott adatkészletet (SMOTE-n keresztül). Ezután hasonlítsa össze a két modell teljesítményét.

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

A betanítás funkciójának fontossága

Határozza meg a kiegyensúlyozatlan adathalmazon betanított modell funkciójának fontosságát:

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

Határozza meg a kiegyensúlyozott adatokra betanított modell funkciójának fontosságát. Az SMOTE létrehozta a kiegyensúlyozott adatokat:

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

A kiegyensúlyozatlan adatkészlettel rendelkező modellek betanításakor a fontos funkciók jelentős különbségeket mutatnak a kiegyensúlyozott adatkészlettel betanított modellel összehasonlítva.

A modellek kiértékelése

Itt értékelheti ki a két betanított modellt:

model betanított nyers, kiegyensúlyozatlan adatokra
smote_model kiegyensúlyozott adatok betanítása

Számítási modell metrikái

Adjon meg egy függvényt prediction_to_spark , amely előrejelzéseket végez, és az előrejelzési eredményeket Spark DataFrame-gé alakítja. Ezután a SynapseML használatával kiszámíthatja az előrejelzési eredmények modellstatisztikáit.

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

A függvény használatával prediction_to_spark előrejelzéseket hajthat végre a két modellel, model és smote_model:

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

Számítási metrikák a két modellhez:

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)

Modellteljesítmény kiértékelése keveredési mátrix használatával

A keveredési mátrix a

valódi pozitív értékek (TP)
valódi negatívok (TN)
hamis pozitív értékek (FP)
hamis negatívok (FN)

tesztadatokkal végzett pontszám esetén a modell által előállított érték. Bináris besorolás esetén a modell egy keveredési mátrixot 2x2 ad vissza. Többosztályos besorolás esetén a modell egy keveredési mátrixot nxn ad vissza, ahol n az osztályok száma.

Használjon keveredési mátrixot a betanított gépi tanulási modellek tesztadatokon végzett teljesítményének összegzéséhez:

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

Ábrázolja a keveredési mátrixot a (kiegyensúlyozott adatokra betanított) előrejelzésekhez smote_model :

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

Ábrázolja a keveredési mátrixot a (nyers, kiegyensúlyozatlan adatokra betanított) előrejelzésekhez model :

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

Modellteljesítmény kiértékelése AUC-ROC és AUPRC mértékekkel

Az AUC-ROC (Curve Receiver Operating Characteristic, AUC-ROC) alatt található terület értékeli a bináris osztályozók teljesítményét. Az AUC-ROC diagram a valódi pozitív ráta (TPR) és a hamis pozitív ráta (FPR) közötti kompromisszumot jeleníti meg.

Bizonyos esetekben célszerűbb kiértékelni az osztályozót a Precision-Recall Curve (AUPRC) mérték alatti terület alapján. Az AUPRC-görbe a következő arányokat egyesíti:

A pontosság vagy a pozitív prediktív érték (PPV)
Visszahívás vagy TPR

A teljesítmény kiértékelése az AUC-ROC és az AUPRC mértékekkel:

Definiáljon egy függvényt, amely az AUC-ROC és az AUPRC mértékeket adja vissza:

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

Naplózza a kiegyensúlyozatlan adatokon betanított modell AUC-ROC- és AUPRC-metrikáit:

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

Naplózza a kiegyensúlyozott adatokra betanított modell AUC-ROC és AUPRC metrikáit:

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

A kiegyensúlyozott adatokra betanított modell magasabb AUC-ROC és AUPRC értéket ad vissza az egyensúlyhiányos adatokon betanított modellhez képest. Ezen mértékek alapján az SMOTE hatékony módszernek tűnik a modell teljesítményének javítására a nagymértékben kiegyensúlyozatlan adatok használatakor.

Ahogy a következő képen is látható, a rendszer minden kísérletet a saját nevével naplóz. A munkaterületen nyomon követheti a kísérlet paramétereit és teljesítménymetrikáit.

Ez a kép a kiegyensúlyozott adatkészleten betanított modell teljesítménymetrikáit mutatja be (a 2. verzióban):

Az 1. verziót választva megtekintheti a kiegyensúlyozatlan adathalmazon betanított modell metrikáit. A metrikák összehasonlításakor az AUROC magasabb a kiegyensúlyozott adatkészlettel betanított modell esetében. Ezek az eredmények azt jelzik, hogy ez a modell jobb az osztályok helyes előrejelzéséhez 0 , és 0az osztályok előrejelzéséhez 1 .1

5. lépés: A modellek regisztrálása

Az MLflow használatával regisztrálja a két modellt:

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

6. lépés: Az előrejelzési eredmények mentése

A Microsoft Fabric lehetővé teszi a felhasználók számára a gépi tanulási modellek skálázható funkcióval történő PREDICT üzembe helyezéset. Ez a függvény támogatja a kötegelt pontozást (vagy kötegelt következtetést) bármely számítási motorban.

Kötegelt előrejelzéseket közvetlenül a Microsoft Fabric-jegyzetfüzetből vagy a modell elemlapjáról hozhat létre. További információ: PREDICTModell pontozása a PREDICT használatával a Microsoft Fabricben.

Töltse be a jobb teljesítményű modellt (2. verzió) a kötegelt pontozáshoz, és hozza létre az előrejelzési eredményeket:

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)

Előrejelzések mentése a lakehouse-ba:

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

Oktatóanyag: Csalásészlelési modell létrehozása, értékelése és pontszáma

Előfeltételek

Követés jegyzetfüzetben

A beépített jegyzetfüzet megnyitása

A jegyzetfüzet importálása a GitHubról

1. lépés: Egyéni kódtárak telepítése

2. lépés: Az adatok betöltése

Töltse le az adathalmazt, és töltse fel a lakehouse-ba

MLflow-kísérletkövetés beállítása

Nyers adatok olvasása a lakehouse-ból

3. lépés: Feltáró adatelemzés végrehajtása

A nyers adatok megjelenítése

Az adatok átalakítása

Az osztályeloszlás megismerése az adathalmazban

4. lépés: A modellek betanítása és kiértékelése

Adathalmazok betanítása és tesztelése

SMOTE alkalmazása a betanítási adatkészletre

Gépi tanulási modellek betanítása és kísérletek futtatása

A betanítás funkciójának fontossága

A modellek kiértékelése

Számítási modell metrikái

Modellteljesítmény kiértékelése keveredési mátrix használatával

Modellteljesítmény kiértékelése AUC-ROC és AUPRC mértékekkel

5. lépés: A modellek regisztrálása

6. lépés: Az előrejelzési eredmények mentése

Visszajelzés

Visszajelzés

További források

Oktatóanyag: Csalásészlelési modell létrehozása, értékelése és pontszáma

Előfeltételek

Követés jegyzetfüzetben

A beépített jegyzetfüzet megnyitása

A jegyzetfüzet importálása a GitHubról

1. lépés: Egyéni kódtárak telepítése

2. lépés: Az adatok betöltése

Töltse le az adathalmazt, és töltse fel a lakehouse-ba

MLflow-kísérletkövetés beállítása

Nyers adatok olvasása a lakehouse-ból

3. lépés: Feltáró adatelemzés végrehajtása

A nyers adatok megjelenítése

Az adatok átalakítása

Az osztályeloszlás megismerése az adathalmazban

4. lépés: A modellek betanítása és kiértékelése

Adathalmazok betanítása és tesztelése

SMOTE alkalmazása a betanítási adatkészletre

Gépi tanulási modellek betanítása és kísérletek futtatása

A betanítás funkciójának fontossága

A modellek kiértékelése

Számítási modell metrikái

Modellteljesítmény kiértékelése keveredési mátrix használatával

Modellteljesítmény kiértékelése AUC-ROC és AUPRC mértékekkel

5. lépés: A modellek regisztrálása

6. lépés: Az előrejelzési eredmények mentése

Kapcsolódó tartalom

Visszajelzés

Visszajelzés

További források