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
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.
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.
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.
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 Amount
kivé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én1
érték, máskülönben0
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
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)
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 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.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. 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.
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)
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
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
képzése nyers, kiegyensúlyozatlan adatokra -
smote_model
betanítva kiegyensúlyozott adatokon
Számítási modell metrikái
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
A
prediction_to_spark
függvénnyel előrejelzéseket hajthat végre a két modellel,model
éssmote_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 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.
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
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")
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:
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
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 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 PREDICT
további információkért lásd: Modell pontozása a PREDICT használatával a Microsoft Fabric.
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 adattárba:
# Save the predictions to the lakehouse batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")