acceptodds
Under review as a conference paper at ICLR 2027

WOODELF-HD: Efficient Background SHAP for High-Depth Decision Trees

Abstract

Decision-tree ensembles are a cornerstone of predictive modeling, and SHAP is a standard framework for interpreting their predictions. Among its variants, Background SHAP offers high accuracy by modeling missing features using a background dataset. Historically, this approach did not scale well, as the time complexity for explaining instances using background samples included an component. Recent methods such as Woodelf and PLTreeSHAP reduce this to , but introduce a preprocessing bottleneck that grows as with tree depth , rendering them impractical for deep trees. We address this limitation with WoodelfHD, an extension of WoodelfHD that reduces the factor to . The key idea is a Strassen-like multiplication scheme that exploits the structure of Woodelf matrices, reducing matrix–vector multiplication from to through a fully vectorized, non-recursive implementation. In addition, we merge path nodes with identical features, further reducing cache size and memory usage. When run in standard environments, WoodelfHD enables exact Background SHAP computation for tree models with depths up to , whereas previous methods fail due to excessive memory usage. For ensembles with depths of and , it achieves speedups of and , respectively, over the state of the art.

Primary area:
interpretability and explainable AI
Keywords:
decision trees, Shapley, SHAP, TreeSHAP

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_UYduOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes WOODELF-HD. Building upon the original WOODELF framework and leveraging the block identities of the M-matrix M1=0 and M4=M2+M3, it reduces the matrix-vector multiplications per leaf from four blocks to two via recursion, and observes that the final computation depends only on the off-diagonal blocks of the matrix, thereby reducing memory consumption from O(3^D) to O(2^D). Meanwhile, the authors introduce the Unique Feature Decision Pattern (UFDP) to merge same-feature splits along paths, and compare the runtime and memory performance of WOODELF-HD against SHAP, PLTREESHAP, and WOODELF on four datasets including IEEE-CIS.

Critical strengths
  1. The observation of algebraic structures in this paper is quite profound. In particular, the insight that "the recursive property of M-matrices ultimately reduces to a single anti-diagonal" not only yields implementation-level acceleration but also unifies linear contribution functions such as SHAP, Banzhaf, and interaction indices under the same acceleration framework. Compared to mere engineering optimizations, this represents a universally applicable algorithmic insight.

  2. The experiments cover a broad range, including not only IEEE-CIS but also HIGGS, KDD-99, and California Housing, spanning diverse scenarios such as large-scale, high-dimensional, and few-feature settings. The hyperparameter tuning experiments in the appendix further demonstrate that deep trees are common in practice, strengthening the problem motivation. The results show that the proposed method has significant practical value in medium-to-high depth scenarios of Background SHAP. Notably, depths 18 and 21 can achieve exact computation within a 50GB environment, demonstrating clear advantages over existing methods.

Critical weaknesses
  1. As shown in Table 3, at depth 12, WOODELF is the fastest baseline, taking 104 seconds, which is approximately 33× faster than 58 minutes; at depth 15, PLTREESHAP is the fastest baseline, taking 285 seconds, which is approximately 162× faster than 12.8 hours. In other words, the "state of the art" points to different algorithms at depths 12 and 15. This can easily mislead readers into thinking that it is always relative to the same strongest baseline.
  2. The single-tree extrapolation assumes a strictly linear relationship between runtime and the number of trees, but in practice, factors such as cache, scheduling, and memory pressure can violate this assumption. For comparative experiments claiming to be "state of the art", it is recommended to report the true full runtime at least in small-scale, completable settings, and to conduct a sensitivity analysis of the extrapolation error.
  3. The core contribution of this paper is precisely making depth 18/21 computable, yet it does not provide correctness comparisons with SHAP, brute-force computation, or other independent implementations at these high depths. Since existing methods are unavailable at high depths, the authors could at least construct verifiable scenarios on artificial models with a low number of features but high tree depths, because SHAP or brute-force computation remains feasible in such cases. Otherwise, the correctness at high depths relies mainly on theoretical soundness rather than experimental evidence.
  4. The main text and Tables 1–2 express complexity using tree depth D instead of the D_u that really works.

Some typoes:

  1. Change "50GM RAM" to "50GB RAM" throughout the text.
  2. Unify the spelling of "PLTreeSHAP" and "PLTREESHAP". It is recommended to standardize on one form and maintain consistency throughout the text.
