Pith. sign in

REVIEW 6 major objections 6 minor 51 references

UnIT: Scalable Unstructured Inference-Time Pruning for MAC-efficient Neural Inference on MCUs

T0 review · 6 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 UnIT shows that unstructured inference-time pruning can skip most MACs on microcontrollers, cutting energy and latency without retraining.

desk verdict UnIT is a sound and plausibly useful MCU inference trick, but the headline numbers contradict the paper's own figures and the TTP baseline sparsity is missing. read the letter →

arxiv 2507.07885 v1 pith:DUFK3J7W submitted 2025-07-10 cs.LG cs.AI

Ashe Neth , Sawinder kaur , Mohammad Nur Hossain Khan , Subrata Biswas , Asif Salekin , Bashima Islam This is my paper · ORCID
classification cs.LGcs.AI
keywords UnstructuredpruningInference-timeFastapproximatedivisionMACoperationMicrocontrollerEdgeAIEnergy-efficientinferenceSparsity
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 claims that a microcontroller can decide, at inference time and per connection, whether a multiply-accumulate operation is worth doing, and skip the rest without retraining or specialized hardware. UnIT replaces the multiplication itself with a threshold comparison: instead of computing $|X \cdot W|$ and comparing it to $T$, it compares one operand to $T/|C|$, where $C$ is the operand reused across many connections. On the MSP430 this yields 11.02–82.03% fewer MACs, 27.30–84.19% faster inference, and 27.33–84.38% lower energy than training-time pruning, with accuracy within 0.48–7% of the unpruned model. If true, this makes input-adaptive, fine-grained sparsity practical for battery-free and intermittently powered edge devices.

What carries the argument

The carrying object is the reuse-aware threshold identity $|X \cdot W| \le T \iff |Z| \le T/|C|$, with the control term $C$ selected by layer type to maximize reuse. In linear layers activations are reused across output neurons, so the threshold is $T/|X_i|$ and each weight is tested against it; in convolutional layers weights are reused over spatial positions, so the threshold is $T/|W_j|$ and each activation is tested. A one-time calibration pass fixes a per-layer threshold $T$ at a chosen percentile of activation–weight products from a held-out batch. The three division approximations — bit shifting for fixed-point devices, binary tree search as a universal method, and bit masking on IEEE 754 floating-point units — supply the only remaining arithmetic, turning the pruning decision into comparisons and shifts.

What would settle it

Run UnIT with the same models and threshold percentile, but test on inputs whose activation magnitudes are scaled up or down, or taken from a different room or user than the calibration batch; if accuracy drops by more than the reported 0.48–7% range, or the MAC savings vanish while holding accuracy, the calibrated-threshold assumption fails.

Watch

Extended reading notes

Core claim

UnIT's central claim is that connection-level pruning can be moved from training time to inference time without paying for a MAC to make the pruning decision. The key reformulation is $|X_{i,\ell} \cdot W_{\ell,j}| \le T \iff |Z| \le T/|C|$, where $C$ is chosen as the operand reused by many MACs — activations in fully connected layers, weights in convolutional layers — so one division serves many comparisons. Three cheap division approximations (bit shifting, binary tree search, and bit masking) make the threshold computation affordable on fixed- and floating-point MCUs. The paper reports that this dynamic, input-aware skipping matches or beats training-time pruning in accuracy under domain shift while using fewer MACs, establishing unstructured inference-time pruning as a viable deployment strategy.

Load-bearing premise

The whole scheme assumes the per-layer threshold, calibrated once on a held-out batch, still separates worthless from useful connections on every later input, including inputs from a shifted distribution.

Editorial extensions

If this is right

  • On single-threaded MCUs without SIMD, unstructured per-MAC skipping can be cheaper than structured pruning because the branch cost is only a few cycles versus roughly 77 cycles for a multiplication.
  • UnIT can be layered on top of quantization, training-time pruning, or activation sparsity, since it does not change the model architecture, yielding cumulative MAC and energy savings.
  • Under domain shift, a fixed mask degrades while UnIT adapts: on the WiDaR cross-room protocol it keeps F1 within about 1% while skipping 61–72% of MACs.
  • The three division approximations shrink division overhead enough that the runtime cost of the pruning decision stays small relative to the energy saved.

