Pith. sign in

REVIEW 3 major objections 5 minor 38 references

MVQ:Towards Efficient DNN Compression and Acceleration with Masked Vector Quantization

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

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

Pith's one-line read This paper claims that vector quantization of DNN weights fails because important weights are forced to align with unimportant ones, and that pruning unimportant weights before a masked k-means clustering step reduces clustering error by…

desk verdict Solid compression-acceleration co-design; the flagged zero-denominator issue in the masked update is real but easily fixable and shouldn't block peer review. read the letter →

arxiv 2412.10261 v2 pith:TMLUSJ22 submitted 2024-12-13 cs.CV cs.AR

Shuaiting Li , Chengxuan Wang , Juncan Deng , Zeyu Wang , Zewen Ye , Zongsheng Wang , Haibin Shen , Kejie Huang This is my paper · ORCID
classification cs.CVcs.AR
keywords vectorquantizationN:Mpruningmaskedk-meansmodelcompressionsystolicarrayhardware-softwareco-designstructuredsparsityCNNaccelerator
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 argues that vector quantization (VQ) compresses neural networks by replacing groups of weights with a small codebook, but it loses accuracy because important weights get averaged together with unimportant ones. MVQ first prunes the least important weights in each group using $N{:}M$ structured sparsity, then runs a masked k-means that only looks at the surviving weights, so codewords are shaped by the weights that matter. The authors report that this reduces clustering error by 85% compared to running ordinary k-means on sparse weights, and at about 22x compression it beats the PQF baseline by 0.5 to 1.0 percentage points on ResNet-18 and ResNet-50 while also cutting FLOPs by up to 70%. A companion accelerator design loads weights by index instead of full values and uses a sparse systolic array, yielding 2.3x energy efficiency over the EWS baseline and a 55% smaller array. If true, MVQ would make high-ratio VQ practical for edge deployment without the usual accuracy penalty.

What carries the argument

The load-bearing mechanism is masked k-means, a k-means variant whose assignment step computes distances only on coordinates whose pruning mask is 1, and whose update step sets a codeword coordinate to the average of the unpruned weights assigned to it, via the element-wise division in Eq. 4. This prevents the many zeros left by pruning from pulling codewords toward the pruned values, which is exactly what forces important weights to be misapproximated under ordinary k-means. The same mask is reused in fine-tuning through masked gradients, and the mask itself is stored compactly as a lookup-table index of about $\lceil \log_2 C_M^N \rceil/M$ bits per weight. On the hardware side, a sparse tile with $Q = (N/M)d$ PEs plus a leading-zero-counter encoder implements the same masked sparsity, so the accelerator only computes on unpruned weights.

What would settle it

Instrument the masked update during clustering on a layer with $4{:}16$ sparsity and a small codebook; if any codeword has a coordinate where the summed mask is zero, Eq. 4 divides by zero and that coordinate is either NaN or fixed only by initialization, so the reported error reduction cannot be reproduced as written.

Watch

Extended reading notes

Core claim

The central claim is that the accuracy damage from vector quantization is location-dependent: replacing important weights with their quantized versions collapses accuracy, while replacing unimportant ones hardly matters. MVQ therefore identifies important weights by magnitude, prunes the rest with $N{:}M$ structured sparsity, and applies a masked k-means in which both assignment and centroid update skip pruned coordinates. The paper reports that this reduces masked clustering error by 85% versus common k-means on sparse weights at the same compression ratio, achieving 68.8% top-1 on ResNet-18 and 75.2% on ResNet-50 at about 22x compression, versus 68.2% and 74.2% for PQF, before accounting for FLOP savings. On the hardware side, the same mask lets a sparse systolic array use only $N/M$ of the multipliers, cutting the array area by 55% and raising energy efficiency 2.3x over the base EWS accelerator.

Load-bearing premise

The codeword update assumes that every coordinate of every cluster contains at least one unpruned weight, because it divides by the number of unpruned weights in that coordinate and no fallback is given when that count is zero.

Editorial extensions

