Megosztás a következőn keresztül:

Oktatóanyag: Változás-előrejelzési modell létrehozása, kiértékelése és pontszáma

  • Cikk

Ez az oktatóanyag egy Synapse Data Science-munkafolyamat végpontok közötti példáját mutatja be a Microsoft Fabricben. A forgatókönyv egy modellt hoz létre annak előrejelzésére, hogy a banki ügyfelek elhagyják-e a szolgáltatást. A lemorzsolódási ráta, vagy attrition ráta, azt a mértéket foglalja magában, amellyel a banki ügyfelek megszüntetik a kapcsolatukat a bankkal.

Ez az oktatóanyag az alábbi lépéseket ismerteti:

  • Egyéni könyvtárak telepítése
  • Adatok betöltése
  • Az adatok megismerése és feldolgozása feltáró adatelemzéssel, valamint a Fabric Data Wrangler funkció használatának bemutatása
  • A scikit-learn és a LightGBM használatával gépi tanulási modelleket taníthat be, és nyomon követheti az MLflow és a Fabric autologging funkcióival végzett kísérleteket
  • A végső gépi tanulási modell kiértékelése és mentése
  • A modell teljesítményének megjelenítése Power BI-vizualizációkkal

Előfeltételek

Követés jegyzetfüzetben

A jegyzetfüzetben az alábbi lehetőségek közül választhat a továbbhaladáshoz:

  • Nyissa meg és futtassa a beépített jegyzetfüzetet.
  • Töltse fel a jegyzetfüzetet a GitHubról.

A beépített jegyzetfüzet megnyitása

Ebben az oktatóanyagban a ügyfélvesztés mintajegyzetfüzet található meg.

  1. Az oktatóanyaghoz tartozó mintajegyzetfüzet megnyitásához kövesse a A rendszer előkészítése adatelemzési oktatóanyagokhozcímű témakörben található utasításokat.

  2. A kód futtatása előtt mindenképpen csatoljon egy tóházat a jegyzetfüzethez.

A jegyzetfüzet importálása a GitHubról

A AIsample - Bank Customer Churn.ipynb jegyzetfüzet kíséri ezt az oktatóanyagot.

1. lépés: Egyéni kódtárak telepítése

A gépi tanulási modell fejlesztéséhez vagy az alkalmi adatelemzéshez előfordulhat, hogy gyorsan telepítenie kell egy egyéni kódtárat az Apache Spark-munkamenethez. A kódtárak telepítéséhez két lehetőség közül választhat.

  • A jegyzetfüzet beágyazott telepítési képességeivel (%pip vagy %conda) csak az aktuális jegyzetfüzetben telepíthet tárat.
  • Másik lehetőségként létrehozhat egy Fabric-környezetet, telepíthet nyilvános forrásokból származó kódtárakat, vagy feltölthet hozzá egyéni kódtárakat, majd a munkaterület rendszergazdája alapértelmezettként csatolhatja a környezetet a munkaterülethez. Ezután a környezet összes kódtára elérhetővé válik a munkaterület bármely jegyzetfüzetében és Spark-feladatdefiníciójában. További információ a környezetekről: környezet létrehozása, konfigurálása és használata a Microsoft Fabric.

Ebben az oktatóanyagban a %pip install használatával telepítheti a imblearn könyvtárat a jegyzetfüzetbe.

Jegyzet

A PySpark-kernel %pip install futtatása után újraindul. Telepítse a szükséges könyvtárakat, mielőtt bármilyen más cellát futtatna.

# Use pip to install libraries
%pip install imblearn

2. lépés: Az adatok betöltése

A churn.csv adathalmaza 10 000 ügyfél lemorzsolódási állapotát tartalmazza, valamint 14 jellemzőt, amelyek a következők:

  • Kreditpontszám
  • Földrajzi hely (Németország, Franciaország, Spanyolország)
  • Nem (férfi, nő)
  • Kor
  • Hűségidő (az évek száma, amikor az adott személy az adott bank ügyfele volt)
  • Számla egyenlege
  • Becsült fizetés
  • Az ügyfél által a bankon keresztül vásárolt termékek száma
  • Hitelkártya állapota (függetlenül attól, hogy egy ügyfél rendelkezik-e hitelkártyával)
  • Aktív tag állapota (függetlenül attól, hogy a személy aktív banki ügyfél-e)

Az adatkészlet sorszámot, ügyfél-azonosítót és ügyfél vezetéknévoszlopokat is tartalmaz. Az oszlopok értékei nem befolyásolhatják az ügyfél bankból való kilépésre vonatkozó döntését.

