Pith. sign in

REVIEW 4 major objections 5 minor 30 references

FGFP: A Fractional Gaussian Filter and Pruning for Deep Neural Networks Compression

T0 review · 4 major / 5 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 FGFP compresses ResNet-20 to 14.8% of its original size with a 1.52% accuracy drop by replacing full kernels with seven-parameter fractional Gaussian filters and pruning the rest.

desk verdict A promising compression idea whose central conversion step is missing, so the headline numbers are unverified as written. read the letter →

arxiv 2507.22527 v1 pith:F3FXBDRQ submitted 2025-07-30 cs.LG cs.CV

Kuan-Ting Tu , Po-Hsien Yu , Yu-Syuan Tseng , Shao-Yi Chien This is my paper · ORCID
classification cs.LGcs.CV
keywords networkcompressionfractionalGaussianfilterGrünwald–LetnikovderivativeunstructuredpruningResNetCIFAR-10ImageNet2012modelsizereduction
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 proposes a compression framework that replaces full convolution kernel weights with fractional Gaussian filters (FGFs), kernels built as products of shifted Gaussian functions acted on by fractional derivatives, so each kernel costs only seven learned parameters, plus a layer-wise magnitude-pruning pass that removes small weights from the remaining layers. The claim is that this combination shrinks networks substantially while keeping accuracy nearly intact: on CIFAR-10, ResNet-20 loses 1.52 percentage points while cutting model size by 85.2%, and on ImageNet2012, ResNet-50 loses 1.63 points while cutting model size by 69.1%. If the claim holds, a sizeable part of a trained network's parameters are redundant in a specific sense: many filters can be summarized by a smooth, separable, Gaussian-derived formula. That would make deep models considerably cheaper to store and to load on memory-constrained devices.

What carries the argument

The load-bearing object is the three-dimensional fractional Gaussian filter (3D-FGF): a rank-1 separable kernel expressed as the product of Grünwald–Letnikov fractional derivatives of 1D Gaussians along the $x$, $y$, and channel axes. Its seven parameters replace an entire $n \times n \times ch$ weight tensor, so the parameter count collapses from $9\cdot ch$ (for a $3\times 3$ filter) to 7. The channel-attention variant (CA-FGF) instead keeps five shared filter parameters plus one learned weight per channel, trading a little compression for more accuracy. Adaptive unstructured pruning (AUP) then removes small-magnitude weights in rounds, with fine-tuning after each round and rollback if the accuracy threshold is not met. Together the two mechanisms are what the experiments claim outperform low-rank decomposition and pruning baselines.

What would settle it

Take a pretrained ResNet-20, convert its chosen layers to 3D-FGF parameters, reconstruct the explicit kernels from Eq. (11), and measure the mean relative Frobenius-norm error against the original weights; if the error is large, or if evaluating the converted model before any pruning shows an accuracy drop far above the reported 1.52%, the claim that FGFs carry the compression would be falsified.

Watch

Extended reading notes

Core claim

The central discovery, stated on the authors' terms, is that a convolution filter can be re-parameterized as the product of three Grünwald–Letnikov fractional derivatives of one-dimensional Gaussian functions, $F_{3d} = D_x^a G(x) \times D_y^b G(y) \times D_{ch}^c G(ch)$, with each fractional derivative approximated by a trinomial $D^\alpha f(x) \approx f(x) - \alpha f(x-1) + \frac{\alpha(\alpha-1)}{2} f(x-2)$. Sharing these parameters across all input channels and along the channel direction leaves only seven trainable numbers per kernel: three derivative orders $a,b,c$, two spatial centers plus a channel center, and the Gaussian width $\sigma$. The paper further claims that adding this FGF conversion to a simple adaptive unstructured pruning loop, which prunes low-magnitude weights, fine-tunes, and rolls back if accuracy drops, yields accuracy equal to or better than recent low-rank and pruning-only methods at the same or higher compression ratios.

Load-bearing premise

The whole compression rests on the premise that real pretrained convolution kernels can be accurately written as a product of three truncated fractional derivatives of Gaussians, seven numbers per kernel, with the omitted tail of the Grünwald–Letnikov approximation negligible; the paper does not directly verify this representation.

Editorial extensions

