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

Ez az oktatóanyag a Synapse Adattudomány munkafolyamatának végpontok közötti példáját mutatja be a Microsoft Fabricben. A forgatókönyv egy modellt hoz létre, amely előrejelzi, hogy a banki ügyfelek rovására kelnek-e. Az átváltozási ráta vagy az attrition ráta magában foglalja azt az árfolyamot, amelyen a banki ügyfelek befejezik a vállalkozásukat a bankkal.

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

• Egyéni kódtárak telepítése
• Az 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

• Microsoft Fabric-előfizetés lekérése. Vagy regisztráljon egy ingyenes Microsoft Fabric-próbaverzióra.

• Jelentkezzen be a Microsoft Fabricbe.

• A kezdőlap bal oldalán található élménykapcsolóval válthat a Synapse Adattudomány felületre.

  

• Szükség esetén hozzon létre egy Microsoft Fabric-tóházat a Microsoft Fabricben a Tóház létrehozása című cikkben leírtak szerint.

Követés jegyzetfüzetben

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

• Nyissa meg és futtassa a beépített jegyzetfüzetet a Adattudomány felületen
• Jegyzetfüzet feltöltése a GitHubról a Adattudomány felületre

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

Az oktatóanyaghoz az ügyfél-forgalom mintajegyzetfüzete is hozzá van kísérve.

Az oktatóanyag beépített mintajegyzetfüzetének megnyitása a Synapse Adattudomány felületén:

1. Nyissa meg a Synapse Adattudomány kezdőlapját.

2. Válassza a Minta használata lehetőséget.

3. Válassza ki a megfelelő mintát:

   • Ha a minta Python-oktatóanyaghoz készült, az alapértelmezett Végpontok közötti munkafolyamatok (Python) lapon.
   • A végpontok közötti munkafolyamatok (R) lapról, ha a minta R-oktatóanyaghoz készült.
   • A Gyors oktatóanyagok lapon, ha a minta egy gyors oktatóanyaghoz készült.

4. A kód futtatása előtt csatoljon egy lakehouse-t a jegyzetfüzethez .

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

Az AIsample – Bank Customer Churn.ipynb jegyzetfüzete ezt az oktatóanyagot kíséri.

Az oktatóanyaghoz mellékelt jegyzetfüzet megnyitásához kövesse a Rendszer előkészítése adatelemzési oktatóanyagokhoz című témakör utasításait, és importálja a jegyzetfüzetet a munkaterületre.

Ha inkább erről a lapról másolja és illessze be a kódot, létrehozhat egy új jegyzetfüzetet.

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

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. A környezetekkel kapcsolatos további információkért tekintse meg a Környezetek létrehozását, konfigurálását és használatát a Microsoft Fabricben.

Ebben az oktatóanyagban %pip install a tárat telepítheti imblearn a jegyzetfüzetbe.

Feljegyzés

A PySpark-kernel futás után %pip install újraindul. Telepítse a szükséges kódtá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 adatváltozási állapotát tartalmazza, valamint 14 attribútumot, amelyek a következőket tartalmazzák:

• Kreditpontszám
• Földrajzi hely (Németország, Franciaország, Spanyolország)
• Nem (férfi, nő)
• Kor
• Bérleti jog (azon évek száma, amikor a személy ügyfél volt az adott bankban)
• 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ámlalezárási eseménye határozza meg az ügyfél forgalmá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 megérteni, hogy ezek az attribútumok hogyan járulnak hozzá az Exited állapothoz.

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. Előfordulhat, hogy a pontosságot a Pontosság visszahívási görbe (AUPRC) alatti területtel szeretnénk mérni.

• Ez a táblázat az adatok előnézetét churn.csv mutatja be:

CustomerID (Ügyfél azonosítója)	Vezetéknév	CreditScore	Földrajzi hely	Nem	Kor	Pályafutás	Egyenleg	NumOfProducts	HasCrCard	IsActiveMember	Becsült értékesítés	Kilépett
15634602	Hargrave	619	Franciaország	Nő	42	2	0,00	0	0	0	101348.88	1
15647311	Hill	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

A futtatás előtt vegyen fel egy lakehouse-t 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-ból

Ez a kód beolvassa a nyers adatokat a tóház Fájlok szakaszából, é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 az alapvető statisztikákat, és jelenítsen meg diagramnézeteket. Először importálnia kell az adatvizualizációhoz szükséges kódtárakat – például a seabornt. 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. A jegyzetfüzet menüszalagjának Adatok lapján a Data Wrangler legördülő menüben tallózhat a szerkesztésre elérhető aktivált pandas DataFrame-ek között. Válassza ki a Data Wranglerben megnyitni kívánt DataFrame-et.

Feljegyzés

A Data Wrangler nem nyitható meg, amíg a jegyzetfüzet kernele foglalt. A cellavégrehajtásnak le kell fejeződnie a Data Wrangler elindítása előtt. További információ a Data Wranglerről.

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ó.

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ő kvartilis
• 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])

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)

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

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

A Data Wrangler használata egy gyakori 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:

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 forgalom aránya
• 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. Véletlenszerű erdő- és LightGBM-modellek alkalmazása ebben a jegyzetfüzetben.

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:

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 automatikus kereséssel kapcsolatos további információkért tekintse meg az Automatikus keresés a Microsoft Fabricben című témakört.

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 imblearn 1. lépésben telepített 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 az éles 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ót az SMOTE és a Véletlenszerű túl mintavételezésből az SMOTE-ba és az ADASYN-be című témakörben talál. A kiegyensúlyozatlan learn webhely ü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érletfuttatások automatikusan a kísérlet összetevőjéhez lesznek mentve. Az összetevő a munkaterületen talá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 a sample-bank-churn-experiment nevet.

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 Csalásészlelési mintában látható módon a SynapseML-eszközökkel is ábrázolhat keveredési mátrixot.

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

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

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

Eredmények mentése a Power BI-hoz

Mentse a deltakeretet a lakehouse-ba, és helyezze át a modell előrejelzési eredményeit 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 a OneLake adatközpontot
2. Válassza ki a jegyzetfüzethez hozzáadott tóházat
3. A Lakehouse megnyitása szakaszban válassza a Megnyitás lehetőséget
4. A menüszalagon válassza az Új szemantikai modell lehetőséget. Válassza a lehetőségetdf_pred_results, majd válassza a Folytatás lehetőséget az előrejelzésekhez csatolt új Power BI szemantikai modell létrehozásához
5. Válassza az Új jelentést a szemantikai modellek lap tetején található eszközök közül a Power BI jelentéskészítő oldalá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.

Feljegyzés

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:

Azonban egy valódi ügyfél-forgalom használati eset, a felhasználónak szüksége lehet egy alaposabb követelményeket a vizualizációk létrehozásához, a témával kapcsolatos szakértelem alapján, és amit a cég és az üzleti elemzési csapat és a cég szabványosított metrikák.

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 aránya magasabb a franciaországi és spanyolországi ügyfelekhez képest. (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

• Gépi tanulási modell a Microsoft Fabricben
• Gépi tanulási modellek betanítása
• Gépi tanulási kísérletek a Microsoft Fabricben