Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

Efficient Mixed Precision Quantization in Graph Neural Networks

T0 review · 3 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read The paper claims that integer-only message passing can reproduce full-precision FP32 aggregation exactly, and that searching per-component bit-widths with relaxed parameters yields 5.5x and 5.1x reductions in bit operations for node and…

desk verdict The central theorem, which guarantees integer message passing exactly matches FP32, is algebraically wrong as stated—the C3 zero-point cross term drops a factor of n—though the mixed-precision search framework is a legitimate new application and is worth serious referee attention once the proof and reported averages are fixed. read the letter →

arxiv 2505.09361 v1 pith:546KWPSW submitted 2025-05-14 cs.LG

Samir Moustafa , Nils M. Kriege , Wilfried N. Gansterer This is my paper · ORCID
classification cs.LG
keywords graphneuralnetworksmixedprecisionquantizationinteger-onlyinferencemessagepassingbit-widthsearchquantization-awaretrainingbitoperationscontinuousrelaxation
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

The paper tries to show that quantized graph neural networks can do their most expensive step—aggregating messages from neighbors—entirely in integer arithmetic, with no loss in numerical fidelity relative to full-precision aggregation. Its Theorem 1 gives an identity that rewrites the quantized product $Q_y(AX)$ as the integer product $Q_a(A)Q_x(X)$ plus cheap scale and zero-point corrections, so sparse-dense matrix multiplication over the graph no longer needs floating point. On top of this, MixQ-GNN uses a differentiable search over bit-width choices for every component of a GNN layer, returning a per-component precision assignment without exhaustive enumeration. If the framework holds up, the reported 5.5x and 5.1x reductions in bit operations for node and graph classification would make GNN inference substantially cheaper on integer-friendly hardware.

What carries the argument

The load-bearing object is Theorem 1, the Quantized Message Passing Schema identity $Q_y(AX) = C_1 \odot Q_a(A)Q_x(X) \odot C_2 + C_3$. It converts the aggregation step $AX$—normally a sparse-dense FP32 matrix multiplication—into an integer matrix product of the quantized adjacency and feature matrices, with the scale vectors $C_1$, $C_2$ and the zero-point correction $C_3$ applied as cheap post- and pre-processing. The second piece of machinery is the relaxed bit-width search: each quantizer is replicated for every allowed bit-width and mixed by softmax weights $\alpha$, so gradients can flow into the choice itself, and a differentiable penalty $C(T) = \sum_i b_i p_i |T|$ pushes the search toward low bit-widths. Together these separate the what-precision question, solved by relaxation, from the how-to-compute-exactly question, solved by the theorem.

What would settle it

Measure wall-clock inference time for a full quantized GCN on Cora and GraphSAGE on Reddit at the exact bit-widths MixQ-GNN selects, on the same AMD EPYC and Apple M1 hardware used in Figure 8; if the end-to-end speedup is far below the reported 5.5x BitOPs reduction, the efficiency claim collapses. A separate check: numerically compare $Q_y(AX)$ from the theorem's integer path against $Q_a^f(A)Q_x^f(X)$ for random $A$ and $X$; any disagreement beyond integer rounding would falsify the equality claim.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that message passing in GNNs can be fused through quantization: the output of aggregation, $Y = AX$, can be computed directly from the quantized integer matrices $Q_a(A)$ and $Q_x(X)$ as $Q_y(AX) = C_1 \odot Q_a(A)Q_x(X) \odot C_2 + C_3$, where $C_1 = S_a$, $C_2 = S_x \oslash S_y$, and $C_3$ collects zero-point offset terms. The corrections involve only elementwise operations and rank-one terms, so the integer sparse-dense multiplication remains the dominant cost. The theorem is verified in the code on GCN and GIN layers, and it is the basis for the claim that integer-only aggregation produces exactly the aggregated result that the fake-quantized FP32 pipeline would compute. The surrounding MixQ-GNN framework then performs quantization-aware training with a softmax relaxation over bit-width choices such as $\{2,4,8\}$ or $\{4,8\}$, with a memory-style penalty controlled by $\lambda$, and selects the highest-probability bit-width per component after training.

Load-bearing premise

The reported efficiency gains assume that the BitOPs metric—a bit-width-weighted count of operations—is proportional to actual inference time, a link the paper validates only on a single message-passing layer, with a moderate 0.59 Pearson correlation on one of the three tested platforms.

Editorial extensions

If this is right

  • Aggregation in any sum-based message passing network can run as integer sparse-dense matrix multiplication with no numerical penalty relative to fake-quantized FP32, opening GNN layers to integer hardware accelerators.
  • The per-component bit-width search is differentiable, so precision assignments over inputs, adjacency matrices, parameters, and intermediate activations can be learned simultaneously instead of chosen by exhaustive search.
  • On node classification, the framework reports an average 5.5x reduction in bit operations versus FP32 across Cora, CiteSeer, PubMed, and OGB-Arxiv; on graph classification, it reports 5.1x across five TUDatasets.
  • Existing graph-structure-aware quantizers can be inserted into the framework: combining with the DQ quantizer raises Cora accuracy to 81.8 percent while keeping bit operations near the low end.
  • Large-scale GraphSAGE experiments show the search transfers to graphs with millions of edges, with an average 5.6x bit-operation reduction over the FP32 baseline.

