Kurz: Vytvorenie, vyhodnotenie a skóre modelu zisťovania podvodov

Tento tutoriál predstavuje komplexný príklad pracovného postupu Synapse Data Science v Microsoft Fabric. Scenár vytvára model detekcie podvodov pomocou algoritmov machine learning trénovaných na historických dátach. Potom použije model na zisťovanie budúcich podvodných transakcií.

V tomto kurze sú obsiahnuté tieto kroky:

• Inštalácia vlastných knižníc
• Načítanie údajov
• Pochopenie a spracovanie údajov prostredníctvom prieskumnej analýzy údajov
• Použite scikit-learn na trénovanie modelu strojového učenia a sledujte experimenty pomocou funkcií MLflow a Fabric Autologging
• Uložte a zaregistrujte model machine learning, ktorý má najvyšší výkon
• Načítajte model machine learning na skórovanie a predpovede

Predpoklady

• Získajte predplatné Microsoft Fabric . Alebo sa zaregistrujte na bezplatnú skúšobnú verziu Microsoft Fabric.

• Prihláste sa do Microsoft Fabric.

• Prepnite na Fabric pomocou prepínača skúseností v ľavom dolnom rohu domovskej stránky.

  

• Ak je to potrebné, vytvorte Microsoft Fabric jazerný domček, ako je popísané v Vytvorte jazerný dom v Microsoft Fabric.

Sledovanie v poznámkovom bloke

Ak chcete sledovať v zápisníku, vyberte si jednu z týchto možností:

• Otvorte a spustite vstavaný poznámkový blok.
• Nahraj svoj zápisník z GitHub.

Otvorenie vstavaného poznámkového bloku

Tento kurz sprevádza ukážkový poznámkový blok zisťovanie podvodov.

1. Ak chcete otvoriť vzorový poznámkový blok pre tento kurz, postupujte podľa pokynov v téme Príprava systému na kurzy dátovej vedy.

2. Uistite sa, že pripojiť lakehouse na notebook, ako začnete bežať kód.

Importujte zápisník z GitHub

K tomuto tutoriálu patrí zápisník AIsample - Fraud Detection.ipynb.

• Ak chcete otvoriť sprievodný poznámkový blok pre tento kurz, postupujte podľa pokynov v téme Príprava systému na kurzy dátových vied na import notebooku do pracovného priestoru.

• Ak by ste radšej skopírovali a prilepili kód z tejto stránky, môžete vytvoriť nový poznámkový blok.

• Uistite sa, že pripojiť lakehouse k notebooku, ako začnete bežať kód.

Krok č. 1: Inštalácia vlastných knižníc

Pri vývoji modelov machine learning alebo ad-hoc analýze dát možno budete musieť rýchlo nainštalovať vlastnú knižnicu pre vašu Apache Spark reláciu. Na inštaláciu knižníc máte dve možnosti.

• Ak chcete nainštalovať knižnicu iba v aktuálnom poznámkovom bloku, použite možnosti vnorenej inštalácie (%pip alebo %conda).
• Alternatívne môžete vytvoriť Fabric prostredie, inštalovať knižnice z verejných zdrojov alebo nahrať vlastné knižnice a potom môže váš administrátor pracovného priestoru pripojiť prostredie ako predvolené pre daný pracovný priestor. Všetky knižnice v prostredí sú dostupné na použitie v akýchkoľvek zápisníkoch a definíciách úloh Spark v pracovnom priestore. Pre viac informácií o prostrediach pozri create, conkonfigur, and use a environment in Microsoft Fabric.

V tomto kurze použite %pip install na inštaláciu knižnice imblearn v poznámkovom bloku.

Nota

Jadro PySpark sa reštartuje po spustení %pip install. Pred spustením ďalších buniek nainštalujte potrebné knižnice.

# Use pip to install imblearn
%pip install imblearn

Krok č. 2: Načítanie údajov

Súbor údajov o detekcii podvodov obsahuje transakcie kreditnými kartami zo septembra 2013, ktoré európski držitelia kariet uskutočnili počas dvoch dní. Množina údajov obsahuje iba číselné funkcie z dôvodu transformácie hlavnej analýzy súčastí (PCA) použitej na pôvodné funkcie. PCA transformovala všetky funkcie okrem Time a Amount. Na ochranu dôvernosti nie sú k dispozícii pôvodné funkcie alebo ďalšie informácie o datasete.

