Pith. sign in

REVIEW 3 major objections 6 minor 35 references

StruM: Structured Mixed Precision for Efficient Deep Learning Hardware Codesign

T0 review · 3 major / 6 minor · reviewed 2026-08-09 · deepseek-v4-flash

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

Pith's one-line read StruM claims that pretrained INT8 CNN weights can be split into blocks, with half quantized to 4-bit or power-of-two values, letting hardware replace half the multipliers with barrel shifters while keeping top-1 accuracy within 1% of…

desk verdict A real accuracy result for block-wise structured mixed precision, but the MIP2Q hardware datapath as described cannot handle negative power-of-two weights, so the area/power claims are not yet supported. read the letter →

arxiv 2501.18953 v2 pith:2DT327WG submitted 2025-01-31 cs.AR

Michael Wu , Arnab Raha , Deepak A. Mathaikutty , Martin Langhammer , Engin Tunali , Daksha Sharma This is my paper · ORCID
classification cs.AR
keywords structuredmixedprecisionweightquantizationpower-of-twobarrelshifterdeeplearninginferencehardwareacceleratorINT8CNNacceleration
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 introduces StruM, a structured mixed-precision scheme that partitions each block of weights into two sets and quantizes one set to a lower precision, aiming to cut inference cost without retraining or fine-tuning. On ImageNet, with block size [1,16] and p=0.5, quantizing half of each block from INT8 to INT4 (DLIQ) or to a power-of-two value (MIP2Q) keeps top-1 accuracy within 1% of the INT8 baseline across the tested VGG, ResNet, Inception, and Darknet networks. The hardware co-design replaces half of the INT8 multipliers in a FlexNN processing element with barrel shifters, giving 31-34% PE power savings and 23-26% PE area savings, with about 10% power savings at the full accelerator (DPU) level. The point of the claim is that quantization and acceleration can be applied post-training by a hardware vendor without access to the customer's dataset, removing a main obstacle to efficient deployment.

What carries the argument

The load-bearing object is MIP2Q's power-of-two weight: when a low-precision weight is stored as an exponent k, the product $A \times 2^k$ is a barrel shift of the activation, replacing an INT8 multiplier. The mask header in each $[1,w]$ block is the routing mechanism, sending mask-bit=1 operands to INT8 multipliers and mask-bit=0 operands to shifters, and the block size $[1,16]$ is chosen to match the accelerator's 16-input-channel compute granularity. This combination is what turns a 50% precision reduction into concrete PE power and area savings, and it is also the point where the paper's hardware model depends on the encoding of signed weights.

What would settle it

Take a pretrained INT8 CNN such as ResNet-50, apply MIP2Q with p=0.5, q=4, L=7, and instrument the low-precision set: if any meaningful fraction of those weights is negative and the shift-only datapath has no sign handling, the computed dot products will be wrong and the reported under-1% top-1 loss will not hold without extra sign-correction hardware that changes the 31-34% PE power estimate.

Watch

Extended reading notes

Core claim

For each block of weights, StruM sorts values by absolute magnitude and assigns a fixed fraction p to low precision. DLIQ quantizes those values to a q-bit integer, while MIP2Q quantizes them to the nearest power of two, choosing the partition that minimizes the L2 reconstruction error via exhaustive search over the block. A one-bit mask header per block tells the dot-product unit which operands go to full INT8 multipliers and which go to INT4 multipliers (DLIQ) or barrel shifters (MIP2Q); the stored exponent k in MIP2Q means the product with an activation is an arithmetic shift. The paper reports that at p=0.5 and q=4 both methods stay within 1% top-1 accuracy of the INT8 baseline across the tested ImageNet networks, and MIP2Q reports better accuracy than structured sparsity at equal weight-compression across the compression range shown. Replacing four of eight INT8 multipliers with L=7 or L=5 barrel shifters yields the reported PE and DPU area and power savings while leaving the critical path unchanged.

Load-bearing premise

The claim stands on the assumption that a low-precision weight equal to a power of two can be applied by a single arithmetic shift, which requires encoding negative and zero weights; the paper does not specify how a sign bit is handled.

Editorial extensions