Reading between the lines

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

  • If the calibrated per-layer threshold is not representative of deployment inputs, the skip decisions become either too aggressive, dropping accuracy, or too conservative, erasing the savings; the paper does not report how results vary with the calibration percentile, so sweeping that percentile is the natural stress test.
  • On many-core parallel hardware, per-branch divergence could offset the savings, and the authors themselves predict that speedups will shrink as core count grows.
  • The same threshold-reuse trick could transfer to generic sparse matrix multiplication or attention layers, wherever one operand is reused enough to amortize a single division.
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

6 major / 6 minor

Summary. The manuscript proposes UnIT, an unstructured inference-time pruning method for low-power microcontrollers. Instead of computing each multiply-accumulate (MAC) and then thresholding it, UnIT reformulates the pruning condition as a comparison between one operand and a precomputed threshold divided by the other operand, reusing each division across many connections. It introduces three approximate division techniques (bit shifting, binary tree search, and bit masking) and evaluates the approach on MNIST, CIFAR-10, KWS, and WiDaR using the MSP430FR5994 MCU and a modified PyTorch/C++ backend. The paper claims large reductions in MACs, latency, and energy relative to training-time pruning and FATReLU, as well as robustness under domain shift.

Significance. If the claims held, UnIT would be a practically useful, retraining-free deployment strategy for unstructured pruning on MCUs, combining an interesting threshold-reuse idea with hardware-aware approximations and deterministic, input-dependent skipping. The authors deserve credit for evaluating on real microcontroller hardware with energy measurements and for including a domain-shift experiment. However, the headline quantitative claims are internally inconsistent and contradicted by the paper's own figures, and the evaluation lacks crucial baseline details and error reporting. The core idea is worth pursuing, but the current evidence does not establish the stated advantages.

major comments (6)
  1. [Abstract; Section 4.1; Figures 6-7] The abstract claims UnIT achieves 11.02% to 82.03% MAC reduction, 27.30% to 84.19% faster inference, and 27.33% to 84.38% lower energy compared to training-time pruned models. Section 4.1, however, states UnIT has '5.85–42.2% less MAC operation compared to train-time pruning,' and Figures 6-7 show UnIT is slower than training-time pruning on CIFAR-10 (2523 ms vs. 2182 ms) and on KWS (251.0 ms vs. 249.9 ms), with KWS energy also slightly higher (1.05 mJ vs. 1.04 mJ). These numbers cannot all describe the same experiments. Please reconcile the ranges, report per-dataset raw values, and state precisely which baseline each percentage is computed against.
  2. [Section 2.2, Eq. (4)] Equation (4) states |X| ≤ T ⇒ n ≥ log2(|X|/T), where n is the shift count obtained from the bit-shifting approximation. This is mathematically incorrect as written: if X is represented as 2^n, then n = log2|X|, and the condition |X| ≤ T is equivalent to n ≤ log2 T (for positive T), not n ≥ log2(|X|/T). The direction of the inequality and the appearance of |X| inside the logarithm make the equation dimensionally inconsistent. Please correct the formula and verify that the implemented comparison matches the corrected version.
  3. [Section 3.4; Section 4.1] The training-time pruning (TTP) baseline is described only as 'global unstructured magnitude pruning' with no sparsity level reported. The relative MAC, latency, and energy comparisons are uninterpretable without knowing how many weights the TTP baseline removes. If TTP is lightly pruned, the claimed savings are trivial; if heavily pruned, the accuracy comparison is unfair. Please report the sparsity of the TTP baseline for each dataset and ensure that the comparison holds both sparsity and accuracy fixed where possible.
  4. [Section 2.1; Section 4.2] The adaptive threshold calibration uses a held-out batch and a 'fixed percentile (e.g., 20th)' to set per-layer thresholds, but there is no analysis of sensitivity to the calibration percentile or to the representativeness of the calibration batch. Since all reported savings depend on these thresholds remaining appropriate at test time, the paper should include an ablation over the percentile and an experiment where calibration and test distributions differ (beyond the WiDaR setup, where the unpruned baseline already reports nonzero MAC skipping). Without this, the risk of either accuracy collapse or vanishing savings under distribution shift is not quantified.
  5. [Table 2] Table 2 lists 'MAC Skipped %' values of 16.50-17.19% for the 'Unpruned' rows. An unpruned model should skip zero MACs by definition. If these numbers arise from activation sparsity in the SONIC runtime or from some other mechanism, that needs to be stated explicitly; as written, the table undermines the claim that UnIT's MAC reductions are purely due to the proposed method and makes the domain-shift comparison difficult to interpret.
  6. [Results; Section 3.5] The experimental results in Figures 5-7 and Table 2 appear to be single-run measurements with no error bars, confidence intervals, or repeated trials. Several key comparisons are small (e.g., KWS runtime difference of 1.1 ms and energy difference of 0.01 mJ), and without variance information it is impossible to tell whether the reported differences are significant. Please include multiple independent runs and report means with standard deviations or confidence intervals.
