Towards Adaptive Deep Learning: Model Elasticity via Prune-and-Grow CNN Architectures

Dolly Sapra; Pooja Mangal; Sudaksh Kalra

REVIEW 5 major objections 5 minor 28 references

Towards Adaptive Deep Learning: Model Elasticity via Prune-and-Grow CNN Architectures

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

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

Pith's one-line read A CNN can be pruned into a compact core and then grown back, so one model holds nested sizes switchable without retraining.

desk verdict The runtime-adaptivity claim is unsupported: the paper measures offline pruning and rebuilding, never tests switching, and never verifies the embedded core. read the letter →

arxiv 2505.11569 v1 pith:R5U2N2MY submitted 2025-05-16 cs.LG cs.AI

Pooja Mangal , Sudaksh Kalra , Dolly Sapra This is my paper · ORCID

classification cs.LGcs.AI

keywords modelelasticitystructuredpruningdependencygraphsnetworkrebuildingnestedsubnetworksadaptiveCNNsruntimeadaptivityCIFAR-10

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 tries to establish that a single convolutional neural network can be made elastic: it can contain a compact version of itself nested inside the full-size network and switch between the two at runtime without retraining. The proposed route is structured pruning, which removes entire filters to form a small core model, followed by rebuilding the original architecture by reinserting the removed filters with their original weights and fine-tuning only the new parts. The payoff, if the claim holds, is one deployed model that can serve both low-resource edge devices and high-capacity servers without storing or paging multiple separate models. Experiments on VGG-16, AlexNet, ResNet-20, and ResNet-56 over CIFAR-10 show rebuilt models recovering most or all of the original accuracy, with iterative pruning giving smoother recovery than one-shot pruning.

What carries the argument

The load-bearing mechanism is a prune-and-grow cycle built on dependency-aware structured pruning. A dependency graph tracks which layers are structurally coupled, so pruning a filter automatically prunes the matching channels in skip connections, batch-norm layers, and downstream convolutions; this keeps the shrunken model valid. The grow half reinserts previously removed filters into a full-sized copy of the original network and restores their original weights. During post-rebuild fine-tuning, the core (unpruned) filters are frozen and gradients are zeroed for them, so only the reinserted filters are updated; this freezing step is what is supposed to preserve the compact subnetwork inside the rebuilt model and make later runtime switching training-free.

What would settle it

Take a rebuilt model and run inference using only its core filters, then compare accuracy against the same core model fine-tuned in isolation. If the two accuracies differ substantially, or if the internal normalization statistics of the core have shifted during post-rebuild fine-tuning, the claim that switching between sizes requires no retraining would be refuted.

Watch

Extended reading notes

Core claim

The central claim is that pruning and rebuilding can be reversed without losing the pruned model. Concretely, a trained CNN is structurally pruned with dependency-aware filter pruning, producing a smaller core model; the removed filters are not discarded but logged with their positions and weights. A full-sized copy of the original network is then created, the removed filters are reinserted in their original places, and the model is fine-tuned with the core filters frozen so that only the reintroduced filters change. The intended outcome is a single architecture containing nested capacity levels, so the compact core and the full model coexist in one set of weights and a deployment can move between them without retraining. Across the architectures tested, rebuilt models generally recovered the bulk of the lost accuracy and sometimes exceeded the original baseline.

Load-bearing premise

Freezing the core filters while fine-tuning the rebuilt network preserves the compact subnetwork's behavior closely enough that a user can switch to it later without retraining — a premise the paper assumes but never directly measures.

Editorial extensions

If this is right

A single deployed model could serve devices with different compute budgets: run the core filters when resources are tight, run the full network when they are not, with no retraining step in between.
Restoring a larger configuration costs only a short fine-tuning pass over the reinserted filters, not training from scratch, because the original weights are reused.
Iterative prune-and-grow yields several intermediate capacity levels in one model, so adaptivity can step through sizes rather than jump between two extremes.
Selective pruning choices, such as leaving alternate layers untouched, can retain more accuracy than uniform pruning, so the pruning pattern itself becomes a design lever for adaptivity.
Rebuilt models sometimes match or exceed baseline accuracy, implying the pipeline can act as a cheap capacity-increasing fine-tune rather than just a recovery step.

