Skip to content

Puppet-CNN: Continuous Parameter Dynamics for Input-Adaptive Convolutional Networks

Conference: ECCV2026
Paper: ECCV
Area: Model Compression
Keywords: input-adaptive convolution, neural ODE, parameter generation, dynamic convolution, parameter efficiency

TL;DR

Puppet-CNN treats the convolution kernels of an entire CNN backbone as samples along one continuous trajectory in parameter space, evolved by a tiny "puppeteer" neural ODE over a normalized coordinate \(s\in[0,1]\), so that network depth becomes the sampling resolution \(\lfloor 1/\Delta s\rfloor\) and the trajectory's initial state and step size are both driven by an entropy-based input complexity; on CIFAR-10 it reaches 72.51% Top-1 with 1.08 trainable parameters (the paper labels the column "MB", but the magnitudes indicate a parameter count in millions, ⚠️ refer to the original paper), while sample-wise parameter and depth adaptation fall out of the dynamical system itself rather than from an add-on controller.

Background & Motivation

Modern CNNs organize computation as a discrete stack of layers: each layer's convolution kernel is a separately stored, separately learned tensor, and the number of layers is fixed before training as an architectural hyper-parameter. This organization underpins most progress from AlexNet to ResNet, but it has two direct consequences. First, parameter redundancy — adjacent layers learn their kernels from scratch, so depth translates almost linearly into parameter count and storage; under this paper's restricted CIFAR-10 protocol, AlexNet / VGG / ResNet must store 11.65 / 39.01 / 44.84 parameters respectively. Second, computational rigidity — whether the input is a textureless sky or a detail-dense street scene, every sample traverses exactly the same number of layers. A body of work already attacks the latter: early exiting (BranchyNet exits at an intermediate layer based on confidence), layer skipping (SkipNet gates whether a layer is executed), and dynamic recursion (DRNN adjusts the number of residual transformations inside a block). What they share is that adaptivity happens by selecting, skipping, or reusing components of a predefined structure; the layer parameters themselves are still explicitly learned and stored, and the shape of the architecture does not change at all.

A second, more parameter-centric line is input-conditioned parameterization. CondConv combines a bank of expert kernels with sample-dependent routing weights, Dynamic Convolution further constrains the normalization of those combination coefficients, and pixel-adaptive / attention-style methods modulate convolutional responses with spatially varying masks — in all of these the kernel tensors are predefined and the input only decides how they are activated. One step further, parameters are generated directly: DFN, HyperNetworks, WeightNet and DDFN use an auxiliary network to produce each layer's weights on the fly from that layer's input features. Yet regardless of whether parameters are modulated or generated, the common structure is layer-wise: the parameters of layer \(l\) are determined independently by layer \(l\)'s features (or by the \(l\)-th mapping), and depth remains a predefined structural dimension. Diffusion-based weight generation changes the granularity by treating the whole parameter set as a distribution to be sampled, but its "generative time" is the sampling process in parameter space rather than network depth, and the architecture stays fixed. The core tension thus surfaces: if parameters can perfectly well have structure along depth, why must depth itself be a hyper-parameter nailed down before training?

This paper's angle is to treat parameterization itself as a continuous dynamical system: the convolutional kernel parameters \(\mathbf{P}(s)\) are a state along a normalized evolution coordinate \(s\in[0,1]\), and their rate of change is given by a learnable neural function \(G(\cdot;\theta)\). The forward pass is still executed layer by layer, but each layer's kernel is no longer stored independently — it is a sample of one and the same trajectory at a different \(s\). The discretization step \(\Delta s\) determines how many layers can be drawn, so depth turns from an "architectural hyper-parameter" into a "sampling resolution". Going further, both the trajectory's initial state and its sampling step can depend on the input complexity \(c(\mathbf{X}_0)\), which places parameter adaptation and depth adaptation onto the same continuous object. Core idea: generate all convolution kernels with a single shared neural ODE in parameter space, reinterpret network depth as the sampling resolution of that continuous trajectory, and let the trajectory's starting point and sampling density vary with input complexity — parameter count is thereby decoupled from depth, and adaptive computation becomes a structural consequence of the dynamical system rather than an externally attached controller.

Method

Overall Architecture

