Opetusohjelma: Vaihtuvuusennustemallin luominen, arvioiminen ja pisteytys

Tässä opetusohjelmassa esitellään päästä päähän -esimerkki Synapse Data Science -työnkulusta Microsoft Fabricissa. Skenaariossa luodaan malli, joka ennustaa, vaihtuvatko pankkiasiakkaat vai eivät. Vaihtuvuusprosentti eli vaihtuvuusprosentti liittyy siihen kurssiin, jolla pankkiasiakkaat lopettavat liiketoimintansa pankkiin.

Tässä opetusohjelmassa käsitellään seuraavat vaiheet:

• Mukautettujen kirjastojen asentaminen
• Lataa tiedot
• Tietojen ymmärtäminen ja käsitteleminen valmistelevan tietoanalyysin avulla sekä Fabric Data Wrangler -ominaisuuden käytön osoittaminen
• Scikit-learnin ja LightGBM:n avulla voit kouluttaa koneoppimismalleja sekä seurata MLflow- ja Fabric Autologging -ominaisuuksien kokeiluja
• Lopullisen koneoppimismallin arvioiminen ja tallentaminen
• Mallin suorituskyvyn näyttäminen Power BI -visualisointien avulla

Edellytykset

• Hanki Microsoft Fabric -tilaus. Voit myös rekisteröityä ilmaiseen Microsoft Fabric -kokeiluversioon.

• Kirjaudu sisään Microsoft Fabriciin.

• Siirry Synapse Data Science -käyttökokemukseen aloitussivun vasemmassa reunassa olevan käyttökokemuksen vaihtajan avulla.

  

• Luo tarvittaessa Microsoft Fabric Lakehouse kohdan Lakehouse luominen Microsoft Fabricissa ohjeiden mukaan.

Seuraa mukana muistikirjassa

Voit valita jonkin seuraavista vaihtoehdoista, joita voit seurata muistikirjassa:

• Avaa ja suorita sisäinen muistikirja Data Science -kokemuksessa
• Lataa muistikirjasi GitHubista Data Science -kokemukseen

Avaa sisäinen muistikirja

Asiakas vaihtuva muistikirja -malli on tämän opetusohjelman mukana.

Opetusohjelman sisäinen näytemuistikirja avataan Synapse Data Science -kokemuksesta seuraavasti:

1. Siirry Synapse Data Science -aloitussivulle.

2. Valitse Käytä mallia.

3. Valitse vastaava malli:

   • Oletusarvoisen Päästä päähän -työnkulkujen (Python) välilehdestä, jos malli on tarkoitettu Python-opetusohjelmaa varten.
   • Jos malli on R-opetusohjelmassa, päästä päähän -työnkulut (R) -välilehdeltä.
   • Pikaopetusohjelmat-välilehdessä, jos malli on pikaopetusohjelmaa varten.

4. Liitä muistikirjaan lakehouse, ennen kuin aloitat koodin suorittamisen.

Tuo muistikirja GitHubista

Tämän opetusohjelman mukana on AIsample - Bank Customer Churn.ipynb -muistikirja.

Jos haluat avata tämän opetusohjelman liitteenä olevan muistikirjan, tuo muistikirja työtilaasi noudattamalla ohjeita kohdassa Järjestelmän valmisteleminen datatieteen opetusohjelmia varten.

Jos haluat kopioida ja liittää koodin tältä sivulta, voit luoda uuden muistikirjan.

Muista liittää lakehouse muistikirjaan ennen kuin aloitat koodin suorittamisen.

Vaihe 1: Mukautettujen kirjastojen asentaminen

Koneoppimismallin kehittämistä tai ad-hoc-tietojen analysointia varten sinun on ehkä asennettava nopeasti mukautettu kirjasto Apache Spark -istuntoa varten. Sinulla on kaksi vaihtoehtoa kirjastojen asentamiseen.

