Skip to content

Cvičenie 8 - Stabilita a interpretovateľnosť modelov

Týždeň: 8 | Predpoklady: Cvičenie 7, numpy, pandas, matplotlib, scikit-learn, shap

Príprava prostredia Anchor

V aktivovanom virtuálnom prostredí spustite nasledujúci príkaz:

Zdrojový kód

pip install numpy pandas matplotlib scikit-learn shap

O čom je cvičenie Anchor

Model s dobrými výsledkami ešte nemusí byť modelom, ktorému rozumieme. Pri rozhodovaní o ľuďoch, napríklad o úveroch, treba vedieť vysvetliť, prečo model dospel ku konkrétnemu výsledku, a zároveň overiť, či by sa toto vysvetlenie nezmenilo, keby sme model natrénovali na trochu iných dátach. Cvičenie nadväzuje na Cvičenie 7 a pracuje s tou istou dátovou sadou aj rovnakým rozdelením dát. Najprv preskúmate stabilitu koeficientov logistickej regresie a potom vysvetlíte predikcie modelu posilňovania pomocou Shapleyho hodnôt na úrovni celej dátovej sady aj jedného klienta. Na záver zistíte, čo by musel zamietnutý klient zmeniť, aby úver dostal, a ako možno zrozumiteľné správanie modelu zabezpečiť už pri jeho trénovaní.

Ciele Anchor

  1. Posúdiť stabilitu koeficientov modelu pri opakovanom trénovaní na bootstrapových vzorkách.
  2. Vysvetliť správanie modelu na úrovni celej dátovej sady pomocou Shapleyho hodnôt.
  3. Vysvetliť predikciu modelu pre jedného klienta a overiť aditivitu Shapleyho hodnôt.
  4. Overiť stabilitu vysvetlení pri modeloch natrénovaných na rôznych vzorkách dát.
  5. Nájsť kontrafaktuálne vysvetlenie zamietnutého klienta a vynútiť požadované správanie modelu monotónnymi obmedzeniami.

Dátová sada

Na tomto cvičení budeme pracovať s dátovou sadou Give Me Some Credit, ktorá obsahuje údaje o 150 000 klientoch žiadajúcich o úver. Úlohou je predikovať, či sa klient v nasledujúcich dvoch rokoch dostane do vážnych finančných ťažkostí, teda či sa so splátkou omešká o 90 a viac dní. Ide o binárnu klasifikáciu s nevyváženými triedami, pozitívnu triedu tvorí približne 6,7% záznamov.

Dátová sada obsahuje 10 číselných príznakov. Dva z nich, mesačný príjem a počet vyživovaných osôb, obsahujú chýbajúce hodnoty.

Postup Anchor

Nasledujúci kód načíta dáta a rozdelí ich rovnako ako v Cvičení 7. Kalibračnú množinu v tomto cvičení nepoužijete, rozdelenie však zachováme, aby trénovacia a testovacia množina boli rovnaké ako v Cvičení 7. Kód zároveň natrénuje dva modely z Úlohy 1.1 Cvičenia 7, ktoré budete interpretovať: logistickú regresiu a model HistGradientBoostingClassifier bez váh tried.

Zdrojový kód

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.datasets import fetch_openml
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

RANDOM_STATE = 42

# fetch the `Give Me Some Credit` dataset
data = fetch_openml(data_id=46929, as_frame=True)

# shorter feature names keep the tables and plots readable
X = data.data.rename(columns={
    "RevolvingUtilizationOfUnsecuredLines": "revolving_utilization",
    "NumberOfTime30-59DaysPastDueNotWorse": "late_30_59",
    "NumberOfTime60-89DaysPastDueNotWorse": "late_60_89",
    "NumberOfTimes90DaysLate": "late_90",
    "DebtRatio": "debt_ratio",
    "MonthlyIncome": "monthly_income",
    "NumberOfOpenCreditLinesAndLoans": "open_credit_lines",
    "NumberRealEstateLoansOrLines": "real_estate_loans",
    "NumberOfDependents": "dependents",
})
y = (data.target == "Yes").astype(int)

# the same split as in Exercise 7: 60% training, 20% calibration (not used here) and 20% test set
X_train, X_rest, y_train, y_rest = train_test_split(X, y, test_size=0.40, stratify=y, random_state=RANDOM_STATE)
X_calib, X_test, y_calib, y_test = train_test_split(X_rest, y_rest, test_size=0.50, stratify=y_rest, random_state=RANDOM_STATE)