Reading between the lines

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

  • Inference: The theorem separates aggregation precision from message precision, so one could quantize edge and feature messages more aggressively while keeping aggregation exact; the paper does not test this decoupling.
  • Inference: If BitOPs track energy consumption as well as time on integer-friendly hardware, the same 5x reductions could translate into comparable energy savings, a claim the paper does not make and does not measure.
  • Inference: Because the correction terms $C_3$ are rank-one and cheap, the theorem may extend to other bilinear aggregation operators, but not directly to mean or max pooling; the paper's choice of max pooling in graph-level tasks suggests overflow was the practical concern.
  • Inference: The relaxed one-shot search could be reused as a warm start for post-training quantization, amortizing the search cost across many deployments of the same architecture; the paper only trains from scratch.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. The paper proposes MixQ-GNN, a mixed-precision quantization framework for GNN inference. Its main theoretical contribution is Theorem 1, which claims that the quantized message-passing product Qy(AX) can be computed from integer matrix products Qa(A)Qx(X) plus precomputed correction terms C1, C2, C3, with numerical equality to the FP32 quantized aggregation. The framework then uses a DARTS-style continuous relaxation to select bit-widths for each GNN component, and reports 5.5x and 5.1x average BitOPs reductions on node and graph classification benchmarks, with code and unit tests provided.

Significance. If the theorem can be corrected, the paper's idea of exact integer-only message passing with per-component mixed precision is a useful contribution for GNN deployment. The inclusion of DQ integration, large-scale experiments, and public code/tests are strengths. However, the correctness of the theorem and the reproducibility of the headline efficiency numbers are currently the main obstacles.

major comments (3)
  1. [Section 4, proof of Theorem 1] The expansion of Qf_a(A)Qf_x(X) in the proof of Theorem 1 is algebraically incorrect. With per-row S_a, Z_a and per-column S_x, Z_x, the fourth term of the expansion is n(Z_a⊙S_a)(Z_x⊙S_x)^T, not (Z_a⊙S_a)(Z_x⊙S_x)^T; the factor n comes from 1_n^T 1_n. Equivalently, the product of the two broadcast zero-point matrices is 1_n[(Z_a⊙S_a)^T 1_n](Z_x⊙S_x)^T. As printed, C3 omits this factor, so the claimed equality Qy(AX)=C1⊙Qa(A)Qx(X)⊙C2+C3 does not follow from the derivation. Because this theorem is the basis for the integer-only message-passing scheme, the central correctness claim is currently unsupported. Correcting C3, and stating the broadcasting convention for the zero-point vectors explicitly, would fix the proof; the repository tests cannot validate the theorem as stated unless the implementation already uses the corrected offset.
  2. [Section 5.3 and Section 5.4] The headline efficiency claims are not reproducible from the reported tables. Section 5.3 states an average 5.5x reduction in bit operations across Cora, CiteSeer, PubMed, and OGB-Arxiv, but Table 3 does not support this: for λ=-ε the per-dataset GBitOPs reductions are 16.11/3.95=4.08, 50.68/12.44=4.07, 41.7/10.34=4.03, and 692.87/167.50=4.14, averaging 4.08; for λ=0.1 the average is about 6.2, and for λ=1 about 8.6. Similarly, the 5.1x claim in Section 5.4 is not supported by Table 8: with λ* the per-dataset ratios average 4.15, and with λ=1 they average 4.76. The authors should recompute the averages, specify exactly which configuration is used, or qualify the claims accordingly.
  3. [Section 5.1, Figure 8] The BitOPs metric is validated only on a single message-passing layer, and the Pearson correlations are 0.59 on the AMD EPYC 9534, 0.70 on Intel Xeon, and 0.95 on Apple M1. The text's conclusion that 'inference times increase proportionally as BitOPs increase' is too strong, especially for the AMD platform that matches the CPU in the main experiments. Since all reported speedups are in BitOPs rather than wall-clock time, the paper should either provide end-to-end timing for full GNN inference on the target hardware or substantially temper the efficiency claims.
minor comments (5)
  1. [Figure 2 caption] The caption says 'Bit-width options: {2, 4, 8}, totaling 39 possible combinations,' but 3^9 = 19683; the text later correctly says 19,683 combinations, so the caption should be corrected.
  2. [Equations (1) and (2)] The displayed MPNN definitions have missing mathematical symbols due to formatting; they should be typeset cleanly so the message/aggregate/update structure is unambiguous.
  3. [Section 4, notation] The proof of Theorem 1 uses ⊙ with vectors and matrices without specifying the broadcasting convention; the dimensions and broadcasting of S_a, Z_a, S_x, and Z_x should be defined explicitly before the expansion.
  4. [Table 3] The PubMed block lists 'DQ [16]' in the DQ row, which appears to be a citation inconsistency; the table and the surrounding text should use consistent labels for the compared methods.
  5. [Figure 1] The x-axis appears to mix memory units (MB) and operation counts; the axis label and tick units should be clarified.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular reasoning: Theorem 1 is an algebraic re-arrangement of the paper's own quantization definitions, and the bit-width search is a data-driven optimization validated against random baselines and external benchmarks.