Puppet-CNN consists of two parts: a "generating" puppeteer module (a neural ODE) and an "executing" puppet module (a standard convolutional backbone). The flow is as follows. An input image \(\mathbf{X}_0\) is first reduced to a scalar complexity \(c(\mathbf{X}_0)\); two deterministic scalar mappings \(\psi\) and \(\phi\) turn it into the trajectory's initial state \(\mathbf{P}_0\) and the discretization step \(\Delta s\); the puppeteer propagates the parameter state along \(s\) inside a fixed-dimensional maximal tensor space \((C^{max}_{out}, C^{max}_{in}, K_{max}, K_{max})\) using a shared neural function \(G(\cdot;\theta)\); each sampled state is resized to the true kernel shape of the corresponding layer and used directly as that layer's convolution kernel in the puppet backbone; after the Conv-BN-ReLU stack, the backbone emits the classification output. As many states as are sampled along \(s\), that many layers are instantiated, so the number of layers actually executed, \(D=\lfloor 1/\Delta s\rfloor\), is also determined by the input.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Input image X0"] --> B["Input-adaptive trajectory modulation<br/>complexity c(X0) sets initial state and step"]
    B --> C["Continuous parameter evolution<br/>shared ODE along s"]
    C --> D["Layer-wise resized injection<br/>sampled state scaled to each kernel"]
    D --> E["Puppet convolutional backbone<br/>Conv + BN + ReLU + pooling"]
    E --> F["Classification output"]

Key Designs

1. Input-adaptive trajectory modulation: one complexity scalar sets both the trajectory's origin and its sampling density

Once the evolution function \(G\) is fixed, the trajectory \(\mathbf{P}(s)\) is uniquely determined by its initial state; if every input started from the same \(\mathbf{P}_0\) and sampled with the same \(\Delta s\), this continuous parameterization would degenerate into a static shared-weight scheme with no adaptivity at all. The paper starts from a scalar complexity signal: the empirical-distribution entropy of pixel intensities in the spatial domain, the entropy of the Fourier-transformed representation in the frequency domain, and their average as \(c(\mathbf{X}_0)\).

\[E(\mathbf{X})=-\sum_{x_i}p(x_i)\log p(x_i),\qquad c(\mathbf{X}_0)=\tfrac{1}{2}E(\mathbf{X}_0)+\tfrac{1}{2}E(\mathcal{F}(\mathbf{X}_0))\]

This scalar then controls two things. The first is parameter-level adaptation, \(\mathbf{P}_0=\psi(c(\mathbf{X}_0))\): different inputs follow different trajectories under the same evolution rule, so the network's "weights" differ from sample to sample. The second is depth-level adaptation, \(\Delta s=\phi(c(\mathbf{X}_0))\), where \(\phi\) preserves a monotonic relation between complexity and sampling resolution, so complex inputs are sampled more finely and instantiate deeper networks while simple inputs are sampled coarsely and stay shallow. Both \(\psi\) and \(\phi\) are deterministic scalar transforms that introduce no additional learnable parameters.

It is worth stressing how this differs from "letting a gating network decide how deep to go": there is no extra controller network here and no addition or removal of anything in the architecture — the depth change is merely how many pieces the same continuous interval \([0,1]\) is cut into. The authors are also explicit that the entropy measure is a "feasibility instantiation" rather than an optimized complexity estimator, and that any other scalar measure could be plugged into the same continuous evolution without altering the shared dynamics. The corresponding equations are corrupted in the PDF text extraction (the \(\mathbf{P}_0\) line retains fragments of an \(\exp(\cdot)\) form), and the paper never reports the actual values of \(\Delta s\) or the distribution of \(D\) at inference time; ⚠️ refer to the original paper for the exact form.

2. Continuous parameter evolution: writing the depth-wise organization as one ODE trajectory, which turns "depth" into sampling resolution

Escaping the "one independent tensor per layer" scheme requires a generation rule shared across layers, ideally one that carries a continuous "layer-count knob" of its own. The paper sets a normalized evolution coordinate \(s\in[0,1]\) and lets the rate of change of the kernel parameters \(\mathbf{P}(s)\) along \(s\) be given by a learnable neural function \(G(\cdot;\theta)\):

\[\frac{d\mathbf{P}(s)}{ds}=G(\mathbf{P}(s);\theta),\qquad \mathbf{P}_l=\mathbf{P}_{l-1}+G(\mathbf{P}_{l-1};\theta)\,\Delta s\]

The integral form has no closed-form solution, so an explicit Euler step is taken over \([s,s+\Delta s]\) to obtain the next state; the number of states sampled uniformly on \([0,1]\) with step \(\Delta s\) is exactly the effective depth \(D=\lfloor 1/\Delta s\rfloor\). Each sampled state corresponds to one convolutional transformation in the puppet module, and training back-propagates through this discretized trajectory — training the puppet network therefore reduces to optimizing only the puppeteer's parameters \(\theta\), from which every convolution kernel is generated.