If this is right

  • If MVQ is right, then at the same storage budget a VQ-compressed network can retain more accuracy than dense VQ baselines, because quantization error is concentrated on pruned, unimportant coordinates.
  • Because the pruned structure is $N{:}M$, the compressed model also has fewer FLOPs, not just fewer bytes, so VQ stops being purely a storage optimization and becomes a compute optimization as well.
  • The mask storage cost is small enough to be worthwhile: with a lookup table for valid $N{:}M$ patterns, the extra bits per weight are logarithmic in the number of patterns rather than one bit per weight.
  • The approach transfers beyond image classification, with reported gains on Mask R-CNN object detection and segmentation and on DeepLab semantic segmentation, where uniform low-bit quantization degrades far more.
  • On the accelerator side, the same structural sparsity that preserves accuracy also permits smaller systolic arrays and higher energy efficiency, so the algorithm and hardware gains compound rather than trade off.

Reading between the lines

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

  • The paper leaves untested whether weight magnitude is the right importance measure; if importance is instead defined by gradient sensitivity or loss curvature, pruning may remove weights whose reconstruction actually matters, and MVQ's accuracy advantage could shrink.
  • The masked update assumes every coordinate of every cluster has at least one unpruned weight; adding a small epsilon or a fallback to the dense update for empty coordinates would make MVQ robust at higher sparsity ratios, such as $1{:}16$, which the paper does not explore.
  • MVQ could likely be combined with adaptive, layerwise $N{:}M$ ratios rather than a fixed pattern, since the paper's own pruning study shows that different models tolerate very different sparsity levels before pruning accuracy drops.
  • A testable extension would be to apply MVQ to activations as well as weights, using the same masked-clustering idea on activation patches, although the paper does not claim this.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. The paper introduces Masked Vector Quantization (MVQ), a compression pipeline that applies N:M pruning to group weights, clusters the unpruned entries with a masked k-means algorithm, quantizes the resulting codebook, and fine-tunes codewords with masked gradients. It then presents a systolic-array accelerator built on the authors' prior EWS dataflow, with assignment-aware weight loading and a sparse tile that skips multiplications on pruned entries. Experiments report accuracy gains over PQF, BGD, and PvQ at comparable compression ratios, FLOPs reductions, and 40 nm ASIC results showing 2.3x energy-efficiency improvement and 55% systolic-array area reduction over the EWS baseline.

Significance. If the reported results hold, MVQ is a practically useful integration of structured pruning and vector quantization. The four-way ablation in Table 3 and the SSE comparison in Table 5 provide direct evidence for the central claim that masking the pruned entries during clustering preserves important weights much better than dense or naively sparse k-means. The hardware evaluation is internally consistent and includes post-synthesis area, power, and energy-efficiency data across three array sizes, which is a clear strength. The main gap is a fixable but load-bearing degeneracy in the masked-update rule, described below, which must be resolved before the algorithm can be reproduced as written; credit is also due for benchmarking against external baselines rather than defining the success metric through the proposed objective.

major comments (3)
  1. [§4.4, Eq. (4)] The masked update divides element-wise by the sum of masks over subvectors assigned to a codeword. For 4:16 sparsity with d=16, each subvector has only 4 unpruned coordinates, so a cluster of moderate size can easily have zero unpruned weights in some coordinate, and an empty cluster makes the denominator zero in every coordinate. The paper does not specify a fallback (epsilon smoothing, skipping the coordinate update, reinitialization, or a minimum-cluster-size rule), so Eq. (4) is undefined in these cases and the algorithm is not reproducible from the text. Because the central '85% clustering-error reduction' claim and the accuracy results depend on this update rule, this gap is load-bearing and must be addressed.
  2. [§4.6, Eq. (6)] The masked-gradient fine-tuning step uses the same element-wise division by sum_p n_p as Eq. (4). The same zero-denominator cases therefore arise during fine-tuning, and no safeguard is described for empty clusters or coordinates with no unpruned weight. Please state explicitly how these cases are handled in the optimizer step; the fine-tuning results reported in Tables 3-6 require this information to be independently reproducible.
  3. [§6.3, Table 3] The headline 85% clustering-error reduction is the ratio of Mask SSE for case D over case C at one configuration (ResNet-18, one sparsity pattern, one codebook size). Since k-means is initialization-dependent and the paper does not report the initialization scheme, number of restarts, or variance across seeds, the reader cannot tell whether the reported error gap is robust. Please report the k-means initialization and seed sensitivity, or state that the reported numbers are from a single run; this is needed to verify the central algorithmic claim.