Reading between the lines

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

Inference: if the frozen-core premise holds, the scheme could be applied recursively: each new build level freezes everything below it, yielding a ladder of nested models with more than two operating points from a single training run.
Inference: the same machinery could be pointed at modern architectures such as vision transformers, but the dependency graph would need to cover attention heads and layer-norm couplings; the paper does not test this.
Inference: the decisive missing experiment is to extract the compact core from a rebuilt model at inference time and compare it against an independently fine-tuned core; internal normalization statistics or shared layers could shift during post-rebuild fine-tuning and break the no-retraining switch.

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.

Desk Editor's Note

read the letter

Colleague,

My take on arXiv:2505.11569: the headline claim—a single CNN can switch between compact and full configurations at runtime without retraining—is not supported by the experiments. The paper never tests runtime switching; the evaluation section says so explicitly, and §6.3 lists dynamic runtime adaptation as out of scope. The rebuilt model is never decomposed back into the core subnetwork and checked for functional equivalence.

What the paper does well is a fairly systematic comparison of structured pruning criteria (magnitude, Taylor, Hessian, soft, manual) on VGG-16, AlexNet, ResNet-20/56, with an iterative prune-and-rebuild loop. Rebuilding with cached weights does recover most of the lost accuracy, and the ablation on pruning only alternate layers is a reasonable experiment. The authors are honest about many limitations, which is more than some theses manage.

The soft spots are serious and mostly about the gap between abstract and evidence. The two "adaptivity" chapters are about rebuilding offline, not runtime elasticity. The stress-test point about BatchNorm is correct: freezing the gradients of retained convolutional weights does not freeze BatchNorm running statistics, which update during fine-tuning in train mode. Since the core is never extracted and evaluated inside the rebuilt model, the claim that the core is "preserved" is unverified. Table 5.4 is mislabeled (caption says ResNet-20, numbers are ResNet-56). The abstract promises Imagenette; the body only uses CIFAR-10. No error bars, no code, and some numbers look inconsistent between tables (e.g., ResNet-20 baseline is 92.60 in Table 5.1 and 91.5 in Table 5.2/5.7).

The novelty is modest. NestDNN already does freeze-and-grow nested subnets, and the paper cites it as the adopted strategy. The contribution here is essentially an implementation using DepGraph metadata plus a few ablations. That is useful as an engineering exercise, not as a new result.

Who is this for? Someone working through pruning toolchains may find the methodology notes useful, but I would not send it to a serious venue as-is. If it were submitted as a paper, my recommendation is desk reject: the central claim is untested and the paper contradicts itself on the scope.

Referee Report

5 major / 5 minor

Summary. The manuscript, a master's thesis posted on arXiv, proposes a prune-and-grow approach for CNNs. It applies dependency-aware structured pruning (via DepGraph/Torch-Pruning) to obtain a compact 'core' model, then rebuilds the full architecture by reinserting the previously pruned filters at their original positions with their original weights. During post-rebuild fine-tuning, the retained core channels are frozen (gradients zeroed) while the reinserted channels are updated. The paper claims this procedure creates nested subnetworks within a single CNN, allowing runtime switching between compact and full-sized configurations without retraining. Experiments are reported on CIFAR-10 with VGG-16, AlexNet, ResNet-20, and ResNet-56, comparing one-shot and iterative pruning across magnitude, Taylor, Hessian, manual, and soft pruning criteria, plus an alternate-layer pruning ablation. The paper's own evaluation and limitations sections state that dynamic runtime adaptivity was not tested and is beyond the scope of the work.