minor comments (6)
  1. [Abstract; Section 1] The text contains a doubled percent sign in '27.30–84.19%%'; please correct the typographical error.
  2. [Section 3.2; Section 3.3] The dataset name is spelled inconsistently as 'WiDaR' in Section 3.2 and 'WiDAR' in Table 1; please standardize throughout.
  3. [Section 4.1] The latency ranges '7.5–151 and 3.8–125 seconds' appear to be inconsistent with Figure 6, whose axes are in milliseconds; please correct the units and the numbers.
  4. [Figure 5 caption] The caption states that results are shown 'across four datasets,' but the figure legend displays only MNIST, CIFAR-10, and KWS; WiDaR appears only in Table 2. Please clarify which datasets Figure 5 actually includes.
  5. [Section 2.2, Eq. (5)] Equation (5) is typeset incorrectly, and the accompanying claim that 'the mantissa term lies in the range [1/2, 2]' is imprecise for IEEE 754; the significand is normally in [1, 2) for normal numbers. Please rewrite the equation and the surrounding explanation.
  6. [Section 6.5] The text refers to 'Sys's adaptability' where 'UnIT's' is clearly intended; please fix this typo.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: UnIT's pruning criterion is an exact algebraic reformulation, and its only fitted constants (per-layer thresholds) are calibrated on a held-out validation set and evaluated on a separate test set.

full rationale

The paper's central derivation is self-contained. Equation (1) states |X_i,l * W_l,j| <= T iff |Z| <= T/|C|, which is an exact algebraic identity used to replace multiplication with comparison; the direction of reuse (activations in linear layers, weights in convolutions) does not assume the reported efficiency gains. Thresholds are the only fitted quantities and are obtained once from a held-out batch: Section 3.2 says 'Validation data is used only to tune pruning thresholds, and test data is reserved for final evaluation.' The reported accuracy retention, MAC counts, latency, and energy are therefore measurements on test inputs after that disclosed calibration, not quantities defined by the fit. The three division approximations are benchmarked directly against conventional division (Section 4.3), so their speed and energy claims are empirical rather than derived from the pruning rule. Self-citations to Zygarde [18], FreeML [11], and QUADS [7] appear only as motivation, architecture alignment, or related-work context, and no uniqueness theorem or load-bearing assumption is imported from those papers. The remaining concerns are consistency and verifiability issues, not circularity: the abstract's claim of 11.02-82.03% MAC reduction relative to training-time pruning conflicts with Section 4.1's '5.85-42.2% less MAC operation compared to train-time pruning,' and Figures 6-7 show UnIT slower on CIFAR-10 and slightly slower and higher-energy on KWS than training-time pruning; these internal contradictions affect the reliability of the headline numbers but do not constitute a derivation that reduces to its inputs. Limitations stated in Sections 6.2, 6.4, and 6.7 further bound the claims without creating circular reasoning. Overall, no prediction or first-principles result in this paper is equivalent by construction to its fitted inputs.

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

The paper introduces no new particles or physical entities. It does depend on per-layer thresholds and a hand-chosen percentile as fitted parameters, plus hardware assumptions about branch and division costs on MCUs.

