Kurz: Vytvorenie, vyhodnotenie a skóre modelu predpovede výpovede

Tento kurz predstavuje komplexný príklad pracovného postupu synapse Data Science v službe Microsoft Fabric. Scenár vytvára model, ktorý predpovedá, či klienti banky odišli alebo nie. Sadzba výpovede alebo sadzba výnosu zahŕňa sadzbu, podľa ktorej klienti banky končia svoje podnikanie s bankou.

V tomto kurze sú obsiahnuté tieto kroky:

Predpoklady

• Získajte predplatné služby Microsoft Fabric . Alebo si zaregistrujte bezplatnú skúšobnú služby Microsoft Fabric.

• Prihláste sa do služby Microsoft Fabric.

• Pomocou prepínača skúseností v ľavej dolnej časti domovskej stránky sa prepnete na službu Fabric.

  

• Ak je to potrebné, vytvorte si podľa popisu v téme Vytvorenie jazera v službe Microsoft Fabric.

Sledovanie v poznámkovom bloke

Môžete si vybrať jednu z týchto možností, ktorú si môžete vyskúšať v notebooku:

• Otvorte a spustite vstavaný poznámkový blok.
• Nahrajte poznámkový blok z GitHubu.

Otvorenie vstavaného poznámkového bloku

Tento kurz sprevádza ukážkový odchodu zákazníka poznámkového bloku.

1. Ak chcete otvoriť vzorový poznámkový blok pre tento kurz, postupujte podľa pokynov v téme Príprava systému na kurzy dátovej vedy.

2. Uistite sa, že pripojiť lakehouse na notebook, ako začnete bežať kód.

Importovanie notebooku z GitHubu

Tento kurz sprevádza AIsample - Bank Customer Churn.ipynb notebook.

• 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 k notebooku, ako začnete bežať kód.

Krok č. 1: Inštalácia vlastných knižníc

Na vývoj modelu strojového učenia alebo analýzu údajov ad hoc možno budete musieť rýchlo nainštalovať vlastnú knižnicu pre reláciu Apache Spark. Na inštaláciu knižníc máte dve možnosti.

• Ak chcete nainštalovať knižnicu iba v aktuálnom poznámkovom bloku, použite možnosti vnorenej inštalácie (%pip alebo %conda).
• Prípadne môžete vytvoriť prostredie služby Fabric, nainštalovať knižnice z verejných zdrojov alebo do neho nahrať vlastné knižnice a potom môže správca pracovného priestoru k prostrediu pripojiť ako predvolené prostredie pre pracovný priestor. Všetky knižnice v prostredí budú potom k dispozícii na použitie v poznámkových blokoch a definíciách úloh služby Spark v pracovnom priestore. Ďalšie informácie o prostrediach nájdete v téme vytvorenia, konfigurácie a používania prostredia v službe Microsoft Fabric.

V tomto kurze použite %pip install na inštaláciu knižnice imblearn v poznámkovom bloku.

# Use pip to install libraries
%pip install imblearn

Krok č. 2: Načítanie údajov

Množina údajov v churn.csv obsahuje stav vypovedania zmluvy pre 10 000 zákazníkov spolu so 14 atribútmi, ktoré zahŕňajú:

• Kreditné skóre
• Geografická poloha (Nemecko, Francúzsko, Španielsko)
• Pohlavie (muž, žena)
• Vek
• Doba využívania (počet rokov, počas ktorých bola osoba zákazníkom v tejto banke)
• Zostatok na konte
• Odhadovaný plat
• Počet produktov, ktoré zákazník kúpil prostredníctvom banky
• Stav kreditnej karty (bez ohľadu na to, či má zákazník kreditnú kartu)
• Stav aktívneho člena (bez ohľadu na to, či je táto osoba aktívnym bankovým zákazníkom)

Množina údajov obsahuje aj stĺpce s číslom riadka, ID zákazníka a priezvisko zákazníka. Hodnoty v týchto stĺpcoch by nemali mať vplyv na rozhodnutie zákazníka opustiť banku.

Udalosť zrušenia bankového konta zákazníka definuje odchod pre daného zákazníka. Stĺpec Exited množiny údajov odkazuje na opustenie zákazníka. Vzhľadom na to, že máme málo kontextu o týchto atribútoch, nepotrebujeme základné informácie o množine údajov. Chceme pochopiť, ako tieto atribúty prispievajú k stavu Exited.