Significance. If the central claim were established, the paper would offer a practical recipe for embedding multiple capacity levels in a single CNN, which is a relevant deployment problem. The work has some strengths: it systematically compares several importance criteria under a common dependency-aware pruning framework, reports parameter and size reductions, and includes an interesting ablation on alternate-layer pruning. The use of DepGraph is appropriate and makes the pruning structurally sound. However, the distinctive claim of the paper—runtime switching without retraining—is not tested in any experiment and is explicitly declared out of scope in §5.1 and §6.3. The reported experiments are a pruning-and-recovery study: they show that reinserting known pretrained weights and fine-tuning restores accuracy, which is largely expected. The empirical base is further weakened by mislabeled tables and a mismatch between the abstract's claimed datasets and the experiments actually described. As a result, the paper's significance for the runtime-adaptivity claim is low, and the evidence does not support the headline contribution.

major comments (5)

[Abstract; §1.0.2; §5.1; §6.3] The central claim that the network can 'dynamically switch between compact and full-sized configurations without retraining' is not supported by the reported experiments. §5.1 states that 'the evaluation does not explicitly test adaptivity in dynamic runtime environments,' and §6.3 states that dynamic runtime adaptation is 'beyond the scope of this work.' No experiment extracts or masks the core subnetwork from the rebuilt model, measures its accuracy, or measures switching overhead. The paper's own limitations therefore contradict the abstract's headline claim.
[§3.3, step 4; §3.4] The claim that freezing retained channels preserves the embedded core subnetwork is not substantiated. Freezing as described only zeroes the gradients of the retained weights during backpropagation; it does not freeze BatchNorm running statistics or other shared state unless explicitly done. After fine-tuning the rebuilt model in training mode, the BatchNorm statistics of core channels can drift, so the embedded core may no longer compute the same function as the reported pruned core even if convolutional weights are unchanged. No extraction test or output-comparison test is reported to rule out this drift, and this evidence is load-bearing for the runtime-switching claim.
[Table 5.4; Table 5.7] Table 5.4 is labeled 'Results from Iterative Pruning and Rebuilding on ResNet-20' but its baseline row (86.50% accuracy, 0.86M parameters, 3.37MB) matches the ResNet-56 baseline in Table 5.1, and the text immediately above the table says 'Table 5.4 shows the changes ... for ResNet-56.' Table 5.7 repeats the ResNet-20 label but reports a different baseline (91.5%, 0.27M, 1.08MB). This internal inconsistency makes the iterative results impossible to interpret and suggests the labels or numbers were swapped.
[Abstract; §4.1; §5] The abstract claims experiments on both CIFAR-10 and Imagenette datasets, but §4.1 states that 'all experiments in this study are conducted on the CIFAR-10 dataset,' and no Imagenette results appear anywhere in Section 5. This is not a mere typo: it overstates the empirical scope of the paper and should be corrected.
[§5.3–§5.5; Tables 5.2, 5.4, 5.5, 5.7] All accuracy claims are based on single runs with no error bars, confidence intervals, or seeds. For example, in Table 5.2, the magnitude-pruned VGG-16 at 30% reports pruned accuracy 88.56 and rebuilt accuracy 88.80, a difference of 0.24 percentage points; such small differences cannot be interpreted without variance information. The repeated claims that 'rebuilt models consistently achieved higher accuracy than their corresponding pruned counterparts' (§5.4) are therefore not statistically supported.

minor comments (5)

[§1.0.2] The 'This thesis is organized as follows' paragraph says Chapter 4 presents experimental results and Chapter 5 evaluates the model, but in the actual manuscript Chapter 4 is the experimental setup and Chapter 5 contains the results; the organization description should be corrected.
[§4.2; §6.3] Section 4.2 says 'we experimented with three popular CNNs (VGG-16, AlexNet, ResNet-20 and ResNet-56)' while listing four architectures, and §6.3 says experiments were conducted only on three architectures; the count should be made consistent.
[Table 5.2] The Taylor / ResNet-20 / 30% rebuilt cell contains a trailing comma ('82.89,') that appears to be a typographical artifact.
[Figures 3.1 and 3.5] Figures 3.1 and 3.5 appear to be the same overview figure with different captions, and Figure 3.1 carries a source citation [1] while Figure 3.5 does not; the duplication and attribution should be clarified.
[§5.3.2, Table 5.3] The text says Table 5.3 'presents the numbers from Manual Pruning,' but the table caption and surrounding discussion refer to pruning results generically; the method used for the numbers in Table 5.3 should be stated explicitly.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: the adaptivity claim is unsupported by measurement, not derived from the method's inputs.