If this is right

  • A pretrained INT8 CNN can be converted to StruM with no retraining: at p=0.5 and q=4, half of the weights in each [1,16] block drop from 8 bits to 4 bits (DLIQ) or to a power-of-two exponent (MIP2Q), keeping ImageNet top-1 accuracy within 1% of the INT8 baseline.
  • An accelerator PE can replace half of its INT8 multipliers with barrel shifters and route each operand by the mask header, yielding 23-26% PE area savings and 31-34% PE power savings in static configuration, with about 10% DPU power savings in both static and dynamic configurations.
  • The compressed weight format shrinks stored weights by a factor $r = (p(q-8)+9)/8$, so at p=0.5, q=4 the weight memory and bandwidth fall by 12.5%; smaller q or larger p reduce storage further.
  • Because MIP2Q matches or beats structured sparsity at the same compression level and does not require fine-tuning, it gives a no-retraining alternative to 2:4 sparse hardware acceleration.
  • Balancing low-precision operands across PEs can in principle provide near-ideal speedup proportional to the precision ratio, avoiding the slowest-PE bottleneck that unstructured low-precision suffers; the paper notes this feature was not explicitly enabled in the current FlexNN implementation.

Reading between the lines

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

  • If the sign-bit gap is real, a corrected MIP2Q datapath would need either sign-magnitude encoding of k (an extra XOR per product) or signed shift logic, which would consume some of the reported 31-34% PE power savings.
  • Because the paper shows that MIP2Q's accuracy holds when block size matches the compute granularity of the PE, the same block-structured idea could be tested on matrix-multiplication tiles and on activation tensors, where the paper only tests weights but similar within-block magnitude variance would be needed.
  • The claim that balancing low-precision operands across PEs avoids the slowest-PE effect could be tested directly by mapping random versus balanced precision assignments across a 16x16 PE array and measuring utilization.
  • Combining StruM's precision bitmap with a separate sparsity bitmap, which the paper notes is theoretically possible, could compound the weight compression and power savings beyond the 12.5% memory reduction reported for p=0.5, q=4.
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

3 major / 6 minor

Summary. The paper presents StruM, a post-training structured mixed-precision quantization scheme for CNNs, together with a hardware co-design built on the FlexNN accelerator. Weights are partitioned into [l,w] blocks; a fraction p of each block is quantized to low precision (DLIQ) or to powers of two (MIP2Q), while the remainder stays INT8, and a mask header records the assignment. ImageNet experiments report less than 1% top-1 accuracy loss at p=0.25 and p=0.5 across ten networks relative to an INT8 baseline. The authors replace a subset of INT8 multipliers in FlexNN PEs with barrel shifters, reporting 31-34% PE power savings, 23-26% PE area savings, and roughly 10-12% DPU power savings.

Significance. If the claims hold, StruM is a practical post-training method for improving inference efficiency without retraining, with a favorable accuracy-versus-savings trade-off. The accuracy study is broad (ten networks, several values of p, q, and block size), and the hardware results are based on actual Chisel/RTL synthesis and place-and-route on a 3nm process, which is a notable strength. The comparison with structured sparsity is informative and shows a consistent advantage for both DLIQ and MIP2Q. The main weakness is not the accuracy evaluation but the underspecified signed power-of-two datapath, which is load-bearing for the hardware-savings claims. The paper also contains an unsupported throughput claim and an incorrect headline figure in the abstract.

major comments (3)
  1. [Sec. IV-D2 and Fig. 8(c)] The MIP2Q low-precision path is specified only as a barrel shifter computing A × 2^k, with no description of how the sign of negative weights is handled. Since INT8 weights are approximately zero-centered, a substantial fraction of weights quantized to powers of two are negative; without a sign bit, a sign-magnitude exponent, or a negation stage, the described PE produces products with the wrong sign for all such weights. The Table I accuracy numbers therefore cannot be reproduced on the described hardware, and the PE power/area savings of Section VII-B do not include the cost of any missing sign logic. Please specify the signed encoding and datapath (including right-shift rounding semantics for negative exponents) and re-evaluate the hardware costs with that datapath.
  2. [Sec. V-B] The claim that the low-precision mode "provide[s] us with 2X acceleration at the layer level" is unsupported. With 4 multipliers and 4 shifters active simultaneously, the PE performs the same 8 products per cycle as the baseline; the only 2X behavior described is the backward-compatibility mode that uses 4 multipliers over 2 cycles, which is a slowdown, not an acceleration. The throughput claim should be removed or replaced with a clear comparison against the baseline PE.
  3. [Abstract and Section VII-B] The abstract states "10% reduction in area at the accelerator level," but Section VII-B reports 10-12% power savings at the DPU level and only 2-3% DPU area savings; the contribution list in Section I correctly says "10% reduction in power consumption at the accelerator level." The headline hardware claim in the abstract is therefore inaccurate and should be corrected to match the reported DPU power savings.
