Pith. sign in

REVIEW 4 major objections 5 minor 46 references

DistShap: Scalable GNN Explanations with Distributed Shapley Values

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read DistShap computes Shapley-value GNN explanations by distributing the work across up to 128 GPUs, turning an infeasible single-GPU computation into a practical one.

desk verdict DistShap is a real distributed systems contribution with credible scaling at 50-100K edges, but the 'millions of candidates' claim is unsupported and likely infeasible under its own memory model. read the letter →

arxiv 2506.22668 v1 pith:OPKRACO6 submitted 2025-06-27 cs.LG cs.AIcs.DCstat.ML

Selahattin Akkas , Aditya Devarakonda , Ariful Azad This is my paper
classification cs.LGcs.AIcs.DCstat.ML
keywords graphneuralnetworksShapleyvaluesexplainableAIdistributedcomputingGPUscalingleastsquaresGNNexplanationKernelSHAP
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper introduces DistShap, a distributed algorithm that computes Shapley-value explanations for graph neural network predictions by spreading the work across many GPUs. The point is to make edge-level credit assignment practical for large graphs, where a single explained node can have tens of millions of candidate edges and previous Shapley-based explainers either take hours or run out of memory. DistShap samples subgraphs in parallel, runs the GNN on batches of sampled subgraphs, and solves a distributed weighted least-squares problem to recover edge Shapley values. The paper reports that DistShap reaches higher Fidelity+ than most existing GNN explanation methods and scales nearly linearly from 8 to 128 GPUs, explaining 50 nodes on the largest tested graphs in about two to three minutes.

What carries the argument

The load-bearing mechanism is the reduction of Shapley-value estimation to a weighted least-squares problem whose normal-form solution is $\phi=(M^\top W M)^{-1}M^\top W \hat y$, where $M$ is a $k\times n$ binary mask matrix of sampled edge coalitions, $W$ is the diagonal Kernel SHAP weight matrix, and $\hat y$ holds the GNN's predictions on the sampled subgraphs. DistShap solves this system with a distributed Conjugate Gradients Least Squares (CGLS) solver under a 1D row layout of $M$, requiring only all-reduces of scalars and $n$-vectors per iteration. Supporting mechanisms are the complementary-pair non-uniform sampling of coalitions, which balances each GPU's load at exactly $nk/2p$ edges, and block-diagonal batching of masked computational graphs, which lets each GPU execute many GNN inferences as one dense batched forward pass.

What would settle it

On a small graph with at most 15 candidate edges, enumerate exact Shapley values for all edges and compare DistShap's estimated edge ranking with the exact ranking across many nodes; a large rank disagreement would show that the 60K-sample approximation, not the Shapley value itself, is what drives the reported fidelity.

Watch

Extended reading notes

Core claim

The central claim is that Shapley-based explanation of GNN predictions is not inherently too expensive; the bottleneck is single-device execution, and a careful distribution removes it. Treating each edge in a node's computational graph as a player, DistShap approximates Shapley values by the Kernel SHAP weighted least-squares solution $\phi=(M^\top W M)^{-1}M^\top W \hat y$, with $M$ a mask matrix of sampled subgraphs, $W$ the kernel weights, and $\hat y$ the GNN predictions on those subgraphs. Sampling is structured so every sampled subgraph is paired with its complement, which balances the workload across GPUs and makes the 50%-sparse mask cheap to generate. Model predictions are batched as block-diagonal masked copies of the computational graph, and the least-squares solve is done by a distributed Conjugate Gradients Least Squares (CGLS) iteration that only communicates scalar norms and $n$-dimensional vectors. The paper argues that this combination is the first distributed GNN explanation method and that it achieves near-linear speedup on up to 128 A100 GPUs, with higher Fidelity+ and Fidelity- than most baselines on six real-world graphs.

Load-bearing premise

The load-bearing premise is that each explained node's computational graph is small enough to be replicated in full on every GPU; if that graph grows beyond a single GPU's memory, the method's replication, load-balancing, and near-linear-scaling design all give way.

Editorial extensions