If this is right

  • A ResNet-50 on ImageNet2012 would shrink from about 25.6 million parameters to about 7.9 million, making it feasible to store the compressed model in on-device memory.
  • Training the compressed model is cheap because entire kernels are governed by seven numbers, so the FGF layers have very few learnable parameters before pruning.
  • The ablation on ResNet-20 suggests FGF conversion adds value beyond pruning alone: at 0.07M remaining parameters, FGFP with CA-FGF loses 0.86 accuracy points versus 1.19 for AUP by itself.
  • The same recipe applies across architectures and scales, since the paper reports results for ResNet-20/32, WRN-28-10, ResNet-18, and ResNet-50.
  • Because the remaining layers are unstructured-sparse, the final model can be stored with sparse formats, which is what turns the parameter reduction into actual memory savings on edge hardware.

Reading between the lines

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

  • Inference: the FGF's functional form is a strong inductive prior, saying useful learned filters are smooth, separable, and close to Gaussian-derivative shapes, so the method will likely compress best in layers whose kernels resemble classical image filters and worst in layers encoding sharp, non-separable features.
  • Inference: a direct reconstruction test would separate the two contributors to the reported numbers: how accurately the seven-parameter form reproduces the original kernels, versus how much accuracy is recovered by fine-tuning and by AUP; the paper does not isolate these.
  • Inference: the framework could be composed with structured pruning, quantization, or distillation to push memory reduction further, since FGF handles filter-level redundancy while AUP handles element-level redundancy.
  • Inference: parameter count is not the same as inference cost; a natural follow-up is to measure latency and energy on mobile CPUs and GPUs, where the separable Grünwald–Letnikov approximation may or may not translate into speedups.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. This paper introduces FGFP, a compression framework that replaces selected convolutional kernels with fractional Gaussian filters formed as products of truncated Grünwald–Letnikov fractional derivatives of Gaussian functions (seven parameters per 3D-FGF kernel, Eq. 11), and then applies adaptive unstructured pruning to the remaining layers. The manuscript reports strong empirical trade-offs: on CIFAR-10, ResNet-20 achieves a 1.52% accuracy drop with 85.2% parameter compression, and on ImageNet2012, ResNet-50 achieves a 1.63% drop with 69.1% compression. The authors claim these results outperform recent pruning and low-rank compression methods.

Significance. If the reported trade-offs are reproducible, the method is a novel and practically useful compression scheme for convolutional networks: the seven-parameter 3D-FGF parameterization is an elegant way to obtain very high parameter compression, and the ablation in Table 3 shows that combining FGF with AUP outperforms AUP alone at the same parameter budget. The paper also gives careful parameter-count accounting and reports experiments on both CIFAR-10 and ImageNet2012. However, the missing conversion algorithm and the unanalyzed truncation error currently prevent independent verification, and some baseline comparisons are not matched; these issues are central rather than cosmetic.

major comments (4)
  1. [Section 2.4 and Figure 2] The paper never specifies how a pretrained convolutional kernel is mapped to the seven-parameter FGF form of Eq. (11). Section 2.4 states only that "we convert the filters of the pre-trained model into the FGF" and Figure 1 labels a "FGF Conversion Process", but no algorithm is given: there is no objective function, initialization scheme, optimizer, or statement of whether the FGF parameters are fitted to the original weights or are randomly initialized and then trained end-to-end. Because the headline compression/accuracy results rest on this conversion, the method is not reproducible from the manuscript in its current form.
  2. [Equations (4)-(5) and (9)-(11)] The truncation of the Grünwald–Letnikov series is not justified. Equation (4) drops the error term epsilon with the sentence "the error can be ignored", but no bound, numerical estimate, or ablation is supplied. Since all FGF forms in Eqs. (9)-(11) are built from the three-term approximation, the validity of the fitted FGF representation depends on this dropped term; please quantify the approximation error over the allowed ranges a,b,c ∈ [0,2] or provide an ablation with additional series terms.
  3. [Table 1 (WRN-28-10) and Table 2] The WRN-28-10 comparison is not apples-to-apples. GrowEfficient and BackSparse report baselines of 96.20% (with deltas marked as validation accuracy), while the FGFP WRN-28-10 baseline is 94.78%, so a smaller accuracy drop from a lower baseline does not establish superiority. Similar baseline discrepancies appear in Table 2 for ResNet-50 (baselines of 75.90, 76.15, and 76.20 across methods). Please retrain or re-evaluate under a matched protocol and clearly separate validation-based numbers from test accuracy.
  4. [Section 3.1 and Tables 1-4] The empirical claims are reported as single points without error bars, number of runs, or seeds. In addition, Section 3.1 does not specify the fine-tuning schedule for the pruning rounds, the rule for reducing pr, the number of rounds, or how the "deeper layers with larger input channels" are selected for conversion. These details are needed to assess whether the reported accuracy/compression trade-offs are stable and not due to favorable initialization or dataset-specific settings.
