SHAP értékek Pythonban: modell magyarázhatóság gyakorlati útmutató 2026

Frissítve: 2026. június 26.

A SHAP (SHapley Additive exPlanations) egy játékelméleti alapokon nyugvó keretrendszer, amely minden egyes jellemzőhöz hozzárendel egy értéket. Ez az érték megmondja, hogy az adott jellemző mennyivel tolta el a modell predikcióját a várható kimenettől. 2026-ban a SHAP a leggyakrabban használt magyarázhatósági (XAI) könyvtár Pythonban, mert egyaránt biztosít lokális (egyetlen predikcióra vonatkozó) és globális (modell-szintű) magyarázatot. Az EU AI Act 2026 augusztusától kötelező átláthatóság egyik bevett gyakorlati megoldása is.

• A SHAP értékek a Lloyd Shapley-féle kooperatív játékelméleti megoldáson alapulnak, és matematikailag egyedi módon osztják fel a predikció és a várható kimenet közötti különbséget a jellemzők között.
• A shap könyvtár 0.46-os verziójától natívan támogatja a NumPy 2.x és Python 3.13 környezetet; telepítés: pip install shap.
• Fa-alapú modelleknél (XGBoost, LightGBM, CatBoost, RandomForest) mindig TreeExplainer-t használj, mert polinomiális idejű, nem mintavételes közelítés.
• A summary_plot egyetlen ábrán mutatja a globális fontosságot és a hatás irányát, a waterfall_plot pedig egyetlen predikciót bont fel jellemzőnként.
• A SHAP nem helyettesíti a feature importance-t, hanem kiegészíti: a permutation importance variancia-alapú, a SHAP additív és predikció-szintű.
• EU AI Act megfelelőséghez dokumentáld a magyarázó típusát (TreeSHAP/KernelSHAP), a háttéradatkészletet, és a stabilitási mérőszámokat.

Mi az a SHAP érték, és miért érdemes használni?

A SHAP értékek a 2017-es Lundberg és Lee tanulmány ("A Unified Approach to Interpreting Model Predictions", NeurIPS 2017) által bevezetett egységes magyarázhatósági keretrendszer. A módszer matematikai alapja Lloyd Shapley 1953-as kooperatív játékelméleti munkája, amelyért 2012-ben közgazdasági Nobel-díjat kapott. A SHAP a Shapley-értékeket alkalmazza a gépi tanulásra: minden jellemzőt egy "játékos"-nak tekint, a predikció pedig a "kifizetés". A Shapley-érték az egyetlen igazságos felosztás, amely kielégíti az additivitás, a hatástalanság, a szimmetria és a linearitás axiómáit.

A gyakorlati előny? Ha egy hitelbírálati modell elutasít egy kérelmet, a SHAP pontosan megmondja, hogy a "fizetési késedelmek száma" +0.42-vel, a "jövedelem" −0.18-cal módosította a logit-ot a várható alapszinthez képest. Ez sokkal informatívabb, mint egy globális fontossági lista, és pontosan ez az a fajta jellemzőszintű attribúció, amit a 2026 augusztusától kötelező EU AI Act magas-kockázatú rendszerei megkövetelnek. Tapasztalatom szerint a SHAP nem csak utólagos riportoláshoz, hanem hibakereséshez is ideális. Egy korábbi projektemben például egy szivárgó jellemző (a célváltozó utáni időbélyeg) SHAP-értéke azonnal kilógott a többi közül, és így három perc alatt találtam meg azt, amit egy hét code review nem hozott felszínre.

SHAP telepítése és a környezet beállítása 2026-ban

A shap könyvtár 0.46-os verziója (2025 ősz) hozta el a NumPy 2.x és Python 3.13 teljes támogatását. A telepítés egyszerű, de érdemes virtuális környezetben dolgozni, mert a függőségi gráf nem kicsi:

python -m venv .venv
source .venv/bin/activate  # Windows-on: .venv\Scripts\activate
pip install --upgrade pip
pip install "shap>=0.46" xgboost scikit-learn pandas matplotlib jupyter

Ellenőrizd a verziót Jupyter notebookból:

import shap
import xgboost
import sklearn
print(f"shap: {shap.__version__}")
print(f"xgboost: {xgboost.__version__}")
print(f"sklearn: {sklearn.__version__}")

A SHAP interaktív JavaScript-vizualizációi (force plot, decision plot) Jupyter környezetben az shap.initjs() hívása után aktiválódnak. Ha VS Code notebookot vagy JupyterLab 4-et használsz, a modern WebView automatikusan rendereli. Colabban viszont 2026-ban is külön kell hívnod az initjs-t a kernel-restart után, ami egy meglepően makacs apróság.