If this is right

  • For a fixed trained GNN, edge-level explanations on nodes with tens of millions of candidate edges become a multi-GPU feasibility rather than a single-GPU impossibility: the paper reports end-to-end times of roughly 106 to 171 seconds for 50 nodes on the three largest graphs.
  • The three distributed components—subgraph sampling, batched inference, and CGLS—are presented as reusable building blocks for any Shapley-value workload with many players, not just GNN explanations.
  • Near-linear scaling on 8 to 128 GPUs (11.1x to 13.5x speedups) implies that explanation time can be traded directly for hardware, which makes high-fidelity Shapley explanations practical for large node-classification deployments.
  • Because DistShap is model-agnostic and was also tested with a two-layer GAT, the same pipeline should apply to any message-passing architecture whose computational graph fits in GPU memory.
  • The paper's fidelity results (best or near-best Fidelity+ across top-k values, and best or near-best Fidelity- across sparsity levels) imply that the top edges it identifies are genuinely the ones whose removal changes the prediction most.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: the method's feasibility rests on the per-node computational graph fitting in one GPU's memory; for deeper GNNs or very dense neighborhoods this breaks down, and the authors identify the memory bottleneck and neighborhood sampling as future work.
  • Editorial inference: because the 50 test nodes were chosen from the largest neighborhoods, the reported averages may be better than what a uniformly random node sample would show; a random-node benchmark would separate method quality from favorable node selection.
  • Editorial inference: DistShap still approximates Shapley values through a finite sample and a surrogate linear model; on small graphs one could compare its top-k ranking against exact Shapley values to quantify approximation error, which the paper does not report.
  • Editorial inference: the same replicated-computational-graph and CGLS pattern could be adapted to feature-level attribution or to explanations of other deep graph models, though the paper only demonstrates edge-level attribution.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes DistShap, a multi-GPU algorithm for Shapley-value-based edge explanations of GNN node predictions. The method replicates the target node's L-hop computational graph on every GPU, distributes KernelSHAP-style coalition sampling across GPUs, performs batched GNN inference on masked subgraphs, and solves the resulting weighted least-squares problem with a distributed CGLS solver. Experiments on six datasets compare fidelity and runtime against several baselines, report strong scaling to 128 A100 GPUs on a supercomputer, and include ablations on sampling, batching, and solver choice. The central claims are that DistShap is the first distributed GNN explanation method, that it reaches higher fidelity than existing state-of-the-art explainers, and that it scales to models with millions of candidate edges/features.

Significance. If the algorithmic and scaling claims hold, DistShap would be a practically valuable contribution: Shapley-based GNN explanations are currently too expensive for large neighborhoods, and a distributed implementation that preserves fidelity while reducing runtime would broaden their use. The paper's strengths are the breadth of experiments (six datasets, multiple baselines, GCN and GAT models), the explicit complexity analysis, and the decomposition of the method into reusable components (distributed sampling, batched prediction, and a distributed least-squares solver). However, the headline scalability claim is not supported by the experiments as reported, and the printed CGLS pseudocode has internal inconsistencies that must be corrected before the method can be reproduced or evaluated.

