Pith. sign in

REVIEW 4 major objections 6 minor 38 references

DeVIT: Low-Power Vision Transformer Acceleration Using Delta Computation

T0 review · 4 major / 6 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 DeVIT turns every dense linear layer of a vision transformer into shift-add plus reuse over delta-encoded weights, lowering normalized computation load to 0.53 and single-GEMM energy to 159.57 nJ.

desk verdict Delta-computation for ViT GEMMs is a plausible idea with honest accuracy reporting, but the multiplier-less claim and headline efficiency numbers rest on an unspecified head-product multiply. read the letter →

arxiv 2608.01343 v1 pith:34QAAJRI submitted 2026-08-02 cs.CV cs.AIcs.AR

Reyhaneh Hosseinzadeh , Parham Zilouchian Moghaddam , Mehdi Modarressi This is my paper
classification cs.CVcs.AIcs.AR
keywords visiontransformerdeltacomputationreuseshift-and-addlow-powerinferencequantizationhardwareacceleratormultiplier-lessmatrixmultiplication
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

DeVIT claims that the dense linear layers of vision transformers—the projections that form queries, keys, and values, the output projection, and the feed-forward network—can be computed without hardware multipliers. The idea is to sort each row of a quantized weight matrix, encode the gaps between neighboring weights as deltas, and reuse each partial product for every later weight in that row: a new product equals the previous product plus the input times the delta. Because low-bit quantization makes most deltas zero or tiny, the update is a shift-and-add or a copy, so matrix multiplication becomes reuse plus shifts instead of multiplications. On four transformer backbones the paper measures normalized computation load 0.53 versus an unoptimized baseline and single-GEMM energy 159.57 nJ, about 5.5% below the lowest-energy shift-add configuration in its comparison. The trade-off is controlled by partition size, which balances reuse against output-buffer size, index width, and a small accuracy loss.

What carries the argument

The mechanism is delta-coded sorted weight rows with input-stationary reuse. For an input element $a$ and a sorted row of weights $w_1 < w_2 < \cdots$, the recurrence $a w_{i+1} = a w_i + a \Delta w$ replaces each fresh multiplication with one shift-and-add of the previous product, and a zero delta means no computation at all. The 4-bit delta code and per-weight destination index are what let the datapath recover original output positions and keep index bandwidth low.

What would settle it

Inspect or synthesize the 15 nm datapath's row-head path: if the first product in each sorted row is implemented with a standard multiplier, or if a shift-add surrogate for it costs as much as one multiply-accumulate, the multiplier-less matrix-multiplication claim and the 159.57 nJ energy figure do not hold as stated. A second check: compare accuracy with exact deltas versus the power-of-two/saturated deltas; if the approximation changes accuracy by more than the reported accuracy gaps, the approximation is the source of the loss.

Watch

Extended reading notes

Core claim

The paper's central claim is that a fixed, quantized weight row can be processed in sorted order under input-stationary execution, so every multiplication by a later weight reuses the earlier product and only pays for the difference between neighboring weights. Deltas are stored with a 4-bit code (sign plus 3-bit magnitude) that represents zero and the powers of two 1, 2, 4, 8, with larger deltas saturated to 8. Each nonzero step is therefore a shift of the input followed by an addition, and zero deltas reuse the running product at no arithmetic cost. Destination indices carry each partial product to its original output column after sorting, and partitioning the weight rows into 64- or 32-el

Load-bearing premise

The load-bearing premise is that the first product in each sorted row—the input element times the smallest weight—is produced without a conventional multiplier, yet the paper never says what hardware computes that head product.

Editorial extensions

If this is right

  • Every dense linear layer in a ViT (query/key/value projections, output projection, and feed-forward network) can run through the same delta-coded datapath, so the gain is not confined to attention and scales with the GEMM-dominated part of the model.
  • The method is orthogonal to token-level pruning and merging; it changes only the weight representation and execution order, so those sparsification techniques can be stacked on top.
  • The 16-element partition encodes each weight in the same number of bits as 8-bit quantization, so a multiplier-free datapath can be obtained at no per-weight storage overhead, while 64-element partitioning adds 2 bits per weight (25% more than the 8-bit baseline).
  • Because buffer writes and reads dominate the 159.57 nJ energy total (70.78 and 31.46 nJ, versus 57.33 nJ compute), further energy gains would have to come from shrinking the partial-product buffer, not from additional arithmetic savings.
  • Accuracy stays within roughly one to three points of FP32; the largest measured drops define the current approximation scheme's practical limit, and partition size is a usable accuracy-energy knob.

