Complexity-Adaptive Pruning (AutoPrune)

• Complexity-Adaptive Pruning is a meta-framework that replaces fixed pruning schedules with dynamic, condition-based policies driven by task or data complexity.
• It employs adaptive signals such as image entropy, mutual information, and weight sensitivity to adjust token, channel, or layer retention across diverse models.
• This approach enables budget-aware optimization in both training and inference, reducing FLOPs and parameter counts while maintaining high accuracy.

Complexity-Adaptive Pruning, often called AutoPrune in several papers, denotes a family of pruning methods that replace a single fixed sparsity schedule with pruning policies conditioned on some notion of complexity. Depending on the work, that complexity may be the difficulty of an input sample, the sensitivity of a layer, the global parameter or FLOPs budget, the skewness of weight distributions, or the current optimization state. In contemporary literature, the term does not refer to one canonical algorithm; rather, it names several related paradigms spanning vision-LLMs, CNNs, transformers, LLMs, variational quantum circuits, and neural symbolic regression (Wang et al., 28 Sep 2025, Lee et al., 11 May 2026, Guenter et al., 2024, Kang et al., 19 Nov 2025).

1. Terminological scope and research lineage

The most important terminological point is that “AutoPrune” is polysemous. In some papers it denotes a training-free, plug-and-play token-pruning policy for large vision-LLMs; in others it denotes adaptive channel search, budget-aware sparsity learning during training, or self-pruning by an LLM. The shared idea is not a single implementation detail but the rejection of one-size-fits-all pruning schedules (Wang et al., 28 Sep 2025, Li et al., 2020, Retsinas et al., 2020, Kang et al., 19 Nov 2025).

A concise way to organize the literature is by the adaptive signal each method uses.

Family	Representative papers	Adaptive signal
Input-conditioned token pruning	(Lee et al., 11 May 2026, Wang et al., 28 Sep 2025, Liu et al., 2022)	image entropy, mutual information, learned thresholds
Training-time budget-aware pruning	(Retsinas et al., 2020, Guenter et al., 2024)	trainable thresholds, Bernoulli gate probabilities
Automatic channel or structure search	(Li et al., 2020, Liu et al., 2021, Mu et al., 2021)	remaining ratios, block importance, RL policy transfer
Self-pruning and algorithm discovery	(Kang et al., 19 Nov 2025, Nascimento et al., 4 Jun 2025)	generated pruning rules, skewness allocation, CKA-based selection

This breadth has created a recurrent misconception: Complexity-Adaptive Pruning is not synonymous with any one pruning granularity. Some methods prune visual tokens (Lee et al., 11 May 2026), others prune channels (Li et al., 2020), layers and filters jointly (Nascimento et al., 4 Jun 2025), or individual weights (Retsinas et al., 2020). A plausible implication is that the field is better understood as a design principle—adaptive allocation of sparsity or retention—than as a fixed algorithmic recipe.

2. Core principles and adaptive signals

Across these works, the central criticism of fixed-ratio pruning is consistent: redundancy is heterogeneous. In high-resolution VLMs, redundancy varies sharply across images, so a uniform token-retention schedule misallocates compute between simple images with broad homogeneous regions and dense images containing text, charts, or many objects (Lee et al., 11 May 2026). In LLM weight pruning, uniform sparsity can over-prune positively skewed, outlier-heavy layers and trigger severe degradation at high pruning ratios (Kang et al., 19 Nov 2025). In channel pruning for CNNs, a single handcrafted per-layer rule is treated as suboptimal relative to learned or searched layer-wise remaining ratios (Li et al., 2020).

The adaptive signal itself differs by domain. In ERASE, complexity is estimated from raw-image patch entropy. For a discrete variable $X$, entropy is

$H(X) = -\sum_{i=1}^{n} P(x_i)\ln P(x_i),$

and the global image complexity is the median of patch-level entropies, denoted $\bar{H}$ (Lee et al., 11 May 2026). In the VLM method "AutoPrune: Each Complexity Deserves a Pruning Policy" (Wang et al., 28 Sep 2025), complexity is the mutual information between visual and textual tokens, estimated from cross-attention-derived probabilities. In LLM self-pruning, complexity is tied to layer sensitivity via skewness of absolute weight magnitudes, which then drives skew-aware dynamic sparsity allocation (Kang et al., 19 Nov 2025). In adaptive sparse ViT, token scores are compared against learnable stage-wise thresholds trained under a FLOPs budget (Liu et al., 2022).