full rationale

Walking the claimed derivation chain, no step reduces an output to an input by construction. The pruning-and-rebuilding pipeline is an engineering procedure: the core model is produced by structured pruning, and the full model is rebuilt by reinserting saved weight metadata (Section 3.3, steps 1-3); accuracy is then measured, not derived. The fact that rebuilt models recover accuracy is unsurprising since known-good original weights are restored, but that is an empirical result rather than a prediction whose value is forced by the fit. No fitted parameter is renamed as a forecast; the only parameters carried over are the saved original weights. There is also no load-bearing self-citation chain: the cited tools and prior methods, such as DepGraph/Torch-Pruning [2,7] and NestDNN [4], are external works by other authors, and the thesis explicitly positions itself as adopting NestDNN's freeze-and-grow idea. The strongest concern is that the headline claim of switching between compact and full configurations without retraining is not tested: Section 5.1 states 'The evaluation does not explicitly test adaptivity in dynamic runtime environments,' and Section 6.3 states the framework 'does not yet support dynamic adaptation at runtime.' That is a real evidence gap in the central claim, but an unsupported or overclaimed implication is not circularity unless the conclusion is shown to be identical to the input, which is not the case here. Therefore the circularity score is 0.

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

The experiments rest on publicly pretrained CIFAR-10 models, on the correctness of the Torch-Pruning dependency graph, and on chosen pruning percentages and learning rates. No new entities are introduced.

free parameters (4)

Pruning percentages (30%, 50%, 70%) = 30, 50, 70
Chosen by hand for one-shot experiments; no search or justification for these specific levels.
Iterative pruning step (20%) = 20% per step
Fixed step size in section 3.5; no sensitivity analysis.
Learning rates per model = 1e-2 to 1e-5 depending on model and stage
Selected by experimentation across values; the paper does not report which rate was used for each model or stage.
Fine-tuning epochs and early stopping = Not specified
Fine-tuning duration is described only as 'several epochs' with early stopping; exact epochs are absent.

assumptions (3)

domain assumption Pretrained CIFAR-10 models from chenyaofo/pytorch-cifar-models are correct and well-trained.
Baselines in Table 5.1 are taken from these pretrained models; the paper does not verify their training or correctness beyond reported accuracy.
domain assumption DepGraph and Torch-Pruning correctly identify all structural dependencies.
The entire pruning pipeline depends on the library's correctness for skip connections and layer couplings; the paper relies on it without independent verification.
domain assumption CIFAR-10 test accuracy from a single run is sufficient evidence.
All tables report single-run accuracies without error bars or multiple seeds.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Towards Adaptive Deep Learning: Model Elasticity via Prune-and-Grow CNN Architectures." pith.science (2026). https://pith.science/paper/R5U2N2MY

@misc{pith2026250511569,
  author       = {Pith},
  title        = {Pith review of: Towards Adaptive Deep Learning: Model Elasticity via Prune-and-Grow CNN Architectures},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/R5U2N2MY}},
  note         = {Machine review of arXiv:2505.11569}
}

read the original abstract

Deploying deep convolutional neural networks (CNNs) on resource-constrained devices presents significant challenges due to their high computational demands and rigid, static architectures. To overcome these limitations, this thesis explores methods for enabling CNNs to dynamically adjust their computational complexity based on available hardware resources. We introduce adaptive CNN architectures capable of scaling their capacity at runtime, thus efficiently balancing performance and resource utilization. To achieve this adaptability, we propose a structured pruning and dynamic re-construction approach that creates nested subnetworks within a single CNN model. This approach allows the network to dynamically switch between compact and full-sized configurations without retraining, making it suitable for deployment across varying hardware platforms. Experiments conducted across multiple CNN architectures including VGG-16, AlexNet, ResNet-20, and ResNet-56 on CIFAR-10 and Imagenette datasets demonstrate that adaptive models effectively maintain or even enhance performance under varying computational constraints. Our results highlight that embedding adaptability directly into CNN architectures significantly improves their robustness and flexibility, paving the way for efficient real-world deployment in diverse computational environments.

