Pith. sign in

REVIEW 3 major objections 5 minor 56 references

Learning Filter Basis for Convolutional Neural Network Compression

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

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

Pith's one-line read Splitting filters along channels beats whole-filter CNN compression

desk verdict Split-wise filter basis is a real contribution, but the SR compression numbers only count residual blocks—so the 'EDSR to SRResNet' claim doesn't hold as stated. read the letter →

arxiv 1908.08932 v2 pith:ZE6XZQYL submitted 2019-08-23 cs.CV

Yawei Li , Shuhang Gu , Luc Van Gool , Radu Timofte This is my paper · ORCID
classification cs.CV
keywords CNNcompressionfilterbasislearningsplit-wisedecompositionlow-rankapproximationsharingnetworkimagesuper-resolutionclassification
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

This paper proposes a filter-basis method for compressing convolutional neural networks. Instead of treating each 3D filter as one indivisible object or each 2D channel filter separately, it splits every filter into $s$ groups along the input-channel dimension and represents all $n \cdot s$ splits as linear combinations of a small shared basis. The paper derives the split count that minimizes the parameter count, $s^* = \sqrt{cwh/n}$, and shows that whole-filter and channel-wise decompositions are only the two extremes of the same formula. On VGG, ResNet, and DenseNet for CIFAR-10 classification and on SRResNet and EDSR for super-resolution, it reports lower error or better PSNR than prior decomposition methods at equal or smaller model size. The point of the approach is that the best compression operates in between the two 'hard' decomposition strategies rather than at either boundary.

What carries the argument

The central object is split-wise filter-basis decomposition: a $c\times w\times h$ filter tensor is cut into $s$ slices of size $p\times w\times h$ with $c = s \cdot p$, and the resulting $n \cdot s$ slices are written as linear combinations of $m$ shared basis filters. The identity that carries the argument is the compression-rate formula $\Gamma_{\text{split}} = \frac{m}{n s} + \frac{m}{p w h}$, which balances basis storage against coefficient storage; minimizing it yields $s^* = \sqrt{cwh/n}$, the in-between operating point. The second mechanism is convolutional re-implementation: the reconstructed filter convolution equals a convolution of each input split with the basis followed by a $1\times 1$ convolution of the coding coefficients, so no special hardware or custom operator is needed. Basis sharing across layers, residual blocks, or entire networks is a further knob that reduces the $m$ term in the compression ratio.

What would settle it

Take a trained convolutional layer with fixed $c$, $n$, $w$, $h$; keep $m$ fixed, sweep $s$ over divisors of $c$, train each split-wise decomposition to convergence, and measure the resulting reconstruction error or end-to-end accuracy. If the $s$ that minimizes $\Gamma_{\text{split}}$ does not also give the best accuracy at a fixed parameter budget, or if narrow splits require a noticeably larger $m$ to match the error of $s=1$, then Eq. (13) selects parameters rather than accuracy and the paper's trade-off claim would fail.

Watch

Extended reading notes

Core claim

The central claim is that every convolutional layer can be approximated as a small learned basis $B$ shared across channel splits plus a $1\times 1$ convolution of coding coefficients $A$, and that the parameter-optimal degree of splitting is neither whole-filter ($s=1$) nor per-channel ($s=c$) but the middle point given by $s^* = \sqrt{cwh/n}$. With $c$ input channels, $n$ output channels, and kernel size $w\times h$, the compression ratio is $\Gamma_{\text{split}} = \frac{m}{n s} + \frac{m}{p w h}$; minimizing it over $s$ with $c = s p$ gives the optimal split. Because the basis has only $p$ input channels, the method can reduce input channels, making narrow networks like DenseNet and $1\times 1$ convolutions compressible, and because convolution is linear, the decomposed operation is implemented exactly as a basis convolution followed by a $1\times 1$ convolution. The paper validates the claim with classification experiments on VGG-16, ResNet-56, and DenseNet-12-40 and super-resolution experiments on SRResNet and EDSR, reporting accuracy and parameter trade-offs favorable against the Factor, Group, K-means, and KSE baselines.