major comments (4)
  1. [Section 3.4, Algorithm 1] The pseudocode is internally inconsistent and does not define a valid CGLS iteration as printed. Line 9 defines v_k but line 10 computes ||v_i||^2; line 14 subtracts v_{i-1}, which has never been assigned; line 17 computes p_i without any assignment that updates the direction vector u, so line 13 always uses u_{i-1}; and the coefficient in line 17, ||s_{i-1}||^2 / ||s_i||^2, is the reciprocal of the standard CGLS beta. Because the paper lists 'a Conjugate Gradients Least-Squares solver' as one of its three contributions, this is load-bearing: the algorithm as printed cannot be implemented or checked. Please provide a corrected, self-consistent pseudocode and verify it against a reference CGLS implementation.
  2. [Section 3.2.3 and Table 3] The scalability claim in the abstract and introduction is contradicted by the paper's own memory model. Section 3.2.3 gives per-GPU mask memory as O(n·k/p). With the paper's standard k=600,000 and p=128, the dense mask alone costs roughly 18.8 GB at n=1M, about 94 GB at n=5M, and about 708 GB for the 37.8M-edge Reddit computational graph listed in Table 3. Yet all scaling and fidelity experiments in Figs. 6-9 use nodes with 50K-100K edges (Section 4.3), where the mask fits in a few GB. The claim of scaling to 'millions of candidates' is therefore not demonstrated, and the dense mask representation makes that extrapolation implausible at the sample counts used. Either run experiments at n>100K with a memory-efficient mask representation or revise the scaling claims to match the demonstrated regime.
  3. [Section 4.3 and Figs. 6-9] The test-node selection is not representative of the datasets. For Reddit, ogbn-arxiv, and ogbn-products, the paper selects only nodes whose computational graphs have 50,000 to 100,000 edges, explicitly excluding both smaller and larger neighborhoods. This choice is reasonable for stress-testing the method, but it means the reported fidelity and scaling results do not support the motivating scenario of 'millions of candidates,' and they do not address the largest computational graphs listed in Table 3. Please clarify how the selected nodes relate to the full distribution of neighborhoods and to the paper's headline claims.
  4. [Section 5.2 and Table 2] The fidelity comparisons in Figs. 7 and 8 use DistShap with 600K samples for large graphs and up to 128 GPUs, while baselines run with their default settings on a single GPU. Table 2 acknowledges the hardware asymmetry for runtime, but the fidelity plots do not separate the effect of sample budget from the quality of the method. To support the claim of 'higher explanation fidelity than existing state-of-the-art,' please report baseline fidelity under a comparable sample budget or explicitly state that the comparison is DistShap with a large sample budget versus baselines with their out-of-the-box budgets.
minor comments (5)
  1. [Abstract and Section 1] The phrase 'millions of features' is ambiguous: the method assigns importance to edges, not to node features. Please replace it with 'millions of candidate edges' or define 'features' precisely on first use.
  2. [Section 3.3] The symbol b is used inconsistently: the text says 'Let b be the number of batches,' but Eq. (7) and Fig. 12 treat b as the batch size. Define b once and use a separate symbol for the number of batches.
  3. [Table 3] Table 3 reports memory only for the replicated computational graph, not for the mask matrix. Since the mask matrix is the binding memory constraint, add a column showing mask memory for the standard settings (e.g., k=600K, p=128 and p=8).
  4. [Figures 6-9] The fidelity and scaling plots show averages over 50 test nodes without error bars or variance information. Please add standard deviations or confidence intervals so the reader can assess the stability of the results.
  5. [Figure 4] The caption contains garbled text ('GPU3GPU2GPU1') and the figure labels are difficult to read; please clean up the caption and legend.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: Shapley scores come from external GNN predictions via KernelSHAP's WLS, fidelity is measured by removal, and the GNNShap self-citation is not load-bearing.

full rationale

DistShap's derivation chain is self-contained in the relevant sense. The edge importance scores are computed by solving the KernelSHAP weighted least-squares problem (Eq. 3, phi = (M^T W M)^{-1} M^T W yhat) from sampled subgraph predictions produced by the frozen GNN; no ground-truth edge importance is fed into the solver, and the reported fidelity is measured by an external removal-based metric (Eq. 8) on test nodes. The only self-citation is to the authors' earlier GNNShap as a source of the non-uniform sampling heuristic (Section 3.2.2, 'Prior work [1, 6] has shown...'), but the sampling formula is Eq. 5 from KernelSHAP [18], an external result, and the evidence for DistShap's scalability and fidelity comes from new 128-GPU experiments against external baselines rather than from GNNShap. The paper's scalability claims may be questioned on evidence grounds: the largest experiments have roughly 50K-100K candidate edges while the abstract claims millions, and the acknowledged memory bottleneck for deeper GNNs is a real limitation. However, those are correctness and evidence weaknesses, not circular derivation. No prediction or first-principles claim in the paper reduces to its own input by construction.

Assumptions & free parameters 4 free parameters · 7 assumptions · 0 invented entities

The central method uses only standard Shapley/Kernel-SHAP machinery. The free parameters are experimental choices, not fitted constants. The main assumptions concern the validity of masking edges as a coalition operation and the locality of the computational graph, both standard for GNN explainability. No new entities are introduced.