Questions for authors
  1. Please report the speedup relative to each baseline separately and explain the selection criteria for the "state of the art" at each depth. At the same time, please explain the specific error ranges for the extrapolation of * and SHAP in Table 3, and it would be best to supplement with actual runs rather than extrapolated results.
  2. Please provide correctness evidence at high depth. For example, construct an artificial decision tree with a low number of features and high tree depth, so that SHAP or brute-force computation can still run, and report the maximum error between WOODELF-HD and the reference results.
  3. Please explicitly use D_u to express complexity in the main text and the complexity table, or annotate its actual meaning next to D.
2 comments
AuthorsOpenReview ↗

Additional Benchmarks, Empirical Correctness Checks, and Complexity Refinements

Thanks for the review!

Raised Weaknesses:

  1. In the revision, we changed the phrasing to “For Background SHAP on CPU, WoodelfHD significantly outperforms the fastest baseline at every depth from 9 onward, achieving a 33x speedup over Woodelf at depth 12 and a 162x speedup over PLTREESHAP at depth 15.”

  2. We added Appendix E.1, which evaluates every Background SHAP setting in Tables 3 and 6 on a single tree: the first tree from each 100-tree model. Results are in Table 8. No runtimes are extrapolated across trees. Only the shap runtimes are still estimated: we use 10 background rows and extrapolate. On California Housing, shap uses the entire training set as the background dataset, so no estimation is needed there. On a single tree, WoodelfHD remains the fastest CPU method in all but one setting. On IEEE-CIS, for example, WoodelfHD is 52x faster than the fastest baseline at depth 12 (vs Woodelf) and 233x faster at depth 15 (vs PLTREESHAP). On 100 trees, the corresponding speedups in Table 3 are 33x and 162x. The only exception is at depth 6 on HIGGS, where Woodelf is 1.2–1.3× faster, as in Table 6. On California Housing, where the shap package runs on the full background dataset, WoodelfHD is 96x–460x faster.

  3. Thanks for the suggestion! The shap package supports computation at any depth (it's just slower than WoodelfHD), so there is no reason not to repeat the depth-9 LightGBM empirical verification at higher depths. In the revised paper, this is exactly what we did. In Appendix E.5, path-dependent SHAP and background SHAP were validated at depths 6, 9, 12, 15, 18, and 21, and path-dependent SHAP IV was validated at depths 6, 9, 12, 15, and 18. We did not test depth-21 interactions because WoodelfHD needs over 50 GB of memory in this case. For background interactions, which shap does not support, we kept the existing depth-6 XGBoost tests. All tests pass with a tolerance of 10−510^{-5}.

  4. WoodelfHD's time and space complexities in Tables 1 and 2 of the main paper now use DuD_u instead of DD. We also updated Appendix D, which analyzes WoodelfHD's complexity for a generic contribution function vv, to use DuD_u instead of DD. Thanks for the suggestion, these complexity bounds are tighter than before.

We fixed the typos. We are sticking with “PLTREESHAP”.

Questions

  1. We changed the phrasing in the revision. See Appendix E.1 for runs without extrapolation across trees.
  2. We extended the empirical verification to LightGBM models with depths 6, 9, 12, 15, 18, and 21.
  3. In the revision, we use DuD_u instead of DD.
Reviewer_UYduOpenReview ↗

Official Comment by Reviewer UYdu

Thank you for clarifying the baseline comparisons and complexity bounds, and for adding correctness checks at high tree depths. These revisions address most of my concerns, and I stand by my positive assessment. Good luck!

Reviewer_SYn4OpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
3
Read review
Paper summary

This paper considers the problem of computing Shapley values and Shapley interactions on tree-based models (e.g. LightGBM) using the "interventional" perturbation technique, which defines a value function by averaging over a background dataset. The paper proposes a fast algorithm focusing on high-depth trees, called WOODELF-HD, that builds on a prior algorithm, called WOODELF (Nadel & Wettenstein, 2026), which itself is an extension of PLTreeSHAP (Zern et al., 2023). The Shaply value has generally an exponential complexity in the number of features. PLTreeSHAP has shown that for a single instance the complexity can be reduced to O(mTL)\mathcal O(m TL), where mm is the size of the background dataset, TT is the number of trees in the ensemble, and LL is the number of leaves, i.e. independent of the number of features. PLTreeSHAP has further observed that the background dataset shares a lot of similar paths through the tree and can thus be summarized without re-computing it for every prediction/instance that has to be explained. This adds another (worst-case) complexity term that depends on the number of explained predictions/instances (n; called consumers here) via O(nT3DD)\mathcal O(n T 3^D D), where DD is the largest depth of the tree, resulting in a total complexity of O(mTL+nT3DD)\mathcal O(mTL + nT3^D D) for nn explained predictions. PLTreeSHAP's extension (Algorithm 2 and 3) are only preferable when the background dataset is extremely large. WOODELF has further observed that the same idea can be used for the explained instances. As a result, WOODELF introduces a 2D×2D2^D \times 2^D matrix MM, which stores the Shapley contributions for each pair of decision patterns for each feature on the path (i.e. DD many), and each leaf in each tree (i.e. LTLT many). This would add a data-independent complexity term of O(TLD4D)\mathcal O(TLD 4^D), which WOODELF further reduces by exploiting the sparsity of MM to O(TLD3D)\mathcal O(TLD3^D). This sparsity originates from the fact that for each leaf there exist pairs of decision patterns where no coalition reaches that leaf, and thus the Shapley contributions are zero. WOODELF's extension is only preferable when both the number of instances and number of background data is extremely large. WOODELF-HD now further reduces the remaining complexity term of MM to O(TLD22D)\mathcal O(TLD^2 2^D). This is achieved by further exploiting the structure of MM (Lemma 1). This allows to execute the necessary computations by evaluating the secondary diagonal (antidiagonal) of MM at D2DD 2^D cost. The intuition behind this step is that the antidiagonal stores the pairs of decision patterns where each split is executed by exactly one of the the two datapoints (explained instance or background datapoint). The remaining contributions can then be recovered from this. Overall, WOODELF-HD's extension is generally preferable over WOODELF and applies to the same regime as WOODELF. The same arguments also apply to the Shapley interaction computation presented here. The authors then evaluate their implementation on 4 datasets with 8,28,1218,28,121 and 397397 features in the high-nn high-mm regime using the full train set as background and full test set as consumers. The evaluation shows that WOODELF-HD outperforms WOODELF and further improves using a GPU implementation, and in this setting outperforms PLTreeSHAP and SHAP implementations for Shapley values and Shapley interactions.

Critical strengths
  1. Fast algorithm for targeted application setting: The paper provides a generally more efficient implementation of WOODELF that applies to the setting of explaning tree-based models with extremely many background samples and explained predictions. The GPU implementation and LightGBM support further strengthens the practical relevance.
Critical weaknesses

The main weaknesses of this paper are incremental contribution, unclear and informal presentation, and insufficient experimental evaluation. In my view, the paper does not satisfy the requirements for presentation at a top tier conference.

  1. Incremental contribution and modest significance: The novelty of this approach lies in the computational improvement of WOODELF's matrix multiplication. As outlined in the summary, WOODLEF's novelty lies in the observation that consumer decision patterns can be precomputed, similar to the background data in PLTreeSHAP. This improvement is only useful when the background data and the number of explained predictions are very large. The case of extremely large background data is itself questionable, since then there is a strong redundancy in the background data. While WOODELF already leaves this discussion open, this paper also does not address it. For instance, an interesting question to address would be if the obtained Shapley values even differ substantially, when compared with more modest background datasets. While WOODELF's application remains narrow, WOODELF-HD presents an improvement in its computation for deeper trees. The technical depth of this improvement is not substantial, the application remains narrow and unjustified, and it is unclear to me, if it is even optimal (see Q1 below).
  2. Flawed presentation and experimental evaluation: The current presentation of the paper is very hard to follow, and mostly not self-contained, as important formal details are missing. The intuition behind the computations is hard to understand. The paper would benefit from a more formal approach to defining value functions and separating it into the relevant terms, instead of targeting mostly the computational details. More importantly, similar to WOODELF, the evaluation here strongly favors WOODELF-HD by using extremely large background datasets (up to millions of datapoints). A better evaluation would be to clearly present when the present approach is beneficial over existing methods such as PLTreeSHAP. The present study only evaluates the depth of the trees and ignores the more substantial difference of changing the size of the background. Moreover, the actual complexity improvements should be clearly separated from other improvements in the implementation (see Q2 below).
Questions for authors
  1. It seems that WOODELF-HD is actually exploiting the fact that a coalition reaches the leaf if and only if the consumer satisfies all splits in the coalition and the background satisfies all splits of the complement. The key novelty to be exploited here seems that this is a single condition on the explained instance and a single condition on the background datapoint, which then factorizes the computation of the Shapley value into a consumer and a background part. Using this natural view, could there be an even more simplified way, which reduces the complexity from D2D^2 to DD for the Shapley value?
  2. What is the isolated benefit of the novel matrix computation in WOODELF-HD without other computational improvements, over WOODELF and PLTreeSHAP. When does the pre-computed consumer patterns unfold their benefit?
8 comments
AuthorsOpenReview ↗

Addressing Complexity, Background Size, and Matrix Definitions

Thanks for the detailed review!

Complexity of the shap package, PLTreeSHAP, Woodelf, and WoodelfHD

First, we want to discuss our complexity and the complexities of previous work. The first polynomial-time interventional SHAP algorithm was proposed by Lundberg et al. (2020). Its complexity is O(nmTL)O(nmTL), and the approach is implemented in the shap package. In Table 1 of the paper, we listed its complexity as O(mnTLD)O(mnTLD) - we fixed this in the revision. Note that the per-row complexity of O(mTL)O(mTL) was first introduced by Lundberg et al. (2020, Methods 10.2), not by PLTreeSHAP. Because of its nmnm dependence, the approach scales poorly when nn and mm are large.

Then came the O(n+m)O(n+m) approaches, pioneered by PLTreeSHAP. PLTreeSHAP's complexity is O(mTL+nT3DD)O(mTL + nT3^D D). Woodelf then offered another approach with complexity O(mTL+nTLD+TL3DD)O(mTL + nTLD + TL3^D D). Its main contributions are a vectorized approach and separating nn from 3D3^D in the complexity. Woodelf is better than PLTreeSHAP when n>Ln > L (nTLD<nT3DDnTLD < nT3^D D since L≤2DL \le 2^D, and TL3DD<nT3DDTL3^D D < nT3^D D when n>Ln > L). WoodelfHD further improves the complexity to O(mTL+nTLD+TL2DD2)O(mTL + nTLD + TL2^D D^2). WoodelfHD is better than PLTreeSHAP when n>LD⋅0.67Dn > LD \cdot 0.67^D. Since 0.67D0.67^D decays exponentially with depth, this condition is often satisfied. See Table 1 in our paper for more details.

To summarize, the O(nmTL)O(nmTL) approach wins when DD is large or when m<Dm < D. Otherwise, PLTreeSHAP wins when n<LD⋅0.66Dn < LD \cdot 0.66^D, and WoodelfHD wins in all other cases: medium to large mm and nn and moderate DD. Of course, the actual performance depends on constants and implementation details and is discussed in our experimental results.

Background data size in experiments

We added Appendix E.2 (Table 9), where we rerun all Background SHAP settings with only m=100m = 100 background rows. WoodelfHD remains the fastest method in most settings: at depths 12–18, it is 1.7–11× faster than the best baseline (on IEEE-CIS at depths 12/15: 11×/7.6×, vs. 33×/162× with the full background).

As you mentioned in the review, our speedups depend on the background size. Path-Dependent SHAP (no background, Table 7) and the full background (Tables 3 and 6) are the two extremes, and m=100m = 100 lies between them: at depths 12/15, the geometric-mean speedup is 3.6×/3.1× for Path-Dependent SHAP, 5.1×/3.9× with 100 background rows, and 24×/708× with the full background. We also moved the IEEE-CIS results with m=100m = 100 into the main paper (Table 4, next to the full-background results in Table 3). The Experimental Results section now states that "The speedup depends on the size of the background dataset" and reports this drop at depths 12 and 15.

Presentation and the definition of the MM matrices

We invite you to read Appendix A of the paper. In this appendix, we define the MM matrices using only pseudo-Boolean terms. This allows readers who are less familiar with previous tree algorithms to understand the structure and formal definition of the MM matrices. In the revision, we added a paragraph in Section 3 that refers readers to Appendix A before we dive into the MM matrix structure and our Strassen-like approach.

We answer you two questions in the next comment.

AuthorsOpenReview ↗

Algorithmic Improvements Inspired by Your Questions

Thank you for the questions!

Q1

Yes, you are right.

Fix a leaf whose path has DD splits. In your view, the contribution of a coalition SS is a product of three parts: a consumer part (the consumer satisfies all splits in SS), a background part (the fraction g(S)g(S) of background rows that satisfy all splits outside SS), and the Shapley weight of SS. The first two parts do not depend on the explained feature. Shapley values are symmetric, so a coalition SS gives one weight to every feature inside it and another weight to every feature outside it. Let AA be the set of splits that the consumer satisfies. Before multiplying by the leaf weight, the contribution of the leaf to feature ii is

ϕi(A)=∑S⊆A,i∈Sw+(∣S∣)g(S)+∑S⊆A,i∉Sw−(∣S∣)g(S)\phi_i(A) = \sum_{S \subseteq A, i \in S} w^+(|S|) g(S) + \sum_{S \subseteq A, i \notin S} w^-(|S|) g(S)

where w+(k)=1/(k(Dk))w^+(k) = 1/(k \binom{D}{k}) and w−(k)=−1/((D−k)(Dk))w^-(k) = -1/((D-k) \binom{D}{k}), with w+(0)=w−(D)=0w^+(0) = w^-(D) = 0. Let G+(A)G^+(A) and G−(A)G^-(A) be the sums of w+(∣S∣)g(S)w^+(|S|) g(S) and of w−(∣S∣)g(S)w^-(|S|) g(S) over all S⊆AS \subseteq A. The coalitions S⊆AS \subseteq A that do not contain ii are exactly the subsets of A∖iA \setminus i. The coalitions that contain ii are all the other subsets of AA. So

ϕi(A)=G+(A)−G+(A∖i)+G−(A∖i)\phi_i(A) = G^+(A) - G^+(A \setminus i) + G^-(A \setminus i)

The functions gg, G+G^+ and G−G^- do not depend on ii. Each is computed for all 2D2^D sets in O(2DD)O(2^D D), once per leaf instead of once per feature. In the paper's terms, StrassenLikeMult (Fig. 5) already computes this factorization. Its first loop is the background part and its second loop is the consumer part.

Currently, WoodelfHD calls StrassenLikeMult once per feature. The equation above shows that two calls per leaf are enough. This reduces the exponential term of the time complexity of Background SHAP from TL2DD2TL 2^D D^2 to TL2DDTL 2^D D, and the exponential term of the space complexity from 2DD2^D D to 2D2^D. We also managed to extend the idea to Shapley interaction values, where the improvement is even greater. Three shared products replace one product per feature pair. This reduces the exponential term from TL2DD3TL 2^D D^3 to TL2DDTL 2^D D in time, and from 2DD22^D D^2 to 2D2^D in space. We hope to introduce these improvements in a paper revision. See more details below.

Q2

We added Appendix E.3 to evaluate our new matrix-vector multiplication formulation, measuring the gains from initialization and from Strassen-like multiplication separately. The largest speedup comes from initialization (7×–295×), since we initialize vectors of size 2D2^D instead of matrices of size 3D3^D. However, initialization is a one-time cost, so its contribution to the overall speedup depends on the model size. Small or shallow trees benefit mainly from faster initialization, while large, deep models benefit mainly from faster matrix-vector multiplication. As discussed above, the precomputed consumer patterns start to pay off when n>LD⋅0.67Dn > LD \cdot 0.67^D.

Improvements and planned paper revision

We want to include these time and space improvements in the paper. We decided to first submit a revision without them, which addresses all your other suggestions and concerns, as well as those of the other reviewers. In parallel, we work on a second revision, which we hope to submit by November 18, possibly even earlier, so that we can discuss it. It will have two improvements:

  1. The complexity improvements of Q1. We have already started working on them. The derivation can also be seen through the MM matrices, and this view fits the story of the paper in an interesting way. The step from 3DD3^D D to 2DD22^D D^2 uses the linearity of Shapley values, and the step from 2DD22^D D^2 to 2DD2^D D uses their symmetry. In this way, each speedup is attributed to the Shapley axiom that drives it. It also shows what each game value gains. Any linear game value, even a nonsymmetric one, gets the first speedup, and values that are both symmetric and linear get both.

  2. An in-place StrassenLikeMult. While investigating your Q2 and benchmarking the matrix-vector multiplication, we came across a large implementation improvement. The vectorized operations in the two loops of StrassenLikeMult (lines 4-9 and 13-16 of Fig. 5) copy the ff and ss vectors several times. The same operations can be done in place, which speeds up the multiplication by 1.5x-10x depending on the depth.

Thank you very much for your review and your questions! They helped us improve both the paper and the WoodelfHD algorithm itself.

I thank the authors for their effort in improving the manuscript and I'm glad to see that the factor of D2D^2 can be reduced to DD.

Overall, I still believe that the targeted domain and contribution of this work is narrow (W1). However, I see potential in this approach, and I would recommend a comprehensive revision of the paper on two levels:

Conceptually (W2): As the authors have shown in their response, the Shapley value for the interventional game can be written in terms of three 2D2^D vectors, which is much more intuitive than the matrix MM of size 2D×2D2^D \times 2^D and the calculations shown in the paper. The matrix MM is mostly an algorithmic tool and in my view, the current version of the manuscript is hard to follow due to terminology, such as Strassen-like, recursions, several algorithms, and unintuitive properties of the object of interest. I think the paper currently lacks important intuition and abstraction on what is actually going on, while the underlying mechanisms could be presented much more simply. Currently, the paper reads as a description of an algorithm, rather than a methodological analysis of the computation of Shapley values on trees. I think the newly provided formula of the Shapley value is an important first step. I'd suggest at least the following for revision:

  • start with the interventional value function which depends on the consumer and background data point and the averaged variant over all background data point, and definition of Shapley value
  • demonstrate for trees how the background can be summarized, give a formula of the shapley value that depends on each explained instance (this is the pltreeshap idea)
  • demonstrate how the calculation depends only on the decision patterns of the consumers, this gives the main object of interest that should be computed, which is independent of single consumers and background data points, i.e. the formula you have provided.
  • given the object of interest, develop an efficient vectorized algorithm by providing intuition on how each of the components is computed, including steps, such as: compressing the background patterns, lookup from the consumer patterns, weighting, etc. (currently this is the main body of the paper but includes a list of technical details on computations which are difficult to follow).

Experimentally (W2): I appreciate the additional results on small background data. However, the goal of a thorough experimental evaluation should be to provide an understanding of the cases where summarizing the consumer (and background) data is preferable and faster. I understand that the authors have improved many computational details and that their implementation is generally faster than other existing algorithms, but there is a natural three-step variant of their algorithm: i) loop over consumers and background data points, ii) loop over consumers and summarize the background patterns, iii) summarize both consumer and background patterns beforehand. These three variants can share mostly the same (optimized) algorithmic backbone. A necessary evaluation would then be a large experimental study that varies the number of consumers (n) and background data points (m) and demonstrates when each approach is preferable. A natural second question concerns the size of the background: Is it really necessary to use thousands or millions of background data points for tabular data? Do the Shapley values change meaningfully with a larger background? If not, this should be investigated together with the previous question.