minor comments (5)
  1. [Abstract vs. Introduction] The headline numbers are inconsistent: the abstract reports a 1.52% drop with 85.2% compression for ResNet-20, while Section 1 reports a 1.58% drop with 85.1% compression; Table 1 agrees with the abstract, so the introduction should be corrected.
  2. [Figure 1 and Section 2.4] The figure caption and surrounding text refer to "FGFS" in several places (e.g., "Overview of the FGFS methodology", "the FGFS contains two FGF forms"), while the method is named FGFP elsewhere; please unify the terminology.
  3. [Equation (4)] There is a typo in the spelling of Grünwald in Equation (4) ("Grüwald"), and the same equation uses epsilon with an unusual subscript placement; please clean up the notation.
  4. [Section 2.3] The AUP algorithm resembles iterative magnitude pruning but is not compared with standard magnitude pruning or lottery-ticket-style rewinding; such a comparison would help isolate the contribution of the FGF parameterization from the pruning strategy.
  5. [Reproducibility] No code, checkpoints, or configuration files are referenced, which makes it difficult to verify the reported results independently of the textual description.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: FGFP is an empirical architecture/pruning method evaluated on benchmarks, with no fitted parameter renamed as a prediction and no load-bearing self-citation.

full rationale

The derivation chain is not circular. Equations (3)-(5) apply a standard Grünwald-Letnikov expansion and truncate it; dropping the error term is an approximation claim, not a self-referential reduction. Equations (8)-(11) define the FGF, CA-FGF, and 3D-FGF parameterizations as a new filter family; using seven parameters per kernel is an architectural ansatz, not a quantity fitted to the reported accuracy drops. The reported compression ratios are arithmetic parameter counts after conversion and AUP, and the accuracy drops are measured on CIFAR-10 and ImageNet2012 after training and fine-tuning. Nothing in the paper defines a predicted accuracy drop in terms of the FGF parameters themselves, and no load-bearing result is imported from a self-citation: the cited fractional-calculus and FGF works (Zamora et al. 2021; Llanza et al. 2023; Scherer et al. 2011; Jalalinejad et al. 2018) are external. The absence of a detailed description of the FGF conversion procedure in Section 2.4 is a reproducibility gap, not circularity. Therefore no circular step can be quoted with a specific equation-to-equation reduction.

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

The method depends on a set of learned filter parameters, two hand-chosen pruning hyperparameters, and three substantive assumptions: the GL truncation, the representability of pretrained kernels as separable fractional-Gaussian products, and the separability of the Gaussian. No new physical entities are postulated; the invented entities are parametric filter forms evaluated only in this paper.

free parameters (5)
  • fractional derivative orders (a, b for CA-FGF; a, b, c for 3D-FGF)
    Learned during FGF training; constrained to [0,2] so the filters stay within traditional filter forms (Section 2.2).
  • Gaussian center offsets (x0, y0, ch0)
    Learned center positions of the 1D Gaussian factors in x, y, and channel directions (Eq. 6, Eq. 11).
  • Gaussian standard deviation sigma
    Learned spread of the Gaussian factors; sigma > 0 (Section 2.2).
  • pruning percentage per round pr = 3-6%
    Hand-chosen hyperparameter controlling how many parameters are removed each AUP round (Section 2.4).
  • accuracy acceptance threshold theta_acc
    Hand-chosen stopping criterion for accepting or abandoning a pruning round (Section 2.3).
assumptions (4)
  • standard math Grünwald-Letnikov definition of fractional derivative (Eq. 2) is the correct generalization of integer-order derivatives.
    Invoked in Section 2.1 as the basis for the simplified derivative.
  • ad hoc to paper The infinite GL series can be truncated to three terms and the error term epsilon in Eq. (4) can be neglected.
    Eq. (5) is central to the filter construction; the paper drops the error with a one-sentence assertion and no sensitivity analysis.
  • domain assumption A pretrained convolution kernel can be well approximated by a separable product of 1D truncated GL derivatives of Gaussians (FGF representation).
    This is the core modeling assumption behind FGF conversion (Section 2.4); no validation is provided that real kernels have this structure.
  • standard math The 2D Gaussian function is separable, so the FGF can be decomposed into x- and y-direction factors (Eq. 7).
    Used to derive Eq. (8).