full rationale

The paper's central claim, Theorem 1, is derived in Section 4 directly from the quantization/dequantization definitions Qf(·)=Q−1(Q(·))=(Q(·)−Z)⊙S. The proof expands Qf_a(A)Qf_x(X) and then solves for Qy(AX); the correction terms C1, C2, and C3 are obtained by algebra from those definitions, not fitted to the quantities later reported. The integer aggregation formula is therefore self-contained in the sense required by the circularity test, even though a mathematical error in the C3 term is possible (the product of the two zero-point terms may require an n factor); an algebraic mistake is a correctness risk, not circularity. The bit-width selection in MixQ-GNN is a differentiable search with a memory penalty and is validated against random bit-width baselines (Table 10), so the reported BitOP reductions are not fitted to the target accuracy or efficiency numbers. The only self-citations (e.g., TUDataset [69]) are dataset references and are not load-bearing for the theorem or the search method. No prediction in the paper reduces by construction to an input parameter, and no load-bearing uniqueness or ansatz is imported from the authors' prior work.

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

The framework introduces no new physical or formal entities. It relies on standard learned quantization parameters (scales, zero-points, relaxation alphas) and hand-set hyper-parameters (lambda, bit-width sets). The main load-bearing postulates are the validity of the affine quantization model, the BitOPs proxy, and the DARTS relaxation.

free parameters (3)
  • lambda (bit-width penalty weight) = 1e-8, 0.1, 1 per dataset; lambda* chosen post hoc in Table 8
    Hyper-parameter controlling the trade-off between prediction loss and bit-width cost; tuned per dataset and reported as a range.
  • bit-width search set B = {2,4,8}, {4,8}, or {8,16} depending on dataset
    Hand-chosen per dataset as realistic hardware choices; directly constrains the search space and achievable efficiency.
  • Laplacian positional encoding dimension = 50
    Chosen for the CSL synthetic dataset, affecting the expressivity and quantization of the input features.
assumptions (4)
  • domain assumption Quantization with affine scale and zero-point (Eqs. 3-4) is a valid model of low-precision integer arithmetic.
    The entire framework relies on the standard fake-quantization model from Jacob et al.; the theorem's algebra follows from this definition.
  • domain assumption The BitOPs metric, defined as the bit-width weighted operation count, correlates with actual inference time.
    Used as the primary efficiency metric; validated only on a single message-passing layer with correlations 0.59 to 0.95 across three platforms in Section 5.1.
  • domain assumption DARTS-style continuous relaxation with the memory penalty C(T) identifies effective bit-width configurations.
    The search is a standard continuous relaxation; its effectiveness for GNN quantization is assumed and tested only indirectly via final accuracy.
  • domain assumption Each GNN component is quantized to a single bit-width because mixed precision inside a component is not hardware-supported.
    Restricts the search space and is justified by hardware references; if violated, the framework's component model would not apply.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Efficient Mixed Precision Quantization in Graph Neural Networks." pith.science (2026). https://pith.science/paper/546KWPSW

@misc{pith2026250509361,
  author       = {Pith},
  title        = {Pith review of: Efficient Mixed Precision Quantization in Graph Neural Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/546KWPSW}},
  note         = {Machine review of arXiv:2505.09361}
}
read the original abstract

Graph Neural Networks (GNNs) have become essential for handling large-scale graph applications. However, the computational demands of GNNs necessitate the development of efficient methods to accelerate inference. Mixed precision quantization emerges as a promising solution to enhance the efficiency of GNN architectures without compromising prediction performance. Compared to conventional deep learning architectures, GNN layers contain a wider set of components that can be quantized, including message passing functions, aggregation functions, update functions, the inputs, learnable parameters, and outputs of these functions. In this paper, we introduce a theorem for efficient quantized message passing to aggregate integer messages. It guarantees numerical equality of the aggregated messages using integer values with respect to those obtained with full (FP32) precision. Based on this theorem, we introduce the Mixed Precision Quantization for GNN (MixQ-GNN) framework, which flexibly selects effective integer bit-widths for all components within GNN layers. Our approach systematically navigates the wide set of possible bit-width combinations, addressing the challenge of optimizing efficiency while aiming at maintaining comparable prediction performance. MixQ-GNN integrates with existing GNN quantization methods, utilizing their graph structure advantages to achieve higher prediction performance. On average, MixQ-GNN achieved reductions in bit operations of 5.5x for node classification and 5.1x for graph classification compared to architectures represented in FP32 precision.

Figures

Figures reproduced from arXiv: 2505.09361 by the authors.

