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:
- Inštalácia vlastných knižníc
- Načítanie údajov
- Pochopte a spracujte údaje prostredníctvom prieskumnej analýzy údajov a zobrazte použitie funkcie Fabric Data Wrangler
- Používanie nástrojov scikit-learn a LightGBM na trénovanie modelov strojového učenia a sledovanie experimentov s funkciami MLflow a Fabric Autologging
- Vyhodnotenie a uloženie konečného modelu strojového učenia
- Zobrazenie výkonu modelu pomocou vizualizácií Power BI
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.
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.
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.
Nota
Jadro PySpark sa reštartuje po spustení %pip install
. Pred spustením ďalších buniek nainštalujte potrebné knižnice.
# 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:
Dôležitý
Pred spustením pridajte do notebooku lakehouse. Ak to neurobíte, bude to mať za následok chybu.
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.
Nota
Nie je možné otvoriť data Wrangler, zatiaľ čo jadro notebooku je zaneprázdnené. Spustenie bunky sa musí skončiť pred spustením Wranglera údajov. Ďalšie informácie oData Wrangler .
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:
- Na ľavom paneli vyberte pracovný priestor.
- 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:
- Na ľavej strane vyberte OneLake.
- Vyberte domov lakehouse, ktorý ste pridali do tohto poznámkového bloku.
- V časti
Open this Lakehouse (Otvoriť túto Lakehouse) vyberte položkyOpen . - Na páse s nástrojmi vyberte Nový sémantický model. Vyberte položku
df_pred_results
a potom výberom položky Potvrdiť vytvorte nový sémantický model služby Power BI prepojený s predpoveďami. - Otvorte nový sémantický model. Môžete ho nájsť v OneLake.
- 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.
Nota
Na tejto snímke obrazovky je znázornený príklad analýzy uložených výsledkov predpovede v Power BI:
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.")