Reading between the lines

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

  • An implication the paper leaves implicit: the same delta-coded, input-stationary GEMM should transfer to any transformer or large language model whose linear layers are compute-bound, provided their quantized weight rows show a similarly zero-heavy delta distribution.
  • A testable extension: deliberately increase the zero-delta fraction by grouping or re-quantizing similar weights before encoding, then measure how DeVIT's cycle count and energy fall with delta sparsity; the paper reports the distributions but does not optimize them.
  • The per-GEMM energy comparison does not include the offline sort-and-encode step or the cost of index-based routing at system level, so an end-to-end deployment study would be the real test of whether the 5.5% advantage over the shift-add baseline survives.
  • The saturation of deltas above 8 is a systematic rounding bias; a per-row compensation term or a wider delta code for the heavy-tailed feed-forward matrices might recover part of the accuracy loss at modest cost.
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 / 6 minor

Summary. The paper proposes DeVIT, a hardware-oriented acceleration scheme for vision transformer linear layers. Weight rows are sorted, quantized, and stored as delta values; with an input-stationary dataflow, products for subsequent weights are obtained by shift-add operations on power-of-two deltas rather than by full multipliers. The authors evaluate ViT-B/16, DeiT, Swin, and DETR after 8-bit quantization, reporting accuracy loss that is often small, a normalized computation load of 0.53 relative to an unoptimized baseline, and a single-GEMM energy of 159.57 nJ, about 5.5% lower than the lowest-energy ShiftAddLLM configuration. The paper includes a synthesis-oriented architecture description, delta-distribution analysis, and partition-size tradeoffs.

Significance. If the efficiency results were fully supported, DeVIT would be a useful contribution to algorithm-hardware co-design for ViTs: it extends delta-computation reuse from CNNs to transformer dense layers, provides a plausible shift-add datapath, quantifies delta distributions across real ViT weights, and reports synthesized energy at 15 nm. The central claims, however, are not yet substantiated. The initial product in each sorted row is unaccounted for, the normalized-load metric is undefined, the cycle-count formulas are inconsistent, and the ShiftAddLLM energy comparison appears to reuse literature numbers. These issues bear directly on the advertised 0.53 load and 5.5% energy advantage, so the contribution cannot be assessed in its current form.

major comments (4)
  1. [Section V, Eq. (1), Fig. 5] The datapath for the first product in each sorted row/block is never specified. The delta recurrence a×W_{p+1}=a×W_p+a×ΔW only covers updates after the head; the head product a×W_min is not a power-of-two-scaled delta and cannot be produced by the shift-add unit for magnitudes {0,1,2,4,8}. If a conventional multiplier is used, the abstract's 'multiplier-less matrix multiplication' is false. If constant-coefficient shift-adds over the binary expansion of W_min are used, each head costs about popcount(W_min) shift-adds (average ~4 for 8-bit weights), adding roughly 4/S to the normalized load—about 6% for S=64 and 25% for S=16. No such cost appears in the reported 0.53 load or the 57.33 nJ arithmetic energy. Specify the head-product datapath and re-derive all efficiency numbers with its cost included.
  2. [Section VII.C, Fig. 7] 'Normalized computation load' is never defined. The paper does not state whether the baseline counts full-precision MACs, whether DeVIT counts shift-adds and adds separately, whether zero-delta reuse and output-buffer writes are included, or how the head-product overhead is treated. Without a precise counting convention, the 0.53 figure and the FACT comparison are not verifiable. Please define the metric and provide the per-component counts used to produce Fig. 7.
  3. [Section V, cycle formulas] The two cycle-count formulas are inconsistent. The unpartitioned text gives cycles per input row as (M/K)×M, which is the total for an M×M weight matrix. The partitioned formula is given as (M/K)×S, which is only the per-partition cost and is missing the factor M/S for the number of partitions (equivalently, the unpartitioned formula is not the S=1 limit of the partitioned one). The notation K also shifts between 'weight entries processed in parallel' and 'batch size'. Please provide a single, dimensionally consistent cycle model.
  4. [Section VII.D, Fig. 8] The energy comparison with ShiftAddLLM is not based on a same-flow reimplementation. The manuscript does not state whether the ShiftAddLLM numbers are taken from [30] or produced in the same 15 nm RTL flow with the same buffer, read/write, and arithmetic models. Because the claimed 5.5% advantage is a headline result, please re-evaluate ShiftAddLLM under identical assumptions, or clearly report the provenance and state the comparability caveats.