TreeSHAP, KernelSHAP, DeepSHAP és LinearExplainer

A SHAP nem egyetlen algoritmus, hanem egy egységes felület több magyarázó implementáció felett. A választás drasztikusan befolyásolja a futási időt és a pontosságot:

• TreeExplainer (TreeSHAP): döntési fa alapú modellekhez (XGBoost, LightGBM, CatBoost, sklearn RandomForest/GradientBoosting). Polinomiális idejű egzakt algoritmus, nem mintavételezés.
• KernelExplainer (KernelSHAP): modell-agnosztikus, bármilyen feketedoboz-modellhez működik. Lassú, mert minden predikcióhoz 2^n koalíciót közelít LIME-szerű súlyozott lineáris regresszióval.
• DeepExplainer (DeepSHAP): Keras/TensorFlow és PyTorch hálózatokhoz a DeepLIFT-en alapulva.
• LinearExplainer: lineáris modellekhez (LogisticRegression, Lasso), figyelembe veszi a jellemző-korrelációkat.
• PermutationExplainer: modell-agnosztikus, de gyorsabb, mint a KernelSHAP, mert csak permutációkat használ a koalíciók helyett.

Hüvelykujj-szabály: ha fa-modell, mindig TreeExplainer. Egy 100 ezer soros, 30 jellemzős XGBoost-modell magyarázata TreeSHAP-pel másodpercek alatt lefut, KernelSHAP-pel órákig tarthat. A modern shap.Explainer(model, X_background) API ráadásul automatikusan kiválasztja a megfelelő implementációt, ha felismeri a modellt. Explicit explainer típust csak akkor adj meg, ha a heurisztika tévedne.

Teljes XGBoost példa: tanítás, magyarázat, vizualizáció

Az alábbi end-to-end példa egy XGBoost bináris osztályozót tanít a California Housing adatkészleten (mediánár > 200 ezer USD), és lokális, valamint globális SHAP magyarázatokat generál. A példa futtatható, kommentált, és pontosan azt a sorrendet követi, amit egy éles modell auditja megkövetel.

import numpy as np
import pandas as pd
import shap
import xgboost as xgb
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

# 1. Adat betöltése és bináris cél létrehozása
data = fetch_california_housing(as_frame=True)
X = data.data
y = (data.target > 2.0).astype(int)  # 200k USD feletti?

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 2. XGBoost tanítás (2026-ban xgboost 2.1+ ajánlott)
model = xgb.XGBClassifier(
    n_estimators=400,
    max_depth=6,
    learning_rate=0.05,
    eval_metric="logloss",
    tree_method="hist",
)
model.fit(X_train, y_train)

# 3. SHAP magyarázó létrehozása (automatikusan TreeExplainer-t választ)
explainer = shap.Explainer(model, X_train)
shap_values = explainer(X_test)

# 4. Globális összefoglaló: mely jellemzők számítanak átlagosan?
shap.plots.bar(shap_values, max_display=10)

# 5. Lokális magyarázat: az ELSŐ test predikció lebontása
shap.plots.waterfall(shap_values[0])

# 6. Numerikus értékek exportálása auditálható CSV-be
shap_df = pd.DataFrame(
    shap_values.values,
    columns=X_test.columns,
    index=X_test.index,
)
shap_df["base_value"] = shap_values.base_values
shap_df["prediction_logit"] = shap_values.values.sum(axis=1) + shap_values.base_values
shap_df.to_csv("shap_test_explanations.csv")

A 3. lépésben átadott X_train a háttéradatkészlet, ami meghatározza a "várható kimenetet" (base_value). Ha az éles modellben sztratifikált háttér mintát használsz (pl. shap.sample(X_train, 100)), reprodukálható és gyorsabb lesz a magyarázat. Ne hagyd üresen: a háttérválasztás nem opcionális metodológiai döntés, hanem érdemi tervezési lépés.

SHAP vizualizációk: summary, waterfall, dependence, force plot

A SHAP 0.40 utáni új API (shap.plots namespace) sokkal konzisztensebb, mint a régi shap.summary_plot stílusú hívások, és érdemes az új formára átállni. A négy leggyakrabban használt ábra:

Summary plot (beeswarm)

A globális kép: minden test pont egy pont, a vízszintes pozíció a SHAP érték, a szín a jellemző értéke (piros = magas, kék = alacsony). Egyetlen ábráról le tudod olvasni az irányt és a varianciát: shap.plots.beeswarm(shap_values).