minor comments (5)
  1. [§3 and §4.4, Eq. (1)] The notation d𝑊𝑟𝑝 in Eq. (1) is undefined; it should presumably be the reconstructed weight matrix, e.g., \hat{W}_rp. Please correct the notation to make the objective unambiguous.
  2. [§4.4] The description of the masked-assignment GPU implementation using torch.cdist is useful, but the batch size, tensor shapes, and memory usage are not specified. Adding these details would improve reproducibility.
  3. [§6.4, Table 4] The MobileNetV1 row lists two MVQ entries with different compression ratios (17x versus 19x) and different FLOPs, without explaining what configuration differs between them. Please clarify the settings for the second entry.
  4. [§6.4, Table 5] The SSE values are stated to be evaluated before fine-tuning, while accuracy is reported after fine-tuning. Please state explicitly whether the PQF SSE numbers were recomputed under the same protocol or taken from the original paper, since the two choices can affect the comparison.
  5. [§7.6, Table 9] The comparison normalizes energy efficiency to a 40 nm process by citing [32], but the derivation of the normalized efficiency for each prior work is not shown. A brief description of the scaling equations used would make the 1.73x claim easier to verify.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: MVQ's accuracy and SSE claims are measured against external baselines; the only self-citation (EWS dataflow) serves as a comparison baseline, not a forcing premise.

full rationale

MVQ's load-bearing claims are not circular. The clustering error reported in Tables 3 and 5 is the masked squared-error objective of Eq. (1), which the masked k-means update (Eqs. 2-4) optimizes; reporting a lower value than common k-means under the same metric is an empirical algorithm comparison, not the metric being defined by the method. Accuracy is benchmarked against external VQ methods PQF, BGD, and PvQ on ImageNet, COCO, and VOC, and hardware efficiency against external sparse accelerators SparTen, CGNet, SPOTS, and S2TA with process normalization (Table 9). The only self-citation is the authors' prior EWS dataflow [35], referenced as the architectural baseline in Sections 5.1 and 7.1; it is used as a comparison point and does not enter the algorithm-level accuracy derivation, so it does not force the reported gains. The zero-denominator issue in Eqs. (4) and (6) is a reproducibility/robustness caveat rather than a circularity, so the score reflects only the minor, non-load-bearing self-citation.

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

The codebook entries themselves are learned as the output of the compression method and are not counted as hidden free parameters. The listed parameters are the hyperparameters that define the compression regime, and the axioms are the unstated mathematical and modeling assumptions the method depends on.

free parameters (4)
  • Codebook size k = 512 or 1024 per layer; 256 to 8192 in the sweep
    Chosen per model and layer to meet a target compression ratio; not derived from a principle.
  • Block size d = 8 or 16
    Selected as a power of 2 for hardware alignment and as a multiple of M for N:M pruning.
  • N:M pruning ratio = 4:16 for ResNets, 1:2 for MobileNets, 3:16 for VGG16
    Selected from pruning-strategy experiments in Section 6.2 to balance pruning accuracy, clustering error, and mask storage.
  • Codebook quantization scale s_w = Learned per codebook via LSQ
    Fitted to data during fine-tuning; a standard quantization scale that affects the final compression and accuracy.