Z týchto 10 000 zákazníkov odišlo z banky len 2 037 zákazníkov (približne 20%). Vzhľadom na pomer triednej nerovnováhy odporúčame vytváranie syntetických údajov. Presnosť matice zmätku nemusí mať relevantnosť pre nevyváženú klasifikáciu. Možno budeme chcieť zmerať presnosť pomocou oblasti pod Precision-Recall krivkou (AUPRC).

• Táto tabuľka zobrazuje ukážku údajov churn.csv:

ID zákazníka	Priezvisko	CreditScore	Zemepis	Pohlavie	Vek	Vlastníctvo	Bilancia	Početproduktov	HasCrCard	IsActiveMember	Odhady	Vystúpil
15634602	Hargrave	619	Francúzsko	Samica	42	2	0.00	1	1	1	101348.88	1
15647311	Kopec	608	Španielsko	Samica	41	1	83807.86	1	0	1	112542.58	0

Stiahnite si množinu údajov a nahrajte ju do služby lakehouse

Definujte tieto parametre, aby ste mohli používať tento poznámkový blok s rôznymi množinami údajov:

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

Tento kód stiahne verejne dostupnú verziu množiny údajov a potom túto množinu údajov uloží v úložisku Fabric lakehouse:

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

Spustite nahrávanie času potrebného na spustenie poznámkového bloku:

# Record the notebook running time
import time

ts = time.time()

Prečítajte si nespracované údaje z jazera

Tento kód prečíta nespracované údaje zo Files časti jazera a pridá ďalšie stĺpce pre rôzne časti dátumu. Vytvorenie tabuľky rozdelených delta používa tieto informácie.

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

Vytvorenie údajového rámca pandas z množiny údajov

Tento kód konvertuje údajový rámec Spark na údajový rámec Pandas na jednoduchšie spracovanie a vizualizáciu:

df = df.toPandas()

Krok č. 3: Vykonanie prieskumnej analýzy údajov

Zobrazenie nespracovaných údajov

Preskúmajte nespracované údaje pomocou display, vypočítajte niektoré základné štatistiky a zobrazte zobrazenia grafu. Najprv musíte importovať požadované knižnice na vizualizáciu údajov – napríklad námorných. Seaborn je knižnica vizualizácie údajov jazyka Python a poskytuje rozhranie na vysokej úrovni na vytváranie vizuálov na údajových prvkoch a poliach.

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)

Použitie funkcie Data Wrangler na vykonanie počiatočného čistenia údajov

Spustite data Wrangler priamo z notebooku, aby ste mohli preskúmať a transformovať údajové rámce pandas. Na vodorovnom paneli s nástrojmi vyberte rozbaľovací zoznam Data Wrangler na prehľadávanie aktivovaných údajových rámca pandas, ktoré sú k dispozícii na úpravy. Vyberte údajový rámec, ktorý chcete otvoriť vo Wrangleri údajov.

Po spustení služby Data Wrangler sa vygeneruje popisný prehľad panela s údajmi, ako je znázornené na nasledujúcich obrázkoch. Prehľad obsahuje informácie o dimenzii prvku DataFrame, všetky chýbajúce hodnoty atď. Pomocou funkcie Data Wrangler môžete vygenerovať skript a riadky s chýbajúcimi hodnotami, duplicitné riadky a stĺpce s konkrétnymi názvami. Potom môžete skopírovať skript do bunky. Ďalšia bunka zobrazí skopírovaný skript.

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

Určenie atribútov

Tento kód určuje kategorické, číselné a cieľové atribúty:

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

Zobrazenie súhrnu s piatimi číslami

Použitie vykreslenia polí na zobrazenie súhrnu piatich čísel

• minimálne skóre,
• first quartile (prvý quartile)
• Medián
• tretí quartile
• maximálne skóre

pre číselné atribúty.

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

Zobrazenie distribúcie výstupných a nevykonaných zákazníkov

Zobraziť distribúciu výstupných zákazníkov v porovnaní s nepridaných zákazníkmi v rámci kategorických atribútov:

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)

Zobrazenie distribúcie číselných atribútov

Histogram môžete použiť na zobrazenie distribúcie frekvencie číselných atribútov:

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

Vykonávanie inžinierskych funkcií

Inžinier tejto funkcie generuje nové atribúty na základe aktuálnych atribútov:

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