free parameters (2)
  • per-layer threshold T_l = not reported
    Set as a fixed percentile (e.g., 20th) of activation-weight products on a held-out batch; determines the MAC reduction and accuracy tradeoff. Central to all results.
  • calibration percentile = 20th (fixed example)
    Chosen by hand without a sensitivity study; controls the overall sparsity level and is not derived from first principles.
assumptions (4)
  • domain assumption Conditional branching on target MCUs (2-4 cycles) is much cheaper than multiplication (77 cycles), so per-MAC threshold checks are net beneficial.
    Invoked in Section 1 and Section 2; if false, the overhead of checking every connection eliminates the energy savings.
  • domain assumption Approximate division (bit shifting, binary tree, bit masking) preserves enough precision for pruning decisions.
    Used in Section 2.2; the paper reports aggregate accuracy, but does not analyze how often the approximation flips a pruning decision.
  • domain assumption The activation-weight product statistics from the held-out calibration batch generalize to the test and domain-shifted distributions.
    Section 2.1 Adaptive Threshold Calibration; all results depend on this stationarity assumption.
  • standard math The algebraic identity |X*W| <= T iff |Z| <= T/|C| is exact when the product is Z*C.
    Equation 1, Section 2.1; this is standard arithmetic, not a postulate.

how reviews work

0 comments
Cite this review

Pith. "Pith review of UnIT: Scalable Unstructured Inference-Time Pruning for MAC-efficient Neural Inference on MCUs." pith.science (2026). https://pith.science/paper/DUFK3J7W

@misc{pith2026250707885,
  author       = {Pith},
  title        = {Pith review of: UnIT: Scalable Unstructured Inference-Time Pruning for MAC-efficient Neural Inference on MCUs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DUFK3J7W}},
  note         = {Machine review of arXiv:2507.07885}
}
read the original abstract

Existing pruning methods are typically applied during training or compile time and often rely on structured sparsity. While compatible with low-power microcontrollers (MCUs), structured pruning underutilizes the opportunity for fine-grained efficiency on devices without SIMD support or parallel compute. To address these limitations, we introduce UnIT (Unstructured Inference-Time pruning), a lightweight method that dynamically identifies and skips unnecessary multiply-accumulate (MAC) operations during inference, guided by input-specific activation patterns. Unlike structured pruning, UnIT embraces irregular sparsity and does not require retraining or hardware specialization. It transforms pruning decisions into lightweight comparisons, replacing multiplications with threshold checks and approximated divisions. UnIT further optimizes compute by reusing threshold computations across multiple connections and applying layer- and group-specific pruning sensitivity. We present three fast, hardware-friendly division approximations tailored to the capabilities of common embedded platforms. Demonstrated on the MSP430 microcontroller, UnIT achieves 11.02% to 82.03% MAC reduction, 27.30% to 84.19% faster inference, and 27.33% to 84.38% lower energy consumption compared to training-time pruned models, while maintaining accuracy with 0.48-7%. Under domain shift, UnIT matches or exceeds the accuracy of retrained models while requiring significantly fewer MACs. These results establish unstructured inference-time pruning as a viable and practical solution for efficient, retraining-free deployment of deep neural networks on MCUs.

Figures

Figures reproduced from arXiv: 2507.07885 by the authors.