print(f"Training set: {X_train.shape}, calibration set: {X_calib.shape}, test set: {X_test.shape}")
print(f"Share of the positive class: {y_train.mean():.3f}\n")
print("Missing values in the training set:")
print(X_train.isna().sum()[lambda s: s > 0].to_string())

# the two models from Task 1.1 of Exercise 7 that are interpreted in this exercise
models = {
    "Logistic regression": make_pipeline(SimpleImputer(strategy="median"), StandardScaler(), LogisticRegression(max_iter=1000)),
    "Boosting": HistGradientBoostingClassifier(random_state=RANDOM_STATE),
}
print()
for name, model in models.items():
    model.fit(X_train, y_train)
    print(f"{name:20s} AUC on the test set {roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]):.4f}")

Krok 1: Stabilita modelu Anchor

V Cvičení 7 ste sledovali, ako sa pri zmene trénovacej vzorky menia predikcie. Teraz preskúmate, či sa mení aj spôsob, akým model využíva jednotlivé príznaky.

Model natrénovaný na inej vzorke z tej istej populácie môže mať odlišné parametre. Stabilita modelu vyjadruje, nakoľko sú tieto parametre citlivé na zloženie trénovacích dát. Ak sa koeficient príznaku medzi bootstrapovými vzorkami výrazne mení alebo dokonca strieda znamienko, jeho interpretáciu treba brať opatrne.

Pri logistickej regresii znamienko koeficientu určuje, či rast hodnoty príznaku pri nezmenených ostatných príznakoch zvyšuje alebo znižuje predikované riziko. V tomto kroku overíte, nakoľko sú tieto znamienka a veľkosti koeficientov stabilné a ako ich stabilitu ovplyvňuje množstvo trénovacích dát.

Úloha 1.1 - Stabilita koeficientov logistickej regresie Anchor

Pomocou LogisticRegression natrénujte model na 100 bootstrapových vzorkách s 2 000 záznamami a potom na 100 vzorkách s 90 000 záznamami. Použite rovnaký postup predspracovania dát ako pri referenčnom modeli logistickej regresie, ktorý natrénoval úvodný kód.

Pri každom opakovaní vytvorte a natrénujte klon celého objektu Pipeline, aby sa na príslušnej bootstrapovej vzorke naučilo aj dopĺňanie chýbajúcich hodnôt a škálovanie príznakov. Z každého natrénovaného modelu uložte koeficienty.

Pre každý príznak a osobitne pre obe veľkosti vzorky vypočítajte smerodajnú odchýlku koeficientu cez 100 opakovaní a podiel opakovaní, v ktorých má koeficient opačné znamienko než v referenčnom modeli natrénovanom na celej trénovacej množine. Kód následne vypíše vzájomné korelácie troch príznakov opisujúcich omeškania splátok a pomocou krabicových grafov zobrazí rozdelenia koeficientov.

Doplňte miesta označené TODO v pripravenej kostre zdrojového kódu uvedenej nižšie.

Zdrojový kód

from sklearn.base import clone
from sklearn.utils import resample

linear_model = models["Logistic regression"]
# coefficients of the reference model fitted on the whole training set (features are standardized)
full_coef = pd.Series(linear_model[-1].coef_[0], index=X.columns)

N_BOOTSTRAP = 100
coef_samples = {}
for n_samples in [2000, len(X_train)]:
    coefs = []
    for seed in range(N_BOOTSTRAP):
        X_boot, y_boot = resample(X_train, y_train, n_samples=n_samples, stratify=y_train, random_state=seed)
        # TODO 1: fit a clone of the whole pipeline linear_model on the bootstrap sample
        #         and append the coefficients of its last step (coef_[0]) to coefs
        ...
    coef_samples[n_samples] = pd.DataFrame(coefs, columns=X.columns)

columns = {"coefficient": full_coef}
for n_samples, coefs in coef_samples.items():
    # TODO 2: standard deviation of every coefficient over the replications (ddof=1) and the share
    #         of replications in which the sign of the coefficient differs from the sign in full_coef
    columns[f"SD (n = {n_samples})"] = ...
    columns[f"sign flips (n = {n_samples})"] = ...

stability_results = pd.DataFrame(columns)
print(stability_results.round(3).to_string())