• Asenna muistikirjasi sisäiset asennusominaisuudet (%pip tai %conda) kirjastoon, vain senhetkiseen muistikirjaasi.
• Vaihtoehtoisesti voit luoda Fabric-ympäristön, asentaa kirjastoja julkisista lähteistä tai ladata mukautettuja kirjastoja siihen, jonka jälkeen työtilan järjestelmänvalvoja voi liittää ympäristön työtilan oletusarvoksi. Kaikki ympäristön kirjastot ovat sitten käytettävissä missä tahansa muistikirjoissa ja Spark-työmääritelmissä työtilassa. Katso lisätietoja ympäristöistä kohdasta Ympäristön luominen, määrittäminen ja käyttäminen Microsoft Fabricissa.

Tätä opetusohjelmaa varten %pip install voit asentaa kirjaston imblearn muistikirjaasi.

Muistiinpano

PySpark-ydin käynnistyy uudelleen suoritusten jälkeen %pip install . Asenna tarvittavat kirjastot, ennen kuin suoritat muita soluja.

# Use pip to install libraries
%pip install imblearn

Vaihe 2: Lataa tiedot

churn.csv tietojoukko sisältää 10 000 asiakkaan vaihtuvuustilan sekä 14 määritettä, jotka ovat seuraavat:

• Luottopisteet
• Maantieteellinen sijainti (Saksa, Ranska, Espanja)
• Sukupuoli (mies, nainen)
• Ikä
• Hallinnan kesto (vuosien määrä, jolloin henkilö oli kyseisen pankin asiakas)
• Tilin saldo
• Arvioitu palkka
• Asiakkaan pankin kautta ostamien tuotteiden määrä
• Luottokortin tila (riippumatta siitä, onko asiakkaalla luottokortti)
• Aktiivisen jäsenen tila (riippumatta siitä, onko henkilö aktiivinen pankkiasiakas)

Tietojoukko sisältää myös rivin numeron, asiakastunnuksen ja asiakkaan sukunimisarakkeet. Näiden sarakkeiden arvojen ei pitäisi vaikuttaa asiakkaan päätökseen poistua pankista.

Asiakkaan pankkitilin sulkemisen tapahtuma määrittää kyseisen asiakkaan vaihtuvuuden. Tietojoukkosarake Exited viittaa asiakkaan hylkäämiseen. Koska näissä määritteissä ei ole juurikaan kontekstia, emme tarvitse tietojoukon taustatietoja. Haluamme ymmärtää, miten nämä määritteet vaikuttavat Exited tilaan.

Näistä 10 000 asiakkaasta vain 2037 asiakasta (noin 20 %) lähti pankista. Luokan epätasapainosuhteen vuoksi suosittelemme synteettisten tietojen luontia. Hämmennysmatriisin tarkkuudella ei ehkä ole merkitystä epätasapainoisen luokituksen kannalta. Haluamme ehkä mitata tarkkuutta käyttämällä Precision-Recall-käyrän (AUPRC) alla olevaa aluetta.

• Tässä taulukossa näkyy tietojen esikatselu churn.csv :

Asiakastunnus	Surname	CreditScore	Maantieteellinen alue	Sukupuoli	Ikä	Hallinnan kesto	Saldo	NumOfProducts	HasCrCard	IsActiveMember	Arvioituväliarvo	Lopettaneet
15634602	Hargrave	619	Ranska	Nainen	42	2	0.00	1	1	1	101348.88	1
15647311	Hill	608	Espanja	Nainen	41	1	83807.86	1	0	1	112542.58	0

Lataa tietojoukko ja lataa se Lakehouse-palveluun

Määritä nämä parametrit niin, että voit käyttää tätä muistikirjaa eri tietojoukkojen kanssa:

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

Tämä koodi lataa tietojoukosta julkisesti saatavilla olevan version ja tallentaa sitten kyseisen tietojoukon Fabric lakehouse -järjestelmään:

Tärkeä

Lisää muistikirjaan lakehouse ennen kuin suoritat sen. Jos näin ei tehdä, tuloksena on virhe.

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

Aloita muistikirjan suorittamiseen tarvittava aika:

# Record the notebook running time
import time

ts = time.time()

Raakadata Lakehousesta

Tämä koodi lukee raakatiedot Lakehousen Tiedostot-osasta ja lisää sarakkeita eri päivämääräosiin. Osioituja delta-taulukkoja luodaan näitä tietoja hyödyntäen.

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

Pandas DataFrame -kehyksen luominen tietojoukosta