Figure 1
Figure 1. Accuracies of six types of GNNs on the Cora dataset [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Accuracy vs. average bit-width for a two layer GCN [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Histograms of the bit-widths for each component in the two layer GCN architecture on the Pareto front of Figure [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: An example of unfolding tree quantization using DQ, [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: An overview of a quantization example of one-layer message passing: (a) Complete graph [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: Relaxed differentiable architecture for simulated quan￾tization of message passing. Each relaxed connection o bi con￾tains a different quantizer which is characterized by a different bit-width bi ∈ B. Example follows [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: MixQ-GNN with a single-layer GCN example. [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]
Figure 8
Figure 8. Figure 8: Scatter plot between BitOPs and inference times for [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: Effect of λ on the average bit-width and accuracy of MixQ-GNN with two layers of the GCN architecture for thirty runs over Cora dataset. 5.4.1 Synthetic Dataset We evaluated the prediction performance of quantization on the CSL synthetic dataset [68] for graph classifi…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Graph Neural Network for Product Recommendation on the Amazon Co-purchase Graph

    cs.IR 2025-08 unverdicted novelty 2.0 of 10

    A benchmark of four GNN architectures (LightGCN, GraphSAGE, GAT, PinSAGE) for link prediction on the Amazon co-purchase graph, reporting trade-offs between accuracy, training cost, and scalability.

Reference graph

Works this paper leans on

71 extracted references · 68 canonical work pages · cited by 1 Pith paper

  1. [1]

    Warden and D

    P. Warden and D. Situnayake,TinyML: Machine Learning with TensorFlow Lite on Arduino and Ultra-Low-Power Microcontrollers. O’Reilly Media, 2019

    2019

  2. [2]

    On-device training under 256kb memory,

    J. Lin, L. Zhu, W.-M. Chen, W.-C. Wang, C. Gan, and S. Han, “On-device training under 256kb memory,” inPro- ceedings of the Annual Conference on Neural Information Processing Systems (NeurIPS 2022), 2022

    work page 2022

  3. [3]

    A study of lora: Long range and low power networks for the internet of things,

    A. Augustin, J. Yi, T. H. Clausen, and W. M. Townsley, “A study of lora: Long range and low power networks for the internet of things,” Sensors, 2016

    work page 2016

  4. [4]

    Appearance vs Disappearance of broad absorption line troughs in quasars

    M. Nagel, M. Fournarakis, R. A. Amjad, Y . Bondarenko, M. v. Baalen, and T. Blankevoort, “A white paper on neural network quantization,” arXiv preprint arXiv:2103.08499, 2021

    work page Pith review arXiv 2021

  5. [5]

    Ll-gnn: Low-latency graph neural net- works on fpgas for high-energy physics,

    Z. Que, H. Fan, M. Loo, H. Li, M. Blott, M. Pierini, A. Tap- per, and W. Luk, “Ll-gnn: Low-latency graph neural net- works on fpgas for high-energy physics,” ACM Transac- tions on Embedded Computing Systems, 2024

    work page 2024

  6. [6]

    Eta prediction with graph neural networks in google maps,

    A. Derrow-Pinion, J. She, D. Wong, O. Lange, T. Hester, L. Perez, M. Nunkesser, S. Lee, X. Guo, B. Wiltshire, P. W. Battaglia, V . Gupta, A. Li, Z. Xu, A. Sanchez-Gonzalez, Y . Li, and P. Velickovic, “Eta prediction with graph neural networks in google maps,” inProceedings of the 30th ACM International Conference on Information and Knowledge Management (C...

    work page 2021

  7. [7]

    Point-gnn: Graph neural net- work for 3d object detection in a point cloud,

    W. Shi and R. Rajkumar, “Point-gnn: Graph neural net- work for 3d object detection in a point cloud,” in Pro- ceedings of the 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2020

    work page 2020

  8. [8]

    Degree-quant: Quantization-aware training for graph neu- ral networks,

    S. A. Tailor, J. Fernandez-Marques, and N. D. Lane, “Degree-quant: Quantization-aware training for graph neu- ral networks,” in Proceedings of the International Confer- ence on Learning Representations, 2021

    work page 2021

Show all 71 references
  1. [9]

    Goodfellow, Y

    I. Goodfellow, Y . Bengio, and A. Courville,Deep Learning. MIT Press, 2016. Preprint – Efficient Mixed Precision Quantization in Graph Neural Networks 13

    2016

  2. [10]

    Mea- suring and relieving the over-smoothing problem for graph neural networks from the topological view,

    D. Chen, Y . Lin, W. Li, P. Li, J. Zhou, and X. Sun, “Mea- suring and relieving the over-smoothing problem for graph neural networks from the topological view,” inProceedings of the AAAI Conference on Artificial Intelligence, 2019

    2019

  3. [11]

    Understanding over-squashing and bottlenecks on graphs via curvature,

    J. Topping, F. Di Giovanni, B. P. Chamberlain, X. Dong, and M. M. Bronstein, “Understanding over-squashing and bottlenecks on graphs via curvature,” in Proceedings of the International Conference on Learning Representations (ICLR), 2022

    2022

  4. [12]

    Beyond over-smoothing: Uncovering the trainability challenges in deep graph neural networks,

    J. Peng, R. Lei, and Z. Wei, “Beyond over-smoothing: Uncovering the trainability challenges in deep graph neural networks,” in Proceedings of the 33rd ACM International Conference on Information and Knowledge Management (CIKM ’24), ACM, 2024

    2024

  5. [13]

    Opti- mization of graph neural networks: Implicit acceleration by skip connections and more depth,

    K. Xu, M. Zhang, S. Jegelka, and K. Kawaguchi, “Opti- mization of graph neural networks: Implicit acceleration by skip connections and more depth,” in Proceedings of the 38th International Conference on Machine Learning (ICML 2021), 2021

    2021

  6. [14]

    L. Wu, P. Cui, J. Pei, L. Zhao, and X. Guo, Graph Neu- ral Networks: Foundations, Frontiers, and Applications. Springer Singapore, 1st ed., 2022

    2022

  7. [15]

    Quantization of deep neural networks for accurate edge computing,

    W. Chen, H. Qiu, J. Zhuang, C. Zhang, Y . Hu, Q. Lu, T. Wang, Y . Shi, M. Huang, and X. Xu, “Quantization of deep neural networks for accurate edge computing,” Journal of Emerging Technologies in Computing Systems, 2021

    2021

  8. [16]

    Aggregation-aware quantization for graph neu- ral networks,

    Z. Zhu, F. Li, Z. Mo, Q. Hu, G. Li, Z. Liu, X. Liang, and J. Cheng, “Aggregation-aware quantization for graph neu- ral networks,” inProceedings of the Eleventh International Conference on Learning Representations, 2023

    2023

  9. [17]

    Semi-supervised classification with graph convolutional networks,

    T. N. Kipf and M. Welling, “Semi-supervised classification with graph convolutional networks,” in Proceedings of the International Conference on Learning Representations (ICLR 2017), 2017

    2017

  10. [18]

    Graph attention networks,

    P. Veliˇckovi´c, G. Cucurull, A. Casanova, A. Romero, P. Liò, and Y . Bengio, “Graph attention networks,” inProceedings of the International Conference on Learning Representa- tions (ICLR 2018), 2018

    2018

  11. [19]

    How powerful are graph neural networks?,

    K. Xu, W. Hu, J. Leskovec, and S. Jegelka, “How powerful are graph neural networks?,” in Proceedings of the Inter- national Conference on Learning Representations (ICLR 2019), 2019

    2019

  12. [20]

    Masked label prediction: Unified message passing model for semi-supervised classification,

    Y . Shi, Z. Huang, S. Feng, H. Zhong, W. Wang, and Y . Sun, “Masked label prediction: Unified message passing model for semi-supervised classification,” in Proceedings of the Thirtieth International Joint Conference on Artificial Intel- ligence (IJCAI ’21), 2021

    2021

  13. [21]

    Topology-adaptive graph convolutional networks,

    J. Du, S. Zhang, G. Wu, J. M. F. Moura, and S. Kar, “Topology-adaptive graph convolutional networks,”arXiv preprint arXiv:1710.10370, 2017

    2017 arXiv

  14. [22]

    How to find your friendly neighbor- hood: Graph attention design with self-supervision,

    D. Kim and A. Oh, “How to find your friendly neighbor- hood: Graph attention design with self-supervision,” in Proceedings of the International Conference on Learning Representations (ICLR 2021), 2021

    2021

  15. [23]

    NVIDIA Hopper Architec- ture In-Depth,

    M. Andersch, G. Palmer, R. Krashinsky, N. Stam, V . Mehta, G. Brito, and S. Ramaswamy, “NVIDIA Hopper Architec- ture In-Depth,” 2022

    2022

  16. [24]

    Ladder: Enabling e fficient low-precision deep learning computing through hardware-aware tensor transformation,

    L. Wang, L. Ma, S. Cao, Q. Zhang, J. Xue, Y . Shi, N. Zheng, Z. Miao, F. Yang, T. Cao, Y . Yang, and M. Yang, “Ladder: Enabling e fficient low-precision deep learning computing through hardware-aware tensor transformation,” in Proceedings of the 18th USENIX Symposium on Op- er...

    2024

  17. [25]

    NVIDIA Blackwell Architecture Technical Brief,

    NVIDIA Corporation, “NVIDIA Blackwell Architecture Technical Brief,” 2024

    2024

  18. [26]

    Extension of accu- rate numerical algorithms for matrix multiplication based on error-free transformation,

    K. Ozaki, D. Mukunoki, and T. Ogita, “Extension of accu- rate numerical algorithms for matrix multiplication based on error-free transformation,” Japan Journal of Industrial and Applied Mathematics, 2024

    2024

  19. [27]

    Neural message passing for quantum chem- istry,

    J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl, “Neural message passing for quantum chem- istry,” inProceedings of the 34th International Conference on Machine Learning (ICML 2017), 2017

    2017

  20. [28]

    Inductive representation learning on large graphs,

    W. L. Hamilton, Z. Ying, and J. Leskovec, “Inductive representation learning on large graphs,” in Proceedings of the 31st International Conference on Neural Information Processing Systems (NeurIPS 2017), 2017

    2017

  21. [29]

    Estimating or propagating gradients through stochastic neurons for conditional computation,

    Y . Bengio, N. Léonard, and A. C. Courville, “Estimating or propagating gradients through stochastic neurons for conditional computation,” arXiv preprint arXiv:1308.3432, 2013

    2013 arXiv

  22. [30]

    Quantization and train- ing of neural networks for efficient integer-arithmetic-only inference,

    B. Jacob, S. Kligys, B. Chen, M. Zhu, M. Tang, A. Howard, H. Adam, and D. Kalenichenko, “Quantization and train- ing of neural networks for efficient integer-arithmetic-only inference,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR ...

    2018

  23. [31]

    Vertex-centric visual programming for graph neural networks,

    Y . Wu, Y . Gui, T. Jin, J. Cheng, X. Yan, P. Yin, Y . Cai, B. Tang, and F. Yu, “Vertex-centric visual programming for graph neural networks,” in Proceedings of the 2022 In- ternational Conference on Management of Data (SIGMOD ’22), ACM, 2022

    2022

  24. [32]

    Regraphx: NoC-enabled 3d heteroge- neous ReRAM architecture for training graph neural net- works,

    A. I. Arka, J. R. Doppa, P. P. Pande, B. K. Joardar, and K. Chakrabarty, “Regraphx: NoC-enabled 3d heteroge- neous ReRAM architecture for training graph neural net- works,” in Proceedings of the 2021 Design, Automation and Test in Europe Conference and Exhibition (DATE ’21), 2021

    2021

  25. [33]

    Graphite: Optimizing graph neural net- works on CPUs through cooperative software-hardware techniques,

    Z. Gong, H. Ji, Y . Yao, C. W. Fletcher, C. J. Hughes, and J. Torrellas, “Graphite: Optimizing graph neural net- works on CPUs through cooperative software-hardware techniques,” inProceedings of the 2022 ACM International Conference on Architectural Support for Programming Lan...

    2022

  26. [34]

    Graphiler: Optimizing graph neural networks with message passing data flow graph,

    Z. Xie, M. Wang, Z. Ye, Z. Zhang, and R. Fan, “Graphiler: Optimizing graph neural networks with message passing data flow graph,” in Proceedings of the 2022 Machine Learning and Systems Conference (MLSys ’22), 2022. Preprint – Efficient Mixed Precision Quantization in Graph Ne...

    2022

  27. [35]

    Rubik: A hierarchical architecture for efficient graph neural network training,

    X. Chen, Y . Wang, X. Xie, X. Hu, A. Basak, L. Liang, M. Yan, L. Deng, Y . Ding, Z. Du, and Y . Xie, “Rubik: A hierarchical architecture for efficient graph neural network training,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 2022

    2022

  28. [36]

    A unified lottery ticket hypothesis for graph neural networks,

    T. Chen, Y . Sui, X. Chen, A. Zhang, and Z. Wang, “A unified lottery ticket hypothesis for graph neural networks,” in Proceedings of the 38th International Conference on Machine Learning (ICML 2021), 2021

    2021

  29. [37]

    Comprehensive graph gradual prun- ing for sparse training in graph neural networks,

    C. Liu, X. Ma, Y . Zhan, L. Ding, D. Tao, B. Du, W. Hu, and D. P. Mandic, “Comprehensive graph gradual prun- ing for sparse training in graph neural networks,” IEEE Transactions on Neural Networks and Learning Systems, 2022

    2022

  30. [38]

    GraphSAINT: Graph sampling based induc- tive learning method,

    H. Zeng, H. Zhou, A. Srivastava, R. Kannan, and V . Prasanna, “GraphSAINT: Graph sampling based induc- tive learning method,” in Proceedings of the International Conference on Learning Representations (ICLR 2020) , 2020

    2020

  31. [39]

    GNNAutoScale: Scalable and expressive graph neural networks via historical embeddings,

    M. Fey, J. E. Lenssen, F. Weichert, and J. Leskovec, “GNNAutoScale: Scalable and expressive graph neural networks via historical embeddings,” in Proceedings of the 38th International Conference on Machine Learning (ICML 2021), 2021

    2021

  32. [40]

    Vq-gnn: A universal framework to scale up graph neural networks using vector quantization,

    M. Ding, K. Kong, J. Li, C. Zhu, J. P. Dickerson, F. Huang, and T. Goldstein, “Vq-gnn: A universal framework to scale up graph neural networks using vector quantization,” in Proceedings of the 35th International Conference on Neural Information Processing Systems (NeurIPS 2021), 2021

    2021

  33. [41]

    Epquant: A graph neural network compression approach based on product quantization,

    L. Huang, Z. Zhang, Z. Du, S. Li, H. Zheng, Y . Xie, and N. Tan, “Epquant: A graph neural network compression approach based on product quantization,”Neurocomputing, 2022

    2022

  34. [42]

    Sgquant: Squeezing the last bit on graph neural networks with specialized quantization,

    B. Feng, Y . Wang, X. Li, S. Yang, X. Peng, and Y . Ding, “Sgquant: Squeezing the last bit on graph neural networks with specialized quantization,” in Proceedings of the 2020 IEEE 32nd International Conference on Tools with Artifi- cial Intelligence (ICTAI), 2020

    2020

  35. [43]

    Graph neural architecture search,

    Y . Gao, H. Yang, P. Zhang, C. Zhou, and Y . Hu, “Graph neural architecture search,” in Proceedings of the 29th International Joint Conference on Artificial Intelligence (IJCAI ’20), 2020

    2020

  36. [44]

    Graphnas++: Distributed architecture search for graph neural networks,

    Y . Gao, P. Zhang, H. Yang, C. Zhou, Z. Tian, Y . Hu, Z. Li, and J. Zhou, “Graphnas++: Distributed architecture search for graph neural networks,” IEEE Transactions on Knowl- edge and Data Engineering, 2023

    2023

  37. [45]

    Distilling knowledge from graph convolutional networks,

    Y . Yang, J. Qiu, M. Song, D. Tao, and X. Wang, “Distilling knowledge from graph convolutional networks,” in Pro- ceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR 2020), 2020

    2020

  38. [46]

    Graph-less neural networks: Teaching old MLPs new tricks via distillation,

    S. Zhang, Y . Liu, Y . Sun, and N. Shah, “Graph-less neural networks: Teaching old MLPs new tricks via distillation,” in Proceedings of the International Conference on Learn- ing Representations (ICLR 2022), 2022

    2022

  39. [47]

    Exponentially improving the complexity of simulating the weisfeiler- lehman test with graph neural networks,

    A. Aamand, J. Y . Chen, P. Indyk, S. Narayanan, R. Rubin- feld, N. Schiefer, S. Silwal, and T. Wagner, “Exponentially improving the complexity of simulating the weisfeiler- lehman test with graph neural networks,” in Proceedings of the 36th International Conference on Neural I...

    2022

  40. [48]

    Meta- aggregator: Learning to aggregate for 1-bit graph neural networks,

    Y . Jing, Y . Yang, X. Wang, M. Song, and D. Tao, “Meta- aggregator: Learning to aggregate for 1-bit graph neural networks,” in Proceedings of the 2021 IEEE/CVF Interna- tional Conference on Computer Vision (ICCV), 2021

    2021

  41. [49]

    Binarized graph neural network,

    H. Wang, D. Lian, Y . Zhang, L. Qin, X. He, Y . Lin, and X. Lin, “Binarized graph neural network,” World Wide Web, 2020

    2020

  42. [50]

    Binary graph neural networks,

    M. Bahri, G. Bahl, and S. Zafeiriou, “Binary graph neural networks,” in Proceedings of the 2020 IEEE/CVF Confer- ence on Computer Vision and Pattern Recognition (CVPR), 2020

    2020

  43. [51]

    MEGA: A memory-efficient GNN accelerator exploiting degree-aware mixed-precision quantization,

    Z. Zhu, F. Li, G. Li, Z. Liu, Z. Mo, Q. Hu, X. Liang, and J. Cheng, “MEGA: A memory-efficient GNN accelerator exploiting degree-aware mixed-precision quantization,” in Proceedings of the 2024 IEEE International Symposium on High-Performance Computer Architecture (HPCA), 2024

    2024

  44. [52]

    DARTS: Differen- tiable architecture search,

    H. Liu, K. Simonyan, and Y . Yang, “DARTS: Differen- tiable architecture search,” in Proceedings of the Inter- national Conference on Learning Representations (ICLR 2019), 2019

    2019

  45. [53]

    Rethinking di fferentiable search for mixed-precision neural networks,

    Z. Cai and N. Vasconcelos, “Rethinking di fferentiable search for mixed-precision neural networks,” in Proceed- ings of the 2020 IEEE/CVF Conference on Computer Vi- sion and Pattern Recognition (CVPR), 2020

    2020

  46. [54]

    One-shot model for mixed-precision quan- tization,

    I. Koryakovskiy, A. Yakovleva, V . Buchnev, T. Isaev, and G. Odinokikh, “One-shot model for mixed-precision quan- tization,” in Proceedings of the 2023 IEEE/CVF Confer- ence on Computer Vision and Pattern Recognition (CVPR), 2023

    2023

  47. [55]

    Sparse GPU kernels for deep learning,

    T. Gale, M. Zaharia, C. Young, and E. Elsen, “Sparse GPU kernels for deep learning,” in SC20: International Conference for High Performance Computing, Networking, Storage and Analysis, 2020

    2020

  48. [56]

    Efficient quantized sparse matrix operations on tensor cores,

    S. Li, K. Osawa, and T. Hoefler, “Efficient quantized sparse matrix operations on tensor cores,” in Proceedings of the International Conference for High Performance Comput- ing, Networking, Storage and Analysis (SC ’22), 2022

    2022

  49. [57]

    QGTC: Accelerating quantized graph neural networks via GPU tensor core,

    Y . Wang, B. Feng, and Y . Ding, “QGTC: Accelerating quantized graph neural networks via GPU tensor core,” in Proceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’22), 2022

    2022

  50. [58]

    Pytorch 2: Faster ma- chine learning through dynamic Python bytecode transfor- mation and graph compilation,

    J. Ansel, E. Yang, H. He, N. Gimelshein, A. Jain, M. V oznesensky, B. Bao, P. Bell, D. Berard, E. Burovski, G. Chauhan, A. Chourdia, W. Constable, A. Desmaison, Z. DeVito, E. Ellison, W. Feng, J. Gong, M. Gschwind, B. Hirsh, S. Huang, K. Kalambarkar, L. Kirsch, M. Lazos, M. Le...

    2024

  51. [59]

    SDQ: Stochastic di fferen- tiable quantization with mixed precision,

    X. Huang, Z. Shen, S. Li, Z. Liu, X. Hu, J. Wicaksana, E. Xing, and K.-T. Cheng, “SDQ: Stochastic di fferen- tiable quantization with mixed precision,” in Proceedings of the 39th International Conference on Machine Learning (ICML 2022), PMLR, 2022

    2022

  52. [60]

    Bayesian bits: Unifying quantization and pruning,

    M. van Baalen, C. Louizos, M. Nagel, R. A. Amjad, Y . Wang, T. Blankevoort, and M. Welling, “Bayesian bits: Unifying quantization and pruning,” in Proceedings of the 34th International Conference on Neural Information Processing Systems (NeurIPS 2020), 2020

    2020

  53. [61]

    Searching for low-bit weights in quantized neural networks,

    Z. Yang, Y . Wang, K. Han, C. Xu, C. Xu, D. Tao, and C. Xu, “Searching for low-bit weights in quantized neural networks,” inProceedings of the 34th International Confer- ence on Neural Information Processing Systems (NeurIPS 2020), 2020

    2020

  54. [62]

    AMD EPYC ™ 9534 Processor,

    Advanced Micro Devices, Inc. (AMD), “AMD EPYC ™ 9534 Processor,” 2024

    2024

  55. [63]

    Arm Limited, Arm Architecture Reference Manual for A- profile Architecture, 2024

    2024

  56. [64]

    Bisong, Google Colaboratory

    E. Bisong, Google Colaboratory. Apress, 2019

    2019

  57. [65]

    Revisiting semi-supervised learning with graph embeddings,

    Z. Yang, W. W. Cohen, and R. Salakhutdinov, “Revisiting semi-supervised learning with graph embeddings,” in Pro- ceedings of the 33rd International Conference on Machine Learning (ICML 2016), 2016

    2016

  58. [66]

    Open graph benchmark: Datasets for machine learning on graphs,

    W. Hu, M. Fey, M. Zitnik, Y . Dong, H. Ren, B. Liu, M. Catasta, and J. Leskovec, “Open graph benchmark: Datasets for machine learning on graphs,” in Proceedings of the 34th International Conference on Neural Informa- tion Processing Systems (NeurIPS 2020), 2020

    2020

  59. [67]

    Igb: Addressing the gaps in labeling, features, heterogeneity, and size of public graph datasets for deep learning research,

    A. Khatua, V . S. Mailthody, B. Taleka, T. Ma, X. Song, and W.-m. Hwu, “Igb: Addressing the gaps in labeling, features, heterogeneity, and size of public graph datasets for deep learning research,” in Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Dat...

    2023

  60. [68]

    Rela- tional pooling for graph representations,

    R. Murphy, B. Srinivasan, V . Rao, and B. Ribeiro, “Rela- tional pooling for graph representations,” in Proceedings of the 36th International Conference on Machine Learning (ICML 2019), 2019

    2019

  61. [69]

    TUDataset: A collection of benchmark datasets for learning with graphs,

    C. Morris, N. M. Kriege, F. Bause, K. Kersting, P. Mutzel, and M. Neumann, “TUDataset: A collection of benchmark datasets for learning with graphs,” in Proceedings of the ICML 2020 Workshop on Graph Representation Learning and Beyond (GRL+ 2020), 2020

    2020

  62. [70]

    Low-bit quantization for deep graph neural networks with smoothness-aware message propagation,

    S. Wang, B. Eravci, R. Guliyev, and H. Ferhatosmanoglu, “Low-bit quantization for deep graph neural networks with smoothness-aware message propagation,” in Proceedings of the 32nd ACM International Conference on Information and Knowledge Management (CIKM ’23), ACM, 2023

    2023

  63. [71]

    Benchmarking graph neural networks,

    V . P. Dwivedi, C. K. Joshi, A. T. Luu, T. Laurent, Y . Bengio, and X. Bresson, “Benchmarking graph neural networks,” Journal of Machine Learning Research (JMLR), 2023

    2023

Pith tools

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