Compared with the closest lines of work, the difference is structural. Against layer-wise generation (DFN / HyperNetworks / WeightNet / DDFN): there, layer \(l\)'s weights are the output of the \(l\)-th independent mapping — even when conditioned on intermediate features, each layer's weights remain a discrete entity — and depth is given in advance; here all layers are different samples of one trajectory, explicitly coupled across depth, and parameter count no longer grows linearly with depth. Against CondConv / Dynamic Convolution: those methods (softly) select or combine kernels from a predefined expert bank with input-dependent weights, and the kernel tensors themselves are fixed and stored; here there is no expert bank and no routing weights at all — the kernels are evolved. This is precisely where "continuous" parts ways with discrete selection: an MoE-style scheme can only pick among finitely many experts, so changing the layer count means swapping in a different set of discrete parameters, whereas this method takes samples at arbitrary resolution along a continuous trajectory, adjacent layers' parameters are naturally close to each other, and adding a layer merely places one more point on a finer grid. Against diffusion-based weight generation: there the generative time corresponds to sampling a parameter distribution while the architecture stays fixed; here the evolution coordinate maps directly onto network depth.

3. Layer-wise resized injection: evolve in a fixed-dimensional state space, then project onto each layer's true kernel shape

Kernel shapes differ across the layers of one backbone (channels go from 64 to 512, and \(K\) may differ between layers), and if the parameter state space had to follow each layer, "sharing one trajectory" would be hopeless. The paper defines the continuous state on a single maximal tensor shape \((C^{max}_{out}, C^{max}_{in}, K_{max}, K_{max})\), and evolution always happens in this fixed-dimensional space; so that \(G\) can process the state convolutionally, the spatial kernel dimensions are reorganized into a convolution-friendly layout (Fig. 3 in the original), while the object is still kept as one unified parameter state. Each sampled state \(\mathbf{P}_l\) is then projected by a deterministic resizing operation (3D average pooling in the implementation) onto the shape the layer actually needs, \((C^{out}_l, C^{in}_l, K_l, K_l)\), and used directly as that layer's kernel \(\mathbf{W}_l\).

This step is what makes "one trajectory serving heterogeneous layers" work, and its cost lands entirely on the puppeteer's state size: the number of variables is governed by the maximum output channel and grows quadratically with \(C^{max}_{out}\), since a kernel tensor is a product over its dimensions. The measured behaviour is that going from \(C^{max}_{out}=64\) to 4096 raises the variable count from 0.04M to 167.83M (see the experiments). The configuration used in the paper is \(C^{max}_{out}=512\), corresponding to roughly 2.63M variables and the 1.08 trainable-parameter scale reported in the tables. In other words, this parameterization removes "depth" from the cost side entirely, but promotes "maximum channel capacity" into the new cost term — the key constraint on whether it can scale to ImageNet-level backbones.

Loss & Training

No new loss term comes with this parameterization; the objective is still standard categorical cross-entropy, and what actually changes is the object being optimized — every convolution kernel in the puppet module is generated by the shared \(G(\cdot;\theta)\), so training the whole network reduces to back-propagating through the discretized trajectory into \(\theta\). Implementation details: PyTorch, a single RTX 4090, Adam, batch size 64, 800 epochs, learning rate decayed from \(1\times10^{-3}\) to \(1\times10^{-5}\); backbone channel configuration {64, 128, 256, 512}, each convolution followed by BN and ReLU, 2D max-pooling wherever the channel dimension changes, all kernels \(3\times3\); the dynamical function \(G\) is implemented as one depthwise-separable convolution followed by BN and tanh; sampled states are resized to each layer's kernel dimensions via 3D average pooling; the mappings for \(\Delta s\) and \(\mathbf{P}_0\) are deterministic and contain no learnable parameters. To keep the comparison focused on the parameterization mechanism rather than on a training recipe, all baselines are re-implemented and trained under identical data splits and optimization settings, the maximum number of output channels is capped at 512 for every method, and no data augmentation is applied unless explicitly stated.

Key Experimental Results

Main Results

All experiments run under a restricted protocol: CIFAR-10 uses only 10,000 images randomly drawn from the official training set (20% of which are held out for validation); CIFAR-100 uses the full training set (20% held out); mini-ImageNet is split 8:1:1 with images resized to \(64\times64\). The original groups its comparisons into adaptive-parameter methods, adaptive-depth methods and lightweight architectures; the table below collects all three groups (values from Tables 1 and 3 of the original, same restricted protocol):