Tämä koodi muuntaa Spark DataFramen pandas DataFrame -kehykseksi, mikä helpottaa käsittelyä ja visualisointia:

df = df.toPandas()

Vaihe 3: Suorita valmisteleva tietoanalyysi

Raakatietojen näyttäminen

Tutustu raakatietoihin käyttämällä display, laske joitakin perustilastoja ja näytä kaavionäkymät. Sinun on ensin tuotava datavisualisointiin tarvittavat kirjastot, esimerkiksi merisyntyinen. Seaborn on Python-tietojen visualisoinnin kirjasto, ja se tarjoaa korkean tason käyttöliittymän visualisointien luomiseen tietokehyksiin ja matriiseihin.

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)

Tietojen ensimmäisen puhdistuksen suorittaminen Data Wrangler -funktion avulla

Käynnistä Data Wrangler suoraan muistikirjasta pandas-tietokehysten tutkimista ja muuntamista varten. Käytä muistikirjan valintanauhan Tiedot-välilehdessä avattavaa Data Wrangler -kehotetta selataksesi muokkausta varten käytettävissä olevia aktivoituja pandas DataFrame -kehyksiä. Valitse DataFrame, jonka haluat avata Data Wranglerissa.

Muistiinpano

Data Wrangleria ei voi avata, kun muistikirjan ydin on varattu. Solun suorituksen on oltava valmis, ennen kuin käynnistät Data Wranglerin. Lue lisää Data Wranglerista.

Kun Data Wrangler käynnistyy, tietopaneelista luodaan kuvaava yleiskatsaus seuraavissa kuvissa esitetyllä tavalla. Yleiskatsaus sisältää tietoja DataFramen dimensiosta, puuttuvista arvoista jne. Data Wrangler -funktion avulla voit luoda komentosarjan, jolla voit pudottaa rivit, joilla on puuttuvat arvot, rivien kaksoiskappaleet ja sarakkeet, joilla on tietyt nimet. Sen jälkeen voit kopioida komentosarjan soluun. Seuraavassa solussa näytetään kopioitu komentosarja.

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

Määritteiden määrittäminen

Tämä koodi määrittää luokittaiset, numeeriset ja kohdemääritteet:

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

Näytä viisinumeroinen yhteenveto

Näytä viisinumeroinen yhteenveto ruutukaavioiden avulla

• vähimmäispisteet
• ensimmäinen louhos
• Mediaani
• kolmas louhos
• enimmäispisteet

numeerisille määritteille.

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

Näytä poistuneiden ja poistumattomien asiakkaiden jakauma

Näytä poistuneiden ja poistumattomien asiakkaiden jakauma luokittaisten määritteiden välillä:

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)

Numeeristen määritteiden jakauman näyttäminen

Näytä numeeristen määritteiden jakauma histogrammin avulla:

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

Ominaisuuksien suunnittelun suorittaminen

Tämä ominaisuustekniikka luo uusia määritteitä nykyisten määritteiden perusteella:

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

Käytä Data Wrangler -funktiota yhden kuuman koodauksen suorittamiseen

Samat vaiheet data Wranglerin käynnistämiseen, kuten aiemmin mainittiin, käytä Data Wrangleria yhden kuuman koodauksen suorittamiseen. Tässä solussa näytetään kopioitu luotu komentosarja yhden kuuman koodauksen koodausta varten:

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

Luo Delta-taulukko Power BI -raportin luomiseksi

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

Yhteenveto valmistelevan tietoanalyysin havainnoista

• Suurin osa asiakkaista on ranskasta. Espanjan vaihtuvuusaste on alhaisin Verrattuna Ranskaan ja Saksaan.
• Useimmilla asiakkailla on luottokortit
• Jotkut asiakkaat ovat sekä yli 60-vuotiaita että heillä on luottopisteet alle 400. Niitä ei kuitenkaan voida pitää poikkeavina arvoina.
• Vain harvoilla asiakkailla on enemmän kuin kaksi pankkituote
• Passiivisten asiakkaiden vaihtuvuusaste on suurempi
• Sukupuoli- ja virkavuosilla ei ole juurikaan vaikutusta asiakkaan päätökseen sulkea pankkitili