A second recurrent principle is budget awareness. Several methods optimize pruning not as unconstrained sparsification but as a trade-off with explicit parameter, FLOPs, or token budgets. "Weight Pruning via Adaptive Sparsity Loss" (Retsinas et al., 2020) uses a weighted sparsity loss with layer coefficients $c_i$ to steer the network toward parameter or FLOP budgets. "Complexity-Aware Training of Deep Neural Networks for Optimal Structure Discovery" (Guenter et al., 2024) makes expected FLOPS and expected parameter counts explicit in the objective and reduces their control to three interpretable hyperparameters. This suggests that complexity-adaptive pruning has two axes: what signal decides importance and what resource budget constrains the final policy.

3. Instance-adaptive token pruning in vision and multimodal transformers

The most explicit modern realization of input-conditioned pruning appears in multimodal token pruning. ERASE is a two-stage hierarchical framework for VLMs that first removes spatial redundancy at the image level and then removes prompt-irrelevant tokens inside the decoder (Lee et al., 11 May 2026). The motivation is concrete: a 4K image can produce about 16K vision tokens, and quadratic attention makes naive full-token inference expensive in prefill latency and KV-cache memory. ERASE therefore computes local patch entropy, takes the median entropy $\bar{H}$ as a global complexity signal, maps it to one of four levels found by Bayesian optimization, and uses that level to select both a Stage-1 retention ratio and a Stage-2 pruning layer (Lee et al., 11 May 2026).

Stage 1 keeps the highest-entropy patches and is intentionally lightweight and non-iterative, operating on raw image patches rather than latent attention maps. Stage 2 is prompt-conditioned: it uses text-to-vision attention to identify the most relevant Stage-1-retained tokens, but unlike fixed-layer methods it routes simple images to an early pruning layer and complex images to a mid-to-late layer. ERASE also performs retrospective KV-cache eviction, removing tokens dropped in Stage 2 from earlier KV states up to the selected layer (Lee et al., 11 May 2026). Quantitatively, on Qwen2.5-VL-7B at 85% pruning, ERASE retains 89.46% of original accuracy, versus 78.19% for IVC-Prune; on 4K images it reduces KV-cache memory from 891.27 MB to about 135.75 MB, lowers prefill latency from 3694 ms to 2337 ms, and reports a 1.56× end-to-end speedup (Lee et al., 11 May 2026).

The 2025 VLM paper explicitly titled "AutoPrune: Each Complexity Deserves a Pruning Policy" (Wang et al., 28 Sep 2025) follows a closely related but distinct strategy. Instead of entropy, it quantifies complexity through mutual information between visual and textual tokens and maps that scalar to a budget-constrained logistic retention curve

$$f_q(x)=\frac{N_{\rm init}}{1+\exp\bigl(k_q(x-x_0^q)\bigr)}.$$

The curve parameters depend linearly on mutual information, and the curve is then renormalized so that its integral matches a target token or FLOPs budget (Wang et al., 28 Sep 2025). On LLaVA-1.5-7B, the method prunes 89% of visual tokens, reduces inference FLOPs by 76.8%, and retains 96.7% of the original accuracy averaged over tasks, which the paper reports as a 9.1% improvement over PDrop (Wang et al., 28 Sep 2025). The same framework is also applied to a VLA model for autonomous driving, Senna, without hyperparameter tuning for that task (Wang et al., 28 Sep 2025).

Related transformer work shows the same adaptive pattern in pure vision or medical settings. "Adaptive Sparse ViT" (Liu et al., 2022) uses self-attention-derived token scores and three learnable thresholds inserted at selected depths, optimizing them with a budget-aware objective; on DeiT-S it reports a 50% throughput improvement with only a 0.2% top-1 drop. APFormer extends adaptive pruning to medical image segmentation by combining query-wise pruning and dependency-wise pruning inside transformer attention, reporting that adaptive pruning can act as a plug-n-play module on other hybrid- or transformer-based architectures (Lin et al., 2022).

4. Training-time budget-aware pruning of weights, units, and layers

A second major lineage treats pruning as a training-time optimization problem rather than an inference-time token-routing problem. In "Weight Pruning via Adaptive Sparsity Loss" (Retsinas et al., 2020), pruning is embedded directly into SGD through hard magnitude thresholding with a trainable threshold per layer and a Straight-Through Estimator in backpropagation. Under a zero-centered Gaussian approximation, layer sparsity is modeled as

$$s_i=\operatorname{erf}\!\left(\frac{b_i}{\sigma_i\sqrt{2}}\right),$$