Figures

Figures reproduced from arXiv: 2505.11569 by the authors.

**Figure 3.1.** Overview of the iterative pruning and rebuilding process. The model is progressively compressed via structured pruning steps and later reconstructed in reverse using preserved weight metadata. [1] Handling Dependencies with Dependency Graph Pruning As neural networks become more interconnected, pruning decisions made in one layer can affect other layers. For instance, in a ResNet block, reducing the number of outpu… view at source ↗

**Figure 3.2.** Dependency-aware pruning ensures consistency across layers with structural dependencies. For example, pruning Conv2 also requires pruning Conv1, BN1, and BN2 within the block. The Dependency Graph tracks such relationships automatically. Source: [2] • A fixed percentage of the least important filters is pruned from each selected layer independently, making the pruning selection local. • The Dependency Graph tracks a… view at source ↗

Figures from the paper (13 more)

**Figure 3.3.** Figure 3.3: Illustration of model freezing and rebuilding [PITH_FULL_IMAGE:figures/full_fig_p022_3_3.png]

**Figure 3.4.** Figure 3.4: Overview of the pruning and rebuilding process for adaptivity. Structured pruning removes entire filters (shown as dotted circles), resulting in a smaller core model. Later, previously pruned filters are reinserted into the architecture during the rebuilding phase, a…

**Figure 3.5.** Figure 3.5: Overview of the iterative pruning and rebuilding process. The model is progressively compressed via structured pruning steps and later reconstructed in reverse using preserved weight metadata. The iterative pruning procedure begins with a fully pre-trained model. In…

**Figure 3.** Figure 3: illustrates the overall pipeline for our iterative pruning and rebuilding strategy. [PITH_FULL_IMAGE:figures/full_fig_p026_3.png]

**Figure 5.1.** Figure 5.1: Accuracy progression across different pruning strategies on three architectures (AlexNet, ResNet-20, and VGG-16) at 70% pruning. Each method shows three accuracy points: the original (unpruned) model, accuracy immediately after pruning, and accuracy after rebuilding …

**Figure 5.** Figure 5: presents two bar plots. The top plot shows how the number of parameters [PITH_FULL_IMAGE:figures/full_fig_p035_5.png]

**Figure 5.2.** Figure 5.2: Comparison of parameter count and model size across different pruning stages (30%, 50%, 70%) for VGG-16, AlexNet, and ResNet-20. The plot demonstrates how model size is reduced through pruning and restored via rebuilding. Pruning reduces model complexity, while rebui…

**Figure 5.** Figure 5: and Figure 5.4 illustrates the effectiveness of our rebuilding strategy. The [PITH_FULL_IMAGE:figures/full_fig_p038_5.png]

**Figure 5.3.** Figure 5.3: and [PITH_FULL_IMAGE:figures/full_fig_p038_5_3.png]

**Figure 5.4.** Figure 5.4: Profiling metrics of AlexNet showing changes in parameter count and model size across pruning levels. 5.5 Ablation Studies To explore how pruning decisions affect overall performance, we conducted ablation studies in which instead of pruning all convolutional layers…

**Figure 5.5.** Figure 5.5: Ablation study on partial pruning: alternating layers are pruned while the rest are left intact. Accuracy is compared across the original, pruned, and rebuilt stages for AlexNet, VGG-16, and ResNet-20. Reconstruction continues to recover performance even when only a …

**Figure 5.6.** Figure 5.6: Profiling metrics of ResNet-20 showing changes in parameter count and model size across pruning levels. and adapt its weights to the reduced structure at every stage. This gradual adjustment helped prevent drastic accuracy drops and reduced the risk of losing critica…