print("\nPearson correlation of the three delinquency features:")
print(X_train[["late_30_59", "late_60_89", "late_90"]].corr().round(3).to_string())

fig, axes = plt.subplots(1, 2, figsize=(13, 4.5), sharey=True)
for ax, (n_samples, coefs) in zip(axes, coef_samples.items()):
    ax.boxplot(coefs.values)
    ax.set_xticks(range(1, len(coefs.columns) + 1), coefs.columns, rotation=60, ha="right")
    ax.axhline(0, color="grey", linewidth=1)
    ax.set_title(f"Bootstrap samples of {n_samples} rows")
    ax.grid(alpha=0.25)
axes[0].set_ylabel("Coefficient of the standardized feature")

plt.tight_layout()
plt.show()

Poznámka

Bootstrap ukazuje, ako citlivo odhad modelu reaguje na zloženie trénovacej vzorky. Stabilný koeficient však nie je dôkazom príčinného vzťahu. Znamená iba to, že model pri rôznych vzorkách opakovane nachádza podobný vzťah medzi príznakom a cieľovou premennou pri zahrnutí ostatných príznakov v modeli.

Dokumentácia: clone, resample

Krok 2: Vysvetľovanie predikcií pomocou Shapleyho hodnôt Anchor

Pri hodnotení modelu nás zaujíma aj to, prečo konkrétnemu klientovi priradil vyššie alebo nižšie riziko. Pri logistickej regresii nám pri interpretácii pomáhajú koeficienty. Pri modeli posilňovania však takýto jednoduchý prehľad nemáme.

Shapleyho hodnoty ( z angl. SHapley Additive exPlanations, SHAP) umožňujú rozložiť predikciu na príspevky jednotlivých príznakov vzhľadom na základnú hodnotu modelu. Ukazujú tak, ktoré príznaky predikciu pre konkrétneho klienta zvýšili alebo znížili. Ich zhrnutím cez viacerých klientov získame aj celkový pohľad na to, ako model príznaky využíva.

V tomto kroku pomocou knižnice shap najprv preskúmate model na vzorke klientov a potom vysvetlíte jednu konkrétnu predikciu. Napokon overíte, nakoľko sa vysvetlenia menia, keď model natrénujete na iných vzorkách dát.

Úloha 2.1 - Globálne vysvetlenie modelu Anchor

Spustite nasledujúci kód, ktorý pre model HistGradientBoostingClassifier bez váh tried, natrénovaný úvodným kódom, vypočíta Shapleyho hodnoty pre 2 000 náhodne vybraných klientov testovacej množiny.

Pre každého klienta a každý príznak vznikne jedna hodnota vyjadrujúca príspevok príznaku k predikcii. Súčet týchto príspevkov a základnej hodnoty dáva výstup modelu. V tomto nastavení je výstup vyjadrený v jednotkách logaritmu šancí ( z angl. log-odds), nie priamo ako pravdepodobnosť. Kladný príspevok zvyšuje predikované riziko finančných ťažkostí, záporný ho znižuje.

Kód vypíše priemernú absolútnu Shapleyho hodnotu každého príznaku ako mieru jeho globálnej dôležitosti a vykreslí dva grafy, konkrétne:

  • Rojový graf ( z angl. beeswarm plot) - zobrazí príspevky príznakov pre jednotlivých klientov. Každý bod predstavuje jedného klienta; jeho vodorovná poloha vyjadruje Shapleyho hodnotu a farba hodnotu príznaku.
  • Graf závislosti ( z angl. dependence plot) - zobrazí pre globálne najdôležitejší príznak, ako sa jeho Shapleyho hodnota mení v závislosti od hodnoty príznaku.

Zdrojový kód

import shap

explained_model = models["Boosting"]

# a random sample of the test set keeps the plots readable and the computation fast
X_explain = X_test.sample(2000, random_state=RANDOM_STATE)

# TreeExplainer computes exact SHAP values for tree ensembles, in the units of the raw model output (log-odds)
explainer = shap.TreeExplainer(explained_model)
shap_values = explainer(X_explain)

print(f"SHAP values: {shap_values.values.shape}, base value: {float(shap_values.base_values[0]):.3f}")

# global importance of a feature = mean absolute SHAP value over the explained clients
shap_importance = pd.Series(np.abs(shap_values.values).mean(axis=0), index=X.columns).sort_values(ascending=False)
print("\nMean absolute SHAP value:")
print(shap_importance.round(3).to_string())