which yields a differentiable sparsity surrogate and enables weighted network-wide sparsity penalties. The method supports both fixed layer-wise sparsity and adaptive, budget-aware sparsity under parameter and FLOP targets (Retsinas et al., 2020). On ImageNet, the paper reports that its adaptive budget-constrained variant can reach around 70% overall sparsity on ResNet-50 without significant accuracy loss, corresponding to about 7.5M parameters; for AlexNet, an unconstrained adaptive variant reduces the model to 2.65M parameters with 56.62% top-1 versus 56.58% for the dense reference (Retsinas et al., 2020).

"Complexity-Aware Training of Deep Neural Networks for Optimal Structure Discovery" (Guenter et al., 2024) generalizes this idea to combined unit/filter pruning and layer pruning during training. The method introduces Bernoulli random variables for layers and units, learns their variational probabilities jointly with weights, and constructs a complexity-aware objective in which expected FLOPS and expected parameter counts are explicit functions of the variational parameters. The entire regularization system is controlled by only three user-defined parameters: $\log\gamma$ for overall pruning strength, $\beta$ for the FLOPS-versus-parameter balance, and $\alpha$ for the layer-versus-unit emphasis (Guenter et al., 2024). The paper also proves that the optimized solutions are deterministic networks, since the minimum over the Bernoulli parameters occurs at extreme points. This is a more formalized version of complexity-adaptive pruning: the network structure itself is the solution of a stochastic optimization problem, rather than the output of a post hoc selection heuristic (Guenter et al., 2024).

Adaptive structured pruning for deployment-oriented CNN compression shows a parallel development. "Adaptive Activation-based Structured Pruning" (Zhao et al., 2022) prunes whole filters using activation-based attention maps, rewinds surviving weights in Lottery-Ticket style, and adaptively increases a global threshold until an accuracy, memory, or FLOPs target is reached. On ResNet-56 with CIFAR-10, the paper reports 79.11% parameter reduction and 70.13% FLOPs reduction with no accuracy drop (Zhao et al., 2022). In quantized networks, "Automatic Pruning for Quantized Neural Networks" (Guerra et al., 2020) uses geometry-aware filter ranking relative to quantized weights and Bayesian optimization for per-layer pruning ratios, reporting for ResNet-18 on ImageNet a 26.12% model-size pruning under BNN quantization with 47.32% top-1 in 2.47 MB, and 59.30% top-1 for a 2-bit DoReFa-Net in 4.36 MB (Guerra et al., 2020).

5. Automated policy search, self-pruning, and representation-guided selection

A third strand emphasizes automatic policy generation. "AutoPruning for Deep Neural Network with Dynamic Channel Masking" (Li et al., 2020) formulates pruning as a two-objective problem over weights and per-layer remaining ratios. The key searchable variable is the continuous remaining ratio $H(X) = -\sum_{i=1}^{n} P(x_i)\ln P(x_i),$0 for each convolutional layer, combined with a dynamic masking process that allows channels to disappear and later re-enter if the learned ratio increases. The optimization alternates between updating weights on training data and updating remaining ratios on validation data, thereby treating channel counts as learnable hyperparameters (Li et al., 2020). On ImageNet, it reports 76.02% accuracy with 50.60% FLOPs pruning on ResNet-50, and on CIFAR-10 it reports 93.51% accuracy with 50.00% FLOPs pruning on ResNet-56 (Li et al., 2020).

Reinforcement-learning-based auto-pruning introduces a different notion of adaptivity: the pruning policy is learned, and later accelerated by transfer from prior pruning tasks. "Boosting the Convergence of Reinforcement Learning-based Auto-pruning Using Historical Data" (Mu et al., 2021) uses transfer learning, augmented transfer learning, and assistant learning to reuse historical pruning data and improve RL sample efficiency. The reported acceleration is 1.5–2.5× for ResNet20 and 1.81–2.375× for ResNet56, ResNet18, and MobileNet v1 (Mu et al., 2021). "AdaPruner" (Liu et al., 2021) offers a lighter-weight variant in which BN scaling parameters define block importance, a bisection method solves for the compact subnetwork satisfying the budget, and several weight-inheritance criteria are evaluated after BN recalibration; on ImageNet, it reports 32.8% FLOPs reduction for MobileNetV2 with only 0.62% top-1 decrease (Liu et al., 2021).

The most radical automation appears in LLM self-pruning. "Breaking Expert Knowledge Limits: Self-Pruning for LLMs" (Kang et al., 19 Nov 2025) asks whether an LLM can design its own pruning algorithm. Its framework combines Graph-driven Chain-of-Thought (GCoT), which explores multiple candidate pruning algorithms through a directed acyclic reasoning graph, with Skew-aware Dynamic Sparsity Allocation (SDSA), which adjusts per-layer sparsity according to skewness of absolute weight magnitudes and global sparsity level. The paper explicitly contrasts its discovered score,