Waterfall plot

Egyetlen predikció: a base_value-ról indul, és minden jellemző egy nyíllal módosítja az értéket a végső f(x)-ig. Tökéletes regulátori riportokhoz: shap.plots.waterfall(shap_values[0]).

Dependence plot

Egy adott jellemző SHAP értéke a jellemző értékének függvényében, automatikus színezéssel egy interakciós partnerre. Itt látható a nem-lineáris hatás: shap.plots.scatter(shap_values[:, "MedInc"], color=shap_values).

Force plot

Interaktív "erőjáték" formátum, amely a pozitív és negatív hozzájárulásokat ellentétes irányból mutatja. Notebook-bemutatókhoz remek, statikus PDF-be inkább a waterfall való. Hívás: shap.plots.force(shap_values[0]).

SHAP vs feature importance: melyik a jobb?

A kérdés rosszul van föltéve, mert a kettő mást mér. A klasszikus gain-alapú feature importance (XGBoost get_score) azt méri, hogy mennyit csökkenti egy jellemző a veszteséget a fa-split-ekben; ez kompenzálatlanul kedvez a magas számosságú kategóriáknak és a folytonos változóknak. A permutation importance (sklearn permutation_importance) megrángatja a jellemzőt, és nézi a teszt-pontosság csökkenését. Variancia-érzékeny és számításigényes.

Tulajdonság	SHAP (TreeSHAP)	Gain importance	Permutation importance
Mérték típusa	Additív, predikció-szintű	Veszteség-csökkenés	Pontosság-csökkenés
Lokális magyarázat	Igen	Nem	Nem
Globális magyarázat	Igen (átlagos abszolút)	Igen	Igen
Korreláló jellemzőkkel robusztus	Részben (TreeSHAP path-dependent)	Nem	Nem
Számítási költség	O(T·L·D²) fa-modellnél	O(1) tanítás után	O(n_iter · n_features)
Audit-képesség	Magas (matematikailag egyedi)	Alacsony	Közepes

Őszintén szólva, a gyakorlatban mindhármat együtt használom: a gain gyors smoke-test, a permutation független ellenőrzés, a SHAP pedig a riport. Ha ezek nem egyeznek a rangsorban, az diagnosztikus jel; gyakran adatszivárgásra vagy korreláló jellemzőre utal. A korábbi cikkemben az XGBoost, LightGBM és CatBoost összehasonlításáról ugyanezt a háromrétegű ellenőrzést használtam.

Hogyan használható a SHAP mélytanuló modelleknél?

Mély hálózatoknál két út van: a DeepExplainer (a DeepLIFT-en alapul, ami a backprop-szerű attribúciókat súlyozza), vagy a GradientExplainer (Integrated Gradients-szerű mintavételezés). Mindkettő működik Keras 3 és PyTorch 2.x modellekkel:

import shap
import torch
import torchvision.models as models

model = models.resnet50(weights="IMAGENET1K_V2").eval()
background = torch.randn(50, 3, 224, 224)
test_batch = torch.randn(5, 3, 224, 224)

explainer = shap.GradientExplainer(model, background)
shap_values = explainer.shap_values(test_batch)
shap.image_plot(shap_values, test_batch.numpy())

Transformer-alapú szövegmodelleknél a shap.Explainer(model, masker=shap.maskers.Text(tokenizer)) a leggyakoribb minta. A 0.46-os release jegyzéke (lásd a SHAP GitHub release oldalát) hozott egy gyorsított Partition magyarázót, ami a Hugging Face pipeline-okkal sokkal jobban együttműködik, mint a régi KernelExplainer. Tabuláris adatra azonban, még ha "deep tabular" hálózatot is használsz (mint a SAINT vagy a TabNet), a gyakorlat azt mutatja, hogy ugyanazon az adaton egy gradient-boosting modell és TreeSHAP jobb, gyorsabb magyarázatot ad.

SHAP és az EU AI Act 2026-ban

Az EU AI Act magas-kockázatú rendszerekre vonatkozó kötelezettségei 2026. augusztus 2-án lépnek életbe (a teljes szabályzat hivatkozása: artificialintelligenceact.eu). A 13. cikk megköveteli az "átláthatóságot és a használók számára érthető információt", a 86. cikk pedig az érintett személyeknek a magyarázathoz való jogát mondja ki. A SHAP a gyakorlatban két szempontból illeszkedik ide: lokális magyarázatot ad minden egyedi döntésre (86. cikk), és modell-szintű feature-attribúcióval támogatja a kockázatértékelést (15. cikk).

