Kurz Časť 3: Trénovanie a registrácia modelu strojového učenia

V tomto kurze sa naučíte trénovať viacero modelov strojového učenia a vybrať si z nich najlepší, aby ste mohli predpovedať, z ktorých klientov bánk pravdepodobne odídu.

V tomto kurze:

Modely Train Random Forest a LightGBM.
Použite natívna integrácia služby Microsoft Fabric s architektúrou MLflow na zaznamenávanie trénovaných modelov strojového učenia, použitých hyperaparametrov a metrík hodnotenia.
Registrácia trénovaného modelu strojového učenia
Hodnotte výkony trénovaných modelov strojového učenia pri overovacej množine údajov.

MLflow je open-source platforma na spravovanie životného cyklu strojového učenia s funkciami, ako je sledovanie, modely a databáza Registry modelov. MLflow je natívne integrovaný so skúsenosťou z dátovej vedy služby Fabric.

Požiadavky

Získajte predplatné na Microsoft Fabric. Alebo si zaregistrujte bezplatnú skúšobnú verziu služby Microsoft Fabric.
Prihláste sa do služby Microsoft Fabric.
Prepnite na Fabric pomocou prepínača skúseností v ľavom dolnom rohu domovskej stránky.

Toto je 3. diel z 5 série kurzov. Ak chcete dokončiť tento kurz, najskôr dokončite tieto kroky:

Časť 1: Ingest data into a Microsoft Fabric lakehouse using Apache Spark.
Časť 2: Preskúmajte a vizualizujte údaje pomocou poznámkových blokov služby Microsoft Fabric a získajte ďalšie informácie o údajoch.

Sledovanie v notebooku

3-train-evaluate.ipynb je notebook, ktorý sprevádza tento kurz.

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 na notebook , ako začnete spustiť kód.

Dôležité

Pripojte rovnaký lakehouse ste použili v časti 1 a časť 2.

Inštalácia vlastných knižníc

V tomto notebooku nainštalujete nevyvážené učenie (importované ako imblearn) pomocou .%pip install Nevyvážené vzdelávanie je knižnica pre metódu oversampling Technique (SMOTE) syntetickej menšiny, ktorá sa používa pri riešení nevyvážených množín údajov. Jadro služby PySpark sa reštartuje po %pip install, takže pred spustením iných buniek budete musieť nainštalovať knižnicu.

Získate prístup k SMOTE pomocou knižnice imblearn . Nainštalujte ju teraz pomocou funkcií in-line inštalácie (napr. %pip, %conda).

# Install imblearn for SMOTE using pip
%pip install imblearn

%pip install scikit-learn==1.6.1

%pip install "mlflow==2.12.2"

Dôležité

Túto inštaláciu spustite vždy, keď reštartujete poznámkový blok.

Keď nainštalujete knižnicu v notebooku, je k dispozícii len počas trvania relácie poznámkového bloku a nie v pracovnom priestore. Ak reštartujete poznámkový blok, budete musieť knižnicu nainštalovať znova.

Ak často používate knižnicu a chcete ju sprístupniť všetkým poznámkovým blokom vo svojom pracovnom priestore, môžete na tento účel použiť prostredie služby Fabric. Môžete vytvoriť prostredie, nainštalovať do nej knižnicu a potom môže správca pracovného priestoru k pracovnému priestoru pripojiť prostredie ako predvolené prostredie. Ďalšie informácie o nastavení prostredia ako predvoleného pracovného priestoru nájdete v téme Nastavenie predvolených knižníc pre pracovný priestor správcom.

Informácie o migrácii existujúcich knižníc pracovných priestorov a vlastnostiach služby Spark do prostredia nájdete v téme Migrácia knižníc pracovných priestorov a vlastností Spark do predvoleného prostredia.

Načítanie údajov

Pred trénovaním akéhokoľvek modelu strojového učenia musíte načítať tabuľku delta z jazera, aby ste mohli prečítať vyčistené údaje, ktoré ste vytvorili v predchádzajúcom notebooku.

import pandas as pd
SEED = 12345
df_clean = spark.read.format("delta").load("Tables/df_clean").toPandas()

Generovanie experimentu na sledovanie a zapisovanie modelu do denníka pomocou toku MLflow