invented entities (2)
  • 3D-FGF (three-dimensional fractional Gaussian filter)
    purpose: Represents each convolution kernel with seven learned parameters by applying fractional derivatives of a Gaussian along x, y, and channel dimensions (Eq. 11).
    This is a new filter construction introduced by the paper; the only evidence for its utility is the paper's own experiments.
  • CA-FGF (channel-attention fractional Gaussian filter)
    purpose: Shares the five FGF parameters across channels and adds per-channel scalar weights to reduce parameters to 5+ch (Section 2.2).
    Introduced in this paper as a middle ground between independent FGFs and full sharing; evidence is limited to the paper's experiments.

how reviews work

0 comments
Cite this review

Pith. "Pith review of FGFP: A Fractional Gaussian Filter and Pruning for Deep Neural Networks Compression." pith.science (2026). https://pith.science/paper/F3FXBDRQ

@misc{pith2026250722527,
  author       = {Pith},
  title        = {Pith review of: FGFP: A Fractional Gaussian Filter and Pruning for Deep Neural Networks Compression},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/F3FXBDRQ}},
  note         = {Machine review of arXiv:2507.22527}
}
read the original abstract

Network compression techniques have become increasingly important in recent years because the loads of Deep Neural Networks (DNNs) are heavy for edge devices in real-world applications. While many methods compress neural network parameters, deploying these models on edge devices remains challenging. To address this, we propose the fractional Gaussian filter and pruning (FGFP) framework, which integrates fractional-order differential calculus and Gaussian function to construct fractional Gaussian filters (FGFs). To reduce the computational complexity of fractional-order differential operations, we introduce Gr\"unwald-Letnikov fractional derivatives to approximate the fractional-order differential equation. The number of parameters for each kernel in FGF is minimized to only seven. Beyond the architecture of Fractional Gaussian Filters, our FGFP framework also incorporates Adaptive Unstructured Pruning (AUP) to achieve higher compression ratios. Experiments on various architectures and benchmarks show that our FGFP framework outperforms recent methods in accuracy and compression. On CIFAR-10, ResNet-20 achieves only a 1.52% drop in accuracy while reducing the model size by 85.2%. On ImageNet2012, ResNet-50 achieves only a 1.63% drop in accuracy while reducing the model size by 69.1%.

Figures

Figures reproduced from arXiv: 2507.22527 by the authors.

Figure 1
Figure 1. Overview of the FGFS methodology. The FGF conversion process begins with selecting the largest layer in the pre-trained model and then converting weights into FGF representations to generate the FGF-based model. This process repeats until all selected layers are converted. The AUP process, where the remaining layers of the FGF-based model undergo adaptive unstructured pruning, transforms dense kernels into sparse ke… view at source ↗
Figure 2
Figure 2. The details of FGF Transformation in the FGFS. The composition of the original FGF for a single kernel, where independent FGFs are applied to each channel, reduces the number of parameters from n × n × ch to 5 × ch. On the other hand, the FGFS contains two FGF forms, the CA-FGF and the 3D-FGF. The FGFS shares the parameters of the FGF across all channels. The CA-FGF can reduce the parameter count to 5 + ch with the … view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 26 canonical work pages

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  2. [2]

    Low-rank Tensor Decomposition for Compression of Convolutional Neural Networks Using Funnel Regularization

    Chu, B.-S. and Lee, C.-R. Low-rank tensor decomposition for compression of convolutional neural networks using funnel regularization. arXiv preprint arXiv:2112.03690, 2021

    work page Pith review arXiv 2021

  3. [3]

    L., Zaremba, W., Bruna, J., LeCun, Y., and Fergus, R

    Denton, E. L., Zaremba, W., Bruna, J., LeCun, Y., and Fergus, R. Exploiting linear structure within convolutional networks for efficient evaluation. In Advances in Neural Information Processing Systems, 2014

    work page 2014

  4. [4]

    and Carbin, M

    Frankle, J. and Carbin, M. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019

    2019

  5. [5]

    and Woods, R

    Gonzalez, R. and Woods, R. Digital Image Processing. Prentice Hall, 2008. ISBN 9780131687288

    work page 2008

  6. [6]

    Compact model training by low-rank projection with energy transfer

    Guo, K., Lin, Z., Chen, C., Xing, X., Liu, F., and Xu, X. Compact model training by low-rank projection with energy transfer. IEEE Transactions on Neural Networks and Learning Systems, pp.\ 1--15, 2024. doi:10.1109/TNNLS.2024.3400928

    work page arXiv 2024

  7. [7]

    Learning both weights and connections for efficient neural network

    Han, S., Pool, J., Tran, J., and Dally, W. Learning both weights and connections for efficient neural network. In Advances in Neural Information Processing Systems, 2015

    work page 2015

  8. [8]

    Deep residual learning for image recognition

    He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp.\ 770--778, 2016

    work page 2016