Použitie služby Data Wrangler na vykonanie one-hotového kódovania

Pomocou rovnakých krokov na spustenie nástroja Data Wrangler, ako bolo popísané vyššie, použite funkciu Data Wrangler na vykonanie one-hotového kódovania. V tejto bunke sa zobrazí skopírovaný vygenerovaný skript na jedno horúce kódovanie:

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

Vytvorenie tabuľky delta na generovanie zostavy Power BI

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

Súhrn pozorovaní z prieskumnej analýzy údajov

• Väčšina zákazníkov pochádza z Francúzska. Španielsko má najnižšiu sadzbu výpovedí v porovnaní s Francúzskom a Nemeckom.
• Väčšina zákazníkov má kreditné karty
• Niektorí zákazníci majú viac ako 60 rokov a majú kreditné skóre pod 400 rokov. Nemožno ich však považovať za odľahlé hodnoty.
• Len veľmi málo zákazníkov má viac ako dva bankové produkty
• Neaktívni zákazníci majú vyššiu sadzbu výpovede
• Pohlavie a doba využívania majú malý vplyv na rozhodnutie zákazníka zrušiť bankový účet

Krok č. 4: Vykonanie trénovania a sledovania modelu

Keď sú údaje na mieste, môžete teraz definovať model. Použiť náhodné lesa a LightGBM modely v tomto notebooku.

Na implementáciu modelov s niekoľkými riadkami kódu použite knižnice scikit-learn a LightGBM. Okrem toho použite MLfLow a Fabric automatické označovanie sledovať experimenty.

Tento vzorový kód načíta tabuľku delta z jazera. Môžete použiť iné delta tabuľky, ktoré samy o sebe používajú lakehouse ako zdroj.

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

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

V tejto časti sa dozviete, ako vygenerovať experiment a určuje parametre modelu a trénovania a metriky bodovania. Okrem toho zobrazuje, ako trénovať modely, zapísať ich do denníka a uložiť trénované modely na neskoršie použitie.

import mlflow

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

Automatické označovanie automaticky zaznamenáva hodnoty vstupných parametrov aj výstupné metriky modelu strojového učenia pri trénovaní tohto modelu. Tieto informácie sa potom prihlásia do vášho pracovného priestoru, kde môžu rozhrania API MLflow alebo príslušný experiment vo vašom pracovnom priestore získať prístup a vizualizovať ich.

Po dokončení by mal váš experiment vyzerať takto:

Všetky experimenty s príslušnými názvami sa zapíšu do denníka a môžete sledovať ich parametre a metriku 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) # Use a date stamp to append to the experiment
mlflow.autolog(exclusive=False)

Import nástrojov scikit a LightGBM

# 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éningových a testovacích množín údajov

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)

Použitie SMOTE na tréningové údaje

Nevyvážená klasifikácia má problém, pretože má príliš málo príkladov menšinovej triedy na to, aby model efektívne naučil rozhodovaciu hranicu. Na zvládnutie tohto problému je Technika oversamplingu syntetickej menšiny (SMOTE) najpoužívanejšou technikou na synchronizáciu nových vzoriek pre menšinovú triedu. Prístup k SMOTE s knižnicou imblearn, ktorú ste nainštalovali v kroku 1.

Použite SMOTE iba na trénovateľskú množinu údajov. Ak chcete v pôvodných údajoch dosiahnuť platnú aproximáciu výkonu modelu, testovaciu množinu údajov musíte nechať v pôvodnej nevyváženej distribúcii. Tento experiment predstavuje situáciu v produkcii.

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)

Ďalšie informácie nájdete SMOTE a Od náhodného nadmerného vzorkovania po SMOTE a ADASYN. Nevyvážené-learn webové stránky hostí tieto zdroje.

Trénovať model

Pomocou služby Random Forest trénujte model s maximálnou hĺbkou štyri a štyri 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) # 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])

Pomocou lesa Random Forest trénujte model s maximálnou hĺbkou osem a so šiestimi funkciami:

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

Trénujte 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_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])

Zobrazenie experimentálnych artefaktov na sledovanie výkonu modelu

Spustenia experimentu sa automaticky uložia do artefaktu experimentu. Daný artefakt môžete nájsť v pracovnom priestore. Názov artefaktu je založený na názve použitom na nastavenie experimentu. Všetky trénované modely, ich spustenia, metriky výkonu a parametre modelu sa zaznamenávajú na stránke experimentu.