$H(X) = -\sum_{i=1}^{n} P(x_i)\ln P(x_i),$1

with Magnitude, SparseGPT, and Wanda (Kang et al., 19 Nov 2025). It reports that GCoT outperforms naive prompting and linear CoT on LLaMA-2 7B, and that AutoPrune improves WikiText perplexity relative to Wanda and SparseGPT at 50%, 60%, and structured sparsity settings (Kang et al., 19 Nov 2025).

A different but related automated decision rule appears in "Pruning Everything, Everywhere, All at Once" (Nascimento et al., 4 Jun 2025). There, each pruning step generates both a layer-pruned candidate and a filter-pruned candidate, then selects between them using Centered Kernel Alignment (CKA) with the current parent model. On ResNet56, the paper reports 72.67% FLOPs reduction with +0.19 pp accuracy change, and at more aggressive compression 86.37% FLOPs reduction with -1.36 pp; on ResNet110, it reports 95.82% FLOPs reduction with -2.91 pp (Nascimento et al., 4 Jun 2025). This approach is adaptive not at the sample level but at the structure-family level: the pruning operator itself is chosen iteratively.

6. Generalization beyond standard DNN compression, empirical regularities, and open issues

Complexity-adaptive pruning has already expanded beyond conventional deep image models. In variational quantum circuits, QAdaPrune computes parameter-importance scores during training, determines a threshold adaptively from score statistics, and prunes parameters whose scores fall below that threshold; the paper frames this as a move from hyperparameter-driven pruning to adaptive thresholding in response to the current optimization state (Kulshrestha et al., 2024). In neural symbolic regression, SymbolNet performs adaptive dynamic pruning of weights, input features, and unary or binary operators within a single training run, using trainable thresholds and sparsity-dependent decay factors to converge toward target sparsity ratios (Tsoi et al., 2024).

Several empirical regularities recur across domains. First, adaptive methods are most differentiated at high compression: ERASE’s advantage over prior VLM token-pruning baselines widens markedly at 85% token pruning (Lee et al., 11 May 2026), and LLM self-pruning with SDSA is motivated precisely by the collapse of uniform sparsity at high pruning ratios (Kang et al., 19 Nov 2025). Second, the adaptive signal must be reliable early enough to be useful but mature enough to be trustworthy. AS-ViT reports that pruning too early can be unstable because early class attention is unreliable (Liu et al., 2022); APFormer delays updates of its gate-control parameter $H(X) = -\sum_{i=1}^{n} P(x_i)\ln P(x_i),$2 to avoid aggressive early pruning (Lin et al., 2022); ERASE routes complex images to later decoder layers because early-layer pruning becomes less stable as image entropy rises (Lee et al., 11 May 2026). Third, budget control is increasingly explicit: logistic-curve normalization in VLM token pruning (Wang et al., 28 Sep 2025), weighted sparsity loss in magnitude pruning (Retsinas et al., 2020), and expected-complexity regularizers in variational training (Guenter et al., 2024) all treat exact or near-exact resource compliance as a first-class objective.

The main open issue is conceptual rather than merely engineering. The literature shows that “complexity” can mean input entropy, text–vision mutual information, weight-distribution skewness, FLOPs contribution, activation saliency, or optimization-state sensitivity. This suggests that Complexity-Adaptive Pruning is a meta-framework whose specific realization depends on which variable best predicts safe redundancy in a given domain. The corresponding limitations are domain-specific: LLM-generated pruning code may be unsafe or not provably optimal (Kang et al., 19 Nov 2025); mutual-information-based retention assumes early cross-attention is informative (Wang et al., 28 Sep 2025); adaptive quantum pruning depends on the stability of local importance estimates (Kulshrestha et al., 2024); and training-time adaptive pruning often incurs additional optimization or search overhead (Retsinas et al., 2020, Guenter et al., 2024).

Taken together, these works define Complexity-Adaptive Pruning as a shift from static compression schedules to conditional sparsification policies. Whether implemented as entropy-routed token removal, budget-constrained logistic curves, variational Bernoulli gates, dynamic remaining ratios, RL transfer, self-generated pruning rules, or adaptive thresholds in nonclassical models, the common claim is that pruning should track the heterogeneity of data, tasks, layers, and budgets rather than impose a uniform schedule on all of them.