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

Tento kurz predstavuje komplexný príklad pracovného postupu synapse Data Science v službe Microsoft Fabric. Tento scenár vytvára model zisťovania podvodov s algoritmami strojového učenia trénovanými na historické údaje. Potom použije model na zisťovanie budúcich podvodných transakcií.

V tomto kurze sú obsiahnuté tieto kroky:

Predpoklady

• Získajte predplatné služby Microsoft Fabric . Alebo si zaregistrujte bezplatnú skúšobnú služby Microsoft Fabric.

• Prihláste sa do služby Microsoft Fabric.

• Pomocou prepínača skúseností v ľavej dolnej časti domovskej stránky sa prepnete na službu Fabric.

  

• Ak je to potrebné, vytvorte si podľa popisu v téme Vytvorenie jazera v službe Microsoft Fabric.

Sledovanie v poznámkovom bloke

Môžete si vybrať jednu z týchto možností, ktorú si môžete vyskúšať v notebooku:

• Otvorte a spustite vstavaný poznámkový blok.
• Nahrajte poznámkový blok z GitHubu.

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.

Importovanie notebooku z GitHubu

Tento kurz sprevádza poznámkový blok 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

Na vývoj modelu strojového učenia alebo analýzu údajov ad hoc možno budete musieť rýchlo nainštalovať vlastnú knižnicu pre reláciu Apache Spark. 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).
• Prípadne môžete vytvoriť prostredie služby Fabric, nainštalovať knižnice z verejných zdrojov alebo do neho nahrať vlastné knižnice a potom môže správca pracovného priestoru k prostrediu pripojiť ako predvolené prostredie pre pracovný priestor. Všetky knižnice v prostredí budú potom k dispozícii na použitie v poznámkových blokoch a definíciách úloh služby Spark v pracovnom priestore. Ďalšie informácie o prostrediach nájdete v téme vytvorenia, konfigurácie a používania prostredia v službe Microsoft Fabric.

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

# Use pip to install imblearn
%pip install imblearn

Krok č. 2: Načítanie údajov

Množina údajov zisťovania podvodov obsahuje transakcie kreditných kariet od septembra 2013, ktoré sa v priebehu dvoch dní uskutočnili v európskych držiteľoch kariet. 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. Z dôvodu ochrany dôvernosti nemôžeme poskytnúť pôvodné funkcie ani ďalšie základné informácie o množine údajov.

Tieto podrobnosti popisujú množinu údajov:

• Funkcie V1, V2, V3, ..., V28 sú hlavné komponenty získané pomocou PCA
• Funkcia Time obsahuje uplynulé sekundy medzi transakciou a prvou transakciou v množine údajov
• Funkcia Amount je čiastka transakcie. Túto funkciu môžete použiť napríklad na výuku závislé od nákladov
• Stĺpec Class je premenná odpovede (cieľ). Má hodnotu 1 podvodov a v opačnom prípade 0 hodnoty.

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:

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

Definujte tieto parametre, aby ste mohli používať tento poznámkový blok s rôznymi množinami údajov:

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 množiny údajov a potom ju uloží v úložisku Fabric lakehouse.

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

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áte spôsob, ako získať lepšie výsledky pri spustení konkrétneho experimentu. V týchto prípadoch by ste mali experiment zastaviť a skúsiť nový.

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

Pomocou automatického označovania môžete jednoducho sledovať a porovnávať výkon rôznych modelov a experimentov bez toho, aby bolo potrebné manuálne sledovanie. Ďalšie informácie nájdete automatické označovanie v službe Microsoft Fabric.

Ak chcete zakázať automatické označovanie služby Microsoft Fabric v relácii poznámkového bloku, 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 nespracované údaje a zobrazte si štatistiky vysokej úrovne pomocou príkazu display. Ďalšie informácie o vizualizácii údajov nájdete v téme Vizualizácia poznámkového blokov v službe 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á. Pred trénovaním modelu je preto potrebné vopred poskytnúť údaje, aby sa zabránilo prepísaniu.

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 príklade trénujete model LightGBM na klasifikáciu transakcií podvodov. 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)

Ďalšie informácie o SMOTE nájdete na referenčnej stránke scikit-learn pre metódu SMOTE, kde aj príručku pre používateľov s súpravou scikit-learn o prepájaní zdrojov.

Trénovanie modelov strojového učenia a spúšťanie experimentov

Apache Spark v službe Microsoft Fabric umožňuje strojové učenie s veľkým objemom údajov. Pomocou Apache Spark môžete získať cenné prehľady z veľkého množstva štruktúrovaných, neštruktúrovaných a rýchlo sa pohybujúcich údajov.

Na trénovanie modelov strojového učenia so službou Apache Spark v službe Microsoft Fabric máte k dispozícii niekoľko možností: Apache Spark MLlib, SynapseML a ďalšie knižnice typu open-source. Ďalšie informácie nájdete Modely strojového učenia v službe Microsoft Fabric.

Experiment strojového učenia slúži ako primárna jednotka organizácie a kontroly pre všetky súvisiace spustenia strojového učenia. Spustenie zodpovedá jedinému vykonaniu kódu modelu. Strojové učenie sledovanie experimentov zahŕňa správu všetkých experimentov a ich súčastí, ako sú parametre, metriky, modely a ďalšie artefakty.

Na sledovanie experimentov môžete usporiadať všetky požadované súčasti konkrétneho experimentu strojového učenia. Vďaka uloženým experimentom môžete tiež jednoducho reprodukovať predchádzajúce výsledky. Ďalšie informácie o experimentoch strojového učenia nájdete v téme pokusoch strojového učenia v službe 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")
   

Ak chcete trénovať model s nevyváženou množinou údajov, dôležité funkcie majú v porovnaní s modelom trénovaným s vyváženou množinou údajov významné rozdiely.

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á vykonáva predpovede, a konvertuje výsledky predpovede na údajový rámec Spark. Následne môžete pomocou SynapseMLvypočítať štatistiky modelu z výsledkov predpovede.

   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. Pomocou funkcie prediction_to_spark môžete vykonávať predpovede s dvomi 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. Maticu zmätku použite na sumarizáciu výkonu trénovaných modelov strojového učenia na testovacích údajoch:

   # 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, každý experiment sa zapíše do denníka s príslušným názvom. Parametre experimentu a metriky výkonu môžete sledovať vo svojom pracovnom priestore.

Tento obrázok zobrazuje metriky výkonu pre model trénovaný na vyváženej množine údajov (v verzii 2):

Môžete vybrať Verzie 1 a zobrazia sa metriky pre model trénovaný v nevyváženej množine údajov. Keď porovnávate metriky, verzia AUROC je vyššia pre model trénovaný s vyváženou množinou údajov. 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 umožňuje používateľom využiť modely strojového učenia pomocou PREDICT škálovateľnej funkcie. Táto funkcia podporuje dávkové bodovanie (alebo odvodenie dávky) v akomkoľvek výpočtovom nástroji.

Predpovede dávky môžete vytvárať priamo z poznámkového bloku služby Microsoft Fabric alebo zo stránky položky modelu. Ďalšie informácie o PREDICTnájdete v téme Skóre modelov pomocou funkcie PREDICT v službe 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ť poznámkové bloky služby Microsoft Fabric
• modelu strojového učenia v službe Microsoft Fabric
• modely strojového učenia
• experimentov strojového učenia v službe Microsoft Fabric