Zobrazenie experimentov:

1. Na ľavom paneli vyberte pracovný priestor.
2. Nájdite a vyberte názov experimentu, v tomto prípade ukážkový experiment-bank-churn-experiment.

Krok 5: Vyhodnotenie a uloženie konečného modelu strojového učenia

Otvorte uložený experiment v pracovnom priestore a vyberte a uložte najlepší model:

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

Vyhodnotenie výkonu uložených modelov v testovacej množine údajov

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

Zobraziť skutočne/falošne pozitívne/negatívne výsledky pomocou matice zámeny

Na vyhodnotenie presnosti klasifikácie vytvorte skript, ktorý vykreslí maticu zmätku. Maticu zmätku môžete tiež zobraziť pomocou nástrojov SynapseML, ako je to znázornené vo vzorovomzisťovania podvodov .

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

Vytvorte maticu zmätku pre náhodný klasifikant lesa s maximálnou hĺbkou štyri a štyri vlastnosti:

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

Vytvorte maticu zmätku pre náhodný klasifikant lesa s maximálnou hĺbkou 8 a so šiestimi funkciami:

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

Vytvorte maticu zmätku pre LightGBM:

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

Uloženie výsledkov pre službu Power BI

Uložte delta rám do jazera, aby sa výsledky predpovede modelu premiestnili do vizualizácie Power BI.

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

Krok č. 6: Prístup k vizualizáciám v službe Power BI

Prístup k uloženej tabuľke v Power BI:

1. Na ľavej strane vyberte OneLake.
2. Vyberte domov lakehouse, ktorý ste pridali do tohto poznámkového bloku.
3. V časti Open this Lakehouse (Otvoriť túto Lakehouse) vyberte položky Open.
4. Na páse s nástrojmi vyberte Nový sémantický model. Vyberte položku df_pred_resultsa potom výberom položky Potvrdiť vytvorte nový sémantický model služby Power BI prepojený s predpoveďami.
5. Otvorte nový sémantický model. Môžete ho nájsť v OneLake.
6. V časti nástroje v hornej časti stránky s sémantickými modelmi vyberte položku Vytvoriť novú zostavu pod súborom a otvorte stranu na vytváranie zostáv v službe Power BI.

Nasledujúca snímka obrazovky znázorňuje ukážkové vizualizácie. Panel údajov zobrazuje delta tabuliek a stĺpcov, ktoré sa majú vybrať z tabuľky. Po výbere príslušnej kategórie (x) a hodnoty (y) osi môžete vybrať filtre a funkcie – napríklad súčet alebo priemer stĺpca tabuľky.

V prípade skutočného zákazníka môže byť potrebné vykonať dôkladnejší súbor požiadaviek na vizualizácie na základe odborných znalostí v danej oblasti, ako aj to, čo sa firmy a analytický tím či firma štandardizovali ako metriky.

V zostave služby Power BI sa zobrazuje, že zákazníci, ktorí používajú viac ako dva z bankových produktov, majú vyššiu sadzbu výpovedí. Len málo zákazníkov však malo viac ako dva produkty. (Pozrite si vykreslený graf na ľavom dolnom paneli.) Banka by mala zhromažďovať viac údajov, ale mala by tiež preskúmať ďalšie funkcie, ktoré korelujú s viacerými produktmi.

Klienti bánk v Nemecku majú vyššiu sadzbu výpovedí v porovnaní so zákazníkmi vo Francúzsku a Španielsku. (Pozrite sa na vykresleného grafu v pravom dolnom paneli). Na základe výsledkov zostáv mohlo pomôcť preskúmanie faktorov, ktoré povzbudzovali zákazníkov k odchodu.

V strednom veku je viac zákazníkov (od 25 do 45 rokov). Zákazníci vo veku 45 až 60 rokov majú tendenciu opustiť viac.

Nakoniec, zákazníci s nižšími úverovými skóre by s najväčšou pravdepodobnosťou opustiť banku pre iné finančné inštitúcie. Banka by mala preskúmať spôsoby, ako povzbudiť zákazníkov s nižšími úverovými skóre a zostatkami na konte, aby zostali v banke.

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

Súvisiaci obsah

• modelu strojového učenia v službe Microsoft Fabric
• modely strojového učenia
• experimentov strojového učenia v službe Microsoft Fabric