V tejto časti sa dozviete, ako generovať experiment, zadať model strojového učenia a parametre trénovania, ako aj metriky bodovania, trénovať modely strojového učenia, zaznamenávať ich a ukladať trénované modely na neskoršie použitie.

import mlflow
# Setup experiment name
EXPERIMENT_NAME = "bank-churn-experiment-SBM"  # MLflow experiment name

Rozšírenie funkcií automatického označovania toku MLflow funguje tak, že automaticky zaznamenáva hodnoty vstupných parametrov a výstupné metriky modelu strojového učenia počas jeho trénovania. Tieto informácie sa potom prihlásia do vášho pracovného priestoru, kde k nim bude možné získať prístup a vizualizovať pomocou rozhraní API toku MLflow alebo príslušného experimentu vo vašom pracovnom priestore.

Všetky experimenty s príslušnými názvami sa zapíšu do denníka a budete môcť sledovať ich parametre a metriky výkonu. Ďalšie informácie o automatickom označovaní nájdete v téme Automatické označovanie v službe Microsoft Fabric.

Nastavenie špecifikácií experimentov a automatického označovania

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(exclusive=False)

Import nástrojov scikit a LightGBM

Vďaka vašim údajom teraz môžete definovať modely strojového učenia. V tomto notebooku použijete modely Random Forest a LightGBM. Modely môžete použiť scikit-learn a lightgbm implementovať v rámci niekoľkých riadkov kódu.

# Import the required libraries for model training
from sklearn.model_selection import train_test_split
from lightgbm import LGBMClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score, precision_score, confusion_matrix, recall_score, roc_auc_score, classification_report

Príprava trénovaných, overovacích a testovacích množín údajov

train_test_split Použite funkciu od scikit-learn a rozdeľte údaje na trénované, overovacie a testovacie množiny.

y = df_clean["Exited"]
X = df_clean.drop("Exited",axis=1)
# Split the dataset to 60%, 20%, 20% for training, validation, and test datasets
# Train-Test Separation
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=SEED)
# Train-Validation Separation
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=SEED)

Uloženie testovacích údajov do delta tabuľky

Uložte testovacie údaje do tabuľky delta na použitie v ďalšom poznámkovom bloku.

table_name = "df_test"
# Create PySpark DataFrame from Pandas
df_test=spark.createDataFrame(X_test)
df_test.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark test DataFrame saved to delta table: {table_name}")

Použite SMOTE na tréningové údaje na synchronizáciu nových vzoriek pre menšinové triedy

Prieskum údajov v časti 2 ukázal, že z 10 000 údajových bodov zodpovedajúcich 10 000 zákazníkom odišlo z banky len 2 037 zákazníkov (približne 20 %). To znamená, že množina údajov je veľmi nevyvážené. Problémom nevyváženej klasifikácie je, že existuje príliš málo príkladov menšinovej triedy na to, aby model efektívne naučil rozhodovaciu hranicu. SMOTE je najpoužívanejší prístup na synchronizáciu nových vzoriek pre menšinové triedy. Ďalšie informácie o SMOTE nájdete tu a tu.

Prepitné

Všimnite si, že SMOTE sa má použiť len na trénovacie množiny údajov. Ak chcete dosiahnuť platnú aproximáciu výkonu modelu strojového učenia na pôvodných údajoch, čo predstavuje situáciu vo výrobe, musíte testovaciu množinu údajov nechať v pôvodnej nevyváženej distribúcii.

from collections import Counter
from imblearn.over_sampling import SMOTE

sm = SMOTE(random_state=SEED)
X_res, y_res = sm.fit_resample(X_train, y_train)
new_train = pd.concat([X_res, y_res], axis=1)

Prepitné

Môžete bezpečne ignorovať hlásenie s upozornením toku MLflow, ktoré sa zobrazí pri spustení tejto bunky. Ak sa zobrazuje správa ModuleNotFoundError , zmeškali ste spustenie prvej bunky v tomto poznámkovom bloku, ktorý nainštaluje knižnicu imblearn . Túto knižnicu je potrebné nainštalovať vždy, keď reštartujete poznámkový blok. Vráťte sa a znova spustite všetky bunky začínajúce prvou bunkou v tomto notebooku.

Trénovaie modelu

Trénujte model pomocou lesa Random Forest s maximálnou hĺbkou 4 a 4 funkcie

