Megosztás a következőn keresztül:


Oktatóanyag: Csalásfelismerő modell létrehozása, értékelése és pontozása

Ez az oktatóanyag egy Synapse Data Science-munkafolyamat 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önyvtárak telepítése
  • 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

Kövesd egy jegyzetfüzetben

Választhat egyet ezek közül az opciók közül, hogy jegyzetfüzetben követhesse a folyamatot.

  • Nyissa meg és futtassa a beépített jegyzetfüzetet.
  • Töltse fel a jegyzetfüzetet a GitHubról.

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

Az oktatóanyagot a csalásészlelési-jegyzetfüzet minta kíséri.

  1. Az oktatóanyaghoz tartozó mintajegyzetfüzet megnyitásához kövesse a A rendszer előkészítése adatelemzési oktatóanyagokhozcímű témakörben található utasításokat.

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

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

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

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. További információ a környezetekről: környezet létrehozása, konfigurálása és használata a Microsoft Fabric.

Ebben az oktatóanyagban a %pip install használatával telepítheti a imblearn könyvtárat a jegyzetfüzetbe.

Jegyzet

A PySpark-kernel %pip install futtatása után újraindul. Telepítse a szükséges könyvtá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 Time és a Amountkivételével minden funkciót átalakított. 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, V3, ..., V28 funkciók a PCA-val beszerzett fő összetevők
  • A Time funkció a tranzakció és az adathalmaz első tranzakciója közötti eltelt másodperceket tartalmazza
  • A Amount funkció a tranzakció összege. Ezt a funkciót példafüggő, költségérzékeny tanuláshoz használhatja.
  • A Class oszlop a válasz (cél) változó. Csalás esetén 1 érték, máskülönben 0

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 csak körülbelül 0,172% az adatokból.

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

Idő 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 Mennyiség 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 adjon hozzá egy lakehouse- a jegyzetfüzethez. 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 Data Science 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 az adatelemzési é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 naplózás a Microsoft Fabric.

Ha le szeretné tiltani a Microsoft Fabric automatikus használatát egy jegyzetfüzet-munkamenetben, hívja fel mlflow.autolog(), és állítsa be a 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

  1. Fedezze fel a nyers adatokat, és tekintse meg a magas szintű statisztikákat a display paranccsal. További információért az adatvizualizációval kapcsolatban tekintse meg a Microsoft Fabric jegyzetfüzet-vizualizációját .

    display(df)
    
  2. 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

  1. 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)
    
  2. 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

  1. 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 a következő 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.

  2. 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)
    
  3. 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. A Class egyensúlyhiány problémáját azonban először megoldhatja, 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ítasz egy LightGBM-modellt a kiegyensúlyozatlan adatkészletre é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ódtár a szintetikus kisebbségi túlhasználati technika (SMOTE) megközelítést használja a kiegyensúlyozatlan besorolás problémájának megoldására. 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 értékeli a modellt, szüksége van egy közelítő eredményre a modell teljesítményéről az éles környezetben még nem látott adatok esetében. 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 a produkciós 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)

További információk az SMOTE módszerről a scikit-learn referenciaoldalon találhatók az SMOTE módszernél, és a scikit-learn felhasználói útmutatóban a túlmintavételezés erőforrásokró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 Fabric.

A gépi tanulási kísérlet az összes kapcsolódó gépi tanulási futtatás szervezésének és vezérlésének elsődleges egysége. A futtatás egyetlen végrehajtásának felel meg a modellkódnak. A gépi tanulás kísérletkövetési 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. További információ a gépi tanulási kísérletekről: Gépi tanulási kísérletek a Microsoft Fabric.

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

    mlflow.autolog(exclusive=False)
    
  2. 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 jellemzők fontosságának meghatározása a betanításhoz

  1. 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")
    
  2. 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 képzése nyers, kiegyensúlyozatlan adatokra
  • smote_model betanítva kiegyensúlyozott adatokon

Számítási modell metrikái

  1. Adjon meg egy prediction_to_spark függvényt, amely előrejelzéseket végez, és az előrejelzési eredményeket Spark DataFrame-gé alakítja. Ezután kiszámíthatja az előrejelzési eredmények modellstatisztikáit 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. A prediction_to_spark függvénnyel 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()
    
  3. 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 2x2 keveredési mátrixot ad vissza. Többosztályos besorolás esetén a modell egy nxn keveredési mátrixot ad vissza, amelyben n az osztályok száma.

  1. 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)
    
  2. Ábrázolja a smote_model előrejelzéseinek keveredési mátrixát (kiegyensúlyozott adatokon betanított):

    # 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. A model előrejelzéseinek keveredési mátrixának ábrázolása (nyers, kiegyensúlyozatlan adatokon betanított):

    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

A görbevevő működési jellemzője (AUC-ROC) alatti terület értékeli a bináris osztályozók teljesítményét. A 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 az Precision-Recall Görbe alatti terület (AUPRC) mutató 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 a AUC-ROC és az AUPRC-mértékekkel:

  1. Definiáljon egy függvényt, amely a 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    
    
  2. 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})
    
  3. Naplózza a kiegyensúlyozott adatok alapján 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ékeket ad vissza a kiegyensúlyozatlan 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.

A nyomon követett kísérlet képernyőképe.

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

A naplózott modell teljesítménymetrikáinak és modellparamétereinek képernyőképe.

Az 1-es verzió kiválasztásával megtekintheti a kiegyensúlyozatlan adatkészleten 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 jobban előrejelzi 0 osztályokat 0, és 1 osztályokat 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, hogy a PREDICT skálázható függvénnyel üzembe helyezik a gépi tanulási modelleket. Ez a függvény támogatja a kötegelt pontozást (vagy kötegelt kiértékelést) bármely számítási környezetben.

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

  1. 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)
    
  2. Előrejelzések mentése a Lakehouse adattárba:

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