Category Model Top-1 (%) Top-5 (%) Params Speed (s/img)
Adaptive params DFN 68.59 93.13 75.89 0.0012
Adaptive params WeightNet 62.77 93.52 45.87 0.0040
Adaptive params DDFN-SW (modified to sample-wise) 55.55 93.34 300.83 0.0059
Adaptive depth BranchyNet 70.00 93.94 27.69 0.0015
Adaptive depth SkipNet 55.82 87.95 68.88 0.0115
Adaptive depth DRNN 41.71 63.89 45.78 0.0025
Lightweight AlexNet 65.86 92.05 11.65 0.0006
Lightweight MobileNet-v1 58.58 91.17 7.52 0.0018
Lightweight MobileNet-v2 66.73 93.33 8.90 0.0032
Lightweight SqueezeNet 63.31 94.34 3.96 0.0022
Ours Puppet-CNN 72.51 96.85 1.08 0.0039

⚠️ The parameter column is labelled "Params (MB)" in the original, but given magnitudes such as 75.89 and 300.83 it actually denotes a parameter count (in millions) rather than bytes; Table 7's "2.63M variables → 1.08 MB" also does not convert under a float32 interpretation. Treat the unit as given in the original paper. Larger speed values mean slower inference.

Under the harder generalization settings (CIFAR-100 and mini-ImageNet, more classes and fewer training samples per class), Puppet-CNN again leads with 1.08 parameters (values from Table 6 of the original):

Model CIFAR-100 Top-1 / Top-5 mini-ImageNet Top-1 / Top-5 Params
AlexNet 41.46 / 67.67 36.92 / 64.35 11.84
VGG 45.06 / 67.66 32.95 / 59.94 39.20
ResNet 44.07 / 70.96 38.41 / 68.58 45.02
Puppet-CNN 53.26 / 79.63 46.46 / 74.38 1.08

Ablation Study

The original ablation is progressive: first replace independently learned per-layer parameters with parameters generated by the shared evolution (+ Puppet-Puppeteer), then add parameter-level adaptation (+ Parameter Adaptation). The three backbones cover shallow convolution, deep sequential convolution and residual connection (values from Table 2 of the original; format is Top-1 / Top-5 / Params):

Backbone Fixed-CNN + Puppet-Puppeteer + Parameter Adaptation
AlexNet 65.86 / 92.05 / 11.65 69.33 / 94.05 / 1.08 70.05 / 94.13 / 1.08
VGG 67.84 / 91.98 / 39.01 67.78 / 93.02 / 1.08 68.42 / 90.13 / 1.08
ResNet 68.94 / 95.17 / 44.84 66.69 / 95.46 / 1.08 68.25 / 94.31 / 1.08

Depth adaptation's role here is not accuracy but cost control — generating parameters at fixed depth roughly doubles inference computation, and adaptive depth brings it back to near the original backbone (values from Table 5 of the original):

Variant Params Mult-Adds (G) Speed (s/img)
ResNet (fixed parameters) 44.84 11.40 0.0019
Puppet-ResNet (generated params, fixed depth) 1.08 23.44 0.0061
Puppet-CNN (generated params + adaptive depth) 1.08 12.34 0.0039