Tieto podrobnosti popisujú množinu údajov:

• Vlastnosti V1, V2, V3, ..., V28 sú hlavné komponenty získané pomocou PCA.
• Funkcia Time obsahuje uplynulé sekundy medzi transakciou a prvou transakciou v datasete.
• Funkcia Amount je čiastka transakcie. Túto funkciu môžete využiť na učenie závislé od napríklad, citlivé na náklady.
• Stĺpec Class je premenná odpovede (cieľ). Má to hodnotu 1 pre podvody a 0 inak.

Iba 492 transakcií, z celkového počtu 284 807 transakcií, sú podvodné. Množina údajov sa veľmi nevyváži, pretože menšinová (podvodná) trieda predstavuje len približne 0,172% údajov.

Táto tabuľka zobrazuje ukážku údajov creditcard.csv:

Čas	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	Množstvo	Trieda
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"

Stiahnite si množinu údajov a nahrajte ju do služby lakehouse

Definujte tieto parametre tak, aby ste mohli tento zápisník používať s rôznymi datasetmi:

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

Tento kód stiahne verejne dostupnú verziu datasetu a potom ju uloží do jazerného domu Fabric.

Dôležitý

Predtým, než spustíte zápisník, pridajte chatu pri jazere. Inak dostanete chybu.

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.z13.web.core.windows.net/data/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.")

Nastavenie sledovania experimentov s MLflow

Proces sledovania experimentov uloží všetky relevantné informácie súvisiace s experimentom pre každý experiment, ktorý spustíte. Niekedy nemôžete dosiahnuť lepšie výsledky, keď vykonáte konkrétny experiment. V takých prípadoch experiment ukončite a skúste nový.

Skúsenosti so Synapse Data Science v Microsoft Fabric zahŕňajú funkciu automatického logovania. Táto funkcia znižuje množstvo kódu potrebného na automatické zaznamenávanie parametrov, metrík a položiek modelu machine learning počas trénovania. Funkcia rozširuje možnosti automatického označovania toku MLflow. Má hlbokú integráciu v skúsenostiach z dátovej vedy.

Použitím autologovania môžete jednoducho sledovať a porovnávať výkonnosť rôznych modelov a experimentov bez potreby manuálneho sledovania. Pre viac informácií pozri Autologging v Microsoft Fabric.

Ak chcete zakázať automatické prihlásenie Microsoft Fabric v relácii zápisníka, zavolajte mlflow.autolog() a nastavte disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Prečítajte si nespracované údaje z jazera

Tento kód prečíta nespracované údaje z jazera:

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

Krok č. 3: Vykonanie prieskumnej analýzy údajov

V tejto časti najprv preskúmate nespracované údaje a štatistiky na vysokej úrovni. Ak chcete transformovať údaje, pretypujte stĺpce do správnych typov a skonvertujte ich z údajového rámca Spark na údajový rámec pandas, aby ste ich mohli jednoduchšie vizualizáciu skonvertovať. Nakoniec preskúmate a vizualizujete distribúcie tried v údajoch.

Zobrazenie nespracovaných údajov

1. Preskúmajte surové dáta a zobrazte si štatistiky na vyššej úrovni pomocou príkazu display . Pre viac informácií o vizualizácii dát pozri Notebook visualization v Microsoft Fabric.

   display(df)
   

2. Vytlačte niektoré základné informácie o množine údajov:

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

Transformácia údajov

1. Pretypovať stĺpce množiny údajov do správnych typov:

   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. Konvertujte údajový rámec Spark na údajový rámec Pandas na jednoduchšiu vizualizáciu a spracovanie:

   df_pd = df.toPandas()
   

Preskúmanie distribúcie tried v množine údajov

1. Zobrazí distribúciu tried v množine údajov:

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

   Kód vráti toto rozdelenie triedy množiny údajov: 99,83% No Frauds a 0,17% Frauds. Distribúcia tejto triedy ukazuje, že väčšina transakcií je neaudulentná. Preto je potrebné predspracovanie dát pred trénovaním modelu, aby sa predišlo nadmernému prispôsobeniu.