# every dot is one client: position = contribution to the prediction, colour = value of the feature
shap.plots.beeswarm(shap_values, max_display=10)

# dependence plot of the most important feature; the x-axis ends at the 99th percentile because of the outliers
top_feature = shap_values[:, shap_importance.index[0]]
shap.plots.scatter(top_feature, xmax=top_feature.percentile(99))

Upozornenie

Shapleyho hodnoty vysvetľujú predikcie modelu. Nehovoria, čo je príčinou finančných ťažkostí, ani čo by sa stalo, keby klient hodnotu príznaku zmenil.

Dokumentácia: shap.TreeExplainer, shap.plots.beeswarm

Úloha 2.2 - Vysvetlenie predikcie jedného klienta Anchor

Globálny pohľad teraz doplníte vysvetlením jednej konkrétnej predikcie. Spustite nasledujúci kód, ktorý spomedzi 2 000 klientov z Úlohy 2.1 vyberie toho, ktorému model predikuje najvyššiu pravdepodobnosť finančných ťažkostí.

Pre vybraného klienta kód overí základnú vlastnosť Shapleyho hodnôt - základná hodnota a súčet príspevkov všetkých príznakov sa rovnajú výstupu modelu. Tento súčet porovná s výstupom metódy decision_function, ktorý je vyjadrený v jednotkách logaritmu šancí. Zo súčtu potom logistickou funkciou vypočíta pravdepodobnosť a porovná ju s hodnotou z predict_proba.

Kód následne vypíše hodnoty príznakov vybraného klienta spolu s ich Shapleyho príspevkami a vykreslí vodopádový graf ( z angl. waterfall plot). Ten ukáže, ako jednotlivé príznaky zvyšujú alebo znižujú výstup modelu od základnej hodnoty až po výslednú predikciu pre tohto klienta.

Zdrojový kód

proba_explain = explained_model.predict_proba(X_explain)[:, 1]
# position of the client with the highest predicted probability in X_explain
client = int(np.argmax(proba_explain))

# raw output of the model for the client (log-odds of the positive class)
raw_output = explained_model.decision_function(X_explain.iloc[[client]])[0]
# additivity of SHAP values: base value + contributions of all features
reconstructed = shap_values.base_values[client] + shap_values.values[client].sum()
# the logistic function turns log-odds into a probability
reconstructed_proba = 1 / (1 + np.exp(-reconstructed))

print(f"Raw model output:                   {raw_output:.4f}")
print(f"Base value + sum of SHAP values:    {reconstructed:.4f}")
print(f"Probability from the SHAP values:   {reconstructed_proba:.4f}")
print(f"Probability from predict_proba:     {proba_explain[client]:.4f}")

contributions = pd.DataFrame({
    "feature_value": X_explain.iloc[client],
    "shap_value": shap_values.values[client],
}).sort_values("shap_value", key=abs, ascending=False)
print()
print(contributions.round(3).to_string())

# from the base value (average client) to the prediction of this client, one feature at a time
shap.plots.waterfall(shap_values[client], max_display=10)

Dokumentácia: shap.plots.waterfall, decision_function

Úloha 2.3 - Stabilita globálnej dôležitosti príznakov Anchor

Globálne vysvetlenie z Úlohy 2.1 opisuje jeden model natrénovaný na jednej vzorke dát. Teraz overíte, nakoľko sa dôležitosť príznakov a ich poradie menia pri zmene trénovacej vzorky.

Spustite nasledujúci kód, ktorý natrénuje po 10 modelov HistGradientBoostingClassifier na bootstrapových vzorkách s 2 000 a 90 000 záznamami (rovnako ako skupiny modelov v Úlohe 3.1 Cvičenia 7) a pre každý z nich vypočíta priemernú absolútnu Shapleyho hodnotu každého príznaku. Všetky modely vysvetľuje na rovnakej množine klientov X_explain, aby porovnanie neovplyvňoval výber vysvetľovaných klientov.

Zhodu poradia príznakov vyjadruje pomocou Spearmanovej korelácie - vypočíta ju medzi vektormi dôležitosti pre každú dvojicu rôznych modelov v skupine a získané korelácie spriemeruje.