Figure 1
Figure 1. In a fully connected network, traditional pruning applies a fixed mask to zero out inputs regardless of [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Comparison between train-time and inference-time pruning strategies. While train-time pruning applies [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Bit shifting can approximate the order of magnitude of any integer or fixed-point number 0 0 0 0 1 1 0 0  x»=1 𝐿 was originally less than 2𝐿 [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Starting with the head, the value at each sub-tree’s head is compared to the value we are checking. If the point v [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]
Figure 5
Figure 5. Figure 5: Accuracy drop versus remaining MAC operations across four datasets. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Inference runtime comparison across MNIST, [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 7
Figure 7. Figure 7: Average energy consumption during infer [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]
Figure 8
Figure 8. Figure 8: Approximate division methods using bit shift [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

51 extracted references · 38 canonical work pages

  1. [1]

    Efficient Multiplication and Division Using MSP430 ™ MCUs

    2018. Efficient Multiplication and Division Using MSP430 ™ MCUs. https://www.ti.com/lit/an/slaa329a/slaa329a.pdf

    work page 2018

  2. [2]

    MSP430 User Guide

    2024. MSP430 User Guide. https://www.ti.com/sc/docs/products/ micro/msp430/userguid/as_5.pdf

    work page 2024

  3. [3]

    Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. 2017. Structured pruning of deep convolutional neural networks. ACM Journal on Emerging Technologies in Computing Systems (JETC) 13, 3 (2017), 1– 18

    work page 2017

  4. [4]

    Kambiz Azarian, Yash Bhalgat, Jinwon Lee, and Tijmen Blankevoort

    work page

  5. [5]

    Abu Bakar, Rishabh Goel, Jasper De Winkel, Jason Huang, Saad Ahmed, Bashima Islam, Przemysław Pawełczak, Kasım Sinan Yıldırım, and Josiah Hester. 2022. Protean: An energy-efficient and heterogeneous platform for adaptive and hardware-accelerated battery-free comput- ing. In Proceedings of the 20th ACM Conference on Embedded Networked Sensor Systems. 207–221

    work page 2022

  6. [6]

    Manoj Bharadhwaj, Gitakrishnan Ramadurai, and Balaraman Ravin- dran. 2022. Detecting vehicles on the edge: Knowledge distillation to improve performance in heterogeneous road traffic. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition . 3192–3198

    work page 2022

  7. [7]

    Subrata Biswas, Mohammad Nur Hossain Khan, and Bashima Islam

    work page

  8. [8]

    Yu Cheng, Duo Wang, Pan Zhou, and Tao Zhang. 2017. A survey of model compression and acceleration for deep neural networks. arXiv preprint arXiv:1710.09282 (2017)

    arXiv 2017

Show all 51 references
  1. [9]

    Li Deng. 2012. The mnist database of handwritten digit images for machine learning research. IEEE Signal Processing Magazine 29, 6 (2012), 141–142

    2012

  2. [10]

    Maha S Diab and Esther Rodriguez-Villegas. 2022. Embedded machine learning using microcontrollers in wearable and ambulatory systems for health and care applications: A review. IEEE Access 10 (2022), 98450–98474

    2022

  3. [11]

    Pietro Farina, Subrata Biswas, Eren Yıldız, Khakim Akhunov, Saad Ahmed, Bashima Islam, and Kasım Sinan Yıldırım. 2024. Memory- efficient Energy-adaptive Inference of Pre-Trained Models on Battery- less Embedded Systems. arXiv preprint arXiv:2405.10426 (2024)

    2024 arXiv

  4. [12]

    Jonathan Frankle and Michael Carbin. 2018. The lottery ticket hy- pothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations

    2018

  5. [13]

    Graham Gobieski, Brandon Lucia, and Nathan Beckmann. 2019. Intel- ligence beyond the edge: Inference on intermittent embedded systems. In Proceedings of the Twenty-Fourth International Conference on Archi- tectural Support for Programming Languages and Operating Systems . 199–213

    2019

  6. [14]

    Maria Gorlatova, Peter Kinget, Ioannis Kymissis, Dan Rubenstein, Xiaodong Wang, and Gil Zussman. 2010. Energy harvesting active networked tags (EnHANTs) for ubiquitous object networking. IEEE Wireless Communications 17, 6 (2010), 18–25

    2010

  7. [15]

    Song Han, Huizi Mao, and William J Dally. 2015. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149 (2015)

    2015 arXiv

  8. [16]

    Song Han, Jeff Pool, John Tran, and William Dally. 2015. Learning both weights and connections for efficient neural network. Advances in neural information processing systems 28 (2015)

    2015

  9. [17]

    Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. 2016. Binarized neural networks. InAdvances in neural information processing systems. 4107–4115

    2016

  10. [18]

    Bashima Islam and Shahriar Nirjon. 2019. Zygarde: Time-sensitive on-device deep inference and adaptation on intermittently-powered systems. arXiv preprint arXiv:1905.03854 (2019)

    2019 arXiv

  11. [19]

    Aman Kansal and Mani B Srivastava. 2003. An environmental energy harvesting framework for sensor networks. In Proceedings of the 2003 international symposium on Low power electronics and design. 481–486

    2003

  12. [20]

    Kishore Konda, Roland Memisevic, and David Krueger. 2015. Zero-bias autoencoders and the benefits of co-adapting features. arXiv:1402.3337 [stat.ML] https://arxiv.org/abs/1402.3337

    2015 arXiv

  13. [21]

    Alex Krizhevsky. 2009. Learning multiple layers of features from tiny images. (2009)

    2009

  14. [22]

    Mark Kurtz, Justin Kopinsky, Rati Gelashvili, Alexander Matveev, John Carr, Michael Goin, William Leiserson, Sage Moore, Nir Shavit, and Dan Alistarh. 2020. Inducing and exploiting activation sparsity for fast inference on deep neural networks. In International Conference on M...

    2020

  15. [23]

    Se Jung Kwon, Dongsoo Lee, Byeongwook Kim, Parichay Kapoor, Baeseong Park, and Gu-Yeon Wei. 2020. Structured compression by weight encryption for unstructured pruning and quantization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 1909–1918

    2020

  16. [24]

    Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. 2017. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710 (2017)

    2017 arXiv

  17. [25]

    Ji Lin, Yongming Rao, Jiwen Lu, and Jie Zhou. 2017. Runtime Neural Pruning. In Advances in Neural Information Processing Sys- tems, I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fer- gus, S. Vishwanathan, and R. Garnett (Eds.), Vol. 30. Curran Asso- ciates, Inc. https://...

    2017

  18. [26]

    Baoyuan Liu, Min Wang, Hassan Foroosh, Marshall Tappen, and Mari- anna Pensky. 2019. Sparse convolutional neural networks. In Proceed- ings of the IEEE conference on computer vision and pattern recognition . 8060–8068

    2019

  19. [27]

    Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Dar- rell. 2017. Rethinking the value of network pruning. In International Ashe Neth, Sawinder kaur, Mohammad Nur Hossain Khan, Subrata Biswas, Asif Salekin, and Bashima Islam Conference on Learning Representations

    2017

  20. [28]

    Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. 2018. Rethinking the value of network pruning. arXiv preprint arXiv:1810.05270 (2018)

    2018 arXiv

  21. [29]

    Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. 2017. Thinet: A filter level pruning method for deep neural network compression. In Proceedings of the IEEE international conference on computer vision . 5058–5066

    2017

  22. [30]

    Bo Lyu, Hang Yuan, Longfei Lu, and Yunye Zhang. 2021. Resource- constrained neural architecture search on edge devices. IEEE Transac- tions on Network Science and Engineering 9, 1 (2021), 134–142

    2021

  23. [31]

    Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. 2017. Varia- tional dropout sparsifies deep neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70 . JMLR. org, 2498–2507

    2017

  24. [32]

    Alessandro Montanari, Manuja Sharma, Dainius Jenkus, Mohammed Alloulah, Lorena Qendro, and Fahim Kawsar. 2020. ePerceptive: energy reactive embedded intelligence for batteryless sensors. In Proceedings of the 18th Conference on Embedded Networked Sensor Systems . 382– 394

    2020

  25. [33]

    Peihan Qi, Xiaoyu Zhou, Yuanlei Ding, Zhengyu Zhang, Shilian Zheng, and Zan Li. 2022. Fedbkd: Heterogenous federated learning via bidirec- tional knowledge distillation for modulation classification in iot-edge system. IEEE Journal of Selected Topics in Signal Processing 17, 1...

    2022

  26. [34]

    Xiaoyang Qu, Jianzong Wang, and Jing Xiao. 2020. Quantization and knowledge distillation for efficient federated learning on edge de- vices. In 2020 IEEE 22nd International Conference on High Performance Computing and Communications; IEEE 18th International Conference on Smart...

    2020

  27. [35]

    Isma-Ilou Sadou, Seyed Morteza Nabavinejad, Zhonghai Lu, and Ma- soumeh Ebrahimi. 2022. Inference Time Reduction of Deep Neu- ral Networks on Embedded Devices: A Case Study. In 2022 25th Eu- romicro Conference on Digital System Design (DSD) . 205–213. https: //doi.org/10.1109/...

    2022

  28. [36]

    Maying Shen, Pavlo Molchanov, Hongxu Yin, and Jose M Alvarez

  29. [37]

    Surat Teerapittayanon, Bradley McDanel, and Hsiang-Tsung Kung

  30. [38]

    Kleanthis C Thramboulidis, G Doukas, and G Koumoutsos. 2007. A SOA-based embedded systems development environment for indus- trial automation. EURASIP Journal on Embedded Systems 2008 (2007), 1–15

    2007

  31. [39]

    Pete Warden. 2018. Speech commands: A dataset for limited- vocabulary speech recognition. arXiv preprint arXiv:1804.03209 (2018)

    2018 arXiv

  32. [40]

    Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. 2016. Learning structured sparsity in deep neural networks. In Advances in neural information processing systems . NIPS, 2074–2082

    2016

  33. [41]

    Jiaxiang Wu, Cong Leng, Yuhang Wang, Qinghao Hu, and Jian Cheng

  34. [42]

    Tien-Ju Yang, Andrew Howard, Bo Chen, Xiao Zhang, Alec Go, Mark Sandler, Vivienne Sze, and Hartwig Adam. 2018. Netadapt: Platform- aware neural network adaptation for mobile applications. In Proceed- ings of the European conference on computer vision (ECCV) . 285–300

    2018

  35. [43]

    Yun Ye, Ganmei You, Jong-Kae Fwu, Xia Zhu, Qing Yang, and Yuan Zhu. 2020. Channel Pruning via Optimal Thresholding. In Neural Information Processing, Haiqin Yang, Kitsuchart Pasupa, Andrew Chi- Sing Leung, James T. Kwok, Jonathan H. Chan, and Irwin King (Eds.). Springer Intern...

    2020

  36. [44]

    Zhang, Y

    Y. Zhang, Y. Zheng, K. Qian, G. Zhang, Y. Liu, C. Wu, and Z. Yang. 2022. Widar3.0: Zero-Effort Cross-Domain Gesture Recognition With Wi-Fi. IEEE Transactions on Pattern Analysis and Machine Intelligence 44, 11 (nov 2022), 8671–8688. https://doi.org/10.1109/TPAMI.2021.3105387

    2022

  37. [45]

    Kaiqi Zhao, Animesh Jain, and Ming Zhao. 2023. Automatic Attention Pruning: Improving and Automating Model Pruning using Attentions. arXiv:2303.08595 [cs.LG] https://arxiv.org/abs/2303.08595

    2023 arXiv

  38. [46]

    In Proceedings of the IEEE conference on computer vision and pattern recognition

    Quantized convolutional neural networks for mobile devices. In Proceedings of the IEEE conference on computer vision and pattern recognition. 4820–4828

  39. [51]

    Michael Zhu and Suyog Gupta. 2017. To prune, or not to prune: Ex- ploring the efficacy of pruning for model compression. arXiv preprint arXiv:1710.01878 (2017). Received 1 July 2025

    2017 arXiv

  40. [2016]

    In 2016 23rd international conference on pattern recognition (ICPR)

    Branchynet: Fast inference via early exiting from deep neural networks. In 2016 23rd international conference on pattern recognition (ICPR). IEEE, 2464–2469

    2016

  41. [2020]

    https://doi.org/10.48550/arXiv

    Learned Threshold Pruning. https://doi.org/10.48550/arXiv. 2003.00075

    2003 doi arXiv

  42. [2022]

    In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition

    When to prune? a policy towards early structural pruning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 12247–12256

  43. [2025]

    arXiv preprint arXiv:2505.14723 (2025)

    QUADS: QUAntized Distillation Framework for Efficient Speech Language Understanding. arXiv preprint arXiv:2505.14723 (2025)

    2025 arXiv

Pith tools

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