minor comments (6)
  1. [Table I] The caption says "Top-1 ImageNet classification error comparison," but the listed values are top-1 accuracies; rename the caption to "accuracy comparison" for consistency with the text and with the baseline values.
  2. [Sec. IV-C] The phrase "Without loss of generalization" should be "Without loss of generality."
  3. [Sec. IV-B, footnote 2] The footnote claims that similar classification accuracy persists across different block dimensional configurations with the same total number of elements, but no supporting experiment is shown; either provide the data or state this as an assumption.
  4. [Sec. IV-D1] The sentence "the actual weight value is 2k" should be typeset as 2^k, and the allowed range of k, including whether k is signed, should be defined precisely.
  5. [Sec. VII-B and Fig. 13] The figure caption does not identify which panel corresponds to the statically configured PE and which to the dynamically configurable PE; the text should refer to panels (a) and (b) explicitly.
  6. [Abstract] The phrase "up to a 50% reduction in precision for 8-bit integer weights to 4-bit values" is misleading because only a fraction p of weights in each block is reduced; suggest wording such as "reducing the effective precision of half the weights in each block to 4 bits."

Circularity Check

1 steps flagged · score 2.0 of 10

No circular derivation: accuracy and power/area results are measured against ImageNet labels and post-layout synthesis; the only circularity-pass issue is minor self-citation of the FlexNN baseline and Graffitist quantizer, which is not load-bearing.

  1. other [Section VI (Experimental Methodology) and Section VII-B (DPU-level Area and Power Savings)]
    "We implemented StruM on top of the FlexNN architecture [1] ... our baseline numbers are based on the FlexNN architecture [1]. ... we first conducted static calibration using Graffitist [15] to quantize both activations and weights to INT8 for all layers across all models."

    FlexNN [1] and Graffitist [15] are prior works by overlapping author sets (Raha and Mathaikutty for FlexNN; Wu for Graffitist). They provide the hardware baseline and the INT8 quantization baseline. This is a self-citation, but it is not load-bearing in a circular sense: the accuracy deltas in Table I are measured on ImageNet labels, and the PE/DPU power and area savings come from post-layout synthesis of the modified PE versus the baseline PE. No equation or fitted parameter is redefined as the claimed result, so the central claims do not reduce to the citation.

full rationale

I walked the claimed derivation chain for StruM. The quantization methods DLIQ and MIP2Q are encoding schemes plus a mask-selection procedure; MIP2Q minimizes an L2 reconstruction error on weights, which is an unsupervised objective and does not use ImageNet labels as a fitting target. The subsequent top-1 accuracy numbers are measurements against the ImageNet validation set, so the 'negligible loss' claim is not a prediction forced by construction. The hardware claims (23-26% PE area, 31-34% PE power, 10% DPU power savings) are post-layout synthesis results comparing a barrel-shifter PE to the FlexNN multiplier PE; while FlexNN is an in-house, self-cited baseline and Graffitist is a self-cited quantization tool, the savings are not derived from an equation that equates the baseline to the result. Hyperparameters (p, q, block size, L) are chosen by hand and via ablations on the same networks; this is a selection-bias/overfitting concern for generalization, not a circularity, and the reported numbers are honestly presented as results, not predictions on held-out hardware. The sign-handling omission noted in the reader's take (negative power-of-two weights cannot be realized by a left barrel shifter alone) is an internal underspecification and correctness risk, not a circularity. Overall, there is no self-definitional reduction, no fitted input renamed as a prediction, and no load-bearing self-citation chain; the score of 2 reflects only the presence of minor self-citations in the baseline and tooling.

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

The central accuracy claim rests on an empirical distribution assumption about weight magnitudes and on hand-chosen hyperparameters p, q, block size, and L. The hardware claims rest additionally on the unstated representability of signed power-of-two weights and on a proprietary synthesis flow.