Kód pre každý príznak a obe veľkosti trénovacej vzorky vypíše:

  • priemernú dôležitosť naprieč modelmi,
  • smerodajnú odchýlku tejto dôležitosti,
  • najlepšie a najhoršie poradie, ktoré príznak medzi modelmi dosiahol.

Zdrojový kód

N_EXPLAINED = 10

importance_samples = {}
for n_samples in [2000, len(X_train)]:
    rows = []
    for seed in range(N_EXPLAINED):
        # bootstrap sample of the training set (the same samples as the first 10 ensemble members in Exercise 7)
        X_boot, y_boot = resample(X_train, y_train, n_samples=n_samples, stratify=y_train, random_state=seed)
        member = HistGradientBoostingClassifier(random_state=RANDOM_STATE).fit(X_boot, y_boot)
        # the same clients are explained for every member, only the model changes
        member_shap = shap.TreeExplainer(member)(X_explain)
        rows.append(np.abs(member_shap.values).mean(axis=0))
    importance_samples[n_samples] = pd.DataFrame(rows, columns=X.columns)

for n_samples, importance in importance_samples.items():
    ranks = importance.rank(axis=1, ascending=False)
    # Spearman correlation between the importance vectors of every pair of members
    rank_corr = importance.T.corr(method="spearman").values
    mean_rank_corr = rank_corr[np.triu_indices_from(rank_corr, k=1)].mean()

    summary = pd.DataFrame({
        "mean_importance": importance.mean(),
        "SD": importance.std(ddof=1),
        "best_rank": ranks.min().astype(int),
        "worst_rank": ranks.max().astype(int),
    }).sort_values("mean_importance", ascending=False)
    print(f"Members trained on {n_samples} rows, mean rank correlation between two members: {mean_rank_corr:.3f}")
    print(summary.round(3).to_string(), "\n")

fig, axes = plt.subplots(1, 2, figsize=(13, 4.5), sharey=True)
for ax, (n_samples, importance) in zip(axes, importance_samples.items()):
    ax.boxplot(importance.values)
    ax.set_xticks(range(1, len(importance.columns) + 1), importance.columns, rotation=60, ha="right")
    ax.set_title(f"Members trained on {n_samples} rows")
    ax.grid(alpha=0.25)
axes[0].set_ylabel("Mean absolute SHAP value")

plt.tight_layout()
plt.show()

Dokumentácia: shap.TreeExplainer, DataFrame.corr

Krok 3: Kontrafaktuálne vysvetlenia a monotónne obmedzenia Anchor

Shapleyho hodnoty odpovedajú na otázku, prečo model rozhodol tak, ako rozhodol. Klient, ktorému banka zamietla úver, sa však skôr pýta, čo by musel urobiť inak, aby úver dostal. Na takúto otázku odpovedá kontrafaktuálne vysvetlenie ( z angl. counterfactual explanation) - čo najmenšia zmena príznakov, pri ktorej by model rozhodol opačne.

Zrozumiteľnosť modelu však nemusí prísť až dodatočne. Ak vopred vieme, ako má príznak na predikciu pôsobiť, napríklad že viac omeškaní nesmie znamenať nižšie riziko, môžeme toto správanie modelu vynútiť už pri trénovaní pomocou monotónnych obmedzení ( z angl. monotonic constraints).

Úloha 3.1 - Kontrafaktuálne vysvetlenie Anchor

Banka zamieta úver klientom, ktorých pravdepodobnosť finančných ťažkostí prekročí prah 0,091 odvodený z cien chýb v Úlohe 2.2 Cvičenia 7. Model posilňovania bez váh tried je dobre kalibrovaný, preto jeho predikcie s týmto prahom môžeme priamo porovnať.

Klient vie ovplyvniť iba niektoré príznaky. Vek ani počet omeškaní v minulosti nezmení, môže však splatiť časť dlhu na kreditnej karte (revolving_utilization) alebo iných dlhov (debt_ratio). Funkcia counterfactual vyskúša všetky kombinácie zníženia týchto dvoch príznakov na 100%, 95%, … až 0% súčasnej hodnoty a spomedzi zmien, pri ktorých predikcia klesne pod prah, vyberie tú najmenšiu.