Vaihe 4: Mallin harjoittamisen ja seurannan suorittaminen

Kun tiedot ovat paikoillaan, voit nyt määrittää mallin. Käytä satunnaiset metsä- ja LightGBM-malleja tässä muistikirjassa.

Käytä scikit-learn- ja LightGBM-kirjastoja mallien käyttöönottoon muutamalla koodirivillä. Käytä lisäksi MLfLow'ta ja Fabric Autologgingia kokeilujen seuraamiseen.

Tämä koodimalli lataa delta-taulukon Lakehousesta. Voit käyttää muita delta-taulukoita, jotka itse käyttävät lähdettä Lakehouse.

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

Luo kokeilu mallien seurantaa ja kirjaamista varten MLflow:n avulla

Tässä osiossa näytetään, miten voit luoda kokeiluja, ja se määrittää mallin ja harjoittamisen parametrit sekä pisteytyksen mittarit. Lisäksi siinä kerrotaan, miten malleja koulutetaan, ne kirjataan lokiin ja miten harjoitetut mallit tallennetaan myöhempää käyttöä varten.

import mlflow

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

Automaattinen kirjaaminen tallentaa automaattisesti sekä syöteparametriarvot että koneoppimismallin tulosarvot, kun kyseistä mallia harjoitetaan. Nämä tiedot kirjataan sitten työtilaan, jossa MLflow-ohjelmointirajapinnat tai niitä vastaavat kokeilut työtilassasi voivat käyttää ja visualisoida niitä.

Kun olet valmis, kokeilusi muistuttaa tätä kuvaa:

Kaikki kokeilut niiden nimillä kirjataan, ja voit seurata niiden parametreja ja suorituskykymittareita. Saat lisätietoja automaattianalyysipalveluista ohjeartikkelista Automaattinen lokiloggaus Microsoft Fabricissa.

Määritä kokeilu- ja automaattianalyysimääritykset

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

Tuo scikit-learn ja 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

Koulutuksen ja testitietojoukkojen valmistelu

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)

Sovella SMOTE:a koulutustietoihin

Epätasapainoinen luokitus on ongelma, koska sillä on liian vähän esimerkkejä vähemmistöluokasta, jotta malli oppisi tehokkaasti päätösrajan. Tämän käsittelemiseksi synteettisvähemmistön ylimyyntitekniikka (SMOTE) on yleisin tekniikka, jolla syntetisoidaan uusia näytteitä vähemmistöluokalle. Käytä SMOTE:a imblearn vaiheessa 1 asentamasi kirjaston avulla.

Sovella SMOTE:a vain koulutustietojoukkoon. Testitietojoukko on jätettävä alkuperäiseen epätasapainoisen jakautumisensa, jotta alkuperäiset tiedot saavat kelvollisen arvion mallin suorituskyvystä. Tämä koe edustaa tuotantotilannetta.

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)

Saat lisätietoja ohjeartikkelista SMOTE ja From random over-sampling to SMOTE and ADASYN. Epätasapainoinen Learn-sivusto isännöi näitä resursseja.

Sinun täytyy harjoittaa malli.

Käytä Random Forestia mallin harjoittamiseen, enimmäissyvyytenä neljä ja neljä ominaisuutta:

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

Käytä Random Forestia mallin harjoittamiseen, enimmäissyvyys on kahdeksan, ja siinä on kuusi ominaisuutta:

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

Harjoita mallia LightGBM:llä:

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

Tarkastele kokeiluarteefaktia mallin suorituskyvyn seuraamiseksi

Kokeilusuoritukset tallennetaan automaattisesti kokeiluarteefaktiin. Löydät kyseisen artefaktin työtilasta. Artefaktin nimi perustuu kokeilun määrittämiseen käytettyun nimeen. Kaikki koulutetut mallit, niiden suoritukset, suorituskykymittarit ja malliparametrit kirjataan kokeilusivulle.

Voit tarkastella kokeitasi:

1. Valitse vasemmassa paneelissa työtilasi.
2. Etsi ja valitse kokeilun nimi, tässä tapauksessa sample-bank-churn-experiment.