While I appreciate the new experimental results, I think that the required changes are currently too substantial to be addressed during this rebuttal period, and therefore maintain my current recommendation of reject.

Reviewer_CA6iOpenReview ↗
Rating
4
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper improves the scalability of SHAP explanations for deep trees by recognizing that the M matrix as used by the existing Woodelf algorithms has a particular structure that can be exploited to (1) reduce the complexity of a matrix-vector product and (2) reduce storage requirements for this matrix. The paper formally proves that this structure is present in the M matrices and experimentally shows that their insights and algorithmic changes lead to significant speedups over the SotA. Additionally, the paper presents a method to further reduce the size of this matrix by merging splits on the same feature.

Critical strengths

SHAP explanations are slow for deeper trees and deeper trees are used in practice (eg LightGBM, RFs), so this problem is relevant and well motivated.

The insight that the M matrix has the blocked structure is novel and clever, and provides a clear solution with a clear improvement over the SotA to the problem.

The concepts are clearly explained with easy to follow examples.

Critical weaknesses

Only evaluation results for a single dataset in the main paper. The appendix has results for three additional datasets. I would consider moving these results to the main paper and saving some space by e.g. moving Figure 5 to the appendix and compressing Figure 4 (or writing it out in LaTeX math).

Questions for authors

Given that the problem and proposed solution are clear to me, I have no further questions.

1 comment
AuthorsOpenReview ↗

Expanded Experiments in the Main Paper

Thanks for the review and the positive feedback!

We included more experimental results in the main paper. We added Table 4 which includes results on the KDD-99 and California Housing datasets when the entire background dataset is used and results on the IEEE-CIS datasets when just 100 background rows are used. We discuss these additional results in the Experimental Results section of the main paper.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.