Load-bearing premise

The optimal split count is derived from parameter counts alone: it assumes that a basis of fixed size $m$ represents narrow splits about as accurately as wide ones, so the cheapest split is also the accuracy-preserving one, but the experiments choose $m$ and $p$ per network rather than testing that invariance.

Editorial extensions

If this is right

  • Every standard convolution can be replaced by a basis convolution followed by a $1\times 1$ convolution, so the compressed model runs on ordinary deep-learning libraries without custom layers.
  • Layers with many more input channels than output channels, the narrow-network case such as DenseNet, become compressible because splitting reduces the per-basis input channel count.
  • $1\times 1$ convolutions fall under the same formula, so bottleneck and transition layers can be compressed instead of being left untouched.
  • The compression-rate identity unifies prior decomposition work: $s=1$ is whole-filter decomposition and $s=c$ is channel-wise decomposition, making them boundary cases of one knob.
  • Basis sharing within residual blocks, groups, or whole networks multiplies the savings of the split-wise scheme with little additional accuracy loss, as shown in the EDSR and DenseNet results.

Reading between the lines

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

  • Since Eq. (13) reduces to $s^* \approx \sqrt{w \cdot h}$ when $c \approx n$, a no-search rule of thumb follows: try 3-way splits for $3\times 3$ kernels and 5-way splits for $5\times 5$ kernels; the paper's tables are consistent with that region but do not state it as a rule.
  • The decomposition is a structured low-rank factorization in which input-channel splits share one basis, which suggests the same ratio-balancing argument could be ported to tensorized architectures or to convolution-like operators in other domains where $w \cdot h$ is replaced by the effective kernel dimension.
  • Because $m$ and $s$ are selected manually per network in the experiments, an immediate extension is to treat them as learnable per-layer hyperparameters, using Eq. (13) as initialization or as a regularizer toward the parameter-optimal point.
  • The compression is orthogonal to pruning and quantization, so stacking all three on one network should give roughly multiplicative savings; the paper does not test this combination.
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 proposes a filter-basis decomposition method for convolutional neural network compression. It splits the 3D filters of a convolution layer along the input channel dimension and represents the resulting p×w×h filter splits as linear combinations of a learned basis set. The authors derive compression-rate formulas for whole-filter, channel-wise, and split-wise decompositions, obtain a closed-form split choice that minimizes the parameter count for a fixed basis size, and show that the decomposition can be implemented as a shared-weight convolution followed by a 1×1 convolution. Experiments are reported on CIFAR-10 image classification (VGG-16, ResNet-56, DenseNet-12-40) and on image super-resolution (SRResNet, EDSR-8-128, EDSR), with comparisons to several filter-decomposition baselines. The paper claims state-of-the-art compression performance in terms of parameter reduction and accuracy preservation.

Significance. The split-wise formulation is a natural generalization that interpolates between whole-filter and channel-wise filter decomposition, and the convolution-equivalence derivation in Section 3.3 is sound. If the experimental claims are confirmed, the method would be a flexible and practical compression tool, particularly for architectures with many 1×1 convolutions or narrow layers. Strengths of the paper include the transparent derivation of the parameter-count formulas (Eqs. 7–13), the practical implementation via shared-weight convolutions, and validation on external benchmarks with publicly released code. However, the central claim of network-level state-of-the-art compression currently rests on per-residual-block parameter accounting, which is not sufficient to establish the advertised model-size reductions. The significance as presented is therefore not yet fully established.