free parameters (4)
  • sample budget k = 60,000 (small graphs), 600,000 (large graphs)
    Chosen from saturation in Fig. 6; directly affects fidelity and runtime, not derived from theory.
  • batch size = 50
    Optimal per Fig. 12 ablation; affects GPU memory and prediction time.
  • number of test nodes = 50
    Arbitrary selection from test data; results are averages over these nodes.
  • GPU count = 8 for small datasets, 128 for large datasets
    Hardware budget choice; the comparison with baselines uses different GPU counts.
assumptions (7)
  • standard math Kernel SHAP weighted least squares yields Shapley value estimates.
    Invoked in Section 2.3 (Eq. 3-5), from Lundberg and Lee [18]; DistShap adopts this without new proof.
  • domain assumption The GNN prediction for node v depends only on its L-hop computational graph.
    Section 2.1 and 3.2.1: enables replication and masking of the local subgraph; standard for GNNs with L layers.
  • domain assumption Removing edges via binary mask produces a valid GNN input whose output is a meaningful coalition value.
    Used throughout Section 3.3 and the fidelity metric Eq. 8-9; assumes the model handles disconnected subgraphs consistently.
  • domain assumption Block-diagonal batching yields identical predictions to per-subgraph inference.
    Section 3.3 and Fig. 5; relies on the GNN being local and permutation-invariant across batch entries.
  • domain assumption The complementary-pair non-uniform sampling approximates true Shapley values.
    Section 3.2.2; asserted from GNNShap [1] and validated empirically in Fig. 6, not proven.
  • standard math CGLS converges to the least squares solution with a fixed tolerance.
    Section 3.4 and Algorithm 1; convergence of CGLS is standard, but the pseudocode as printed has a bug in the direction vector update.
  • domain assumption The selected 50 test nodes are representative of each dataset's explanation difficulty.
    Section 4.3 chooses nodes with the largest computational graphs, which is not a random sample and likely overstates difficulty and fidelity.

how reviews work

0 comments
Cite this review

Pith. "Pith review of DistShap: Scalable GNN Explanations with Distributed Shapley Values." pith.science (2026). https://pith.science/paper/OPKRACO6

@misc{pith2026250622668,
  author       = {Pith},
  title        = {Pith review of: DistShap: Scalable GNN Explanations with Distributed Shapley Values},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OPKRACO6}},
  note         = {Machine review of arXiv:2506.22668}
}
read the original abstract

With the growing adoption of graph neural networks (GNNs), explaining their predictions has become increasingly important. However, attributing predictions to specific edges or features remains computationally expensive. For example, classifying a node with 100 neighbors using a 3-layer GNN may involve identifying important edges from millions of candidates contributing to the prediction. To address this challenge, we propose DistShap, a parallel algorithm that distributes Shapley value-based explanations across multiple GPUs. DistShap operates by sampling subgraphs in a distributed setting, executing GNN inference in parallel across GPUs, and solving a distributed least squares problem to compute edge importance scores. DistShap outperforms most existing GNN explanation methods in accuracy and is the first to scale to GNN models with millions of features by using up to 128 GPUs on the NERSC Perlmutter supercomputer.

Figures

Figures reproduced from arXiv: 2506.22668 by the authors.