**Figure 5.** Figure 5: , pruning significantly reduced both the number of parameters and the [PITH_FULL_IMAGE:figures/full_fig_p043_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

28 extracted references · 12 canonical work pages

[1]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 if FUNCTIO...

work page
[2]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 if FUNCTIO...

work page
[3]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...

work page
[4]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...

work page
[5]

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 word.in bbl.in ":" * " " * FUNCTION f...
[6]

, " * write output.state after.block = add.period write newline

ENTRY address author booktitle chapter edition editor howpublished institution journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.all := #1 'mid.sentence := #2 '...

work page
[7]

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 word.in bbl.in capitalize " " * FUNCT...

work page
[8]

@esa ( ) , n @biblabelnum##1 ##1

\@ifclassloaded aguplus natbib The aguplus class already includes natbib coding, so you should not add it explicitly Type <Return> for now, but then later remove the command natbib from the document \@ifclassloaded nlinproc natbib The nlinproc class already includes natbib coding, so you should not add it explicitly Type <Return> for now, but then later r...

Show all 28 references

[9]

@stdbsttrue NAT@ctr \@lbibitem[ NAT@ctr ] \@lbibitem[#1]#2 \@extra@b@citeb \@ifundefined br@#2\@extra@b@citeb \@namedef br@#2 \@nameuse br@#2\@extra@b@citeb \@ifundefined b@#2\@extra@b@citeb @num @parse #2 [ @natanchorstart #2\@extra@b@citeb \@biblabel @num @natanchorend] @ifc...
[11]

https://arxiv.org/abs/1608.08710 Pruning Filters for Efficient ConvNets , 2017

Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf . https://arxiv.org/abs/1608.08710 Pruning Filters for Efficient ConvNets , 2017

2017 arXiv
[12]

https://arxiv.org/abs/2301.12900 DepGraph: Towards Any Structural Pruning , 2023

Gongfan Fang, Xinyin Ma, Mingli Song, Michael Bi Mi, and Xinchao Wang . https://arxiv.org/abs/2301.12900 DepGraph: Towards Any Structural Pruning , 2023

2023 arXiv
[13]

https://arxiv.org/abs/2211.14926 SteppingNet: A Stepping Neural Network with Incremental Accuracy Enhancement , 2022

Wenhao Sun, Grace Li Zhang, Xunzhao Yin, Cheng Zhuo, Huaxi Gu, Bing Li, and Ulf Schlichtmann . https://arxiv.org/abs/2211.14926 SteppingNet: A Stepping Neural Network with Incremental Accuracy Enhancement , 2022

2022 arXiv
[14]

http://dx.doi.org/10.1145/3241539.3241559 NestDNN: Resource-Aware Multi-Tenant On-Device Deep Learning for Continuous Mobile Vision

Biyi Fang, Xiao Zeng, and Mi Zhang . http://dx.doi.org/10.1145/3241539.3241559 NestDNN: Resource-Aware Multi-Tenant On-Device Deep Learning for Continuous Mobile Vision . In Proceedings of the 24th Annual International Conference on Mobile Computing and Networking , MobiCom ’1...
[15]

Rui Han, Qinglong Zhang, Chi Harold Liu, Guoren Wang, Jian Tang, and Lydia Y. Chen . http://dx.doi.org/10.1145/3447993.3483249 LegoDNN: block-grained scaling of deep neural networks for mobile vision . In Proceedings of the 27th Annual International Conference on Mobile Comput...
[16]

https://arxiv.org/abs/1812.08928 Slimmable Neural Networks , 2018

Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang . https://arxiv.org/abs/1812.08928 Slimmable Neural Networks , 2018

2018 arXiv
[17]

Torch-Pruning: An Open-Source Library for Structured Pruning in PyTorch

Gongfan Fang, Xinyin Ma, Mingli Song, Michael Bi Mi, and Xinchao Wang . Torch-Pruning: An Open-Source Library for Structured Pruning in PyTorch . https://github.com/VainF/Torch-Pruning, 2020

2020
[18]

Song Han, Huizi Mao, and William J. Dally . https://arxiv.org/abs/1510.00149 Deep Compression: Compressing Deep Neural Networks with Pruning, Trained Quantization and Huffman Coding , 2016

2016 arXiv
[19]

https://arxiv.org/abs/1906.10771 Importance Estimation for Neural Network Pruning , 2019

Pavlo Molchanov, Arun Mallya, Stephen Tyree, Iuri Frosio, and Jan Kautz . https://arxiv.org/abs/1906.10771 Importance Estimation for Neural Network Pruning , 2019

1906 arXiv
[20]

https://arxiv.org/abs/1708.06519 Learning Efficient Convolutional Networks through Network Slimming , 2017

Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang . https://arxiv.org/abs/1708.06519 Learning Efficient Convolutional Networks through Network Slimming , 2017

2017 arXiv
[21]

https://arxiv.org/abs/1608.03665 Learning Structured Sparsity in Deep Neural Networks , 2016

Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li . https://arxiv.org/abs/1608.03665 Learning Structured Sparsity in Deep Neural Networks , 2016

2016 arXiv
[22]

https://arxiv.org/abs/1908.09791 Once-for-All: Train One Network and Specialize it for Efficient Deployment , 2020

Han Cai, Chuang Gan, Tianzhe Wang, Zhekai Zhang, and Song Han . https://arxiv.org/abs/1908.09791 Once-for-All: Train One Network and Specialize it for Efficient Deployment , 2020

1908 arXiv
[23]

https://arxiv.org/abs/1903.05134 Universally Slimmable Networks and Improved Training Techniques , 2019

Jiahui Yu and Thomas Huang . https://arxiv.org/abs/1903.05134 Universally Slimmable Networks and Improved Training Techniques , 2019

1903 arXiv
[24]

https://arxiv.org/abs/2105.07085 MutualNet: Adaptive ConvNet via Mutual Learning from Different Model Configurations , 2021

Taojiannan Yang, Sijie Zhu, Matias Mendieta, Pu Wang, Ravikumar Balakrishnan, Minwoo Lee, Tao Han, Mubarak Shah, and Chen Chen . https://arxiv.org/abs/2105.07085 MutualNet: Adaptive ConvNet via Mutual Learning from Different Model Configurations , 2021

2021 arXiv
[25]

https://arxiv.org/abs/1803.03635 The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks , 2019

Jonathan Frankle and Michael Carbin . https://arxiv.org/abs/1803.03635 The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks , 2019

2019 arXiv
[26]

Snellius

SURF . Snellius . https://servicedesk.surf.nl/wiki/display/WIKI/Snellius. Accessed: 2025-01-22

2025
[27]

https://arxiv.org/abs/1912.01703 PyTorch: An Imperative Style, High-Performance Deep Learning Library , 2019

Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, and Trevor Killeen . https://arxiv.org/abs/1912.01703 PyTorch: An Imperative Style, High-Performance Deep Learning Library , 2019

1912 arXiv
[28]

https://github.com/Lightning-AI/lightning PyTorch Lightning , March 2019

William Falcon and The PyTorch Lightning team . https://github.com/Lightning-AI/lightning PyTorch Lightning , March 2019. Version 1.4, Apache-2.0 License

2019
[29]

https://www.wandb.com/ Experiment Tracking with Weights and Biases , 2020

Lukas Biewald . https://www.wandb.com/ Experiment Tracking with Weights and Biases , 2020. Software available from wandb.com

2020

Pith tools

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

[1] [1]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 if FUNCTIO...

work page

[2] [2]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 if FUNCTIO...

work page

[3] [3]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...

work page

[4] [4]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...

work page

[5] [5]

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 word.in bbl.in ":" * " " * FUNCTION f...

[6] [6]

, " * write output.state after.block = add.period write newline

ENTRY address author booktitle chapter edition editor howpublished institution journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.all := #1 'mid.sentence := #2 '...

work page

[7] [7]

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 word.in bbl.in capitalize " " * FUNCT...

work page

[8] [8]

@esa ( ) , n @biblabelnum##1 ##1

\@ifclassloaded aguplus natbib The aguplus class already includes natbib coding, so you should not add it explicitly Type <Return> for now, but then later remove the command natbib from the document \@ifclassloaded nlinproc natbib The nlinproc class already includes natbib coding, so you should not add it explicitly Type <Return> for now, but then later r...