Vaihe 5: Lopullisen koneoppimismallin arvioiminen ja tallentaminen

Avaa tallennettu kokeilu työtilasta, jotta voit valita ja tallentaa parhaan mallin:

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

Arvioi tallennettujen mallien suorituskykyä testitietojoukossa

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

Näytä true/false-positiiviset/negatiiviset käyttämällä sekaannusmatriisia

Luokituksen tarkkuuden arvioimiseksi luo komentosarja, joka piirtää sekaannusmatriisin. Voit myös suunnitella sekaannusmatriisin SynapseML-työkaluilla Petosten havaitseminen -mallin mukaisesti.

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

Luo sekaannusmatriisi satunnaiselle metsäluokittelulle, jonka enimmäissyvyys on neljä, ja neljä ominaisuutta:

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

Luo sekaannusmatriisi satunnaiselle metsäluokittelulle, jonka enimmäissyvyys on kahdeksan, ja jossa on kuusi ominaisuutta:

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

Luo sekaannusmatriisi LightGBM:lle:

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

Tallenna Power BI:n tulokset

Tallenna delta-kehys Lakehouse-tallennustilaan, jotta mallin ennustetulokset siirretään Power BI -visualisointiin.

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

Vaihe 6: Visualisointien käyttäminen Power BI:ssä

Käytä tallennettua taulukkoa Power BI:ssä:

1. Valitse vasemmalta OneLake-tietokeskus
2. Valitse lakehouse, jonka lisäsit tähän muistikirjaan
3. Valitse Avaa tämä Lakehouse -osassa Avaa
4. Valitse valintanauhasta Uusi semanttinen malli. Valitse df_pred_resultsja valitse sitten Jatka luodaksesi uuden ennusteisiin linkitetyn Power BI -semanttisen mallin
5. Valitse Uusi raportti semanttisten mallien sivun yläosan työkaluista, jotta Power BI -raportin luontisivu avautuu

Seuraavassa näyttökuvassa on esimerkkejä visualisoinneista. Tietopaneelissa näkyvät taulukosta valittavat deltataulukot ja sarakkeet. Kun olet valinnut sopivan luokka-akselin (x) ja arvon (y), voit valita suodattimet ja funktiot , kuten taulukon sarakkeen summan tai keskiarvon.

Muistiinpano

Tässä näyttökuvassa kuvitettu esimerkki kuvaa tallennettujen ennustetulosten analyysia Power BI:ssä:

Asiakaskohtaista käyttötapausta varten käyttäjä saattaa kuitenkin tarvita perusteellisemman joukon vaatimuksia luodakseen subjekteja asiantuntemuksen perusteella sekä sen, mitä yritys- ja liiketoiminta-analytiikkatiimi ja yritys ovat standardoineet mittareina.

Power BI -raportin mukaan asiakkailla, jotka käyttävät yli kahta pankkituotetta, on korkeampi vaihtuvuusprosentti. Vain harvoilla asiakkailla oli kuitenkin enemmän kuin kaksi tuotetta. (Katso vasemman alapaneelin kaavio.) Pankin pitäisi kerätä enemmän tietoja, mutta sen pitäisi myös tutkia muita ominaisuuksia, jotka korreloivat enemmän tuotteita.

Saksan pankkiasiakkaiden vaihtuvuusaste on suurempi kuin Ranskassa ja Espanjassa. (Katso piirtoa oikean alareunan paneelista). Raportin tulosten perusteella tutkimus niistä tekijöistä, jotka kannustivat asiakkaita lähtemään, voisi auttaa.

Keski-ikäisiä asiakkaita on enemmän (25–45-vuotiaita). 45–60-kymppisillä asiakkailla on tapana poistua enemmän.

Lopuksi asiakkaat, joilla on pienemmät luottopisteet, todennäköisesti jättäisivät pankin muille rahoituslaitoksille. Pankin pitäisi tutkia tapoja kannustaa asiakkaita, joilla on pienemmät luottopistemäärät ja tilisaldot, pysymään pankissa.

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

Liittyvä sisältö

• Koneoppimismalli Microsoft Fabricissa
• Koneoppimismallien harjoittaminen
• Koneoppimiskokeilut Microsoft Fabricissa