Figure 1
Figure 1. (a) Information propagation in a two-layer GCN: [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. 𝐹𝑖𝑑𝑒𝑙𝑖𝑡𝑦+ scores for identifying the top 20 most in￾fluential edges and corresponding computation times on the Coauthor-CS graph for seven explanation methods. A two-layer GCN was pre-trained before the explanation task. DistShap was run on 8 GPUs, while other methods used a GPU. Higher 𝐹𝑖𝑑𝑒𝑙𝑖𝑡𝑦+ scores and lower runtimes are desired. introduces a trade-off between explanation accuracy and runtime efficiency, partic… view at source ↗
Figure 3
Figure 3. DistShap computes Shapley values for all edges in the computational graph of a target node [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: DistShap distribution of 25,000 samples among 4 [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: Batch masking and model prediction by stacking [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: Average 𝐹𝑖𝑑𝑒𝑙𝑖𝑡𝑦+ scores (higher is better) for the top-k most important edges identified by DistShap across various sample sizes. Increasing the number of samples generally improves the results, up to a point of saturation. For smaller graphs like Coauthor-CS, we used…
Figure 7
Figure 7. Figure 7: Average 𝐹𝑖𝑑𝑒𝑙𝑖𝑡𝑦+ scores for top-k most important edges (higher is better) with a two-layer GCN model. DistShap gives the best or near-best results for all values of 𝑘. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.00 0.02 0.04 0.06 0.08 0.10 0.12 Coauthor-CS 0.1 0.2 0.3 0.4 0.5 0.6 0…
Figure 8
Figure 8. Figure 8: Average 𝐹𝑖𝑑𝑒𝑙𝑖𝑡𝑦− scores for various sparsity levels (lower is better) with a two-layer GCN model. A 0.7 sparsity means removing 70% of the least important edges. DistShap gives the best or near-best results for all sparsity levels. the slowest, while it achieves reaso…
Figure 9
Figure 9. Figure 9: Scalability of DistShap across different numbers of GPUs. The y-axis denotes the time needed to explain predictions [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 10
Figure 10. Figure 10: Scalability of DistShap on the Reddit dataset using [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]
Figure 11
Figure 11. Figure 11: Scalability of sampling on the Reddit dataset. Total [PITH_FULL_IMAGE:figures/full_fig_p010_11.png]
Figure 13
Figure 13. Figure 13: (left) WLS and CGLS 𝐹𝑖𝑑𝑒𝑙𝑖𝑡𝑦+ score comparison on Coauthor-CS dataset. (right) WLS and CGLS computation times for 60,000 samples with varying players. All of these components scale nearly linearly to 128 GPUs and can be used by any other applications. The distributed …

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

46 extracted references · 30 canonical work pages

  1. [1]

    Selahattin Akkas and Ariful Azad. 2024. Gnnshap: Scalable and accurate gnn explanation using shapley values. In Proceedings of the ACM Web Conference

    work page 2024

  2. [2]

    Federico Baldassarre and Hossein Azizpour. 2019. Explainability techniques for graph convolutional networks. arXiv preprint arXiv:1905.13686 (2019)

    arXiv 2019

  3. [3]

    Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. 2018. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261 (2018)

    arXiv 2018

  4. [4]

    Aleksandar Bojchevski and Stephan Günnemann. 2017. Deep gaussian embed- ding of graphs: Unsupervised inductive learning via ranking. arXiv preprint arXiv:1707.03815 (2017)

    arXiv 2017

  5. [5]

    James Demmel, Laura Grigori, Mark Hoemmen, and Julien Langou. 2012. Communication-optimal parallel and sequential QR and LU factorizations. SIAM Journal on Scientific Computing 34, 1 (2012), A206–A239

    work page 2012

  6. [6]

    Alexandre Duval and Fragkiskos D Malliaros. 2021. Graphsvx: Shapley value explanations for graph neural networks. In Machine Learning and Knowledge Discovery in Databases. Research Track: European Conference, ECML PKDD 2021, Bilbao, Spain, September 13–17, 2021, Proceedings, Part II 21 . Springer, 302–318

    work page 2021

  7. [7]

    Sepideh Ebrahimi and P. Patel. 2022. Scaling SHAP Calculations With PySpark and Pandas UDF. https://www.databricks.com/blog/2022/ 02/02/scaling-shap-calculations-with-pyspark-and-pandas-udf.html. https://www.databricks.com/blog/2022/02/02/scaling-shap-calculations- with-pyspark-and-pandas-udf.html Databricks Blog. Accessed: 2025-04-13

    work page 2022

  8. [8]

    Thorben Funke, Megha Khosla, Mandeep Rathee, and Avishek Anand. 2022. Zorro: Valid, sparse, and stable explanations in graph neural networks. IEEE Transactions on Knowledge and Data Engineering (2022)

    work page 2022

Show all 46 references
  1. [9]

    Shurui Gui, Hao Yuan, Jie Wang, Qicheng Lao, Kang Li, and Shuiwang Ji. 2024. FlowX: Towards Explainable Graph Neural Networks via Message Flows. IEEE Transactions on Pattern Analysis and Machine Intelligence 46, 7 (2024), 4567–4578. doi:10.1109/TPAMI.2023.3347470

    2024

  2. [10]

    Gérard Hamiache and Florian Navarro. 2020. Associated consistency, value and graphs. International Journal of Game Theory 49 (2020), 227–249

    2020

  3. [11]

    William L Hamilton, Rex Ying, and Jure Leskovec. 2017. Inductive representation learning on large graphs. In Proceedings of the 31st International Conference on Neural Information Processing Systems . 1025–1035

    2017

  4. [12]

    Magnus R Hestenes, Eduard Stiefel, et al. 1952. Methods of conjugate gradients for solving linear systems. Journal of research of the National Bureau of Standards 49, 6 (1952), 409–436

    1952

  5. [13]

    Roger W. Hockney. 1994. The communication challenge for MPP: Intel Paragon and Meiko CS-2. Parallel Comput. 20, 3 (1994), 389–398. doi:10.1016/S0167- 8191(06)80021-9

    1994 doi

  6. [14]

    Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. 2020. Open graph benchmark: Datasets for machine learning on graphs. Advances in neural information processing systems 33 (2020), 22118–22133

    2020

  7. [15]

    Qiang Huang, Makoto Yamada, Yuan Tian, Dinesh Singh, and Yi Chang. 2022. Graphlime: Local interpretable model explanations for graph neural networks. IEEE Transactions on Knowledge and Data Engineering (2022)

    2022

  8. [16]

    Kipf and Max Welling

    Thomas N. Kipf and Max Welling. 2017. Semi-Supervised Classification with Graph Convolutional Networks. In International Conference on Learning Repre- sentations (ICLR)

    2017

  9. [17]

    Wanyu Lin, Hao Lan, Hao Wang, and Baochun Li. 2022. Orphicx: A causality- inspired latent variable model for interpreting graph neural networks. In Pro- ceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition . 13729–13738

    2022

  10. [18]

    Scott M Lundberg and Su-In Lee. 2017. A unified approach to interpreting model predictions. Advances in neural information processing systems 30 (2017)

    2017

  11. [19]

    Dongsheng Luo, Wei Cheng, Dongkuan Xu, Wenchao Yu, Bo Zong, Haifeng Chen, and Xiang Zhang. 2020. Parameterized explainer for graph neural network. Advances in neural information processing systems 33 (2020), 19620–19631

    2020

  12. [20]

    Cristine Marsh and Isaac Joseph. 2020. Shparkley: Scaling Shapley Values with Spark. GitHub Repository. https://github.com/Affirm/shparkley. https://github. com/Affirm/shparkley Software implementation presented at MLconf Online

    2020

  13. [21]

    Andrea Mastropietro, Giuseppe Pasculli, Christian Feldmann, Raquel Rodríguez- Pérez, and Jürgen Bajorath. 2022. EdgeSHAPer: Bond-centric Shapley value-based explanation method for graph neural networks. Iscience 25, 10 (2022)

    2022

  14. [22]

    Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. 2013. Distributed representations of words and phrases and their compositionality. Advances in neural information processing systems 26 (2013)

    2013

  15. [23]

    Rohan Mitchell, Eibe Frank, and Geoff Holmes. 2022. GPUTreeShap: massively parallel exact calculation of SHAP scores for tree ensembles. PeerJ Computer Science 8 (2022), e880. doi:10.7717/peerj-cs.880

    2022 doi

  16. [24]

    Paige and Michael A

    Christopher C. Paige and Michael A. Saunders. 1982. Algorithm 583: LSQR: Sparse Linear Equations and Least Squares Problems. ACM Trans. Math. Softw. 8, 2 (June 1982), 195–209. doi:10.1145/355993.356000

    1982

  17. [25]

    Paige and Michael A

    Christopher C. Paige and Michael A. Saunders. 1982. LSQR: An Algorithm for Sparse Linear Equations and Sparse Least Squares. ACM Trans. Math. Softw. 8, 1 (March 1982), 43–71. doi:10.1145/355984.355989

    1982

  18. [26]

    Tamara Pereira, Erik Nascimento, Lucas E Resck, Diego Mesquita, and Amauri Souza. 2023. Distill n’explain: explaining graph neural networks using simple surrogates. In International Conference on Artificial Intelligence and Statistics . PMLR, 6199–6214

    2023

  19. [27]

    Alan Perotti, Paolo Bajardi, Francesco Bonchi, and André Panisson. 2023. Ex- plaining Identity-aware Graph Classifiers through the Language of Motifs. In 2023 International Joint Conference on Neural Networks (IJCNN) . IEEE, 1–8

    2023

  20. [28]

    Phillip E Pope, Soheil Kolouri, Mohammad Rostami, Charles E Martin, and Heiko Hoffmann. 2019. Explainability methods for graph convolutional neural networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 10772–10781

    2019

  21. [29]

    Michael Sejr Schlichtkrull, Nicola De Cao, and Ivan Titov. 2021. Interpreting Graph Neural Networks for NLP With Differentiable Edge Masking. In Interna- tional Conference on Learning Representations . https://openreview.net/forum? id=WznmQa42ZAx

    2021

  22. [30]

    Lloyd S Shapley. 1951. Notes on the n-person game—ii: The value of an n-person game. (1951)

    1951

  23. [31]

    Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. 2018. Pitfalls of graph neural network evaluation. arXiv preprint arXiv:1811.05868 (2018)

    2018 arXiv

  24. [32]

    Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. 2017. Learning important features through propagating activation differences. In International conference on machine learning . PMLR, 3145–3153

    2017

  25. [33]

    Mukund Sundararajan, Ankur Taly, and Qiqi Yan. 2017. Axiomatic attribution for deep networks. In International conference on machine learning . PMLR, 3319– 3328

    2017

  26. [34]

    Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua Bengio. 2018. Graph Attention Networks. InInternational Confer- ence on Learning Representations . https://openreview.net/forum?id=rJXMpikCZ

    2018

  27. [35]

    Minh Vu and My T Thai. 2020. Pgm-explainer: Probabilistic graphical model ex- planations for graph neural networks. Advances in neural information processing systems 33 (2020), 12225–12235. Selahattin Akkas, Aditya Devarakonda, and Ariful Azad

    2020

  28. [36]

    Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. 2019. How Powerful are Graph Neural Networks?. In International Conference on Learning Representa- tions. https://openreview.net/forum?id=ryGs6iA5Km

    2019

  29. [37]

    Zhitao Ying, Dylan Bourgeois, Jiaxuan You, Marinka Zitnik, and Jure Leskovec

  30. [38]

    Hao Yuan, Jiliang Tang, Xia Hu, and Shuiwang Ji. 2020. Xgnn: Towards model- level explanations of graph neural networks. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining . 430– 438

    2020

  31. [39]

    H. Yuan, H. Yu, S. Gui, and S. Ji. 2023. Explainability in Graph Neural Networks: A Taxonomic Survey. IEEE Transactions on Pattern Analysis & Machine Intelligence 45, 05 (may 2023), 5782–5799. doi:10.1109/TPAMI.2022.3204236

    2023

  32. [40]

    Hao Yuan, Haiyang Yu, Jie Wang, Kang Li, and Shuiwang Ji. 2021. On explain- ability of graph neural networks via subgraph explorations. In International conference on machine learning . PMLR, 12241–12252

    2021

  33. [41]

    Shichang Zhang, Yozen Liu, Neil Shah, and Yizhou Sun. 2022. Gstarx: Explaining graph neural networks with structure-aware cooperative games. Advances in Neural Information Processing Systems 35 (2022), 19810–19823

    2022

  34. [42]

    Yue Zhang, David Defazio, and Arti Ramesh. 2021. Relex: A model-agnostic relational model explainer. In Proceedings of the 2021 AAAI/ACM Conference on AI, Ethics, and Society . 1042–1049

    2021

  35. [43]

    Ziwei Zhang, Peng Cui, and Wenwu Zhu. 2020. Deep learning on graphs: A survey. IEEE Transactions on Knowledge and Data Engineering 34, 1 (2020), 249–270

    2020

  36. [44]

    Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang, Changcheng Li, and Maosong Sun. 2020. Graph neural networks: A review of methods and applications. AI open 1 (2020), 57–81

    2020

  37. [2019]

    Ad- vances in neural information processing systems 32 (2019)

    Gnnexplainer: Generating explanations for graph neural networks. Ad- vances in neural information processing systems 32 (2019)

    2019

  38. [2020]

    Accessed: 2025-04-13

    2025

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.