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.
Brug oplevelsesskifteren nederst til venstre på startsiden til at skifte til Fabric.
Dette er del 3 af 5 i selvstudieserien. Hvis du vil fuldføre dette selvstudium, skal du først fuldføre:
- Del 1: Indfødning af data i et Microsoft Fabric lakehouse ved hjælp af Apache Spark.
- Del 2: Udforsk og visualiser data ved hjælp af Microsoft Fabric-notesbøger for at få mere at vide om dataene.
Følg med i notesbogen
3-train-evaluate.ipynb er den notesbog, der følger med dette selvstudium.
Hvis du vil åbne den medfølgende notesbog til dette selvstudium, skal du følge vejledningen i Forbered dit system til selvstudier om datavidenskab importere notesbogen til dit arbejdsområde.
Hvis du hellere vil kopiere og indsætte koden fra denne side, kan du oprette en ny notesbog.
Sørg for at vedhæfte et lakehouse til notesbogen , før du begynder at køre kode.
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:
Vælg dit arbejdsområde i venstre panel.
Filtrer øverst til højre for kun at vise eksperimenter for at gøre det nemmere at finde det eksperiment, du leder efter.
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.
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) # LightGBMVurder 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()
- 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()
- 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()