free parameters (5)
  • p (low-precision proportion) = 0.25, 0.5, 0.75
    User-specified percentage of weight values per block assigned to low precision; the hardware implementation uses p=0.5.
  • q (low-precision bits in DLIQ, exponent bits in MIP2Q) = 4
    Set to 4 in the accuracy tables; in MIP2Q q is tied to shift range L through q = ceil(log2(L+1)) + 1.
  • block size [l,w] = [1,16]
    Chosen to match FlexNN's 16-input-channel register file granularity; footnote 2 asserts similar accuracy for the same total number of block elements.
  • L (shift range) = 7 and 5
    L=5 is selected from the ablation study as having accuracy close to L=7 with more power savings, per Sections VII-A1 and VII-B.
  • N (barrel shifters per PE) = 4
    Hardware design choice replacing 4 of 8 INT8 multipliers; this directly determines the reported area and power savings.
assumptions (5)
  • domain assumption Weight magnitudes within a block are informative for splitting precision: low-magnitude weights can be moved to 4-bit or power-of-two without meaningful accuracy loss.
    Core motivation stated in Sections I and IV; empirically validated in Table I but not derived.
  • ad hoc to paper Partitioning weights depth-wise into [1,w] blocks is without loss of generality for the hardware, and the same total number of elements gives similar accuracy.
    Footnote 2 in Section IV-B; asserted, not proven, and tied to the FlexNN register file width.
  • domain assumption The exhaustive mask search in MIP2Q is computationally manageable for the block sizes used.
    Section IV-C states 'the search space is manageable'; this is relied upon to produce masks and is not analyzed for larger block sizes.
  • ad hoc to paper A power-of-two weight can be multiplied via one barrel shift with no extra sign handling.
    Sections IV-D and V-B do not specify sign encoding for negative weights, which is required for arbitrary INT8 weights.
  • domain assumption Graffitist INT8 quantization is a reliable baseline reference.
    Section VI uses Graffitist for all baselines; if that baseline is weak, the relative accuracy claims are less meaningful.

how reviews work

0 comments
Cite this review

Pith. "Pith review of StruM: Structured Mixed Precision for Efficient Deep Learning Hardware Codesign." pith.science (2026). https://pith.science/paper/2DT327WG

@misc{pith2026250118953,
  author       = {Pith},
  title        = {Pith review of: StruM: Structured Mixed Precision for Efficient Deep Learning Hardware Codesign},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2DT327WG}},
  note         = {Machine review of arXiv:2501.18953}
}
read the original abstract

In this paper, we propose StruM, a novel structured mixed-precision-based deep learning inference method, co-designed with its associated hardware accelerator (DPU), to address the escalating computational and memory demands of deep learning workloads in data centers and edge applications. Diverging from traditional approaches, our method avoids time-consuming re-training/fine-tuning and specialized hardware access. By leveraging the variance in weight magnitudes within layers, we quantize values within blocks to two different levels, achieving up to a 50% reduction in precision for 8-bit integer weights to 4-bit values across various Convolutional Neural Networks (CNNs) with negligible loss in inference accuracy. To demonstrate efficiency gains by utilizing mixed precision, we implement StruM on top of our in-house FlexNN DNN accelerator [1] that supports low and mixed-precision execution. Experimental results depict that the proposed StruM-based hardware architecture achieves a 31-34% reduction in processing element (PE) power consumption and a 10% reduction in area at the accelerator level. In addition, the statically configured StruM results in 23-26% area reduction at the PE level and 2-3% area savings at the DPU level.

Figures

Figures reproduced from arXiv: 2501.18953 by the authors.