minor comments (6)
  1. [Section V] K is used both as the number of weight entries processed in parallel and as the batch size; disambiguate these (e.g., K_w and K_b).
  2. [Section VI] The codebook {0,1,2,4,8} has no code for deltas 3,5,6,7; describe the rounding rule (nearest power of two? floor? saturation) and whether the same rule applies to negative deltas.
  3. [Section VII.B, Table II] The text says 'most reported score changes are below one percentage point.' This is true for ViT and DeiT, but Swin Δ-64 drops 2.88 points and DETR Δ-64 drops 2.14 points, so the sentence should be qualified.
  4. [Fig. 8] The label 'S-Add* 1-bit' is unclear: define the asterisk and state whether 1-bit refers to the additive weight bit-width in ShiftAddLLM.
  5. [Figs. 3 and 4] Explain how the '>8' deltas are handled in the computation-load and energy models (saturated to 8? clipped to the nearest representable code?) and whether the accuracy results account for this saturation.
  6. [Table II] INT8 Swin Top-1 (83.15) exceeds the FP32 value (82.92); this unusual inversion should be discussed or the evaluation protocol clarified.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: DeVIT's load/energy numbers are measurements, not derivations, and the head-product gap is an omission, not a self-referential reduction.

full rationale

I walked the derivation chain. DeVIT's method is a delta-encoding computation-reuse scheme adapted from the authors' prior DeltaNN work; the paper explicitly credits [10] and other prior work, and the transformer-specific contribution is described with its own dataflow, partitioning, index encoding, RTL synthesis, and measured accuracy/energy. No equation in the paper is defined in terms of its target claim. The normalized load 0.53 and energy 159.57 nJ are reported measurements of a synthesized implementation, not quantities fitted to reproduce those numbers. The power-of-two codebook and partition sizes are design parameters reported as swept configurations, not parameters fit to a target. The only questionable step is the unstated implementation of the initial product a×W_min at the head of each sorted row/block: Section V says computations 'begin by multiplying the input element by the smallest weight in the row,' and Eq. (1) only covers subsequent deltas. That is a real accounting/completeness issue that could affect the multiplier-less claim and the load/energy totals, but it is not a circular reduction: no result is equivalent by construction to its input, and no load-bearing argument rests solely on a self-citation. Therefore no circularity step is scored.

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

The central efficiency claims depend on the measured delta distribution (an empirical property of quantized weights), an unreported quantizer, an unreported parallel-lane width K, and a synthesis flow whose comparability to the ShiftAddLLM baseline is not established. These are pulled in from the implementation rather than derived.

free parameters (4)
  • Partition size S = 64 (headline); 32 and 16 also evaluated
    Controls trade-off among reuse, index width, buffer capacity, and accuracy. The reported 0.53 compute load and 159.57 nJ energy are single operating points; the paper does not explicitly state which S corresponds to the headline numbers.
  • Delta magnitude codebook = {0,1,2,4,8} with saturation at 8
    3-bit magnitude plus sign. Values greater than 8 are clamped to 8. This fixed codebook trades accuracy for shift-only deltas; its effect is reported only as end-model accuracy.
  • 8-bit weight quantization scheme = unreported
    The paper says weights were quantized to 8 bits but does not give the quantizer details (clipping range, per-layer vs per-tensor). The large INT8 accuracy spread across models suggests the quantizer matters, and DeVIT's comparison depends on it.
  • Parallel lanes K (batch in cycle formula) = unreported
    The cycle formulas use K as a parallel-processing width, but the paper never gives its value for the reported energy or compute numbers, so the reader cannot check the 0.53 reduction or the cycle counts.