Az ügyfél bankszámlájának lezárási eseménye határozza meg az ügyfél lemorzsolódását. Az adathalmaz Exited oszlop az ügyfél lemondására utal. Mivel kevés kontextusunk van ezekről az attribútumokról, nincs szükségünk háttérinformációkra az adathalmazról. Szeretnénk megtudni, hogyan járulnak hozzá ezek az attribútumok a Exited állapotához.

A 10 000 ügyfél közül csak 2037 ügyfél (nagyjából 20%) hagyta el a bankot. Az osztályegyensúlyozatlanság miatt a szintetikus adatok létrehozását javasoljuk. Előfordulhat, hogy a keveredési mátrix pontosságának nincs jelentősége az egyensúlyhiányos besorolás szempontjából. Érdemes lehet a pontosságot a Precision-Recall görbe alatti területtel (AUPRC) mérni.

  • Ez a táblázat a churn.csv adatainak előnézetét mutatja be:
Ügyfélazonosító Vezetéknév Hitelpontszám Földrajz Társadalmi nem Kor Hivatali idő Mérleg NumOfProducts HasCrCard IsActiveMember Becsült fizetés Kilépett
15634602 Hargrave 619 Franciaország Nő 42 2 0.00 1 1 1 101348.88 1
15647311 Domb 608 Spanyolország Nő 41 1 83807.86 1 0 1 112542.58 0

Töltse le az adathalmazt, és töltse fel a lakehouse-ba

Adja meg ezeket a paramétereket, hogy ezt a jegyzetfüzetet különböző adatkészletekkel használhassa:

IS_CUSTOM_DATA = False  # If TRUE, the dataset has to be uploaded manually

IS_SAMPLE = False  # If TRUE, use only SAMPLE_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_ROOT = "/lakehouse/default"
DATA_FOLDER = "Files/churn"  # Folder with data files
DATA_FILE = "churn.csv"  # Data file name

Ez a kód letölti az adathalmaz nyilvánosan elérhető verzióját, majd egy Fabric lakehouse-ban tárolja az adathalmazt:

Fontos

Futtatás előtt vegyen fel egy lakehouse- a jegyzetfüzetbe. Ennek elmulasztása hibát fog eredményezni.

import os, requests
if not IS_CUSTOM_DATA:
# With an Azure Synapse Analytics blob, this can be done in one line

# Download demo data files into the lakehouse if they don't exist
    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/bankcustomerchurn"
    file_list = ["churn.csv"]
    download_path = "/lakehouse/default/Files/churn/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)
    for fname in file_list:
        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.")

Kezdje el rögzíteni a jegyzetfüzet futtatásához szükséges időt:

# Record the notebook running time
import time

ts = time.time()

Nyers adatok olvasása a lakehouse adattárolóból

Ez a kód a tóház Fájlok szakaszából olvas be nyers adatokat, és további oszlopokat ad hozzá a különböző dátumrészekhez. A particionált deltatábla létrehozása ezt az információt használja.

df = (
    spark.read.option("header", True)
    .option("inferSchema", True)
    .csv("Files/churn/raw/churn.csv")
    .cache()
)

Pandas DataFrame létrehozása az adatkészletből

Ez a kód pandas DataFrame-gé alakítja a Spark DataFrame-et a könnyebb feldolgozás és vizualizáció érdekében:

df = df.toPandas()

3. lépés: Feltáró adatelemzés végrehajtása

Nyers adatok megjelenítése

Fedezze fel a nyers adatokat display, számítsa ki néhány alapstatisztikát, és jelenítsen meg diagramnézeteket. Először importálnia kell az adatvizualizációhoz szükséges könyvtárakat – például a seabornkönyvtárat. A Seaborn egy Python-adatvizualizációs kódtár, amely magas szintű felületet biztosít vizualizációk adatkereteken és tömbökön való létrehozásához.

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 pandas as pd
import itertools

display(df, summary=True)

A Data Wrangler használata kezdeti adattisztításhoz

Indítsa el a Data Wranglert közvetlenül a jegyzetfüzetből a Pandas-adatkeretek felderítéséhez és átalakításához. Válassza a Data Wrangler legördülő menüt a vízszintes eszköztárról a szerkesztésre elérhető aktivált pandas DataFrame-ek tallózásához. Válassza ki a Data Wranglerben megnyitni kívánt DataFrame-et.

Jegyzet