mlflow.sklearn.autolog(registered_model_name='rfc1_sm') # Register the trained model with autologging
rfc1_sm = RandomForestClassifier(max_depth=4, max_features=4, min_samples_split=3, random_state=1) # Pass hyperparameters
with mlflow.start_run(run_name="rfc1_sm") as run:
    rfc1_sm_run_id = run.info.run_id # Capture run_id for model prediction later
    print("run_id: {}; status: {}".format(rfc1_sm_run_id, run.info.status))
    # rfc1.fit(X_train,y_train) # Imbalanaced training data
    rfc1_sm.fit(X_res, y_res.ravel()) # Balanced training data
    rfc1_sm.score(X_val, y_val)
    y_pred = rfc1_sm.predict(X_val)
    cr_rfc1_sm = classification_report(y_val, y_pred)
    cm_rfc1_sm = confusion_matrix(y_val, y_pred)
    roc_auc_rfc1_sm = roc_auc_score(y_res, rfc1_sm.predict_proba(X_res)[:, 1])

Trénujte model pomocou lesa Random Forest s maximálnou hĺbkou 8 a 6 funkcií

mlflow.sklearn.autolog(registered_model_name='rfc2_sm') # Register the trained model with autologging
rfc2_sm = RandomForestClassifier(max_depth=8, max_features=6, min_samples_split=3, random_state=1) # Pass hyperparameters
with mlflow.start_run(run_name="rfc2_sm") as run:
    rfc2_sm_run_id = run.info.run_id # Capture run_id for model prediction later
    print("run_id: {}; status: {}".format(rfc2_sm_run_id, run.info.status))
    # rfc2.fit(X_train,y_train) # Imbalanced training data
    rfc2_sm.fit(X_res, y_res.ravel()) # Balanced training data
    rfc2_sm.score(X_val, y_val)
    y_pred = rfc2_sm.predict(X_val)
    cr_rfc2_sm = classification_report(y_val, y_pred)
    cm_rfc2_sm = confusion_matrix(y_val, y_pred)
    roc_auc_rfc2_sm = roc_auc_score(y_res, rfc2_sm.predict_proba(X_res)[:, 1])

Trénovať model pomocou LightGBM

# lgbm_model
mlflow.lightgbm.autolog(registered_model_name='lgbm_sm') # Register the trained model with autologging
lgbm_sm_model = LGBMClassifier(learning_rate = 0.07, 
                        max_delta_step = 2, 
                        n_estimators = 100,
                        max_depth = 10, 
                        eval_metric = "logloss", 
                        objective='binary', 
                        random_state=42)

with mlflow.start_run(run_name="lgbm_sm") as run:
    lgbm1_sm_run_id = run.info.run_id # Capture run_id for model prediction later
    # lgbm_sm_model.fit(X_train,y_train) # Imbalanced training data
    lgbm_sm_model.fit(X_res, y_res.ravel()) # Balanced training data
    y_pred = lgbm_sm_model.predict(X_val)
    accuracy = accuracy_score(y_val, y_pred)
    cr_lgbm_sm = classification_report(y_val, y_pred)
    cm_lgbm_sm = confusion_matrix(y_val, y_pred)
    roc_auc_lgbm_sm = roc_auc_score(y_res, lgbm_sm_model.predict_proba(X_res)[:, 1])

Experimentuje artefakt na sledovanie výkonu modelu

Spustenia experimentu sa automaticky uložia do artefaktu experimentu, ktorý je možné nájsť v pracovnom priestore. Názov je založený na názve použitom na nastavenie experimentu. Zapisujú sa všetky trénované modely strojového učenia, ich spustenia, metriky výkonu a parametre modelu.

Zobrazenie experimentov:

Na ľavom paneli vyberte pracovný priestor.
V pravej hornej časti vykonajte filtrovanie, aby sa zobrazili iba experimenty, aby ste ľahšie našli experiment, ktorý hľadáte.
Vyhľadajte a vyberte názov experimentu, v tomto prípade experiment s bankou. Ak sa experiment vo vašom pracovnom priestore nezobrazuje, obnovte prehliadač.

Vyhodnotenie výkonu trénovaných modelov v overovacej množine údajov