major comments (3)
  1. [Section 5.1, Tables 1-3] The paper states that 'we report the number of parameters and compression ratio for one residual block since all of the other blocks has the same parameter,' but the surrounding text uses these numbers for network-level conclusions: 'this operating point brings the model size from EDSR level to SRResNet level' and the abstract claims fewer parameters than prior compression baselines. Full-network parameter counts are not reported. EDSR has 32 residual blocks plus uncompressed head, tail, and upsampling convolutions; a per-block count of 17k at the most aggressive setting gives roughly 0.54M parameters for the blocks alone, and the unchanged layers still contribute several million. The reported 'Comp. (%)' values (e.g., 1.5%, 7.6%, 13.9%) are therefore residual-block compression ratios, not whole-network ratios. The 'fewer parameters' and 'EDSR-level to SRResNet-level' claims are not established as stated.
  2. [Tables 1 and 3, Eq. (12)] The parameter counts in Table 1 appear inconsistent with a per-residual-block interpretation. For EDSR with c=n=256, w=h=3 and two splits, Eq. (12) gives 53,248 parameters for a single 3×3 convolution; a residual block of two such convolutions would have 106,496 parameters. Table 1 reports 53k for m=32 without sharing, which is the per-convolution number. The 'Basis Share' entry of 35k is close to the value obtained by amortizing a network-wide shared basis over 32 residual blocks, rather than by sharing only the two convolutions within a residual block as stated in the text. Please clarify the exact parameter accounting and report full-network parameter totals for the compressed models.
  3. [Section 3.2, Eq. (13)] The optimization in Eq. (13) minimizes the parameter count for a fixed basis size m. The closed-form split s* is therefore a parameter-count optimum conditional on m, not an accuracy-parameter optimum. The paper does not analyze or measure how the required basis size m varies with the split width p; the experiments tune both m and p per architecture (Tables 7-9). Thus the claim that Eq. (13) identifies the optimal split configuration for compression is stronger than what is demonstrated. This is a limitation rather than an internal error, but it should be acknowledged and ideally tested with a controlled experiment varying s and m independently.
minor comments (5)
  1. [Table 1 caption] The caption says 'The number of splits p for one convolution is 4,' but in the main text s denotes the number of splits and p the split width; please harmonize the notation.
  2. [Section 5.1, Table 1] The sentence 'when m = 64 and basis sharing is used, the compressed model only accounts for 9% of the parameters' should read 'without basis sharing' to match the 9.0% entry; the basis-sharing entry for m=64 is 5.9%.
  3. [Section 3.2, Eqs. (7)-(10)] Equations (9) and (10) repeat Eqs. (7) and (8) verbatim; please remove the duplicate lines.
  4. [Table 6] The ResNet-56 baseline error for the proposed method is listed as 7.05 in Table 6, while Table 5 uses 6.28 for the same network; the discrepancy should be explained.
  5. [Section 3.2] The statement 'the optimal group s* ≈ sqrt(w×h)' assumes c≈n and ignores the integrality constraints on s and p; a sentence explaining how non-divisible cases are handled in practice would be helpful.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the filter-basis decomposition, compression-rate formulas, and optimal split derivation are self-contained parameter-count arithmetic, and empirical claims are validated on external benchmarks.

full rationale

The paper's derivation chain is self-contained. Section 3 frames filter decomposition as W ≈ B·A and defines compression rates by direct parameter counting (Eqs. 7–12). The split-wise rate Γ_split = m/(n·s) + m/(p·w·h) is obtained by counting basis and coefficient parameters after splitting c input channels into s groups of size p. Eq. (13) minimizes this expression under c = s·p, giving s* = sqrt(c·w·h/n) and p* = sqrt(n·c/(w·h)); this is pure arithmetic and does not presuppose the experimental conclusion. The accuracy claims rest on training compressed networks on CIFAR-10 and DIV2K and testing on held-out benchmarks (Set5, Set14, B100, Urban100, DIV2K validation), so the central result is not equivalent to an input or fitted parameter. The basis size m and split counts are user-chosen operating points, tuned per network in Tables 7–9; this is standard hyperparameter selection, not a fitted parameter renamed as a prediction. The paper cites some of the authors' own prior work (CARN, 3D appearance super-resolution, the NTIRE dataset paper), but these citations are contextual related-work references and are not load-bearing for the compression method or its evaluation. The per-residual-block parameter reporting noted by the skeptic is a potential correctness or presentation issue about how compression ratios extrapolate to full networks, but it is not a circularity: it does not make any derived claim equivalent to its inputs by construction. Overall, the derivation is independent and the score is 0.

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