assumptions (4)
  • ad hoc to paper Masked k-means with alternately assigning and updating converges to a locally optimal codebook for the masked SSE objective in Eq. 1.
    The paper assumes the usual k-means convergence behavior, but the masked update in Eq. 4 can be degenerate when a denominator is zero, and no convergence argument is supplied.
  • domain assumption Magnitude-based N:M pruning identifies the least important weights, and fine-tuning after pruning restores most of the accuracy loss.
    Section 4.1 gives a two-case experiment on ImageNet, but the general claim across layers, models, and tasks is assumed rather than proven.
  • domain assumption The EWS dataflow baseline and its energy model from reference [35] are correct and applicable to the networks mapped in this paper.
    The hardware results inherit the EWS design and its reported behavior from prior work by the same group; it is not re-derived or independently verified here.
  • ad hoc to paper For every codeword and every coordinate, at least one assigned subvector has an unpruned weight at that coordinate, so the division in Eq. 4 is well-defined.
    The masked update formula requires a nonzero denominator for each element; the paper does not state or enforce this condition.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MVQ:Towards Efficient DNN Compression and Acceleration with Masked Vector Quantization." pith.science (2026). https://pith.science/paper/TMLUSJ22

@misc{pith2026241210261,
  author       = {Pith},
  title        = {Pith review of: MVQ:Towards Efficient DNN Compression and Acceleration with Masked Vector Quantization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TMLUSJ22}},
  note         = {Machine review of arXiv:2412.10261}
}
abstract

Vector quantization(VQ) is a hardware-friendly DNN compression method that can reduce the storage cost and weight-loading datawidth of hardware accelerators. However, conventional VQ techniques lead to significant accuracy loss because the important weights are not well preserved. To tackle this problem, a novel approach called MVQ is proposed, which aims at better approximating important weights with a limited number of codewords. At the algorithm level, our approach removes the less important weights through N:M pruning and then minimizes the vector clustering error between the remaining weights and codewords by the masked k-means algorithm. Only distances between the unpruned weights and the codewords are computed, which are then used to update the codewords. At the architecture level, our accelerator implements vector quantization on an EWS (Enhanced weight stationary) CNN accelerator and proposes a sparse systolic array design to maximize the benefits brought by masked vector quantization.\\ Our algorithm is validated on various models for image classification, object detection, and segmentation tasks. Experimental results demonstrate that MVQ not only outperforms conventional vector quantization methods at comparable compression ratios but also reduces FLOPs. Under ASIC evaluation, our MVQ accelerator boosts energy efficiency by 2.3$\times$ and reduces the size of the systolic array by 55\% when compared with the base EWS accelerator. Compared to the previous sparse accelerators, MVQ achieves 1.73$\times$ higher energy efficiency.

Figures

Figures reproduced from arXiv: 2412.10261 by the authors.