Key Findings

  • Replacing per-layer independent parameters with shared evolution costs little accuracy while cutting the parameter count by one to two orders of magnitude. On all three backbones the Puppet-Puppeteer variants match their fixed counterparts in Top-1 (AlexNet +3.47, VGG -0.06, ResNet -2.25), while parameters drop to 1.08 everywhere (versus 11.65 / 39.01 / 44.84). The original adds stronger evidence of consistency: on the full CIFAR-10 training set, Top-1 goes 65.86→83.75 for AlexNet, 81.05→80.57 for VGG and 82.24→80.47 for ResNet, so the effectiveness of the parameterization does not depend on training-set scale, and the small VGG/ResNet drops appear at both data scales.
  • Parameter count is decoupled from network depth. With depth adaptation switched off and the puppet module's layer count increased by hand, conventional CNNs gain parameters linearly with depth while the Puppet variants stay nearly constant, because every kernel comes from the same shared trajectory (Fig. 4 of the original, for VGG and ResNet).
  • The real value of depth adaptation is computation, not accuracy. A fixed-depth Puppet-ResNet pays the ODE generation at every step, pushing Mult-Adds from 11.40G to 23.44G; adding input-adaptive depth brings it back down to 12.34G, roughly level with the original ResNet. Depth adaptation thus acts as the mechanism that offsets generation overhead by executing fewer layers on simpler inputs.
  • The benefit of parameter-level adaptation varies by backbone and is not monotone. Top-1 improves from 69.33 to 70.05 on AlexNet and from 66.69 to 68.25 on ResNet, and from 67.78 to 68.42 on VGG, but VGG's Top-5 drops from 93.02 to 90.13; the original offers no explanation for that inconsistency (⚠️ refer to the original paper). The authors themselves state that the goal of this ablation is not uniformly higher accuracy but evidence that continuous parameter dynamics can serve as a practical, compact parameterization.
  • Parameter scale grows quadratically with the maximum channel capacity. Table 7 of the original gives, for \(C^{max}_{out}\) = 64 / 128 / 256 / 512 / 1024 / 2048 / 4096, puppeteer variable counts of 0.04 / 0.17 / 0.66 / 2.63 / 10.50 / 41.97 / 167.83 (M) and trainable parameter sizes of 0.02 / 0.07 / 0.28 / 1.08 / 4.26 / 16.90 / 67.35. Doubling the channels raises the variable count roughly fourfold, consistent with a kernel tensor being a product over dimensions; at 512 channels the overall scale is still far below a conventional CNN, but moving toward ImageNet-level widths (2048/4096) would visibly erode that advantage.
  • No statistics on the adaptive behaviour itself are reported: neither the distribution of \(\Delta s\), nor the distribution of the instantiated depth \(D\), nor the depth difference between inputs of differing complexity is quantified, so "more complex inputs really do get deeper networks" currently rests on the mechanism alone.

Highlights & Insights

  • Placing the ODE in parameter space rather than feature space is this paper's most distinctive move. The usual neural-ODE usage evolves features or hidden states continuously along depth, and the network still "computes features layer by layer"; here the object being evolved is the convolution kernel itself, so the depth dimension is no longer defined by the number of feature-processing stages but by how densely the parameter trajectory is sampled. That axis swap turns "change the layer count" into "change the sampling rate" and is the source of every adaptive behaviour downstream.
  • "Depth = sampling resolution" unifies architecture and parameters into one generative process. Traditionally, adding a layer means one more independent module and one more chunk of parameters; here it means one more point on the same trajectory with almost no change in parameter count (the flat curves in Fig. 4 come from exactly this). The idea transfers to any setting where the same module is stacked repeatedly: write the repeated block's parameters as one learnable continuous trajectory and the block count becomes a continuous knob that can be tuned to a budget at inference.
  • Adaptivity is not an attached controller but two intrinsic degrees of freedom of the dynamical system. The initial condition and the step size are quantities that already exist in ODE solving, and the authors simply let them depend on input complexity, so parameter adaptation and depth adaptation need no extra module or gate. Compared with early-exit / SkipNet-style schemes that select from an existing architecture, nothing is structurally added or removed, which makes the approach less invasive to implement.
  • A fixed-dimensional state space plus deterministic resizing is the practical answer to serving heterogeneous layers from one trajectory. Evolving in the maximal kernel-tensor space and then pooling each sampled state down to its layer's true shape sidesteps the dead end of "kernel shapes differ, so nothing can be shared"; the price (state growing quadratically with the maximum channel count) is honestly quantified in Table 7, which is the mark of a design that knows where its weakness lies.