Figure 1
Figure 1. An overview of different pruning methods. Gray squares are nonzero values while white squares are zero values. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 3
Figure 3. StruM with DLIQ, where [l, w] = [1, 8] and p = 0.5. ( ) ( ) ( ) ( ) d1 d3 d5 d6 w1 w3 * w5 w6 * w1 w2 w3 w4 d1 d2 d3 d4 w5 w6 w7 w8 d5 d6 d7 d8 w1 w2 w3 w4 d1 d2 d3 d4 w5 w6 w7 w8 d5 d6 d7 d8 * w1 w2 w3 w4 d1 d2 d3 d4 w5 w6 w7 w8 d5 d6 d7 d8 * w1 w2 w3 w4 d1 d2 d3 d4 w5 w6 w7 w8 d5 d6 d7 d8 w8 d2 d4 w2 w4 w7 d7 d8 << + Integer Set Power of 2 Set * w1 w2 w3 w4 d1 d2 d3 d4 w5 w6 w7 w8 d5 d6 d7 d8 w8 d2 d4 w2 w4 w7 d7 … view at source ↗
Figure 4
Figure 4. StruM with MIP2Q, where [l, w] = [1, 8] and p = 0.5. an existing approach used by NVIDIA. In this method, values within a block are divided based on their absolute magnitudes, with a split point determining which values receive a lower precision (0), while the rest remain unchanged. For equal-sized higher precision and lower precision sets (e.g., p = 0.5), the split point is placed at the midpoint of the sorted list… view at source ↗
Figures from the paper (10 more)
Figure 2
Figure 2. Figure 2: An example of a 1 × 1 convolution Consider the 1 × 1 convolution filter depicted in [PITH_FULL_IMAGE:figures/full_fig_p004_2.png]
Figure 6
Figure 6. Figure 6: Proposed StruM dot product multiplier The encoding format also reduces weight memory storage and bandwidth usage. Weight compression level (r) is defined as the ratio between compressed weight memory and uncom￾pressed weight memory (compressed/uncompressed). In the pre…
Figure 5
Figure 5. Figure 5: Encoding uncompressed block into a compressed block [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 7
Figure 7. Figure 7: FlexNN Array and PE Microarchitecture [1] [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: StruM PE integrated to FlexNN accelerator [1] [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]
Figure 9
Figure 9. Figure 9: StruM-based quality configurable PE with multipliers and barrel shifters [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 10
Figure 10. Figure 10: DLIQ ImageNet Top-1 accuracy for Resnet-50 V1.5 [PITH_FULL_IMAGE:figures/full_fig_p009_10.png]
Figure 11
Figure 11. Figure 11: MIP2Q ImageNet Top-1 accuracy for Resnet-50 V1.5 [PITH_FULL_IMAGE:figures/full_fig_p009_11.png]
Figure 12
Figure 12. Figure 12: ImageNet Top-1 Classification Accuracy 2) Classification Accuracy Across Networks In Table I, we present the Top-1 classification accuracy of the proposed methods across various networks on the ImageNet dataset. We employed a block size of [l, w] = [1, 16] for both me…
Figure 13
Figure 13. Figure 13: DPU-level, PE Array-level, and PE-level Area/Power [PITH_FULL_IMAGE:figures/full_fig_p011_13.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

35 extracted references · 21 canonical work pages

  1. [1]

    FlexNN: A dataflow-aware flexible deep learning accelerator for energy-efficient edge devices,

    A. Raha, D. A. Mathaikutty, S. K. Ghosh, and S. Kundu, “FlexNN: A dataflow-aware flexible deep learning accelerator for energy-efficient edge devices,” arXiv preprint arXiv:2403.09026 , 2024

    arXiv 2024

  2. [2]

    Going deeper with convolutions,

    C. Szegedy, W. Liu, Y . Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V . Vanhoucke, and A. Rabinovich, “Going deeper with convolutions,” in Proc. of CVPR , 2015, pp. 1–9

    work page 2015

  3. [3]

    SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and < 0.5 MB model size,

    F. N. Iandola, S. Han, M. W. Moskewicz, K. Ashraf, W. J. Dally, and K. Keutzer, “SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and < 0.5 MB model size,” arXiv preprint arXiv:1602.07360, 2016

    arXiv 2016

  4. [4]

    MobileNets: Efficient convolutional neural networks for mobile vision applications,

    A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam, “MobileNets: Efficient convolutional neural networks for mobile vision applications,” arXiv preprint arXiv:1704.04861, 2017

    arXiv 2017

  5. [5]

    EfficientNetV2: Smaller models and faster training,

    M. Tan and Q. V . Le, “EfficientNetV2: Smaller models and faster training,” arXiv preprint arXiv:2104.00298 , 2021

    arXiv 2021

  6. [6]

    Shufflenet: An extremely efficient convolutional neural network for mobile devices,

    X. Zhang, X. Zhou, M. Lin, and J. Sun, “Shufflenet: An extremely efficient convolutional neural network for mobile devices,” in Proceedings of the IEEE conference on computer vision and pattern recognition , 2018, pp. 6848–6856

    2018

  7. [7]

    Xception: Deep learning with depthwise separable convolu- tions,

    F. Chollet, “Xception: Deep learning with depthwise separable convolu- tions,” in Proceedings of the IEEE conference on computer vision and pattern recognition, 2017, pp. 1251–1258

    2017

  8. [8]

    Neural architecture search with reinforcement learning,

    B. Zoph and Q. Le, “Neural architecture search with reinforcement learning,” in International Conference on Learning Representations ,

    work page

Show all 35 references
  1. [9]

    ProxylessNAS: Direct neural architecture search on target task and hardware,

    H. Cai, L. Zhu, and S. Han, “ProxylessNAS: Direct neural architecture search on target task and hardware,” in Proc. of ICLR , 2019

    2019

  2. [10]

    MnasNet: Platform-aware neural architecture search for mobile,

    M. Tan, B. Chen, R. Pang, V . Vasudevan, M. Sandler, A. Howard, and Q. V . Le, “MnasNet: Platform-aware neural architecture search for mobile,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , 2019, pp. 2820–2828

    2019

  3. [11]

    DoReFa-Net: Training low bitwidth convolutional neural networks with low bitwidth gradients,

    S. Zhou, Y . Wu, Z. Ni, X. Zhou, H. Wen, and Y . Zou, “DoReFa-Net: Training low bitwidth convolutional neural networks with low bitwidth gradients,” arXiv preprint arXiv:1606.06160 , 2016

    2016 arXiv

  4. [12]

    Binarized neural networks,

    I. Hubara, M. Courbariaux, D. Soudry, R. El-Yaniv, and Y . Bengio, “Binarized neural networks,” Advances in neural information processing systems, vol. 29, 2016

    2016

  5. [13]

    FINN: A framework for fast, scalable binarized neural network inference,

    Y . Umuroglu, N. J. Fraser, G. Gambardella, M. Blott, P. Leong, M. Jahre, and K. Vissers, “FINN: A framework for fast, scalable binarized neural network inference,” in Proc. of FPGA , 2017, pp. 65–74. 11

    2017

  6. [14]

    Highly efficient 8-bit low precision inference of convolutional neural networks with IntelCaffe,

    J. Gong, H. Shen, G. Zhang, X. Liu, S. Li, G. Jin, N. Maheshwari, E. Fomenko, and E. Segal, “Highly efficient 8-bit low precision inference of convolutional neural networks with IntelCaffe,” in Proc. of Reproducible Quality-Efficient Systems Tournament on Co-designing Pareto-e...

    2018

  7. [15]

    Trained quantization thresholds for accurate and efficient fixed-point inference of deep neural networks,

    S. R. Jain, A. Gural, M. Wu, and C. H. Dick, “Trained quantization thresholds for accurate and efficient fixed-point inference of deep neural networks,” 2019

    2019

  8. [16]

    XOR-Net: An efficient computation pipeline for binary neural network inference on edge devices,

    S. Zhu, L. H. Duong, and W. Liu, “XOR-Net: An efficient computation pipeline for binary neural network inference on edge devices,” in 2020 IEEE 26th international conference on parallel and distributed systems (ICPADS). IEEE, 2020, pp. 124–131

    2020

  9. [17]

    Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding,

    S. Han, H. Mao, and W. J. Dally, “Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding,” arXiv preprint arXiv:1510.00149 , 2015

    2015 arXiv

  10. [18]

    Learning both weights and connections for efficient neural network,

    S. Han, J. Pool, J. Tran, and W. Dally, “Learning both weights and connections for efficient neural network,” Advances in neural information processing systems, vol. 28, 2015

    2015

  11. [19]

    Pruning filters for efficient ConvNets,

    H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf, “Pruning filters for efficient ConvNets,” arXiv preprint arXiv:1608.08710 , 2016

    2016 arXiv

  12. [20]

    Block-sparse recurrent neural networks,

    S. Narang, E. Undersander, and G. Diamos, “Block-sparse recurrent neural networks,” arXiv preprint arXiv:1711.02782 , 2017

    2017 arXiv

  13. [21]

    GPU kernels for block-sparse weights,

    S. Gray, A. Radford, and D. P. Kingma, “GPU kernels for block-sparse weights,” arXiv preprint arXiv:1711.09224 , vol. 3, 2017

    2017 arXiv

  14. [22]

    Accelerating sparse deep neural networks,

    A. Mishra, J. A. Latorre, J. Pool, D. Stosic, D. Stosic, G. Venkatesh, C. Yu, and P. Micikevicius, “Accelerating sparse deep neural networks,” arXiv preprint arXiv:2104.08378 , 2021

    2021 arXiv

  15. [23]

    The rising costs of training frontier AI models,

    B. Cottier, R. Rahman, L. Fattorini, N. Maslej, and D. Owen, “The rising costs of training frontier AI models,” arXiv preprint arXiv:2405.21015 , 2024

    2024 arXiv

  16. [24]

    XVDPU: A high performance cnn accelerator on versal platform powered by ai engine,

    X. Jia, Y . Zhang, G. Liu, X. Yang, T. Zhang, J. Zheng, D. Xu, Z. Liu, M. Liu, X. Yan et al. , “XVDPU: A high performance cnn accelerator on versal platform powered by ai engine,” ACM Transactions on Reconfigurable Technology and Systems , 2022

    2022

  17. [25]

    Nvidia hopper h100 gpu: Scaling performance,

    J. Choquette, “Nvidia hopper h100 gpu: Scaling performance,” IEEE Micro, 2023

    2023

  18. [26]

    ThiNet: A filter level pruning method for deep neural network compression,

    J.-H. Luo, J. Wu, and W. Lin, “ThiNet: A filter level pruning method for deep neural network compression,” in Proceedings of the IEEE international conference on computer vision , 2017, pp. 5058–5066

    2017

  19. [27]

    Reconciling sparse and structured pruning: A scientific study of block sparsity,

    A. Siswanto, J. Frankle, and M. Carbin, “Reconciling sparse and structured pruning: A scientific study of block sparsity,” in Workshop paper at the 9th International Conference on Learning Representations (ICLR 2021), 2021

    2021

  20. [28]

    Accelerating sparsity in the NVIDIA Ampere architecture,

    J. Pool, “Accelerating sparsity in the NVIDIA Ampere architecture,” GTC 2020, 2020

    2020

  21. [29]

    Deep neural network compression by in-parallel pruning-quantization,

    F. Tung and G. Mori, “Deep neural network compression by in-parallel pruning-quantization,” IEEE transactions on pattern analysis and machine intelligence, vol. 42, no. 3, pp. 568–579, 2018

    2018

  22. [30]

    LogNet: Energy-efficient neural networks using logarithmic computation,

    E. H. Lee, D. Miyashita, E. Chai, B. Murmann, and S. S. Wong, “LogNet: Energy-efficient neural networks using logarithmic computation,” in 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2017, pp. 5900–5904

    2017

  23. [31]

    Deepshift: Towards multiplication-less neural networks,

    M. Elhoushi, Z. Chen, F. Shafiq, Y . H. Tian, and J. Y . Li, “Deepshift: Towards multiplication-less neural networks,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , 2021, pp. 2359–2368

    2021

  24. [32]

    DRQ: Dynamic region-based quantization for deep neural network acceleration,

    Z. Song, B. Fu, F. Wu, Z. Jiang, L. Jiang, N. Jing, and X. Liang, “DRQ: Dynamic region-based quantization for deep neural network acceleration,” in 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA). IEEE, 2020, pp. 1010–1021

    2020

  25. [33]

    HAQ: Hardware-aware automated quantization with mixed precision,

    K. Wang, Z. Liu, Y . Lin, J. Lin, and S. Han, “HAQ: Hardware-aware automated quantization with mixed precision,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , 2019, pp. 8612–8620

    2019

  26. [34]

    Chisel: constructing hardware in a scala embedded language,

    J. Bachrach, H. V o, B. Richards, Y . Lee, A. Waterman, R. Avi ˇzienis, J. Wawrzynek, and K. Asanovi ´c, “Chisel: constructing hardware in a scala embedded language,” in Proceedings of the Design Automation Conference (DAC), 2012, p. 1216–1225. 12

    2012

  27. [2017]

    Available: https://openreview.net/forum?id=r1Ue8Hcxg

    [Online]. Available: https://openreview.net/forum?id=r1Ue8Hcxg

Pith tools

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