The paper introduces no new physical or algorithmic entities beyond learned basis filters and coding coefficients, which are standard optimization parameters. The principal free parameters are the basis size m, the split configuration (p, s), the approximation loss weight gamma, and the basis sharing pattern. The main axioms are the empirical compressibility of CNN filters into a shared linear basis and the use of parameter-count minimization as a proxy for the accuracy-parameter trade-off. The derivation of Eq. (13) is internally consistent, but its practical validity depends on m being independent of split width, which is not tested.

free parameters (4)
  • basis size m = 16-128 depending on network (e.g., 32 for EDSR, 128 for VGG-16)
    The number of basis filters per layer or group; the central knob controlling compression ratio and accuracy. It is chosen per architecture and operating point (Tables 7-9), not derived from theory.
  • split width p or number of splits s = p=4 for EDSR (Table 1); s=1, 6, 12 for DenseNet transition layers
    The channel dimension of each split. Eq. (13) gives a formula for the optimal value, but the paper quantizes it to integers dividing c and adjusts per network (Tables 7-9).
  • approximation loss weight gamma = not reported (unknown)
    The relative weight of the filter approximation term in Eq. (18). The paper never states the value used in training, despite this weight controlling the trade-off between task loss and approximation error.
  • basis sharing configuration = network-wise for DenseNet, group-wise for ResNet, block-wise for EDSR
    Which layers share a basis is chosen by hand for each architecture (Sec. 4.2), and it affects both the compression ratio and the resulting accuracy.
assumptions (4)
  • domain assumption Filters in a convolutional layer, when split along the input channel dimension, lie near a low-dimensional linear subspace, so a shared basis of size m can represent all splits with bounded error.
    This is the core premise of the method. The paper provides no theoretical bound, only empirical validation in Sec. 5.
  • standard math Convolution is linear, so the convolution with a linear combination of basis filters equals the linear combination of convolutions with each basis filter.
    Used in Eq. (14) and Eq. (17) to convert the decomposition into standard convolution operations.
  • domain assumption After replacing the original filters with the basis representation, joint fine-tuning with the loss in Eq. (18) recovers most of the lost accuracy.
    The experiments assume this, but the paper does not analyze when fine-tuning succeeds; it reports only final numbers.
  • domain assumption Minimizing the parameter-count compression rate in Eq. (12) is a sensible proxy for the accuracy-parameter trade-off.
    Eq. (13) derives the optimal split from parameter counts alone; the paper assumes this also gives a good accuracy-parameter operating point, which is only tested empirically for a few configurations.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Learning Filter Basis for Convolutional Neural Network Compression." pith.science (2026). https://pith.science/paper/ZE6XZQYL

@misc{pith2026190808932,
  author       = {Pith},
  title        = {Pith review of: Learning Filter Basis for Convolutional Neural Network Compression},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZE6XZQYL}},
  note         = {Machine review of arXiv:1908.08932}
}
read the original abstract

Convolutional neural networks (CNNs) based solutions have achieved state-of-the-art performances for many computer vision tasks, including classification and super-resolution of images. Usually the success of these methods comes with a cost of millions of parameters due to stacking deep convolutional layers. Moreover, quite a large number of filters are also used for a single convolutional layer, which exaggerates the parameter burden of current methods. Thus, in this paper, we try to reduce the number of parameters of CNNs by learning a basis of the filters in convolutional layers. For the forward pass, the learned basis is used to approximate the original filters and then used as parameters for the convolutional layers. We validate our proposed solution for multiple CNN architectures on image classification and image super-resolution benchmarks and compare favorably to the existing state-of-the-art in terms of reduction of parameters and preservation of accuracy.

