Del via


Selvstudium Del 3: Oplær og registrer en model til maskinel indlæring

I dette selvstudium lærer du at oplære flere modeller til maskinel indlæring for at vælge den bedste for at forudsige, hvilke bankkunder der sandsynligvis forlader.

I dette selvstudium skal du:

  • Oplær tilfældige skov- og lightGBM-modeller.
  • Brug Microsoft Fabric's oprindelige integration med MLflow-strukturen til at logføre de oplærte modeller til maskinel indlæring, de anvendte hyperaparametre og evalueringsdata.
  • Registrer den oplærte model til maskinel indlæring.
  • Vurder ydeevnen for de oplærte modeller til maskinel indlæring i valideringsdatasættet.

MLflow er en åben kildekode platform til administration af livscyklussen for maskinel indlæring med funktioner som sporing, modeller og modelregistreringsdatabase. MLflow er indbygget integreret med Fabric Data Science-oplevelsen.

Forudsætninger

  • Få et Microsoft Fabric-abonnement. Du kan også tilmelde dig en gratis Prøveversion af Microsoft Fabric.

  • Log på Microsoft Fabric.

  • Brug oplevelsesskifteren nederst til venstre på startsiden til at skifte til Fabric.

    Skærmbillede af menuen til skift af oplevelse, der viser, hvor du skal vælge Datavidenskab.

Dette er del 3 af 5 i selvstudieserien. Hvis du vil fuldføre dette selvstudium, skal du først fuldføre:

Følg med i notesbogen

3-train-evaluate.ipynb er den notesbog, der følger med dette selvstudium.

Vigtigt

Vedhæft det samme lakehouse, du brugte i del 1 og del 2.

Installér brugerdefinerede biblioteker

I denne notesbog skal du installere ubalanceret læring (importeret som imblearn) ved hjælp af %pip install. Ubalanceret-learn er et bibliotek for SMOTE (Synthetic Minority Oversampling Technique), som bruges, når der arbejdes med ubalancerede datasæt. PySpark-kernen genstartes efter %pip install, så du skal installere biblioteket, før du kører andre celler.

Du får adgang til SMOTE ved hjælp af imblearn biblioteket. Installér den nu ved hjælp af de indbyggede installationsfunktioner (f.eks. %pip, %conda).

# Install imblearn for SMOTE using pip
%pip install imblearn

Vigtigt

Kør denne installation, hver gang du genstarter notesbogen.

Når du installerer et bibliotek i en notesbog, er det kun tilgængeligt i notesbogsessionens varighed og ikke i arbejdsområdet. Hvis du genstarter notesbogen, skal du installere biblioteket igen.

Hvis du har et bibliotek, du ofte bruger, og du vil gøre det tilgængeligt for alle notesbøger i dit arbejdsområde, kan du bruge et Fabric-miljø til dette formål. Du kan oprette et miljø, installere biblioteket i det, og derefter kan administratoren af arbejdsområdet knytte miljøet til arbejdsområdet som standardmiljø. Du kan få mere at vide om, hvordan du angiver et miljø som standard for arbejdsområdet, under Administrator angiver standardbiblioteker for arbejdsområdet.

Du kan få oplysninger om overførsel af eksisterende arbejdsområdebiblioteker og Spark-egenskaber til et miljø under Overfør arbejdsområdebiblioteker og Spark-egenskaber til et standardmiljø.

Indlæs dataene

Før du oplærer en model til maskinel indlæring, skal du indlæse deltatabellen fra lakehouse'et for at kunne læse de rensede data, du oprettede i den forrige notesbog.

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

Generér eksperiment til sporing og logføring af modellen ved hjælp af MLflow

I dette afsnit kan du se, hvordan du genererer et eksperiment, angiver model til maskinel indlæring og oplæringsparametre samt scoringsmålepunkter, oplærer modeller til maskinel indlæring, logfører dem og gemmer de oplærte modeller til senere brug.

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

Hvis du udvider funktionerne til automatisk logning af MLflow, fungerer automatisklogging ved automatisk at registrere værdierne for inputparametre og outputmetrik for en model til maskinel indlæring, efterhånden som den oplæres. Disse oplysninger logføres derefter i dit arbejdsområde, hvor du kan få adgang til dem og visualisere dem ved hjælp af MLflow-API'erne eller det tilsvarende eksperiment i dit arbejdsområde.

Alle eksperimenter med deres respektive navne logføres, og du kan spore deres parametre og målepunkter for ydeevne. Hvis du vil vide mere om automatisk logning, skal du se Automatisklogning i Microsoft Fabric.

Angiv specifikationer for eksperiment og automatisk logning

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

Importér scikit-learn og LightGBM

Når dine data er på plads, kan du nu definere modeller til maskinel indlæring. Du skal anvende Random Forest- og LightGBM-modeller i denne notesbog. Brug scikit-learn og lightgbm til at implementere modellerne inden for nogle få kodelinjer.