assumptions (4)
  • standard math Addition is commutative and associative, so sorting weights in a row and accumulating partial products by destination index yields the same output as the original GEMM when deltas are exact.
    Section IV relies on this to justify reordering weights. Exact only for exact deltas; the power-of-two approximation introduces the measured error.
  • domain assumption After 8-bit quantization, quantized weights in a row exhibit value locality such that sorted deltas are mostly 0 or small powers of two.
    Empirically shown for ViT-B/16 (Figs. 3, 4) but assumed to hold for other models; the compute reduction (0.53) is derived from this distribution.
  • ad hoc to paper The first (minimum) weight product in each sorted row is either computed by a conventional multiplier or by a shift-add decomposition not described; in either case its cost is included in the energy and compute model.
    Section V says 'Computations begin by multiplying the input element by the smallest weight'. The paper does not detail this datapath, so the multiplier-less claim and energy numbers assume it is cheap or absent.
  • domain assumption The Synopsys Design Compiler 15nm synthesis flow and the buffer model yield energy figures comparable to the published ShiftAddLLM results.
    Section VII-D compares energy against ShiftAddLLM configurations from [30] without stating whether ShiftAddLLM was re-synthesized in the same flow or technology.

how reviews work

0 comments
Cite this review

Pith. "Pith review of DeVIT: Low-Power Vision Transformer Acceleration Using Delta Computation." pith.science (2026). https://pith.science/paper/34QAAJRI

@misc{pith2026260801343,
  author       = {Pith},
  title        = {Pith review of: DeVIT: Low-Power Vision Transformer Acceleration Using Delta Computation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/34QAAJRI}},
  note         = {Machine review of arXiv:2608.01343}
}
read the original abstract

The emergence of transformer-based deep learning models has brought unprecedented performance across various domains, particularly in natural language processing and computer vision. However, deploying these models, especially on resource-constrained devices, poses significant challenges due to their high computational complexity and large memory size and bandwidth requirements. This complexity has led researchers to use low-bit model weights to reduce memory usage and improve efficiency. In addition to reducing processing and memory demands, quantization introduces another useful property: value locality, where the extremely large number of parameters are restricted to a limited range of values. To fully take advantage of this locality, this paper presents DeVIT, an acceleration method for vision transformers that leverages differential computation to enable multiplier-less matrix multiplication.

Figures

Figures reproduced from arXiv: 2608.01343 by the authors.

