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:

Előfeltételek

• Szerezzen be egy Microsoft Fabric-előfizetést. Vagy regisztráljon az ingyenes Microsoft Fabric próbaverzióra.

• Jelentkezzen be a Microsoft Fabric.

• A kezdőlap bal alsó részén található élménykapcsolóval válthat Fabricre.

  

• Ha szükséges, hozzon létre egy Microsoft Fabric lakehouse-t, ahogy az a Lakehouse létrehozása a Microsoft Fabriccímű részben van leírva.

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.

• Az oktatóanyaghoz tartozó jegyzetfüzet megnyitásához kövesse a „A rendszer előkészítése adatelemzési oktatóanyagokhoz” és „” utasításokat, hogy a jegyzetfüzetet importálhassa a munkaterületére.

• 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. 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.

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

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.

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.

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

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

Kapcsolódó tartalom

• Microsoft Fabric-jegyzetfüzetek használata
• Gépi tanulási modell a Microsoft Fabric
• Gépi tanulási modellek betanítása
• Gépi tanulási kísérletek a Microsoft Fabric