Limitations & Future Work

  • The experimental scale is small, with no ImageNet-1k. The largest setting is \(64\times64\) mini-ImageNet, and CIFAR-10 uses a 10k subset with no data augmentation, so the absolute accuracy (72.51%) is well below what standard CIFAR-10 protocols produce. The claim of beating BranchyNet/DFN in Table 1 therefore holds only within this restricted protocol and cannot be extrapolated to standard benchmarks.
  • No direct comparison against CondConv / Dynamic Convolution. Related work devotes considerable space to these two input-conditioned convolution families, but the adaptive-parameter baselines in the experiments are DFN / WeightNet / DDFN-SW, with no head-to-head against the "expert bank + routing weights" form — precisely the comparison that "continuous generation vs discrete selection" most needs.
  • Neither the complexity measure nor the two mappings is ablated. \(c(\mathbf{X}_0)\) is an equal-weight average of spatial and frequency-domain entropy, and \(\psi\)/\(\phi\) are hand-designed deterministic scalar mappings; the paper calls them a feasibility instantiation rather than an optimum, yet offers no replacement study and reports neither the actual values of \(\Delta s\) nor the distribution of instantiated depth \(D\), leaving the effective range of depth adaptation unknown.
  • Parameter generation roughly doubles computation at fixed depth. Puppet-ResNet goes from 11.40G to 23.44G Mult-Adds and from 0.0019 to 0.0061 s/img; even with adaptive depth it still costs 0.0039 s/img, several times slower than AlexNet. The large parameter advantage is bought with inference computation, which the parameter-count narrative does not discuss enough.
  • Parameter count grows quadratically with the maximum channel capacity (Table 7), meaning that at ImageNet-level widths (\(C^{max}_{out}\) of 2048/4096) the puppeteer alone would reach 16.90/67.35 and the saving over a conventional backbone would shrink substantially.
  • The numerics of the ODE are never discussed. Only a single explicit Euler step is used; step-size error, whether \(G\) needs a Lipschitz constraint, and whether higher-order or adaptive-step solvers would help are all left open. Related work also does not cite Neural ODE (Chen et al., 2018), the most direct intellectual antecedent, and the relationship to HyperNetworks is only categorized rather than compared experimentally.
  • vs CondConv / Dynamic Convolution: they maintain a bank of predefined expert kernels and combine them with input-dependent (normalized) coefficients, so the kernel tensors are always stored; this paper has no expert bank and no routing weights, since kernels are evolved by a shared ODE, which lets the layer count change continuously without parameter growth. Conversely, it lacks an accuracy comparison with these two under a common protocol and pays extra ODE-solving cost at inference.
  • vs DFN / HyperNetworks / WeightNet / DDFN: all are layer-wise generation — layer \(l\)'s weights are produced independently by the \(l\)-th mapping (conditioned on features), with depth given in advance; this paper couples all layers through one shared trajectory sampled along depth, with depth set by the sampling resolution. In the experiments DFN reaches 68.59%, WeightNet 62.77% and DDFN-SW 55.55%, all below Puppet-CNN's 72.51%, but the parameter-count conventions and training protocols differ enough that the comparison should be read with care.
  • vs BranchyNet / SkipNet / DRNN: these represent adaptation on top of a fixed architecture (early exit, layer skipping, varying the number of recursions) with parameters still learned explicitly; this paper pushes adaptivity down into parameter generation itself. Puppet-CNN (72.51%) scores above BranchyNet (70.00%), SkipNet (55.82%) and DRNN (41.71%), again within the restricted protocol.
  • vs diffusion-based weight generation (Neural Network Diffusion and similar): those treat the parameter set as a samplable distribution where generative time corresponds to the sampling process in parameter space while the architecture stays fixed; here the evolution coordinate maps directly onto depth, so the two define "generation" differently. A continuous parameter trajectory is naturally closer to "different depth slices of one and the same network", which is a promising angle for controllable weight generation.
  • Transferable insight: rewrite the parameters of a repeated stack as a continuous trajectory and modulate the trajectory's origin and sampling rate with one cheap input scalar. The template is not limited to convolutions — Transformer layer stacks, timestep conditioning in diffusion models, or the per-layer parameters of LoRA-style low-rank adapters could all replace independent per-layer storage with a shared evolution, and pick up a budget-tunable depth knob along the way.

Rating

  • Novelty: ⭐⭐⭐⭐ Moving the neural ODE from feature space to parameter space and redefining depth as a sampling resolution is a perspective worth reading on its own; but input adaptation, the complexity measure and backbone plug-in are largely combinations of existing ideas.
  • Experimental Thoroughness: ⭐⭐ Only CIFAR-10 (10k subset) / CIFAR-100 / mini-ImageNet, no ImageNet-1k; no direct comparison with CondConv/DyConv, no ablation of the complexity measure or of \(\psi\)/\(\phi\), no reported distribution of \(\Delta s\) or instantiated depth \(D\), and the anomalous VGG Top-5 drop is left unexplained.
  • Writing Quality: ⭐⭐⭐ The conceptual layering is clear and the motivation is well told, but several equations are corrupted in the extracted text, the parameter unit ("MB" vs count) is inconsistent, and some conclusions (e.g. the benefit of adaptation) are phrased cautiously without quantitative support.
  • Value: ⭐⭐⭐ The two conclusions — parameter count decoupled from depth, and depth as sampling resolution — have clear transferable value and make a reasonable feasibility case for continuous parameterization; but the current accuracy/efficiency evidence is not yet enough to make it a directly adoptable backbone design.