Figures

Figures reproduced from arXiv: 1908.08932 by the authors.

Figure 1
Figure 1. Comparison of different filter decomposition methods. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Illustration of the proposed basis learning method. Oper [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Basis sharing for the compression of DenseNet-12-40. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: SR results of bird image for upscaling factor ×4. Network compression methods are applied on EDSR [34]. Model Method Top-1 Error (%) / Baseline #Parameters Compression Rate(%) VGG-16 K-means [46] 6.24 / 5.98 3.27M 22.2 Factor [47] 7.12 / 5.98 3.34M 22.7 Group [41] 6.69…
Figure 5
Figure 5. Figure 5: Comparison between our method and KSE [32] for ResNet-56 on CIFAR10. lower than ours, its accuracy is the worst among all the com￾pared methods. For ResNet-56, our method performs com￾parable with Group in terms of accuracy while with 20k fewer parameters [PITH_FULL_I…
Figure 6
Figure 6. Figure 6: Training and testing error of different compression method applied on DenseNet-12-40. [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: Training and testing error of different compression method applied on VGG-16. [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Training and testing error of different compression method applied on ResNet-56. [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: SR results for upscaling factor ×4. Network compression methods are applied on EDSR. PSNR values are reported. C. More Visual Results for Super-Resolution More visual results for image super-resolution are shown in [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 10
Figure 10. Figure 10: SR results for upscaling factor ×4. Network compression methods are applied on SRResNet. PSNR values are reported [PITH_FULL_IMAGE:figures/full_fig_p014_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

56 extracted references · 48 canonical work pages

  1. [1]

    Tensorflow: A system for large-scale machine learning

    Mart ´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghe- mawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for large-scale machine learning. In OSDI, vol- ume 16, pages 265–283, 2016. 5

    work page 2016

  2. [2]

    NTIRE 2017 chal- lenge on single image super-resolution: Dataset and study

    Eirikur Agustsson and Radu Timofte. NTIRE 2017 chal- lenge on single image super-resolution: Dataset and study. In Proc. CVPRW, July 2017. 6

    work page 2017

  3. [3]

    Learning the num- ber of neurons in deep networks

    Jose M Alvarez and Mathieu Salzmann. Learning the num- ber of neurons in deep networks. In Proce. NIPS, pages 2270–2278, 2016. 2

    work page 2016

  4. [4]

    Low-complexity single-image super-resolution based on nonnegative neighbor embedding

    Marco Bevilacqua, Aline Roumy, Christine Guillemot, and Marie Line Alberi-Morel. Low-complexity single-image super-resolution based on nonnegative neighbor embedding. In Proc. BMVC, 2012. 6

    work page 2012

  5. [5]

    Compressing neural networks with the hashing trick

    Wenlin Chen, James Wilson, Stephen Tyree, Kilian Wein- berger, and Yixin Chen. Compressing neural networks with the hashing trick. In Proc. ICML, pages 2285–2294, 2015. 2

    work page 2015

  6. [6]

    Binaryconnect: Training deep neural networks with binary weights during propagations

    Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Proc. NIPS, pages 3123–3131, 2015. 2

    work page 2015

  7. [7]

    Binarized neural networks: Training deep neural networks with weights and activations constrained to +1 or-1

    Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to +1 or-1. arXiv preprint arXiv:1602.02830 ,

    arXiv

  8. [8]

    Eco: Efficient convolution opera- tors for tracking

    Martin Danelljan, Goutam Bhat, Fahad Shahbaz Khan, Michael Felsberg, et al. Eco: Efficient convolution opera- tors for tracking. In Proc. ICCV, volume 1, page 7, 2017. 2

    work page 2017

Show all 56 references
  1. [9]

    Exploiting linear structure within con- volutional networks for efficient evaluation

    Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann Le- Cun, and Rob Fergus. Exploiting linear structure within con- volutional networks for efficient evaluation. In Proc. NIPS, pages 1269–1277, 2014. 2, 5

    2014

  2. [10]

    Learning a deep convolutional network for image super-resolution

    Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Learning a deep convolutional network for image super-resolution. In Proc. ECCV, pages 184–199. Springer,

  3. [11]

    Fast R-CNN

    Ross Girshick. Fast R-CNN. In Proc. ICCV, pages 1440– 1448, 2015. 1

    2015

  4. [12]

    Rich feature hierarchies for accurate object detection and semantic segmentation

    Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In Proc. CVPR, pages 580–587,

  5. [13]

    Multi- bin trainable linear unit for fast image restoration networks

    Shuhang Gu, Radu Timofte, and Luc Van Gool. Multi- bin trainable linear unit for fast image restoration networks. arXiv preprint arXiv:1807.11389, 2018. 1

    2018 arXiv

  6. [14]

    Deep com- pression: Compressing deep neural networks with pruning, trained quantization and huffman coding

    Song Han, Huizi Mao, and William J Dally. Deep com- pression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015. 1, 2

    2015 arXiv

  7. [15]

    Learning both weights and connections for efficient neural network

    Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Proc. NIPS, pages 1135–1143, 2015. 1, 2

    2015

  8. [16]

    Deep residual learning for image recognition

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proc. CVPR, pages 770–778, 2016. 1, 5, 6, 8, 11

    2016

  9. [17]

    AMC: AutoML for model compression and ac- celeration on mobile devices

    Yihui He, Ji Lin, Zhijian Liu, Hanrui Wang, Li-Jia Li, and Song Han. AMC: AutoML for model compression and ac- celeration on mobile devices. In Proc. ECCV, pages 784– 800, 2018. 8

    2018

  10. [18]

    Channel pruning for accelerating very deep neural networks

    Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proc. ICCV, pages 1389–1397, 2017. 1, 2

    2017

  11. [19]

    Densely connected convolutional net- works

    Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kil- ian Q Weinberger. Densely connected convolutional net- works. In Proc. CVPR, pages 2261–2269, 2017. 1, 5, 6, 7, 8, 11

    2017

  12. [20]

    Single image super-resolution from transformed self-exemplars

    Jia-Bin Huang, Abhishek Singh, and Narendra Ahuja. Single image super-resolution from transformed self-exemplars. In Proc. CVPR, pages 5197–5206, 2015. 6

    2015

  13. [21]

    Speeding up convolutional neural networks with low rank expansions

    Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. In Proc. BMVC, 2014. 1, 2, 3, 5

    2014

  14. [22]

    Efficient neural network compression

    Hyeji Kim, Muhammad Umar Karim Khan, and Chong-Min Kyung. Efficient neural network compression. In Proc. CVPR, June 2019. 8

    2019

  15. [23]

    Accurate image super-resolution using very deep convolutional net- works

    Jiwon Kim, Jung Kwon Lee, and Kyoung Mu Lee. Accurate image super-resolution using very deep convolutional net- works. In Proc. CVPR, 2016. 1

    2016

  16. [24]

    Adam: A method for stochastic optimization

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

    arXiv

  17. [25]

    Learning multiple layers of features from tiny images

    Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Cite- seer, 2009. 6, 8

    2009

  18. [26]

    Imagenet classification with deep convolutional neural net- works

    Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural net- works. In Proc. NIPS, pages 1097–1105, 2012. 1

    2012

  19. [27]

    Speeding-up convolutional neural networks using fine-tuned cp-decomposition

    Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Os- eledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. arXiv preprint arXiv:1412.6553, 2014. 2

    2014 arXiv

  20. [28]

    Photo- realistic single image super-resolution using a generative ad- versarial network

    Christian Ledig, Lucas Theis, Ferenc Husz´ar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo- realistic single image super-resolution using a generative ad- versarial network. In Proc. CVPR, pages 105...

    2017

  21. [29]

    Joint blind motion deblurring and depth estimation of light field

    Dongwoo Lee, Haesol Park, In Kyu Park, and Kyoung Mu Lee. Joint blind motion deblurring and depth estimation of light field. In Proc. ECCV, pages 288–303, 2018. 1

    2018

  22. [30]

    Ternary weight networks

    Fengfu Li, Bo Zhang, and Bin Liu. Ternary weight networks. arXiv preprint arXiv:1605.04711, 2016. 1

    2016 arXiv

  23. [31]

    CARN: convolutional anchored re- gression network for fast and accurate single image super- resolution

    Yawei Li, Eirikur Agustsson, Shuhang Gu, Radu Timofte, and Luc Van Gool. CARN: convolutional anchored re- gression network for fast and accurate single image super- resolution. In Proc. ECCVW , pages 166–181. Springer,

  24. [32]

    Exploiting kernel sparsity and entropy for inter- pretable CNN compression

    Yuchao Li, Shaohui Lin, Baochang Zhang, Jianzhuang Liu, David Doermann, Yongjian Wu, Feiyue Huang, and Ron- grong Ji. Exploiting kernel sparsity and entropy for inter- pretable CNN compression. In Proc. CVPR, 2019. 7, 8

    2019

  25. [33]

    3D appearance super-resolution with deep learning

    Yawei Li, Vagia Tsiminaki, Radu Timofte, Marc Pollefeys, and Luc Van Gool. 3D appearance super-resolution with deep learning. In Proc. ICCV, 2019. 1

    2019

  26. [34]

    Enhanced deep residual networks for single image super-resolution

    Bee Lim, Sanghyun Son, Heewon Kim, Seungjun Nah, and Kyoung Mu Lee. Enhanced deep residual networks for single image super-resolution. In Proc. CVPRW, pages 1132–1140,

  27. [35]

    Learning efficient convolutional networks through network slimming

    Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proc. ICCV, pages 2736–2744, 2017. 8

    2017

  28. [36]

    Fully convolutional networks for semantic segmentation

    Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proc. CVPR, pages 3431–3440, 2015. 1

    2015

  29. [37]

    Martin, C

    D. Martin, C. Fowlkes, D. Tal, and J. Malik. A database of human segmented natural images and its application to evaluating segmentation algorithms and measuring ecologi- cal statistics. In Proc. ICCV, volume 2, pages 416–423, July

  30. [38]

    Cascaded projec- tion: End-to-end network compression and acceleration

    Breton Minnehan and Andreas Savakis. Cascaded projec- tion: End-to-end network compression and acceleration. In Proc. CVPR, June 2019. 8

    2019

  31. [39]

    Blind image deblurring using dark channel prior

    Jinshan Pan, Deqing Sun, Hanspeter Pfister, and Ming- Hsuan Yang. Blind image deblurring using dark channel prior. In Proc. CVPR, pages 1628–1636, 2016. 1

    2016

  32. [40]

    Automatic differentiation in Pytorch

    Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Al- ban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in Pytorch. 2017. 5

    2017

  33. [41]

    Extreme network compression via filter group approximation

    Bo Peng, Wenming Tan, Zheyang Li, Shun Zhang, Di Xie, and Shiliang Pu. Extreme network compression via filter group approximation. In Proc. ECCV, pages 300–316, 2018. 1, 2, 3, 7, 8, 11, 13

    2018

  34. [42]

    Xnor-net: Imagenet classification using bi- nary convolutional neural networks

    Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using bi- nary convolutional neural networks. In Proc. ECCV, pages 525–542. Springer, 2016. 1, 2

    2016

  35. [43]

    You only look once: Unified, real-time object de- tection

    Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified, real-time object de- tection. In Proc. CVPR, pages 779–788, 2016. 1

    2016

  36. [44]

    Faster R-CNN: Towards real-time object detection with re- gion proposal networks

    Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster R-CNN: Towards real-time object detection with re- gion proposal networks. In Proc. NIPS, pages 91–99, 2015. 1

    2015

  37. [45]

    Very deep convo- lutional networks for large-scale image recognition

    Karen Simonyan and Andrew Zisserman. Very deep convo- lutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. 1, 6, 8, 11

    2014 arXiv

  38. [46]

    Cluster- ing convolutional kernels to compress deep neural networks

    Sanghyun Son, Seungjun Nah, and Kyoung Mu Lee. Cluster- ing convolutional kernels to compress deep neural networks. In Proc. ECCV, pages 216–232, 2018. 1, 2, 7, 8

    2018

  39. [47]

    Factorized convolutional neural networks

    Min Wang, Baoyuan Liu, and Hassan Foroosh. Factorized convolutional neural networks. In Proc. ICCV, pages 545– 553, 2017. 1, 2, 3, 5, 6, 7, 8, 11, 13

    2017

  40. [48]

    Learning structured sparsity in deep neural networks

    Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Proc. NIPS, pages 2074–2082, 2016. 2

    2016

  41. [49]

    On sin- gle image scale-up using sparse-representations

    Roman Zeyde, Michael Elad, and Matan Protter. On sin- gle image scale-up using sparse-representations. In Interna- tional Conference on Curves and Surfaces , pages 711–730. Springer, 2010. 6

    2010

  42. [50]

    Beyond a gaussian denoiser: residual learning of deep CNN for image denoising

    Kai Zhang, Wangmeng Zuo, Yunjin Chen, Deyu Meng, and Lei Zhang. Beyond a gaussian denoiser: residual learning of deep CNN for image denoising. IEEE TIP, 26(7):3142– 3155, 2017. 1

    2017

  43. [51]

    Learning deep cnn denoiser prior for image restoration

    Kai Zhang, Wangmeng Zuo, Shuhang Gu, and Lei Zhang. Learning deep cnn denoiser prior for image restoration. In Proc. CVPR, pages 3929–3938, 2017. 1

    2017

  44. [52]

    Deep plug- and-play super-resolution for arbitrary blur kernels

    Kai Zhang, Wangmeng Zuo, and Lei Zhang. Deep plug- and-play super-resolution for arbitrary blur kernels. In Proc. CVPR, pages 1671–1681, 2019. 1

    2019

  45. [53]

    Accelerating very deep convolutional networks for classi- fication and detection

    Xiangyu Zhang, Jianhua Zou, Kaiming He, and Jian Sun. Accelerating very deep convolutional networks for classi- fication and detection. IEEE TPAMI, 38(10):1943–1955,

    1943

  46. [54]

    Incremental network quantization: Towards lossless cnns with low-precision weights

    Aojun Zhou, Anbang Yao, Yiwen Guo, Lin Xu, and Yurong Chen. Incremental network quantization: Towards lossless cnns with low-precision weights. arXiv preprint arXiv:1702.03044, 2017. 1

    2017 arXiv

  47. [55]

    Less is more: Towards compact cnns

    Hao Zhou, Jose M Alvarez, and Fatih Porikli. Less is more: Towards compact cnns. In Proc. ECCV , pages 662–677. Springer, 2016. 2

    2016

  48. [56]

    Trained ternary quantization

    Chenzhuo Zhu, Song Han, Huizi Mao, and William J Dally. Trained ternary quantization. arXiv preprint arXiv:1612.01064, 2016. 2 A. Compressed Network Configuration The basis configurations of our filter basis learning method for different networks including DenseNet [19], ResNet [...

    2016 arXiv

Pith tools

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