Show all 30 references
  1. [9]

    A simple and flexible modification of gr \"u nwald--letnikov fractional derivative in image processing

    Jalalinejad, H., Tavakoli, A., and Zarmehi, F. A simple and flexible modification of gr \"u nwald--letnikov fractional derivative in image processing. Mathematical Sciences, 12 0 (3): 0 205--210, 2018

    2018

  2. [10]

    Design of an image edge detection filter using the sobel operator

    Kanopoulos, N., Vasanthavada, N., and Baker, R. Design of an image edge detection filter using the sobel operator. IEEE Journal of Solid-State Circuits, 23 0 (2): 0 358--367, 1988. doi:10.1109/4.996

    1988 doi

  3. [11]

    Heuristic rank selection with progressively searching tensor ring network

    Li, N., Pan, Y., Chen, Y., Ding, Z., Zhao, D., and Xu, Z. Heuristic rank selection with progressively searching tensor ring network. Complex & Intelligent Systems, 8 0 (2): 0 771--785, 2022. doi:10.1007/s40747-021-00308-x

    2022 doi

  4. [12]

    Group sparsity: The hinge between filter pruning and decomposition for network compression

    Li, Y., Gu, S., Mayer, C., Van Gool, L., and Timofte, R. Group sparsity: The hinge between filter pruning and decomposition for network compression. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp.\ 8015--8024, 2020

    2020

  5. [13]

    Towards compact cnns via collaborative compression

    Li, Y., Lin, S., Liu, J., Ye, Q., Wang, M., Chao, F., Yang, F., Ma, J., Tian, Q., and Ji, R. Towards compact cnns via collaborative compression. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp.\ 6434--6443, 2021

    2021

  6. [14]

    Tdlc: Tensor decomposition-based direct learning-compression algorithm for dnn model compression

    Liu, W., Liu, P., Shi, C., Zhang, Z., Li, Z., and Liu, C. Tdlc: Tensor decomposition-based direct learning-compression algorithm for dnn model compression. Concurrency and Computation: Practice and Experience, 2024

    2024

  7. [15]

    E., Shvai, N., and Nakib, A

    Llanza, A., Keddous, F. E., Shvai, N., and Nakib, A. Deep learning models compression based on evolutionary algorithms and digital fractional differentiation. In IEEE Congress on Evolutionary Computation (CEC), pp.\ 1--9, 2023

    2023

  8. [16]

    T., Zniyed, Y., and Nguyen, T

    Pham, V. T., Zniyed, Y., and Nguyen, T. P. Enhanced network compression through tensor decompositions and pruning. IEEE Transactions on Neural Networks and Learning Systems, pp.\ 1--13, 2024 a . doi:10.1109/TNNLS.2024.3370294

    2024

  9. [17]

    T., Zniyed, Y., and Nguyen, T

    Pham, V. T., Zniyed, Y., and Nguyen, T. P. Efficient tensor decomposition-based filter pruning. Neural Networks, 178: 0 106393, 2024 b . ISSN 0893-6080. doi:10.1016/j.neunet.2024.106393. URL https://www.sciencedirect.com/science/article/pii/S0893608024003174

    2024

  10. [18]

    Stable low-rank tensor decomposition for compression of convolutional neural network

    Phan, A.-H., Sobolev, K., Sozykin, K., Ermilov, D., Gusak, J., Tichavsk \`y , P., Glukhov, V., Oseledets, I., and Cichocki, A. Stable low-rank tensor decomposition for compression of convolutional neural network. In European Conference on Computer Vision (ECCV), pp.\ 522--539....

    2020

  11. [19]

    Edp: An efficient decomposition and pruning scheme for convolutional neural network compression

    Ruan, X., Liu, Y., Yuan, C., Li, B., Hu, W., Li, Y., and Maybank, S. Edp: An efficient decomposition and pruning scheme for convolutional neural network compression. IEEE Transactions on Neural Networks and Learning Systems, 32 0 (10): 0 4499--4513, 2024. doi:10.1109/TNNLS.202...

    2024

  12. [20]

    L., Tang, Y., and Huang, J

    Scherer, R., Kalla, S. L., Tang, Y., and Huang, J. The gr \"u nwald–letnikov method for fractional differential equations. Computers & Mathematics with Applications, 62 0 (3): 0 902--917, 2011

    2011

  13. [21]

    Elrt: Efficient low-rank training for compact convolutional neural networks

    Sui, Y., Yin, M., Gong, Y., Xiao, J., Phan, H., and Yuan, B. Elrt: Efficient low-rank training for compact convolutional neural networks. arXiv preprint arXiv:2401.10341, 2024

    2024 arXiv

  14. [22]

    Scop: Scientific control for reliable neural network pruning

    Tang, Y., Wang, Y., Xu, Y., Tao, D., XU, C., Xu, C., and Xu, C. Scop: Scientific control for reliable neural network pruning. In Advances in Neural Information Processing Systems, pp.\ 10936--10947, 2020

    2020

  15. [23]

    All-in-one hardware-oriented model compression for efficient multi-hardware deployment

    Wang, H., Ling, P., Fan, X., Tu, T., Zheng, J., Chen, H., Jin, Y., and Chen, E. All-in-one hardware-oriented model compression for efficient multi-hardware deployment. IEEE Transactions on Circuits and Systems for Video Technology, 34 0 (12): 0 12345--12359, 2024. doi:10.1109/...

    2024

  16. [24]

    Soft independence guided filter pruning

    Yang, L., Gu, S., Shen, C., Zhao, X., and Hu, Q. Soft independence guided filter pruning. Pattern Recognition, 153: 0 110488, 2024. ISSN 0031-3203. doi:10.1016/j.patcog.2024.110488. URL https://www.sciencedirect.com/science/article/pii/S0031320324002395

    2024

  17. [25]

    Arpruning: An automatic channel pruning based on attention map ranking

    Yuan, T., Li, Z., Liu, B., Tang, Y., and Liu, Y. Arpruning: An automatic channel pruning based on attention map ranking. Neural Networks, 174: 0 106220, 2024. ISSN 0893-6080. doi:10.1016/j.neunet.2024.106220. URL https://www.sciencedirect.com/science/article/pii/S0893608024001448

    2024

  18. [26]

    Growing efficient deep networks by structured continuous sparsification

    Yuan, X., Savarese, P., and Maire, M. Growing efficient deep networks by structured continuous sparsification. In International Conference on Learning Representations, 2021

    2021

  19. [27]

    and Komodakis, N

    Zagoruyko, S. and Komodakis, N. Wide residual networks. In Proceedings of the British Machine Vision Conference (BMVC), pp.\ 87.1--87.12, 2016

    2016

  20. [28]

    A., Rhodes, A., Nachman, L., and Sundararajan, N

    Zamora, J., Cruz Vargas, J. A., Rhodes, A., Nachman, L., and Sundararajan, N. Convolutional filter approximation using fractional calculus. In IEEE/CVF International Conference on Computer Vision Workshops (ICCVW), pp.\ 383--392, 2021

    2021

  21. [29]

    A systematic dnn weight pruning framework using alternating direction method of multipliers

    Zhang, T., Ye, S., Zhang, K., Tang, J., Wen, W., Fardad, M., and Wang, Y. A systematic dnn weight pruning framework using alternating direction method of multipliers. In European Conference on Computer Vision (ECCV), pp.\ 184--199. Springer, 2018

    2018

  22. [30]

    Efficient neural network training via forward and backward propagation sparsification

    Zhou, X., Zhang, W., Chen, Z., DIAO, S., and Zhang, T. Efficient neural network training via forward and backward propagation sparsification. In Advances in Neural Information Processing Systems, pp.\ 15216--15229, 2021

    2021

Pith tools

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