Figure 1
Figure 1. Two cases to replace some weights with corre￾sponding vector-quantized ones Methods ResNet-18 ResNet-50 SSE Acc SSE Acc Case 1 576 5.8 695 1.26 Case 2 623 37.46 771 55.39 [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Overall compression pipeline of our MVQ algo￾rithm. 1. The grouping strategy is determined for both prun￾ing and vector clustering. Pruning is performed and the sparse model is fine-tuned. 2. Unpruned weights and the mask are incorporated into the masked k-means algorithm to generate the codebook. 3. Symmetric 8-bit quantization is applied to the codebook to ensure hardware-friendliness. 4. The codebook is fine-tune… view at source ↗
Figure 4
Figure 4. A simple example of masked k-means. For subvec￾tor1 and subvector2 assigned to the same codeword, green blocks represent unpruned weights in subvector1, while red blocks represent unpruned weights in subvector2. During the masked assignment step, only the unpruned weights in subvectors are used to calculate distances with the codeword. During the masked update step, only unpruned weights are involved in updating the… view at source ↗
Figures from the paper (14 more)
Figure 5
Figure 5. Figure 5: A simple example of the fine-tuning process. Weights are reconstructed from the codebook, assignments, and masks for forward computation, while masked gradients are calculated to update the codebook. 4.5 Codebook quantization Quantization can be further applied to the …
Figure 6
Figure 6. Figure 6: Overview of our efficient accelerator with masked vector quantization. 5 Accelerator Implementation for MVQ In this section, we display our hardware microarchitecture design and showcase the hardware-software co-design in￾volving masked vector quantization. Denote 𝑏𝑓 a…
Figure 7
Figure 7. Figure 7: Brief description of EWS dataflow feature map plane traversal: In every consecutive 𝐴 cycles, the activations fetched by systolic array stays in the PEs, so that the PEs can switch weights from the WRFs inside them to multiply with the same activations and get psums co…
Figure 8
Figure 8. Figure 8: Implementation of the sparse tile. Every weight subvector written into the systolic array em￾ploys N:M sparsity, however, the computation of 0 elements is meaningless. For EWS dataflow, since the weights in the systolic array are stationary, only 𝑄 = 𝑁 𝑀 × 𝑑 numbers of…
Figure 9
Figure 9. Figure 9: Implementation of the PE with zero value gating. LZC encoder receives d-bit sparsity masks dispatched to the tile by the weight loading controller as input, and 𝑄 position encodings are output and written to the MRF. The MRF and WRF are written and read simultaneously,…
Figure 11
Figure 11. Figure 11: Pruning strategy experiments on MobileNet-v2. 6.2 Pruning strategy When the pruning rate is higher, the accuracy of pruning decreases, while the clustering error becomes smaller, nar￾rowing the gap between clustering accuracy and pruning accuracy. Also, different prun…
Figure 12
Figure 12. Figure 12: Illustration of the four comparing methods in ablation study. ’DW’/’SW’ denotes Dense weight/Sparse weight to be vector clustered. ’CK’/’MK’ denotes common k-means/masked k-means. ’DR’/’SR’ denotes Dense recon￾structed weight/Sparse reconstructed weight. For models wi…
Figure 13
Figure 13. Figure 13: Comparsion with previous VQ-based methods on ResNet-18 and ResNet-50. Methods ResNet-18 ResNet-50 SSE Acc SSE Acc PQF [23] 605 68.2 1150 74.2 Ours 251 68.8 336 75.2 [PITH_FULL_IMAGE:figures/full_fig_p010_13.png]
Figure 14
Figure 14. Figure 14: Data access cost ratio of different levels of mem￾ory DMA, peripheral interfaces, and system interconnections, under three array sizes. 7.3 Energy Analysis Firstly, we model the data access energy cost based on Tab.8. The DRAM result is obtained from [29] and [3], whi…
Figure 15
Figure 15. Figure 15: Data access cost reduction by employing MVQ compression summarized in [PITH_FULL_IMAGE:figures/full_fig_p011_15.png]
Figure 16
Figure 16. Figure 16: Power consumption breakdown for hardware under test. ’Accel’ means the main accelerator which consists of the systolic array, controller and RF. ’Others’ consists CPU, DMA, interface and IO. increases, the effectiveness of EWS-CMS/WS-CMS becomes more pronounced. 7.4 P…
Figure 18
Figure 18. Figure 18: Roofline Model for EWS Array with different sizes 16x16 32x32 64x64 0 2 4 6 TOPS/W 0.7 1.5 2.1 0.9 2.1 4.5 1.5 2.2 2.9 1.8 2.6 3.8 1.9 3.0 4.3 2.3 4.1 6.9 ResNet18 WS WS-CMS EWS EWS-C EWS-CM EWS-CMS 16x16 32x32 64x64 0 2 4 6 TOPS/W 0.9 1.4 1.9 1.1 2.1 3.2 1.8 2.3 2.6 …
Figure 19
Figure 19. Figure 19: does not include main memory access, which typi￾cally accounts for a significant portion of the total energy consumption. Our proposed accelerator benefits from both reduced energy consumption and enhanced performance, showing significant efficiency improvements for b…
Figure 20
Figure 20. Figure 20: Energy efficiency gain compared to WS baseline on more models. * denotes pointwise convolution only. Furthermore, the efficiency improvements for VGG16, AlexNet, and MobileNetV1 are depicted in [PITH_FULL_IMAGE:figures/full_fig_p013_20.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

38 extracted references · 25 canonical work pages

  1. [1]

    Rethinking atrous convolution for semantic image segmentation

    Liang-Chieh Chen. Rethinking atrous convolution for semantic image segmentation. arXiv preprint arXiv:1706.05587, 2017

    arXiv 2017

  2. [2]

    Towards convolutional neural networks compression via global&progressive product quanti- zation

    Weihan Chen, Peisong Wang, and Jian Cheng. Towards convolutional neural networks compression via global&progressive product quanti- zation. In BMVC, 2020

    work page 2020

  3. [3]

    Eyeriss: An energy-efficient reconfigurable accelerator for deep convolutional neural networks

    Yu-Hsin Chen, Tushar Krishna, Joel S Emer, and Vivienne Sze. Eyeriss: An energy-efficient reconfigurable accelerator for deep convolutional neural networks. IEEE journal of solid-state circuits , 52(1):127–138, 2016

    work page 2016

  4. [4]

    Vahid, Saurabh Adya, and Mohammad Raste- gari

    Minsik Cho, Keivan A. Vahid, Saurabh Adya, and Mohammad Raste- gari. Dkm: Differentiable k-means clustering layer for neural network compression, 2022

    work page 2022

  5. [5]

    Learned step size quantiza- tion

    Steven K Esser, Jeffrey L McKinstry, Deepika Bablani, Rathinakumar Appuswamy, and Dharmendra S Modha. Learned step size quantiza- tion. arXiv preprint arXiv:1902.08153, 2019

    arXiv 1902

  6. [6]

    The pascal visual object classes (voc) challenge

    Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. International journal of computer vision , 88:303–338, 2010

    2010

  7. [7]

    Gemmini: Enabling systematic deep-learning architecture evaluation via full-stack integration

    Hasan Genc, Seah Kim, Alon Amid, Ameer Haj-Ali, Vighnesh Iyer, Pranav Prakash, Jerry Zhao, Daniel Grubb, Harrison Liew, Howard Mao, et al. Gemmini: Enabling systematic deep-learning architecture evaluation via full-stack integration. In 2021 58th ACM/IEEE Design Automation Conference (DAC), pages 769–774. IEEE, 2021

    work page 2021

  8. [8]

    Sparten: A sparse tensor accelerator for convolutional neural networks

    Ashish Gondimalla, Noah Chesnut, Mithuna Thottethodi, and TN Vi- jaykumar. Sparten: A sparse tensor accelerator for convolutional neural networks. In Proceedings of the 52nd Annual IEEE/ACM Interna- tional Symposium on Microarchitecture , pages 151–165, 2019

    work page 2019

Show all 38 references
  1. [9]

    Compress- ing deep convolutional networks using vector quantization

    Yunchao Gong, Liu Liu, Ming Yang, and Lubomir Bourdev. Compress- ing deep convolutional networks using vector quantization. arXiv preprint arXiv:1412.6115, 2014

    2014 arXiv

  2. [10]

    Deep compression: Com- pressing deep neural networks with pruning, trained quantization and huffman coding

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

    2015 arXiv

  3. [11]

    Boosting the performance of cnn accelerators with dy- namic fine-grained channel gating

    Weizhe Hua, Yuan Zhou, Christopher De Sa, Zhiru Zhang, and G Ed- ward Suh. Boosting the performance of cnn accelerators with dy- namic fine-grained channel gating. In Proceedings of the 52nd Annual IEEE/ACM international symposium on microarchitecture , pages 139– 150, 2019

    2019

  4. [12]

    Sibia: Signed bit-slice architecture for dense dnn acceleration with slice-level sparsity exploitation

    Dongseok Im, Gwangtae Park, Zhiyong Li, Junha Ryu, and Hoi-Jun Yoo. Sibia: Signed bit-slice architecture for dense dnn acceleration with slice-level sparsity exploitation. In 2023 IEEE International Symposium on High-Performance Computer Architecture (HPCA), pages 69–80. IEEE, 2023

    2023

  5. [13]

    Product quantiza- tion for nearest neighbor search

    Herve Jegou, Matthijs Douze, and Cordelia Schmid. Product quantiza- tion for nearest neighbor search. IEEE transactions on pattern analysis and machine intelligence, 33(1):117–128, 2010

    2010

  6. [14]

    In-datacenter performance analysis of a tensor pro- cessing unit

    Norman P Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, et al. In-datacenter performance analysis of a tensor pro- cessing unit. In Proceedings of the 44th annual international symposium ...

    2017

  7. [15]

    Adam: A method for stochastic optimization

    Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014

    2014 arXiv

  8. [16]

    Pruning vs quantization: Which is better?, 2023

    Andrey Kuzmin, Markus Nagel, Mart van Baalen, Arash Behboodi, and Tijmen Blankevoort. Pruning vs quantization: Which is better?, 2023

    2023

  9. [17]

    Convolu- tional neural network accelerator with vector quantization

    Heng Lee, Yi-Heng Wu, Yu-Sheng Lin, and Shao-Yi Chien. Convolu- tional neural network accelerator with vector quantization. In 2019 IEEE International Symposium on Circuits and Systems (ISCAS) , pages 1–5. IEEE, 2019

    2019

  10. [18]

    Pruning filters for efficient convnets

    Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Pe- ter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016

    2016 arXiv

  11. [19]

    Microsoft coco: Common objects in context

    Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Per- ona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In Computer Vision–ECCV 2014: 13th European Conference, Zurich, Switzerland, September 6-12, 2014, Proceedin...

    2014

  12. [20]

    Systolic tensor array: An efficient structured-sparse gemm accelerator for mo- bile cnn inference

    Zhi-Gang Liu, Paul N Whatmough, and Matthew Mattina. Systolic tensor array: An efficient structured-sparse gemm accelerator for mo- bile cnn inference. IEEE Computer Architecture Letters , 19(1):34–37, 2020

    2020

  13. [21]

    S2ta: Exploiting structured sparsity for energy-efficient mobile cnn ac- celeration

    Zhi-Gang Liu, Paul N Whatmough, Yuhao Zhu, and Matthew Mattina. S2ta: Exploiting structured sparsity for energy-efficient mobile cnn ac- celeration. In 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA), pages 573–586. IEEE, 2022

    2022

  14. [22]

    Learning sparse neural networks through 𝑙_0 regularization

    Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through 𝑙_0 regularization. arXiv preprint arXiv:1712.01312, 2017

    2017 arXiv

  15. [23]

    Permute, quantize, and fine-tune: Efficient compression of neural networks

    Julieta Martinez, Jashan Shewakramani, Ting Wei Liu, Ioan Andrei Barsan, Wenyuan Zeng, and Raquel Urtasun. Permute, quantize, and fine-tune: Efficient compression of neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p...

    2021

  16. [24]

    Accel- erating sparse deep neural networks

    Asit Mishra, Jorge Albericio Latorre, Jeff Pool, Darko Stosic, Dusan Stosic, Ganesh Venkatesh, Chong Yu, and Paulius Micikevicius. Accel- erating sparse deep neural networks. arXiv preprint arXiv:2104.08378, 2021

    2021 arXiv

  17. [25]

    Importance estimation for neural network pruning

    Pavlo Molchanov, Arun Mallya, Stephen Tyree, Iuri Frosio, and Jan Kautz. Importance estimation for neural network pruning. In Pro- ceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 11264–11272, 2019

    2019

  18. [26]

    Antonio Pullini, Davide Rossi, Igor Loi, Giuseppe Tagliavini, and Luca Benini. Mr. wolf: An energy-precision scalable parallel ultra low power soc for iot edge processing. IEEE Journal of Solid-State Circuits , 54(7):1970–1981, 2019

    1970

  19. [27]

    Comparing rewinding and fine-tuning in neural network pruning

    Alex Renda, Jonathan Frankle, and Michael Carbin. Comparing rewinding and fine-tuning in neural network pruning. arXiv preprint arXiv:2003.02389, 2020

    2003 arXiv

  20. [28]

    4.4 a 1.3 tops/w@ 32gops fully integrated 10-core soc for iot end-nodes with 1.7 𝜇w cognitive wake-up from mram-based state-retentive sleep mode

    Davide Rossi, Francesco Conti, Manuel Eggiman, Stefan Mach, Alfio Di Mauro, Marco Guermandi, Giuseppe Tagliavini, Antonio Pullini, Igor Loi, Jie Chen, et al. 4.4 a 1.3 tops/w@ 32gops fully integrated 10-core soc for iot end-nodes with 1.7 𝜇w cognitive wake-up from mram-based s...

    2021

  21. [29]

    An energy-efficient deep convolutional neural network inference processor with enhanced output stationary dataflow in 65-nm cmos

    Jaehyeong Sim, Somin Lee, and Lee-Sup Kim. An energy-efficient deep convolutional neural network inference processor with enhanced output stationary dataflow in 65-nm cmos. IEEE Transactions on Very Large Scale Integration (VLSI) Systems , 28(1):87–100, 2019

    2019

  22. [30]

    An accelerator for sparse convolutional neural networks leveraging systolic general matrix-matrix multiplication

    Mohammadreza Soltaniyeh, Richard P Martin, and Santosh Na- garakatte. An accelerator for sparse convolutional neural networks leveraging systolic general matrix-matrix multiplication. ACM Trans- actions on Architecture and Code Optimization (TACO), 19(3):1–26, 2022

    2022

  23. [31]

    Clustering con- volutional kernels to compress deep neural networks

    Sanghyun Son, Seungjun Nah, and Kyoung Mu Lee. Clustering con- volutional kernels to compress deep neural networks. In Proceedings of the European conference on computer vision (ECCV) , pages 216–232, 2018

    2018

  24. [32]

    Scaling equations for the accu- rate prediction of cmos device performance from 180 nm to 7 nm

    Aaron Stillmaker and Bevan Baas. Scaling equations for the accu- rate prediction of cmos device performance from 180 nm to 7 nm. Integration, 58:74–81, 2017

    2017

  25. [33]

    And the bit goes down: Revisiting the quantization of neural networks

    Pierre Stock, Armand Joulin, Rémi Gribonval, Benjamin Graham, and Hervé Jégou. And the bit goes down: Revisiting the quantization of neural networks. arXiv preprint arXiv:1907.05686, 2019

    1907 arXiv

  26. [34]

    Dominosearch: Find layer-wise fine-grained n: M sparse schemes from dense neural networks

    Wei Sun, Aojun Zhou, Sander Stuijk, Rob Wijnhoven, Andrew O Nel- son, Henk Corporaal, et al. Dominosearch: Find layer-wise fine-grained n: M sparse schemes from dense neural networks. Advances in neural Masked Vector Quantization For Efficient DNN Compression and Acceleration ...

    2025

  27. [35]

    Ews: An energy-efficient cnn accelera- tor with enhanced weight stationary dataflow

    Chengxuan Wang, Zongsheng Wang, Shuaiting Li, Yuanming Zhang, Haibin Shen, and Kejie Huang. Ews: An energy-efficient cnn accelera- tor with enhanced weight stationary dataflow. IEEE Transactions on Circuits and Systems II: Express Briefs , 2024

    2024

  28. [36]

    Quantized convolutional neural networks for mobile devices

    Jiaxiang Wu, Cong Leng, Yuhang Wang, Qinghao Hu, and Jian Cheng. Quantized convolutional neural networks for mobile devices. In Pro- ceedings of the IEEE conference on computer vision and pattern recogni- tion, pages 4820–4828, 2016

    2016

  29. [37]

    Accelerator design for vector quantized convolutional neural network

    Yi-Heng Wu, Heng Lee, Yu Sheng Lin, and Shao-Yi Chien. Accelerator design for vector quantized convolutional neural network. In2019 IEEE International Conference on Artificial Intelligence Circuits and Systems (AICAS), pages 46–50. IEEE, 2019

    2019

  30. [38]

    Learning n: m fine-grained structured sparse neural networks from scratch

    Aojun Zhou, Yukun Ma, Junnan Zhu, Jianbo Liu, Zhijie Zhang, Kun Yuan, Wenxiu Sun, and Hongsheng Li. Learning n: m fine-grained structured sparse neural networks from scratch. arXiv preprint arXiv:2102.04010, 2021

    2021 arXiv

Pith tools

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