Figure 1
Figure 1. MAC breakdown of ViT-B/16 at two input resolutions: (a) per encoder [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The general architecture of multi-head self-attention and input [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Delta distribution of the QKV and output projection weights ( [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Delta distribution of the FFN weights (Wfc1, Wfc2) of ViT-B/16, averaged over all 12 encoder layers: (a) unpartitioned, (b) 64-element partitions, and (c) 16-element partitions. than the original matrix; potentially decreases power consump￾tion due to the reduced buffe…
Figure 5
Figure 5. Figure 5: The unpartitioned DeVIT core: delta-encoded weights and their index [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 7
Figure 7. Figure 7: Normalized ViT computation load for DeVIT and the three FACT [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: Single-GEMM energy breakdown for DeVIT and ShiftAddLLM (S [PITH_FULL_IMAGE:figures/full_fig_p007_8.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

38 extracted references · 30 canonical work pages

  1. [30]

    ShiftAddLLM: Accelerating pretrained LLMs via post-training multiplication-less reparameterization,

    H. You, Y . Guo, Y . Fu, W. Zhou, H. Shi, X. Zhang, S. Kundu, A. Yazdan- bakhsh, and Y . C. Lin, “ShiftAddLLM: Accelerating pretrained LLMs via post-training multiplication-less reparameterization,”arXiv preprint arXiv:2406.05981, 2024

    arXiv 2024

  2. [1]

    An image is worth 16x16 words: Transformers for image recognition at scale,

    A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gellyet al., “An image is worth 16x16 words: Transformers for image recognition at scale,”arXiv preprint arXiv:2010.11929, 2020

    arXiv 2010

  3. [2]

    End-to-end object detection with transformers,

    N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko, “End-to-end object detection with transformers,” in European Conference on Computer Vision (ECCV). Springer, 2020, pp. 213–229

    2020

  4. [3]

    Swin transformer: Hierarchical vision transformer using shifted windows,

    Z. Liu, Y . Lin, Y . Cao, H. Hu, Y . Wei, Z. Zhang, S. Lin, and B. Guo, “Swin transformer: Hierarchical vision transformer using shifted windows,” in2021 IEEE/CVF International Conference on Computer Vision (ICCV), 2021, pp. 9992–10 002

    2021

  5. [4]

    Similarity-guided layer-adaptive vision transformer for UA V tracking,

    C. Xue, B. Zhong, Q. Liang, Y . Zheng, N. Li, Y . Xue, and S. Song, “Similarity-guided layer-adaptive vision transformer for UA V tracking,” inProceedings of the Computer Vision and Pattern Recognition Confer- ence, 2025, pp. 6730–6740

    work page 2025

  6. [5]

    Stream-ViT: learning streamlined convolutions in vision transformer,

    Y . Pan, Y . Li, T. Yao, C.-W. Ngo, and T. Mei, “Stream-ViT: learning streamlined convolutions in vision transformer,”IEEE Transactions on Multimedia, vol. 27, pp. 3755–3765, 2025

    work page 2025

  7. [6]

    Daneshtalab and M

    M. Daneshtalab and M. Modarressi, Eds.,Hardware Architectures for Deep Learning. Institution of Engineering and Technology, 2020

    work page 2020

  8. [7]

    PTQ4ViT: Post-training quantization for vision transformers with twin uniform quantization,

    Z. Yuan, C. Xue, Y . Chen, Q. Wu, and G. Sun, “PTQ4ViT: Post-training quantization for vision transformers with twin uniform quantization,” in European Conference on Computer Vision (ECCV). Springer, 2022, pp. 191–207

    work page 2022

Show all 38 references
  1. [8]

    I-ViT: Integer-only quantization for efficient vision transformer inference,

    Z. Li and Q. Gu, “I-ViT: Integer-only quantization for efficient vision transformer inference,” inProceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2023, pp. 17 065–17 075

    2023

  2. [9]

    Q-ViT: Fully differentiable quantization for vision transformer,

    Z. Li, T. Yang, P. Wang, and J. Cheng, “Q-ViT: Fully differentiable quantization for vision transformer,”arXiv preprint arXiv:2201.07703, 2022

    2022 arXiv

  3. [10]

    ∆NN: Power-efficient neural network acceleration using differential weights,

    H. Mahdiani, A. Khadem, A. Ghanbari, M. Modarressi, F. Fattahi-Bayat, and M. Daneshtalab, “∆NN: Power-efficient neural network acceleration using differential weights,”IEEE Micro, vol. 40, no. 1, pp. 67–74, 2019

    2019

  4. [11]

    Energy-efficient acceleration of con- volutional neural networks using computation reuse,

    A. Ghanbari and M. Modarressi, “Energy-efficient acceleration of con- volutional neural networks using computation reuse,”Journal of Systems Architecture, vol. 126, p. 102490, 2022

    2022

  5. [12]

    Power-efficient accelerator design for neural networks using computation reuse,

    A. Yasoubi, R. Hojabr, and M. Modarressi, “Power-efficient accelerator design for neural networks using computation reuse,”IEEE Computer Architecture Letters, vol. 16, no. 1, pp. 72–75, 2016

    2016

  6. [13]

    UCNN: Exploiting computational reuse in deep neural networks via weight repetition,

    K. Hegde, J. Yu, R. Agrawal, M. Yan, M. Pellauer, and C. Fletcher, “UCNN: Exploiting computational reuse in deep neural networks via weight repetition,” in2018 ACM/IEEE 45th Annual International Sym- posium on Computer Architecture (ISCA). IEEE, 2018, pp. 674–687

    2018

  7. [14]

    ReMove: Leveraging motion estimation for computation reuse in CNN-based video processing,

    M. Khodarahmi, M. Modarressi, A. Elahi, and F. Pakdaman, “ReMove: Leveraging motion estimation for computation reuse in CNN-based video processing,” in2024 5th CPSSI International Symposium on Cyber-Physical Systems (Applications and Theory) (CPSAT). IEEE, 2024, pp. 1–7

    2024

  8. [15]

    SkippyNN: An embedded stochastic- computing accelerator for convolutional neural networks,

    R. Hojabr, K. Givaki, S. M. R. Tayaranian, P. Esfahanian, A. Khonsari, D. Rahmati, and M. H. Najafi, “SkippyNN: An embedded stochastic- computing accelerator for convolutional neural networks,” inProceed- ings of the 56th Annual Design Automation Conference (DAC), 2019, pp. 1–6

    2019

  9. [16]

    Computation reuse in DNNs by exploiting input similarity,

    M. Riera, J.-M. Arnau, and A. Gonz ´alez, “Computation reuse in DNNs by exploiting input similarity,” in2018 ACM/IEEE 45th Annual Inter- national Symposium on Computer Architecture (ISCA). IEEE, 2018, pp. 57–68

    2018

  10. [17]

    SIRENA: Sparsity-repetition aware nibble- based hardware accelerator for convolutional neural networks,

    L. Medina and J. Flich, “SIRENA: Sparsity-repetition aware nibble- based hardware accelerator for convolutional neural networks,”Journal of Systems Architecture, p. 103529, 2025

    2025

  11. [18]

    DeltaRNN: A power-efficient recurrent neural network accelerator,

    C. Gao, D. Neil, E. Ceolini, S.-C. Liu, and T. Delbruck, “DeltaRNN: A power-efficient recurrent neural network accelerator,” inProceedings of the 2018 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, 2018, pp. 21–30

    2018

  12. [19]

    Low-power online ECG analysis using neural networks,

    M. Modarressi, A. Yasoubi, and M. Modarressi, “Low-power online ECG analysis using neural networks,” in2016 Euromicro Conference on Digital System Design (DSD). IEEE, 2016, pp. 547–552

    2016

  13. [20]

    Training data-efficient image transformers & distillation through attention,

    H. Touvron, M. Cord, M. Douze, F. Massa, A. Sablayrolles, and H. J ´egou, “Training data-efficient image transformers & distillation through attention,” inInternational Conference on Machine Learning (ICML). PMLR, 2021, pp. 10 347–10 357

    2021

  14. [21]

    Low power vision transformer accelera- tor with hardware-aware pruning and optimized dataflow,

    C.-L. Hsiung and T.-S. Chang, “Low power vision transformer accelera- tor with hardware-aware pruning and optimized dataflow,”arXiv preprint arXiv:2510.14393, 2025

    2025 arXiv

  15. [22]

    RePaViT: Scalable vision transformer acceleration via structural reparameterization on feedforward network layers,

    X. Xu, Y . Li, Y . Chen, J. Liu, and S. Wang, “RePaViT: Scalable vision transformer acceleration via structural reparameterization on feedforward network layers,”arXiv preprint arXiv:2505.21847, 2025

    2025 arXiv

  16. [23]

    DynamicViT: Efficient vision transformers with dynamic token sparsification,

    Y . Rao, W. Zhao, B. Liu, J. Lu, J. Zhou, and C.-J. Hsieh, “DynamicViT: Efficient vision transformers with dynamic token sparsification,” in Advances in Neural Information Processing Systems (NeurIPS), 2021

    2021

  17. [24]

    Token merging: Your ViT but faster,

    D. Bolya, C.-Y . Fu, X. Dai, P. Zhang, C. Feichtenhofer, and J. Hoffman, “Token merging: Your ViT but faster,” inInternational Conference on Learning Representations (ICLR), 2023

    2023

  18. [25]

    ViTCoD: Vision transformer acceleration via dedicated algo- rithm and accelerator co-design,

    H. You, Z. Sun, H. Shi, Z. Yu, Y . Zhao, Y . Zhang, C. Li, B. Li, and Y . Lin, “ViTCoD: Vision transformer acceleration via dedicated algo- rithm and accelerator co-design,” in2023 IEEE International Symposium on High-Performance Computer Architecture (HPCA), 2023, pp. 273– 286

    2023

  19. [26]

    HeatViT: Hardware-efficient adaptive token pruning for vision transformers,

    P. Dong, M. Sun, A. Lu, Y . Xie, K. Liu, Z. Kong, X. Meng, Z. Li, X. Lin, Z. Fang, and Y . Wang, “HeatViT: Hardware-efficient adaptive token pruning for vision transformers,” in2023 IEEE International Symposium on High-Performance Computer Architecture (HPCA), 2023, pp. 442– 455

    2023

  20. [27]

    Progressive gradient flow for robust N:M sparsity training in transformers,

    A. R. Bambhaniya, A. Yazdanbakhsh, S. Subramanian, S.-C. Kao, S. Agrawal, U. Evci, and T. Krishna, “Progressive gradient flow for robust N:M sparsity training in transformers,”arXiv preprint arXiv:2402.04744, 2024

    2024 arXiv

  21. [28]

    An algorithm-hardware co-optimized framework for accelerating N:M sparse transformers,

    C. Fang, A. Zhou, and Z. Wang, “An algorithm-hardware co-optimized framework for accelerating N:M sparse transformers,”IEEE Transac- tions on Very Large Scale Integration (VLSI) Systems, vol. 30, no. 11, pp. 1573–1586, 2022

    2022

  22. [29]

    ShiftAddViT: Mixture of multi- plication primitives towards efficient vision transformer,

    H. You, H. Shi, Y . Guo, and Y . Lin, “ShiftAddViT: Mixture of multi- plication primitives towards efficient vision transformer,”Advances in Neural Information Processing Systems, vol. 36, 2024

    2024

  23. [31]

    LUT tensor core: A software-hardware co-design for LUT-based low-bit LLM inference,

    Z. Mo, L. Wang, J. Wei, Z. Zeng, S. Cao, L. Ma, N. Jing, T. Cao, J. Xue, F. Yanget al., “LUT tensor core: A software-hardware co-design for LUT-based low-bit LLM inference,” inProceedings of the 52nd Annual International Symposium on Computer Architecture (ISCA), 2025, pp. 514–528

    2025

  24. [32]

    ShiftAddNet: A hardware-inspired deep network,

    H. You, X. Chen, Y . Zhang, C. Li, S. Li, Z. Liu, Z. Wang, and Y . Lin, “ShiftAddNet: A hardware-inspired deep network,” inAdvances in Neural Information Processing Systems (NeurIPS), vol. 33, 2020, pp. 2771–2783

    2020

  25. [33]

    AccelTran: A sparsity-aware accelerator for dynamic inference with transformers,

    S. Tuli and N. K. Jha, “AccelTran: A sparsity-aware accelerator for dynamic inference with transformers,”IEEE Transactions on Computer- Aided Design of Integrated Circuits and Systems, vol. 42, no. 11, pp. 4038–4051, 2023

    2023

  26. [34]

    FACT: FFN-attention co-optimized transformer architecture with eager correlation prediction,

    Y . Qin, Y . Wang, D. Deng, Z. Zhao, X. Yang, L. Liu, S. Wei, Y . Hu, and S. Yin, “FACT: FFN-attention co-optimized transformer architecture with eager correlation prediction,” inProceedings of the 50th Annual International Symposium on Computer Architecture (ISCA ’23). New Yo...

    2023

  27. [35]

    SwiftTron: An efficient hardware accelerator for quantized transformers,

    A. Marchisio, D. Dura, M. Capra, M. Martina, G. Masera, and M. Shafique, “SwiftTron: An efficient hardware accelerator for quantized transformers,”arXiv preprint arXiv:2304.03986, 2023

    2023 arXiv

  28. [36]

    Additive powers-of-two quantization: An efficient non-uniform discretization for neural networks,

    Y . Li, X. Dong, and W. Wang, “Additive powers-of-two quantization: An efficient non-uniform discretization for neural networks,” inInter- national Conference on Learning Representations (ICLR), 2020

    2020

  29. [37]

    A novel deep learning-based approach for video quality enhancement,

    P. Zilouchian Moghaddam, M. Modarressi, and M. A. Sadeghi, “A novel deep learning-based approach for video quality enhancement,” Engineering Applications of Artificial Intelligence, vol. 144, p. 110118, 2025

    2025

  30. [38]

    Photo-realistic single image super-resolution using a generative adversarial network,

    C. Ledig, L. Theis, F. Husz ´ar, J. Caballero, A. Cunningham, A. Acosta, A. Aitken, A. Tejani, J. Totz, Z. Wanget al., “Photo-realistic single image super-resolution using a generative adversarial network,” in Proceedings of the IEEE Conference on Computer Vision and Pattern R...

    2017

Pith tools

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