A Data Wrangler nem nyitható meg, amíg a jegyzetfüzet kernele foglalt. A cella végrehajtásának be kell fejeződnie a Data Wrangler elindítása előtt. További információ a Data Wrangler.

Képernyőkép a Data Wrangler eléréséhez.

A Data Wrangler elindítása után megjelenik az adatpanel leíró áttekintése, ahogyan az alábbi képeken is látható. Az áttekintés információkat tartalmaz a DataFrame méretéről, a hiányzó értékekről stb. A Data Wrangler használatával létrehozhatja a szkriptet a hiányzó értékeket tartalmazó sorok, az ismétlődő sorok és az adott nevű oszlopok elvetéséhez. Ezután átmásolhatja a szkriptet egy cellába. A következő cellában a másolt szkript látható.

Data Wrangler menüt bemutató képernyőkép.

Képernyőkép a hiányzó adatokról a Data Wranglerben. 

def clean_data(df):
    # Drop rows with missing data across all columns
    df.dropna(inplace=True)
    # Drop duplicate rows in columns: 'RowNumber', 'CustomerId'
    df.drop_duplicates(subset=['RowNumber', 'CustomerId'], inplace=True)
    # Drop columns: 'RowNumber', 'CustomerId', 'Surname'
    df.drop(columns=['RowNumber', 'CustomerId', 'Surname'], inplace=True)
    return df

df_clean = clean_data(df.copy())

Attribútumok meghatározása

Ez a kód határozza meg a kategorikus, numerikus és célattribútumokat:

# Determine the dependent (target) attribute
dependent_variable_name = "Exited"
print(dependent_variable_name)
# Determine the categorical attributes
categorical_variables = [col for col in df_clean.columns if col in "O"
                        or df_clean[col].nunique() <=5
                        and col not in "Exited"]
print(categorical_variables)
# Determine the numerical attributes
numeric_variables = [col for col in df_clean.columns if df_clean[col].dtype != "object"
                        and df_clean[col].nunique() >5]
print(numeric_variables)

Az öt szám összegzésének megjelenítése

Az ötszámos összegzés megjelenítése dobozdiagramokkal

  • a minimális pontszám
  • első negyed
  • medián
  • harmadik kvartilis
  • maximális pontszám

a numerikus attribútumok esetében.

df_num_cols = df_clean[numeric_variables]
sns.set(font_scale = 0.7) 
fig, axes = plt.subplots(nrows = 2, ncols = 3, gridspec_kw =  dict(hspace=0.3), figsize = (17,8))
fig.tight_layout()
for ax,col in zip(axes.flatten(), df_num_cols.columns):
    sns.boxplot(x = df_num_cols[col], color='green', ax = ax)
# fig.suptitle('visualize and compare the distribution and central tendency of numerical attributes', color = 'k', fontsize = 12)
fig.delaxes(axes[1,2])

Képernyőkép a numerikus attribútumok meződiagramjának jegyzetfüzet-megjelenítéséről.

A kilépő és a nem kilépő ügyfelek eloszlásának megjelenítése

A kilépett és a nem kilépő ügyfelek eloszlásának megjelenítése a kategorikus attribútumok között:

attr_list = ['Geography', 'Gender', 'HasCrCard', 'IsActiveMember', 'NumOfProducts', 'Tenure']
fig, axarr = plt.subplots(2, 3, figsize=(15, 4))
for ind, item in enumerate (attr_list):
    sns.countplot(x = item, hue = 'Exited', data = df_clean, ax = axarr[ind%2][ind//2])
fig.subplots_adjust(hspace=0.7)

Képernyőkép, amely a kilépett ügyfelek és a nem kilépő ügyfelek eloszlását ábrázoló jegyzetfüzetet jeleníti meg.

Numerikus attribútumok eloszlásának megjelenítése

Használjon hisztogramot a numerikus attribútumok gyakoriságeloszlásának megjelenítéséhez:

columns = df_num_cols.columns[: len(df_num_cols.columns)]
fig = plt.figure()
fig.set_size_inches(18, 8)
length = len(columns)
for i,j in itertools.zip_longest(columns, range(length)):
    plt.subplot((length // 2), 3, j+1)
    plt.subplots_adjust(wspace = 0.2, hspace = 0.5)
    df_num_cols[i].hist(bins = 20, edgecolor = 'black')
    plt.title(i)
# fig = fig.suptitle('distribution of numerical attributes', color = 'r' ,fontsize = 14)
plt.show()

Numerikus attribútumokat megjelenítő jegyzetfüzet képernyőképe.

Funkciófejlesztés végrehajtása

Ez a szolgáltatásfejlesztés új attribútumokat hoz létre az aktuális attribútumok alapján:

df_clean["NewTenure"] = df_clean["Tenure"]/df_clean["Age"]
df_clean["NewCreditsScore"] = pd.qcut(df_clean['CreditScore'], 6, labels = [1, 2, 3, 4, 5, 6])
df_clean["NewAgeScore"] = pd.qcut(df_clean['Age'], 8, labels = [1, 2, 3, 4, 5, 6, 7, 8])
df_clean["NewBalanceScore"] = pd.qcut(df_clean['Balance'].rank(method="first"), 5, labels = [1, 2, 3, 4, 5])
df_clean["NewEstSalaryScore"] = pd.qcut(df_clean['EstimatedSalary'], 10, labels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Használja a Data Wrangler programot one-hot kódolás végrehajtásához.

A Data Wrangler elindításának korábbi lépéseivel a Data Wrangler használatával hajthat végre egy gyakori kódolást. Ez a cella az egyszeri kódoláshoz másolt létrehozott szkriptet jeleníti meg:

Képernyőkép, amely a Data Wrangler one-hot kódolását jeleníti meg.

Data Wrangler oszlopainak kiválasztását bemutató képernyőkép. 

df_clean = pd.get_dummies(df_clean, columns=['Geography', 'Gender'])

Delta-tábla létrehozása a Power BI-jelentés létrehozásához

table_name = "df_clean"
# Create a PySpark DataFrame from pandas
sparkDF=spark.createDataFrame(df_clean) 
sparkDF.write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")

A feltáró adatelemzés megfigyeléseinek összegzése

  • A legtöbb ügyfél Franciaországból származik. Franciaországhoz és Németországhoz képest Spanyolországban a legalacsonyabb a forgalom.
  • A legtöbb ügyfél hitelkártyával rendelkezik
  • Egyes ügyfelek 60 év felettiek, és 400 alatti kreditpontszámmal rendelkeznek. Ezek azonban nem tekinthetők kiugró értéknek
  • Nagyon kevés ügyfél több mint két banki termékkel rendelkezik
  • Az inaktív ügyfeleknél magasabb a lemorzsolódási arány.
  • A nemek közötti és a bérleti évek kevés hatással vannak az ügyfél bankszámla bezárására vonatkozó döntésére

4. lépés: Modell betanítása és nyomon követése

A helyén lévő adatokkal most már meghatározhatja a modellt. Random forest és LightGBM modellek alkalmazása ebben a notebookban.

A scikit-learn és a LightGBM kódtárak segítségével implementálhatja a modelleket néhány sornyi kóddal. A kísérletek nyomon követéséhez használja az MLfLow és a Fabric autologging parancsot is.

Ez a kódminta betölti a delta táblát a lakehouse-ból. Használhat más deltatáblákat is, amelyek maguk is a lakehouse-t használják forrásként.

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

Kísérlet létrehozása a modellek nyomon követésére és naplózására az MLflow használatával

Ez a szakasz bemutatja, hogyan hozhat létre kísérletet, és megadja a modell- és betanítási paramétereket, valamint a pontozási metrikákat. Emellett bemutatja, hogyan taníthatja be a modelleket, naplózza őket, és hogyan mentheti a betanított modelleket későbbi használatra.

import mlflow

# Set up the experiment name
EXPERIMENT_NAME = "sample-bank-churn-experiment"  # MLflow experiment name

Az automatikus naplózás automatikusan rögzíti a bemeneti paraméter értékeit és a gépi tanulási modell kimeneti metrikáit is, mivel ez a modell be van tanítva. Ezt az információt ezután a rendszer naplózza a munkaterületre, ahol az MLflow API-k vagy a munkaterület megfelelő kísérlete elérheti és megjelenítheti azokat.

Ha befejeződött, a kísérlet a következő képhez hasonlít:

Képernyőkép, amely a banki ügyféllemorzsolódási kísérlet oldalát mutatja.

A rendszer naplózza a hozzájuk tartozó összes kísérletet, és nyomon követheti a paramétereket és a teljesítménymetrikákat. Az autologginggel kapcsolatos további információkért lásd: Autologging a Microsoft Fabric.

Kísérlet és automatikus címkézési specifikációk beállítása

mlflow.set_experiment(EXPERIMENT_NAME) # Use a date stamp to append to the experiment
mlflow.autolog(exclusive=False)

Scikit-learn és LightGBM importálása

# 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

Adathalmazok betanítása és tesztelése

y = df_clean["Exited"]
X = df_clean.drop("Exited",axis=1)
# Train/test separation
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=SEED)

SMOTE alkalmazása a betanítási adatokra

A kiegyensúlyozatlan besorolásnak van egy problémája, mert túl kevés példa van a kisebbségi osztályra ahhoz, hogy egy modell hatékonyan megtanulja a döntési határt. Ennek kezeléséhez a szintetikus kisebbségi túlméretezési technika (SMOTE) a legelterjedtebb módszer a kisebbségi osztály új mintáinak szintetizálására. Az SMOTE elérése az 1. lépésben telepített imblearn kódtárral.

Csak a betanítási adathalmazra alkalmazza az SMOTE-t. Az eredeti kiegyensúlyozatlan eloszlásban kell hagynia a tesztadatkészletet, hogy érvényes modellteljesítmény-közelítést kapjon az eredeti adatokhoz. Ez a kísérlet a gyártási környezet helyzetét mutatja be.

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)

További információ: SMOTE és A véletlenszerű túlmintavételezéstől az SMOTE-ig és az ADASYN-ig. Az imbalanced-learn weboldal üzemelteti ezeket az erőforrásokat.

A modell betanítása

A Random Forest használatával betanítsa a modellt négy maximális mélységgel és négy funkcióval:

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) # Imbalanced training data
    rfc1_sm.fit(X_res, y_res.ravel()) # Balanced training data
    rfc1_sm.score(X_test, y_test)
    y_pred = rfc1_sm.predict(X_test)
    cr_rfc1_sm = classification_report(y_test, y_pred)
    cm_rfc1_sm = confusion_matrix(y_test, y_pred)
    roc_auc_rfc1_sm = roc_auc_score(y_res, rfc1_sm.predict_proba(X_res)[:, 1])

A Random Forest használatával betanítsa a modellt, amelynek maximális mélysége nyolc, és hat funkcióval:

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_test, y_test)
    y_pred = rfc2_sm.predict(X_test)
    cr_rfc2_sm = classification_report(y_test, y_pred)
    cm_rfc2_sm = confusion_matrix(y_test, y_pred)
    roc_auc_rfc2_sm = roc_auc_score(y_res, rfc2_sm.predict_proba(X_res)[:, 1])

A modell betanítása a LightGBM használatával:

# 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_test)
    accuracy = accuracy_score(y_test, y_pred)
    cr_lgbm_sm = classification_report(y_test, y_pred)
    cm_lgbm_sm = confusion_matrix(y_test, y_pred)
    roc_auc_lgbm_sm = roc_auc_score(y_res, lgbm_sm_model.predict_proba(X_res)[:, 1])

A kísérlet összetevőjének megtekintése a modell teljesítményének nyomon követéséhez

A kísérleti futtatások automatikusan a kísérleti adatobjektumban lesznek mentve. Az a lelet a munkaterületen megtalálható. Az összetevő neve a kísérlet beállításához használt névn alapul. Az összes betanított modell, futtatás, teljesítménymetrika és modellparaméter naplózva lesz a kísérletoldalon.

A kísérletek megtekintése:

  1. A bal oldali panelen válassza ki a munkaterületet.
  2. Keresse meg és válassza ki a kísérlet nevét, ebben az esetben sample-bank-churn-experiment.

Képernyőkép az egyik modell naplózott értékeiről.

5. lépés: A végső gépi tanulási modell kiértékelése és mentése

Nyissa meg a munkaterületről mentett kísérletet a legjobb modell kiválasztásához és mentéséhez:

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

A mentett modellek teljesítményének értékelése a tesztadatkészleten

ypred_rfc1_sm = load_model_rfc1_sm.predict(X_test) # Random forest with maximum depth of 4 and 4 features
ypred_rfc2_sm = load_model_rfc2_sm.predict(X_test) # Random forest with maximum depth of 8 and 6 features
ypred_lgbm1_sm = load_model_lgbm1_sm.predict(X_test) # LightGBM

Igaz/hamis pozitív/negatív értékek megjelenítése keveredési mátrix használatával

A besorolás pontosságának kiértékeléséhez hozzon létre egy szkriptet, amely ábrázolja a keveredési mátrixot. A SynapseML-eszközök segítségével konfúziós mátrixot is ábrázolhatja, ahogyan az a Csalásészlelési mintábanis látható.

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

Hozzon létre egy keveredési mátrixot a véletlenszerű erdőosztályozóhoz, amelynek maximális mélysége négy, négy jellemzővel:

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

Képernyőkép, amely egy véletlenszerű erdőhöz tartozó keveredési mátrixot ábrázoló jegyzetfüzetet jelenít meg, amelynek maximális mélysége négy.

Hozzon létre egy keveredési mátrixot a véletlenszerű erdőosztályozóhoz, amelynek maximális mélysége nyolc, hat jellemzővel:

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

Képernyőkép, amely egy véletlenszerű erdőhöz tartozó keveredési mátrixot ábrázoló jegyzetfüzetet jelenít meg, amelynek maximális mélysége nyolc.

Keveredési mátrix létrehozása a LightGBM-hez:

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

A LightGBM-hez tartozó konfúziós mátrixot bemutató jegyzetfüzet képernyőképe.

Eredmények mentése a Power BI-hoz

Mentse el a delta keretet a lakehouse-ba, hogy a modell előrejelzési eredményeit át tudja vinni egy Power BI-vizualizációba.

df_pred = X_test.copy()
df_pred['y_test'] = y_test
df_pred['ypred_rfc1_sm'] = ypred_rfc1_sm
df_pred['ypred_rfc2_sm'] =ypred_rfc2_sm
df_pred['ypred_lgbm1_sm'] = ypred_lgbm1_sm
table_name = "df_pred_results"
sparkDF=spark.createDataFrame(df_pred)
sparkDF.write.mode("overwrite").format("delta").option("overwriteSchema", "true").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")

6. lépés: Vizualizációk elérése a Power BI-ban

A mentett tábla elérése a Power BI-ban:

  1. A bal oldalon válassza OneLakelehetőséget.
  2. Válassza ki a jegyzetfüzethez hozzáadott tóházat.
  3. A Nyissa meg ezt a Lakehouse-t szakaszban válassza a Megnyitáslehetőséget.
  4. A menüszalagon válassza Új szemantikai modelllehetőséget. Válassza a df_pred_resultselemet, majd kattintson a elemre, majd a megerősítése gombra az új Power BI szemantikai modell létrehozásához az előrejelzésekhez kapcsolódóan.
  5. Nyisson meg egy új szemantikai modellt. A OneLake-ben található.
  6. A szemantikai modellek lap tetején található eszközök közül válassza a Új jelentés létrehozása lehetőséget a Power BI jelentéskészítő lapjának megnyitásához.

Az alábbi képernyőképen néhány példavizualizáció látható. Az adatpanelen láthatók a táblázatból kiválasztandó deltatáblák és oszlopok. A megfelelő kategóriatengely (x) és értéktengely (y) kiválasztása után kiválaszthatja a szűrőket és függvényeket – például a táblázat oszlopának összegét vagy átlagát.

Jegyzet

Ebben a képernyőképen az illusztrált példa a Power BI-ban mentett előrejelzési eredmények elemzését ismerteti:

Power BI-irányítópult példáját bemutató képernyőkép.

Azonban egy valódi ügyfélvesztési használati esethez a felhasználónak szüksége lehet alaposabb követelményekre a vizualizációk létrehozásához, a témával kapcsolatos szakértelem alapján, valamint a metríákra, amelyeket a cég és az üzleti elemzési csapat szabványosított.

A Power BI-jelentés azt mutatja, hogy azok az ügyfelek, akik több mint két banki terméket használnak, magasabb a forgalom aránya. Azonban kevés ügyfélnek több mint két terméke volt. (Lásd a rajzot a bal alsó panelen.) A banknak több adatot kell gyűjtenie, de más olyan funkciókat is meg kell vizsgálnia, amelyek több termékkel korrelálnak.

A németországi banki ügyfelek lemorzsolódási aránya magasabb, mint a franciaországi és spanyolországi ügyfeleké. (Lásd a diagramot a jobb alsó panelen). A jelentés eredményei alapján az ügyfelek távozását ösztönző tényezők vizsgálata segíthet.

Több középkorú ügyfél van (25 és 45 között). A 45 és 60 év közötti ügyfelek általában többet lépnek ki.

Végül az alacsonyabb hitelképességű ügyfelek valószínűleg más pénzintézetek számára hagyják el a bankot. A banknak meg kell vizsgálnia, hogyan ösztönözheti az alacsonyabb kreditpontszámmal és számlaegyenleggel rendelkező ügyfeleket, hogy maradjanak a banknál.

# Determine the entire runtime
print(f"Full run cost {int(time.time() - ts)} seconds.")

Kapcsolódó tartalom