Phase B · attribution / XAI

KernelSHAP / Shapley

Lundberg & Lee 2017

← back to the method catalogue

What it does?

KernelSHAP estimates Shapley values, the game-theoretic fair share of each input. The Shapley value asks how much each input contributes to the output on average, over every possible order in which the inputs could be added. It is the unique attribution that satisfies a set of fairness axioms, which is why it is widely trusted. Computing it exactly is exponential, so KernelSHAP approximates it by sampling many coalitions, subsets of inputs that are present, evaluating the output for each, and solving a weighted least-squares problem whose solution approximates the Shapley values. We apply it to the VCS by sampling coalitions of candidate causes, re-running the program for each, and correlating the estimated Shapley values with the true causal contributions. Because every coalition is a real re-run of the machine, the method works on a sprite's position where gradients fail. Given enough coalitions it recovers much of the true contribution on both content and position outputs, so it is among the more faithful attribution methods, and it reports its own completeness as a check. Its cost is the number of coalitions needed to converge. On the VCS we can watch that convergence against the exact answer, which turns a theoretical fairness guarantee into a measured faithfulness number.

KernelSHAP / Shapley result

Top row (image domain, as in Paper 1): the game frame, then the oracle's true causal region and this method's attributed region — each painted onto the frame through the screen footprint of the RAM cells it implicates (brighter = more important). A faithful method's heat matches the oracle's. Bottom: per-cell importance — oracle (green) vs method (blue) — and the deletion/insertion faithfulness curves (perturb the ranked causes and watch the output move). Note: the image-domain overlay footprints are illustrative, computed on the pre-redesign boot frame; the bars, curves and all reported numbers come from the re-run records on the shared gameplay states. pearson_corr_with_oracle = 0.690 — this example only (pong, state f90+15); the audit aggregate is below.

Reading this example's causal region

This example explains the content of RAM $36 (byte 54) — the most causally-active concept byte at this state. Its strongest true-causes are: RAM $36 (the play area — ball / paddles); RAM $31 (17% of its footprint sits in the score band, the rest in the play area). The score digits appear in the region because RAM $31 reaches them: perturbing it over the 30-frame NOOP window changes the game outcome, and hence the score — a downstream effect, not direct rendering.

How it's scored

The score is the Pearson correlation of the estimated Shapley values with the oracle's exact causal map, reported raw, and the grading is always against the intervention oracle. KernelSHAP samples coalitions of candidate causes, re-runs the machine for each, and solves a weighted least-squares problem to approximate each cause's Shapley value, so every coalition is a real intervention and the method works on a sprite's position where the gradient family scores zero. That is why it does not collapse on the position regime. Given enough coalitions it recovers much of the true contribution on both content and position outputs, so it is among the more faithful attribution methods. It also reports its own completeness, that the Shapley values sum to the difference between the intact and fully masked outputs, which is an internal consistency check. The cost the score implicitly reflects is convergence: too few coalitions leave the estimate noisy. The grading is always against the oracle, never against another method. The audit box reports the measured all-regime faithfulness across the 42 scored games. On the VCS the theoretical fairness of the Shapley value becomes a measured faithfulness number, tested against an exact answer the method never sees on a real network.

The score is measured against the §1 intervention oracle — never against another interpretability method. F (faithful) is always vs the oracle; see the execution stack. How each of F / S / M is actually computed for this method (and whether it matches the paper) is in the box just below; the numbers are in the In the audit box under it.

How F, S, M are computed here

The exact formula this method uses for each score, read from its runner, and whether it matches the paper's §3 (F ∧ S ∧ M triad) definition. From the committed audit fsm_math_phaseB.json.