Doplňte miesta označené TODO vo funkcii counterfactual v kostre nižšie. Kód potom funkciu použije na dvoch zamietnutých klientov - na klienta tesne nad prahom a na klienta z Úlohy 2.2 - a vypíše, ako by sa museli zmeniť ovplyvniteľné príznaky. Ďalej zistí, pre aký podiel zamietnutých klientov takáto zmena vôbec existuje, a pre klienta tesne nad prahom vykreslí predikovanú pravdepodobnosť pre všetky vyskúšané zmeny.

Zdrojový kód

# decision threshold derived from the costs in Task 2.2 of Exercise 7 (COST_FP = 1, COST_FN = 10);
# the boosting model without class weights is well calibrated, so its probabilities can be compared with it
THRESHOLD = 1 / (1 + 10)
# features the client can influence: paying off part of the credit card balance or of other debts
ACTIONABLE = ["revolving_utilization", "debt_ratio"]

def counterfactual(model, client_row, threshold=THRESHOLD, steps=21):
    """Smallest reduction of the actionable features that brings the predicted risk below the threshold.

    Both features are multiplied by factors from 1 (no change) to 0 (paid off completely).
    Returns the best change (None if no change is enough) and the whole grid of changes."""
    factors = np.linspace(1, 0, steps)
    grid = pd.DataFrame([(a, b) for a in factors for b in factors],
                        columns=["factor_utilization", "factor_debt"])
    # TODO 1: one copy of client_row per row of the grid, with revolving_utilization and debt_ratio
    #         multiplied by the factors in the columns factor_utilization and factor_debt
    candidates = ...
    # TODO 2: predicted probability of financial distress of every candidate
    grid["proba"] = ...
    # size of the change: 0 = nothing changes, 2 = both features are reduced to zero
    grid["change"] = (1 - grid["factor_utilization"]) + (1 - grid["factor_debt"])
    feasible = grid[grid["proba"] < threshold]
    if feasible.empty:
        return None, grid
    return feasible.sort_values(["change", "proba"]).iloc[0], grid

# a rejected client slightly above the threshold, with a known income and common values of the actionable features
near_threshold = (
    (proba_explain > THRESHOLD) & (proba_explain < 0.2)
    & X_explain["revolving_utilization"].between(0.5, 1.0).to_numpy()
    & X_explain["debt_ratio"].between(0.3, 1.0).to_numpy()
    & X_explain["monthly_income"].notna().to_numpy()
)
selected = {
    "Client near the threshold": int(np.flatnonzero(near_threshold)[0]),
    "Client from Task 2.2": client,
}

for label, pos in selected.items():
    row = X_explain.iloc[pos]
    best, grid = counterfactual(explained_model, row)
    print(f"{label}: probability {proba_explain[pos]:.3f}, "
          f"revolving_utilization {row['revolving_utilization']:.3f}, debt_ratio {row['debt_ratio']:.3f}")
    if best is None:
        print(f"  no change of the actionable features is enough, lowest reachable probability {grid['proba'].min():.3f}")
    else:
        print(f"  revolving_utilization {row['revolving_utilization'] * best['factor_utilization']:.3f}, "
              f"debt_ratio {row['debt_ratio'] * best['factor_debt']:.3f} -> probability {best['proba']:.3f}")

# how many rejected clients could get the loan by changing only the actionable features
rejected = np.flatnonzero(proba_explain > THRESHOLD)
reachable = np.mean([counterfactual(explained_model, X_explain.iloc[pos], steps=11)[0] is not None for pos in rejected])
print(f"\nRejected clients: {len(rejected)}, a counterfactual exists for {reachable:.1%} of them")

# predicted probability for every change of the client near the threshold
_, grid = counterfactual(explained_model, X_explain.iloc[selected["Client near the threshold"]])
surface = grid.pivot(index="factor_debt", columns="factor_utilization", values="proba")
fig, ax = plt.subplots(figsize=(6.5, 5))
mesh = ax.pcolormesh(surface.columns, surface.index, surface.values, cmap="RdYlGn_r", shading="nearest")
ax.contour(surface.columns, surface.index, surface.values, levels=[THRESHOLD], colors="black")
fig.colorbar(mesh, label="Predicted probability of financial distress")
ax.set_xlabel("revolving_utilization (share of the current value)")
ax.set_ylabel("debt_ratio (share of the current value)")
ax.set_title("Client near the threshold (black line = decision threshold)")
plt.tight_layout()
plt.show()

(Prečo kontrafaktuálne vysvetlenie nie je spoľahlivou radou, čo má klient urobiť, prediskutujeme na cvičení.)