# 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

Forbered oplærings-, validerings- og testdatasæt

Brug funktionen train_test_split fra scikit-learn til at opdele dataene i oplæring, validering og testsæt.

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)

Gem testdata i en deltatabel

Gem testdataene i deltatabellen til brug i den næste notesbog.

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

Anvend SMOTE på oplæringsdata for at syntetisere nye eksempler for mindretalsklassen

Dataudforskningen i del 2 viste, at ud af de 10.000 datapunkter, der svarer til 10.000 kunder, har kun 2.037 kunder (ca. 20 %) forladt banken. Dette angiver, at datasættet er meget ubalanceret. Problemet med ubalanceret klassificering er, at der er for få eksempler på mindretalsklassen til, at en model effektivt kan lære beslutningsgrænsen. SMOTE er den mest anvendte metode til at syntetisere nye prøver for minoritetsklassen. Få mere at vide om SMOTE her og her.

Tip

Bemærk, at SMOTE kun skal anvendes på træningsdatasættet. Du skal lade testdatasættet være i dets oprindelige ubalancerede distribution for at få en gyldig tilnærmelse af, hvordan modellen til maskinel indlæring fungerer på de oprindelige data, hvilket repræsenterer situationen i produktionen.

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)

Tip

Du kan trygt ignorere den MLflow-advarselsmeddelelse, der vises, når du kører denne celle. Hvis du får vist meddelelsen ModuleNotFoundError , gik du glip af at køre den første celle i denne notesbog, som installerer imblearn biblioteket. Du skal installere dette bibliotek, hver gang du genstarter notesbogen. Gå tilbage, og kør alle cellerne igen, startende med den første celle i denne notesbog.

Modeltræning

  • Oplær modellen ved hjælp af Random Forest med maksimal dybde på 4 og 4 funktioner
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])
  • Oplær modellen ved hjælp af Random Forest med maksimal dybde på 8 og 6 funktioner
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])
  • Oplær modellen ved hjælp af 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])

Eksperimentartefakt til sporing af modellens ydeevne

Eksperimentkørslerne gemmes automatisk i eksperimentartefakten, der findes fra arbejdsområdet. De navngives på baggrund af det navn, der bruges til at angive eksperimentet. Alle oplærte modeller til maskinel indlæring, deres kørsler, målepunkter for ydeevne og modelparametre logføres.

Sådan får du vist dine eksperimenter:

  1. Vælg dit arbejdsområde i venstre panel.

  2. Filtrer øverst til højre for kun at vise eksperimenter for at gøre det nemmere at finde det eksperiment, du leder efter.

    Skærmbillede, der viser arbejdsområdet med filteret eksperimenter valgt.

  3. Find og vælg eksperimentnavnet, i dette tilfælde bankafgangseksperiment. Hvis du ikke kan se eksperimentet i dit arbejdsområde, skal du opdatere din browser.

    Skærmbillede, der viser eksperimentsiden for bankafgangseksperimentet.

Vurder ydeevnen for de oplærte modeller i valideringsdatasættet

Når du er færdig med oplæring af model til maskinel indlæring, kan du vurdere ydeevnen af oplærte modeller på to måder.

  • Åbn det gemte eksperiment fra arbejdsområdet, indlæs modellerne til maskinel indlæring, og vurder derefter ydeevnen for de indlæste modeller i valideringsdatasættet.

    # 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
    
  • Vurder ydeevnen af de oplærte modeller til maskinel indlæring direkte i valideringsdatasættet.

    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
    

Afhængigt af dine præferencer er begge fremgangsmåder fine og bør tilbyde identiske ydeevner. I denne notesbog skal du vælge den første fremgangsmåde for bedre at demonstrere funktionerne til automatisklogging af MLflow i Microsoft Fabric.

Vis True/False Positives/Negatives ved hjælp af forvirringsmatrixen

Derefter skal du udvikle et script til at afbilde forvirringsmatrixen for at evaluere nøjagtigheden af klassificeringen ved hjælp af valideringsdatasættet. Forvirringsmatrixen kan også afbildes ved hjælp af SynapseML-værktøjer, som vises i Eksemplet på registrering af svindel, som er tilgængelig her.

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')
  • Forvirringsmatrix for Random Forest-klassificering med maksimal dybde på 4 og 4 funktioner
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()

Grafen viser forvirringsmatrixen for Random Forest med maksimal dybde på 4.

  • Forvirringsmatrix for Random Forest-klassificering med maksimal dybde på 8 og 6 funktioner
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()

Grafen viser forvirringsmatrix for Random Forest med maksimal dybde på 8.

  • Forvirringsmatrix til 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()

Grafen viser forvirringsmatrixen for LightGBM.

Næste trin