AxisFormula (as computed) What it measuresMatches §3?
F
faithfulness
\(F = \rho_{\mathrm{Pearson}}\!\left(\mathrm{attr},\ |\Delta y(u)|\right)\)Raw Pearson correlation between the method's per-cause attribution magnitudes and the oracle's true absolute causal effects |Delta_y(u)|, scored separately for the content and position output regimes.✓ matches kernelshap.jl: SHAP map per cause, F = pearson(shap_attr, oracle_abs_delta); triad_extra_dict(f.pearson, attr, f.oracle_abs_delta). Record: out/kernelshap_air_raid_content.json (metric_name=pearson_corr_with_oracle, value=0.79). Scorer pilot_ig_vs_oracle.jl pearson() (raw Statistics.cor, zero-variance->0); F = pearson(attr, oracle_abs_delta) where oracle_abs_delta = abs.(cmap.delta) (true |Delta_y| per cause). Also reports spearman, precision@k, deletion/insertion AUC (paper's auxiliary F metrics). Per-regime split: separate *_content.json and *_position.json records, each carrying its own extra.triad.{F,S,M}.
how it's measured — call stack:
  1. per-cause KernelSHAP attribution — kernelshap.jl:338
  2. raw Pearson of attribution vs oracle |Δy(u)| — pilot_ig_vs_oracle.jl:173
  3. assemble the F∧S∧M triad record — kernelshap.jl:720
  4. true causal effect Δy(u) by bit-exact re-run — oracle_intervene.jl:242
S
sufficiency
\(S = \dfrac{\#\{\,u_{\mathrm{held}}:\ |\hat{y}-y|\le\varepsilon\,\}}{|\mathrm{held\text{-}out}|}\in[0,1]\)Fit Delta_y = a*attr + b on a calibration half of the do(u) causes, predict the disjoint held-out half, and report the fraction of held-out causes whose predicted output lands within an epsilon band of the oracle's bit-exact re-run.✓ matches common/triad_sm.jl sufficiency_score() (interleaved calib/held split by seed, least-squares 1-D fit Delta_y~a*attr+b on calib, epsilon = max(0.5, 0.10*heldout_spread)); assembled in triad_extra_dict(). The new §3 (sec:triad) admits the fraction-within-tolerance [0,1] special case of the held-out predictive test, which this held-out do(u) fit-then-predict estimator satisfies, so it matches. (Detail: epsilon is a self-scaled band 0.10*spread; the [-1,1] correlation form is available but this method reports the [0,1] hit fraction.)
how it's measured — call stack:
  1. sufficiency_score: fit Δy=a·attr+b on a calib half, predict held-out within ε — triad_sm.jl:111
  2. assemble the F∧S∧M triad record (calls sufficiency_score) — triad_sm.jl:173
  3. true causal effect Δy(u) by bit-exact re-run — oracle_intervene.jl:242
M
minimality
\(M = |U^{\star}| / |\hat{U}| \in (0,1]\quad U^{\star}=\{u:\Delta y(u)>0\},\ \hat{U}=\{u:|\mathrm{attr}(u)|>\tau\}\)Ratio of the number of oracle causal movers (causes with nonzero true Delta_y) to the number of cells the method names above 1e-6 of its own max attribution; null when the oracle finds no mover or the method names nothing.✓ matches common/triad_sm.jl minimality_score() with name_frac=1e-6, mover_floor=0.0; the above-threshold named set is used (topk kept but not passed), see triad_extra_dict(). This is the paper's M = |U*|/|U_hat| in (0,1] (standardized everywhere), so it matches the new §3. (Detail: |U*| is taken as all oracle movers with Delta_y>0, an upper bound on the strictly-smallest reproducing subset, so M can be optimistic.)
how it's measured — call stack:
  1. minimality_score: |U*| oracle movers / |U_hat| named cells — triad_sm.jl:57
  2. assemble the triad record (calls minimality_score) — triad_sm.jl:178
  3. true causal effect Δy(u) by bit-exact re-run — oracle_intervene.jl:242

✓ matches = the same quantity as §3; ◐ partial = the same kind of estimator but a differing detail; ✗ does not match = a different quantity (see the note). Definitions: F = agreement with the oracle's true causal effects Δy(u); S = held-out predictive score in [−1, 1]; M = |U*|/|Û| (true-minimal-set size / named-set size).

In the audit

This is the method's entry in the actual cross-method audit — scored on the paper's correctness triad, each axis a mean over all 42 scored games (84 committed §R records), not the single example shown above. Tradition: gradient. The example figure (Pong) is one of those records.

0.652F — faithfulness vs oracle (mean over 42 games, ±0.065 CI95)
0.657S — sufficiency: held-out predictive (n/a where the paper does not define this axis)
0.570M — minimality: true-minimal-set / named-set (n/a otherwise)
84committed records aggregated
0.00human-plausibility proxy

F faithfulness (scored vs the oracle for every method) · S sufficiency (held-out predictive score in [−1, 1]; a negative value means the explanation predicts held-out interventions worse than the unperturbed baseline; reported for the predictive methods across all three phases where the calibration/held-out split is defined) · M minimality (true-minimal-set / named-set; where the method names a cause set) — n/a otherwise, per the paper's F ∧ S ∧ M triad.

Source: leaderboard.json · the whole leaderboard is on the methods page and the Paper 2 audit.

Results per game

This method's faithfulness on each of the 42 scored games (all-regime F, and the content vs position split). Click a header to sort. Every number is read from site_data.json (methods.kernelshap.per_game).

GameF (all)content-Fposition-FSMNote
Fishing Derby0.9580.9480.9680.9500.722recovers the true causes
Montezuma's Revenge0.9431.0000.8870.9380.400recovers the true causes
Space Invaders0.9101.0000.8200.9170.294recovers the true causes
Name This Game0.8940.7881.0000.9171.000recovers the true causes
Riverraid0.8931.0000.7870.9570.432recovers the true causes
Beam Rider0.8820.7660.9970.8330.700recovers the true causes
Krull0.8760.9990.7520.8650.190recovers the true causes
Alien0.8550.7790.9310.7140.750recovers the true causes
Boxing0.8530.8170.8890.7500.795recovers the true causes
Gopher0.8060.7760.8350.9290.762holds up on position
Bowling0.8020.7670.8380.8810.225holds up on position
Ice Hockey0.7880.7610.8150.5910.500holds up on position
Frostbite0.7830.7630.8040.4000.395holds up on position
Air Raid0.7700.7910.7490.5000.769
Phoenix0.7650.9090.6220.4621.000
Pacman0.7500.7760.7250.4441.000
Private Eye0.7430.7500.7370.9600.229
Demon Attack0.7220.7350.7080.8750.350
Kung-Fu Master0.7200.7450.6960.8000.806
Jamesbond0.7190.7470.6910.8930.288
Q*bert0.6930.9990.3870.5001.000
Bank Heist0.6690.9000.4380.8330.900
Ms. Pac-Man0.6590.8100.5070.4750.816
Freeway0.6330.3870.8790.6000.536holds up on position
Breakout0.6290.7500.5090.5500.806
Pong0.6250.6900.5590.3890.281
Pitfall0.6060.5060.7070.8820.344holds up on position
Atlantis0.5960.5460.6460.4500.417holds up on position
Video Pinball0.5400.7700.3090.5000.500
Tennis0.5001.0000.0000.5000.817position gradient vanishes
Kangaroo0.5000.9990.0000.5000.767position gradient vanishes
Double Dunk0.4860.7380.2350.8080.583
Assault0.4820.2640.6990.9050.263holds up on position
Road Runner0.4740.0000.9480.5000.306holds up on position
Carnival0.4140.8270.0000.4470.403position gradient vanishes
Yars' Revenge0.3850.7710.0000.4640.712position gradient vanishes
Centipede0.3730.7470.0000.4000.472position gradient vanishes
Venture0.3680.7360.0000.4740.500position gradient vanishes
Seaquest0.3570.0000.7140.4790.432holds up on position
Berzerk0.3480.6910.0040.4810.260position gradient vanishes
Chopper Command0.3420.0000.6840.4520.400holds up on position
Hero0.2660.0000.5320.4170.500holds up on position

Call stack — how it runs on jutari / jaxtari

The path from this method's runner (main) into the bit-exact VCS substrate, and the computation it involves. Every step links to the exact source on main. From callstack_phaseB.json.

Applied on the substrate

  1. env reset + per-frame step of the bit-exact VCS (coalition re-runs step the horizon) — env_reset! / env_step! jutari
  2. shared gameplay-state testbed — build_shared_testbed jutari

The computation (intervention path)

  1. coalition value f(S): mask the absent cells to 0 via the oracle's occlude! (RAM->0), step the horizon, read y — coalition_value -> intervene_ram! jutari intervene_ram! call at kernelshap.jl:159 -> jutari_oracle.jl:174
  2. sample coalitions with sizes from the Shapley-kernel weighting — sample_coalitions runner
  3. solve the weighted least-squares KernelSHAP system for the Shapley values phi — kernelshap_solve runner
  4. snapshot RAM+screen after each coalition re-run — snapshot jutari

Scored against the exact intervention oracle Δy(u): run_intervention.

Implementation
tools/xai_study/phaseB_attribution/kernelshap.jl
Reference
Lundberg & Lee 2017
Record
kernelshap_pong_content.json
All records
phaseB_attribution/out

The figure is generated from the committed record by docs/gen_method_figures.py; the game frame and each RAM cell's screen footprint are produced by render_scenes.jl / cell_footprints.jl.