Úloha 3.2 - Monotónne obmedzenia Anchor

Spustite nasledujúci kód, ktorý natrénuje model HistGradientBoostingClassifier s monotónnymi obmedzeniami pre tri príznaky o omeškaniach. Parameter monotonic_cst s hodnotou 1 zaručí, že predikované riziko pri raste príznaku nikdy neklesne. Kód porovná roc_auc_score a Brierovo skóre modelu s obmedzeniami a bez nich.

Potom pre každého z 2 000 klientov z Úlohy 2.1 postupne nastaví počet omeškaní na 0 až 5, ostatné príznaky ponechá, a vypíše, u akého podielu klientov predikované riziko pri raste počtu omeškaní niekde klesne. Graf ukazuje priemernú predikovanú pravdepodobnosť pre jednotlivé počty omeškaní.

Zdrojový kód

from sklearn.metrics import brier_score_loss

LATE = ["late_30_59", "late_60_89", "late_90"]

# +1: the predicted risk may only grow (or stay the same) when the number of late payments grows
monotonic_model = HistGradientBoostingClassifier(
    monotonic_cst={feature: 1 for feature in LATE}, random_state=RANDOM_STATE
).fit(X_train, y_train)
compared = {"Without constraints": explained_model, "Monotonic constraints": monotonic_model}

for name, model in compared.items():
    proba = model.predict_proba(X_test)[:, 1]
    print(f"{name:22s} AUC {roc_auc_score(y_test, proba):.4f}, Brier {brier_score_loss(y_test, proba):.4f}")

def risk_curves(model, X_sample, feature, values=range(6)):
    """Predicted probabilities of every client when the feature is set to each of the values."""
    curves = []
    for value in values:
        X_changed = X_sample.copy()
        X_changed[feature] = value
        curves.append(model.predict_proba(X_changed)[:, 1])
    return np.array(curves)  # shape (number of values, number of clients)

rows = []
fig, axes = plt.subplots(1, len(LATE), figsize=(14, 4), sharey=True)
for ax, feature in zip(axes, LATE):
    for name, model in compared.items():
        curves = risk_curves(model, X_explain, feature)
        # share of clients whose predicted risk falls somewhere while the number of late payments grows
        falling = (np.diff(curves, axis=0) < -1e-12).any(axis=0).mean()
        rows.append({"feature": feature, "model": name, "falling_risk": falling})
        ax.plot(range(6), curves.mean(axis=1), marker="o", label=name)
    ax.set_title(feature)
    ax.set_xlabel("Number of late payments")
    ax.grid(alpha=0.25)
axes[0].set_ylabel("Mean predicted probability")
axes[0].legend()
plt.tight_layout()
plt.show()

print("\nShare of clients whose predicted risk falls with more late payments:")
print(pd.DataFrame(rows).pivot(index="feature", columns="model", values="falling_risk").round(3).to_string())

Dokumentácia: Monotonic constraints, HistGradientBoostingClassifier

Doplňujúce úlohy Anchor

  1. Klienta z Úlohy 2.2 vysvetlite aj metódou LIME. Nainštalujte knižnicu príkazom pip install lime a použite triedu LimeTabularExplainer. Chýbajúce hodnoty najprv doplňte pomocou SimpleImputer. Vysvetľujte pravdepodobnosť finančných ťažkostí a päť najvplyvnejších príznakov porovnajte so Shapleyho hodnotami z Úlohy 2.2. Sledujte najmä výber príznakov a smer ich príspevkov, nie priamo ich číselné veľkosti. Vysvetlenie zopakujte s tromi rôznymi hodnotami parametra random_state. Pozorujte zmeny vo výsledkoch.
  2. Pre príznak revolving_utilization vykreslite pomocou PartialDependenceDisplay.from_estimator s parametrom kind="both" graf čiastočnej závislosti ( z angl. partial dependence plot) spolu s krivkami jednotlivých klientov ( z angl. individual conditional expectation, ICE) pre 200 klientov z X_explain. Rozsah osi obmedzte parametrom percentiles=(0.01, 0.99). Porovnajte priemernú krivku s grafom závislosti Shapleyho hodnôt z Úlohy 2.1. Líšia sa krivky jednotlivých klientov iba posunom, alebo aj tvarom?

Doplňujúce zdroje Anchor