2. Pomocou vykreslenia môžete v množine údajov zobraziť triednu nerovnováhu tým, že sa distribúcia podvodných a neaudulentných transakcií rozobrať:

   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. Zobraziť súhrn piatich čísel (minimálne skóre, prvý quartile, medián, tretí quartile a maximálne skóre) pre objem transakcie s vykreslenými políčkami:

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

   V prípade vysoko nevyvážených údajov nemusia rámčeky zobrazovať presné prehľady. Problém s Class nerovnováhou však môžete vyriešiť najprv a potom vytvoriť rovnaké vykreslenia, aby ste mali presnejšie prehľady.

Krok č. 4: Trénovanie a vyhodnotenie modelov

V tomto kroku trénujete model LightGBM na klasifikáciu podvodných transakcií. Model LightGBM trénujete na nevyváženej množine údajov aj na vyváženej množine údajov. Potom porovnajte výkon oboch modelov.

Príprava tréningových a testovacích množín údajov

Pred tréningom rozdeľte údaje do tréningových a testovacích množín údajov:

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

Použitie SMOTE na trénovateľskú množinu údajov

Knižnica imblearn používa prístup Techniky oversampling syntetickej menšiny (SMOTE) na riešenie problému nevyváženej klasifikácie. Nevyvážená klasifikácia sa vyskytne, keď je k dispozícii príliš málo príkladov menšinovej triedy, aby model efektívne naučil rozhodovaciu hranicu. SMOTE je najpoužívanejší prístup na synchronizáciu nových vzoriek pre menšinové triedy.

Použite SMOTE iba na tréningová množinu údajov namiesto testovacej množiny údajov. Keď model skóre pomocou testovacích údajov, je potrebné približné hodnoty výkonu modelu na nezosobnených údajoch vo výrobe. Na aproximáciu sa vaše testovacie údaje spoliehajú na pôvodnú nevyváženú distribúciu, aby čo najužšie reprezentovali produkčné údaje.

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

Trénujte modely machine learning a spúšťajte experimenty

Apache Spark v Microsoft Fabric umožňuje strojové učenie s big data. Použitím Apache Spark môžete získať cenné poznatky z veľkého množstva štruktúrovaných, neštruktúrovaných a rýchlo sa pohybujúcich dát.

Máte niekoľko možností trénovať modely strojového učenia pomocou Apache Spark v Microsoft Fabric: Apache Spark MLlib, SynapseML a ďalšie open-source knižnice. Pre viac informácií pozri Trénovanie modelov strojového učenia v Microsoft Fabric.

Experiment machine learning slúži ako primárna jednotka organizácie a riadenia všetkých súvisiacich machine learning behov. Spustenie zodpovedá jedinému vykonaniu kódu modelu. Machine learning sledovanie experimentov zahŕňa správu všetkých experimentov a ich komponentov, ako sú parametre, metriky, modely a ďalšie artifacts.

Na sledovanie experimentov môžete usporiadať všetky potrebné komponenty konkrétneho experimentu machine learning. Vďaka uloženým experimentom môžete tiež jednoducho reprodukovať predchádzajúce výsledky. Pre viac informácií o experimentoch strojového učenia pozri experimenty strojového učenia v Microsoft Fabric.

1. Ak chcete sledovať ďalšie metriky, parametre a súbory, nastavte exclusive=False na aktualizáciu konfigurácie automatického označovania toku MLflow:

   mlflow.autolog(exclusive=False)
   

2. Trénujte dva modely pomocou LightGBM. Jeden model zvláda nevyváženú množinu údajov a druhý model zvláda vyváženú množinu údajov (cez SMOTE). Potom porovnajte výkon týchto dvoch modelov.

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

Určenie dôležitosti funkcie na školenie

1. Určenie dôležitosti funkcií pre model, ktorý ste natrénovali v nevyváženej množine údajov:

   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. Určte dôležitosť funkcie pre model, ktorý ste trénovali na vyvážených údajoch. SMOTE generované vyvážené dáta:

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

Keď trénujete model s nevyváženou dátovou sadou, dôležité vlastnosti vykazujú významné rozdiely v porovnaní s modelom trénovaným na vyváženej dátovej sade.

Vyhodnotenie modelov

V tomto príklade vyhodnotíte dva trénované modely:

• model sú trénované na nespracovaných a nevyvážených údajoch
• smote_model trénované na vyvážených údajoch

Metriky výpočtového modelu

1. Definujte funkciu prediction_to_spark , ktorá robí predikcie a konvertuje výsledky predikcií do Spark DataFrame. Potom môžete vypočítať modelové štatistiky na základe výsledkov predikcií pomocou 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. Použite túto funkciu prediction_to_spark na predpovede s oboma modelmi model a smote_model:

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