Po dokončení trénovania modelu strojového učenia môžete posúdiť výkon trénovaných modelov dvoma spôsobmi.

Otvorte uložený experiment z pracovného priestoru, načítajte modely strojového učenia a potom zhodnotte výkon načítaných modelov v overovacej množine údajov.

# Define run_uri to fetch the model
# mlflow client: mlflow.model.url, list model
load_model_rfc1_sm = mlflow.sklearn.load_model(f"runs:/{rfc1_sm_run_id}/model")
load_model_rfc2_sm = mlflow.sklearn.load_model(f"runs:/{rfc2_sm_run_id}/model")
load_model_lgbm1_sm = mlflow.lightgbm.load_model(f"runs:/{lgbm1_sm_run_id}/model")
# Assess the performance of the loaded model on validation dataset
ypred_rfc1_sm_v1 = load_model_rfc1_sm.predict(X_val) # Random Forest with max depth of 4 and 4 features
ypred_rfc2_sm_v1 = load_model_rfc2_sm.predict(X_val) # Random Forest with max depth of 8 and 6 features
ypred_lgbm1_sm_v1 = load_model_lgbm1_sm.predict(X_val) # LightGBM

Priame posúdenie výkonu trénovaných modelov strojového učenia pri overovacej množine údajov.

ypred_rfc1_sm_v2 = rfc1_sm.predict(X_val) # Random Forest with max depth of 4 and 4 features
ypred_rfc2_sm_v2 = rfc2_sm.predict(X_val) # Random Forest with max depth of 8 and 6 features
ypred_lgbm1_sm_v2 = lgbm_sm_model.predict(X_val) # LightGBM

V závislosti od vašich preferencií je niektorý z prístupov v poriadku a mal by ponúkať identické výkony. V tomto notebooku si vyberiete prvý prístup, aby ste zlepšili možnosti automatického označovania toku MLflow v službe Microsoft Fabric.

Zobraziť skutočne/falošne pozitívne/negatívne výsledky pomocou matice zmätok

V ďalšom kroku vytvoríte skript na vykreslenie matice zmätku s cieľom vyhodnotiť presnosť klasifikácie pomocou overovacej množiny údajov. Maticu zmätku možno vykresliť aj pomocou nástrojov SynapseML, ktorá sa zobrazuje v ukážke zisťovania podvodov, ktorá je k dispozícii tu.

import seaborn as sns
sns.set_theme(style="whitegrid", palette="tab10", rc = {'figure.figsize':(9,6)})
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
from matplotlib import rc, rcParams
import numpy as np
import itertools

def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):
    print(cm)
    plt.figure(figsize=(4,4))
    plt.rcParams.update({'font.size': 10})
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45, color="blue")
    plt.yticks(tick_marks, classes, color="blue")

    fmt = '.2f' if normalize else 'd'
    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="red" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

Zmätok Matrix pre náhodný klasifikant lesa s maximálnou hĺbkou 4 a 4 prvky

cfm = confusion_matrix(y_val, y_pred=ypred_rfc1_sm_v1)
plot_confusion_matrix(cfm, classes=['Non Churn','Churn'],
                      title='Random Forest with max depth of 4')
tn, fp, fn, tp = cfm.ravel()

V grafe je znázornená matica zmätku pre random forest s maximálnou hĺbkou 4.

Zmätok Matrix pre náhodný klasifikant lesa s maximálnou hĺbkou 8 a 6 funkcií

cfm = confusion_matrix(y_val, y_pred=ypred_rfc2_sm_v1)
plot_confusion_matrix(cfm, classes=['Non Churn','Churn'],
                      title='Random Forest with max depth of 8')
tn, fp, fn, tp = cfm.ravel()

V grafe je znázornená matica zmätku pre random forest s maximálnou hĺbkou 8.

Matica zmätku pre LightGBM

cfm = confusion_matrix(y_val, y_pred=ypred_lgbm1_sm_v1)
plot_confusion_matrix(cfm, classes=['Non Churn','Churn'],
                      title='LightGBM')
tn, fp, fn, tp = cfm.ravel()

Graf znázorňuje maticu zmätku pre LightGBM.

Ďalší krok

Časť 4: Vykonávanie dávkového bodovania a uloženie predpovedí do jazera

Pripomienky

Bola táto stránka užitočná?

Last updated on 2025-12-26