Audit-szempontból a következőket dokumentáld a model card-ban: a használt explainer típus (pl. TreeExplainer), a háttéradatkészlet pontos összetétele és mérete, a stabilitási mérőszám (két független háttérmintán számolt SHAP-rangsor Spearman-korrelációja), valamint az adatszivárgás-ellenőrzés (az időbeli tesztkészleten számolt SHAP konzisztens-e a tanulóhalmazon számolttal). Ezeket a metrikákat a scikit-learn pipeline és ColumnTransformer útmutatóban bemutatott reprodukálható pipeline-okba érdemes integrálni.

Gyakori hibák és teljesítmény-tippek

A SHAP használata kapcsán a leggyakoribb hibák, amiket éles modelleknél láttam:

• Túl nagy háttéradatkészlet. A KernelExplainer-nél a futási idő lineárisan nő a háttér méretével, 100–500 reprezentatív sor általában elegendő. Használd a shap.kmeans(X_train, 100)-at klaszterezett mintához.
• Hibás adatszivárgás-értelmezés. Ha egy "jövőből származó" jellemző (pl. szerződéskötés utáni adat) magas SHAP értéket kap a kockázatbecslésnél, ez nem a modell érdeme, hanem adatszivárgás. SHAP segít ezt korán látni.
• Kategóriális kódolás összekeverése. One-hot-kódolt jellemzőknél a SHAP értékek oszloponként jelennek meg, auditba az egész "ország_*" családot vissza kell aggregálnod összegzéssel.
• Force plot Jupyter outside. A force plot JavaScript-renderelést igényel, nbconvert PDF-be exportáláskor üres marad; ilyenkor mindig matplotlib=True kapcsolóval futtasd.

Teljesítmény-tippként: nagy táblákon (100k+ sor) számold a SHAP értékeket n_jobs-szal párhuzamosítva XGBoost-modellnél, és cache-eld őket parquet formátumban. Egy 1 millió soros kockázati modell teljes SHAP-mátrixa float32-ben 200–400 MB, ami még simán befér a memóriába. Ne felejtsd, hogy a Polars DataFrame natívan kezeli ezeket, ahogy a Polars LazyFrame útmutatóban bemutattam.

Gyakran ismételt kérdések

Mi a különbség a SHAP és a LIME között?

A LIME minden predikció köré lokálisan illesztett lineáris szurrogát-modellel magyaráz, és nem garantálja a globális konzisztenciát. A SHAP a Shapley-axiómákra (additivitás, konzisztencia) épül, ezért egyszerre lokálisan pontos és globálisan additív. A SHAP-értékek átlagos abszolút értéke közvetlenül globális fontosságot ad, a LIME erre nem alkalmas.

Lassú a SHAP nagy adathalmazokon. Mit tehetek?

Először győződj meg róla, hogy TreeExplainer-t használsz fa-modellnél, mert ez O(T·L·D²) komplexitású, nem mintavételes. Aztán mintavételezd a háttéradatkészletet 100–200 sorra (shap.sample vagy shap.kmeans). Végül a teszthalmazon is mintavételezhetsz a vizualizációhoz, és csak a globális metrikákhoz tartsd meg a teljes mintát.

Használható a SHAP idősoros modelleknél?

Igen, de a "jellemzőket" gondosan kell definiálni: ha a modell ablakolt lag jellemzőkkel dolgozik, a SHAP a lagok hozzájárulását mutatja. Rekurrens hálózatoknál a GradientExplainer időlépésenként ad attribúciót, viszont értelmezzed a maszkolás konvencióját, mert a 0-padolás torzíthatja a háttéradatkészletet.

A SHAP érték negatívja azt jelenti, hogy a jellemző rossz?

Nem. A negatív SHAP érték csak azt jelenti, hogy az adott megfigyelésnél a jellemző csökkentette a predikciót a várható alapszinthez (base_value) képest. Egy hitelmodellnél a "magas jövedelem" jellemző negatív SHAP-ja a kockázatra teljesen helyes, mert kevesebb kockázatot jósol.

SHAP használható szabályozott szektorban regulátori bizonyítékként?

Igen, és 2026-tól az EU AI Act-keretben az egyik bevett megoldás. Fontos azonban a magyarázó típusát (TreeSHAP vagy KernelSHAP), a háttéradatkészletet, és a stabilitási teszteket dokumentálni a model card-ban. A SHAP önmagában nem audit-bizonyíték; az audit-bizonyíték a teljes reprodukálható pipeline, amibe a SHAP beágyazódik.