3. Výpočtové metriky pre tieto dva modely:

   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)
   

Vyhodnotenie výkonu modelu pomocou matice zmätku

Matica zmätok zobrazuje počet

• skutočne pozitívne (TP)
• skutočne negatívne (TN)
• falošne pozitívne (FP)
• falošne negatívne (FN)

hodnota, ktorú model vyprodukuje, keď sa ohodnotí testovacími údajmi. V prípade binárnej klasifikácie model vráti maticu 2x2 zmätok. V prípade multitriednej klasifikácie model vráti maticu nxn zmätok, kde n predstavuje počet tried.

1. Použite maticu zmätku na zhrnutie výkonov trénovaných modelov machine learning na testovacích dátach:

   # 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. Vykreslenie matice zmätku pre predpovede smote_model (trénované na vyvážených údajoch):

   # 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. Vykreslenie matice zmätku pre predpovede model (trénované na nespracovaných, nevyvážených údajoch):

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

Vyhodnotenie výkonu modelu pomocou AUC-ROC a mierok AUPRC

Oblasť pod prevádzkovou charakteristikou prijímača krivky (AUC-ROC) posudzuje výkon binárnych klasifikátorov. Graf AUC-ROC vizualizuje kompromis medzi skutočne pozitívnou sadzbou (TPR) a falošne pozitívnou sadzbou (FPR).

V niektorých prípadoch je vhodnejšie vyhodnotiť klasifikant na základe mierky Oblasť pod Precision-Recall krivky (AUPRC). Krivka AUPRC kombinuje tieto sadzby:

• Presnosť alebo kladná prediktívna hodnota (PPV)
• Odvolanie alebo TPR

Na vyhodnotenie výkonu pomocou mierok AUC-ROC a AUPRC:

1. Definujte funkciu, ktorá vráti AUC-ROC a mierky AUPRC:

   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. Do denníka zapíšte metriky AUC-ROC a AUPRC pre model, ktorý ste trénovali na nevyvážené údaje:

   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. Do denníka zapíšte metriky AUC-ROC a AUPRC pre model, ktorý ste trénovali na vyvážené údaje:

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

Model trénovaný na vyvážených údajoch vracia vyššiu AUC-ROC a hodnoty AUPRC v porovnaní s modelom trénovaným na nevyvážených údajoch. Na základe týchto opatrení sa zdá, že SMOTE je efektívnou technikou na zvýšenie výkonu modelu pri práci s vysoko nevyváženými údajmi.

Ako ukazuje nasledujúci obrázok, systém zaznamenáva každý experiment s jeho príslušným názvom. Parametre experimentu a metriky výkonu môžete sledovať vo svojom pracovnom priestore.

Nasledujúci obrázok ukazuje výkonnostné metriky modelu trénovaného na vyváženej datasete ( vo verzii 2):

Vyberte verziu 1, aby ste videli metriky modelu trénovaného na nevyváženom datasete. Keď porovnáte metriky, vidíte, že AUROC je vyšší pre model trénovaný s vyváženou dátovou sadou. Tieto výsledky naznačujú, že tento model lepšie správne predpovedá triedy 0 ako 0a predpovedá triedy 1 ako 1.

Krok č. 5: Registrácia modelov

Na registráciu dvoch modelov použite MLflow:

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

Krok č. 6: Uloženie výsledkov predpovede

Microsoft Fabric používatelia môžu modelmi strojového učenia prevádzkonalizovať pomocou škálovateľnej funkcie PREDICT. Táto funkcia podporuje dávkové bodovanie (alebo odvodenie dávky) v akomkoľvek výpočtovom nástroji.

Dávkové predikcie môžete generovať priamo z Microsoft Fabric notebooku alebo z položky modelu. Pre viac informácií o PREDICT pozri skórovanie Model s PREDICT v Microsoft Fabric.

1. Načítajte model s lepším výkonom (verzia 2) na bodovanie šarží a vygenerujte výsledky predpovede:

   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. Uložiť predpovede do lakehouse:

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

Súvisiaci obsah

• Ako používať Microsoft Fabric zápisníky
• Model strojového učenia v Microsoft Fabric
• Train machine learning modely
• experimenty strojového učenia v Microsoft Fabric