Convolutional Stride Modulator (CSM) Overview

Updated 6 July 2026

CSM is a stride-adaptive mechanism that decouples fixed kernel weights from stride, dynamically modulating token counts in patch-based PDE surrogates.
It replaces fixed-patch encoders and decoders with stride-modulated convolution and transposed-convolution layers, reducing artifacts while preserving transformer cores.
Quantitative benchmarks show CSM improves VRMSE and long-term stability, offering flexible compute trade-offs across classical, Fourier-domain, and quantum convolution settings.

Searching arXiv for the cited papers to ground the article in current records. The Convolutional Stride Modulator (CSM) is a stride-adaptive patching mechanism in which convolutional stride, rather than kernel weights or transformer blocks, becomes the primary control variable for compute allocation. In its most specific recent usage, CSM denotes the lightweight, architecture-agnostic module introduced for patch-based PDE surrogates, where a single learned base kernel is retained while the stride is varied at training and inference to modulate token count, downsampling rate, and runtime without retraining; combined with cyclic patch-size rollout, it is used to mitigate patch artifacts and improve long-term stability in spatiotemporal prediction (Mukhopadhyay et al., 12 Jul 2025). More broadly, the same label has also been applied to distinct stride-adaptive mechanisms in classical Fourier-domain CNNs, hybrid spectral-pooling systems, and flexible-stride quantum convolution, so the term is best understood as naming a family of methods that replace a fixed stride hyperparameter with an explicit modulation mechanism (Riad et al., 2022, Rafif et al., 2024, Yu et al., 2024).

1. Scope and defining idea

In the PDE-surrogate formulation, CSM replaces the fixed-patch encoder and decoder of a Vision-Transformer-style surrogate with stride-modulated versions. The encoder remains a convolution with a fixed kernel size $k^{\text{base}}$ , but its stride is sampled from $\{4,8,16\}$ ; the decoder mirrors this with a transposed convolution using the same kernel size and stride. Because only stride changes, all other convolutional weights and the transformer core remain unchanged. Small strides such as $s=4$ produce many tokens and high accuracy at higher cost, whereas large strides such as $s=16$ produce fewer tokens and lower cost but coarser resolution (Mukhopadhyay et al., 12 Jul 2025).

This construction distinguishes CSM from methods that learn new kernels, change attention topology, or require architecture search. A common misconception is that stride adaptivity necessarily entails retraining or backbone modification. In the PDE setting, the stated design goal is narrower: the module “flexifies” a patch-based encoder/decoder by decoupling kernel weights from stride, so that compute elasticity is realized through token-count modulation rather than through changes to attention, MLP, or loss (Mukhopadhyay et al., 12 Jul 2025).

2. Architectural realization in patch-based PDE surrogates

Let the input field be

$x \in \mathbb{R}^{B \times H \times W \times T \times C},$

with batch size $B$ , spatial dimensions $H \times W$ , time context $T$ , and channels $C$ . Fix a convolutional kernel size $k^{\text{base}}$ , and let $\{4,8,16\}$ 0 denote a 2D convolution with kernel $\{4,8,16\}$ 1 and stride $\{4,8,16\}$ 2. The encoder stage is

$\{4,8,16\}$ 3

followed by an arbitrary transformer core producing latents $\{4,8,16\}$ 4. The decoder is the transposed-convolution mirror

$\{4,8,16\}$ 5

CSM also pads boundary regions with learned tokens so that changing $\{4,8,16\}$ 6 does not introduce edge-cropping artifacts (Mukhopadhyay et al., 12 Jul 2025).

In a standard ViT surrogate, the first stage is a convolutional patchify encoder with fixed kernel and stride and the last stage is a transposed-convolution decoder. CSM simply replaces both with stride-modulated versions. No changes to the transformer’s attention blocks or MLP head are required. During training, $\{4,8,16\}$ 7 is drawn uniformly from $\{4,8,16\}$ 8 each batch; at test time, a single desired stride may be fixed, or multiple strides may be cycled (Mukhopadhyay et al., 12 Jul 2025).

3. Token-count modulation and compute–accuracy trade-off

The token budget induced by CSM is determined directly by stride. For an encoder stage,

$\{4,8,16\}$ 9

By sampling or selecting $s=4$ 0 at each step, CSM dynamically modulates token count with the monotone relation $s=4$ 1 and $s=4$ 2 (Mukhopadhyay et al., 12 Jul 2025).

This makes stride an inference-time systems parameter rather than a fixed architectural commitment. In the pseudocode described for inference, the procedure is: learned boundary-token padding, stride sampling from $s=4$ 3, convolutional encoding with stride $s=4$ 4, transformer processing, and transposed-convolution decoding with the same stride. If the encoder is multi-stage, the stride can be split per stage. The same section also notes that users may cycle among multiple strides, for example $s=4$ 5, to both tune compute and suppress patch artifacts (Mukhopadhyay et al., 12 Jul 2025).

A plausible implication is that CSM converts patch size from a single global hyperparameter into a rollout schedule. In the PDE-surrogate setting, that schedule is coupled to temporal prediction, so stride changes affect not only instantaneous FLOP-equivalent token count but also the accumulation of reconstruction artifacts over long horizons.

4. Plug-and-play properties and backbone compatibility

The PDE-surrogate CSM relies only on standard $s=4$ 6 calls and a learned padding layer. It does not modify the transformer core. Ablations show identical accuracy gains when CSM is applied to both Vanilla ViT and Axial ViT backbones, and even to hybrid models like Continuous ViT (CViT), where only the encoder is patch-based. Because it decouples kernel weights from stride, it can be slotted into existing patchified surrogates, including ViT, Swin, and AFNO-style operators, without changing attention, MLP, or loss (Mukhopadhyay et al., 12 Jul 2025).

These compatibility claims are important because they constrain what CSM is and is not. It is not a new attention mechanism, not a new operator-learning loss, and not a retraining-heavy neural architecture search procedure. Its intervention point is specifically the patchified input/output interface of the surrogate. This suggests that the module is best viewed as a systems-level control layer for tokenization rather than as a representational change to the latent dynamics model.

5. Quantitative behavior in PDE-surrogate benchmarks

On the “Shear” dataset, next-step VRMSE for a vanilla ViT with 100 M parameters improves under CSM at all reported token counts: at 2048 tokens, fixed-patch VRMSE is 0.0067 and CSM VRMSE is 0.0055; at 512 tokens, 0.0096 versus 0.0088; and at 128 tokens, 0.0140 versus 0.0110 (Mukhopadhyay et al., 12 Jul 2025). The reported runtime scaling on the same 100 M parameter vanilla ViT indicates that reducing stride from $s=4$ 7, corresponding to token count $s=4$ 8, increases per-step inference time from approximately 0.21 s to 0.63 s, approximately $s=4$ 9 slower, while cutting next-step VRMSE by more than 30% (Mukhopadhyay et al., 12 Jul 2025).

For 10-step rollout VRMSE, the reported values are as follows:

Dataset	Fixed-patch VRMSE	CSM VRMSE
Shear	0.107	0.053
Turbulent	0.446	0.373
Active	0.370	0.359
Rayleigh	0.227	0.140

The corresponding improvements are reported as +50.5% for Shear, +16.4% for Turbulent, +5.1% for Active, and +38.4% for Rayleigh (Mukhopadhyay et al., 12 Jul 2025). Figure 1 further reports a long-horizon stability distinction: fixed-patch models develop checkerboard artifacts by step 40, whereas CSM and CKM remain stable for 100 steps (Mukhopadhyay et al., 12 Jul 2025).

These results clarify another frequent misunderstanding. CSM is not presented only as a runtime knob that trades accuracy for cost; in the reported experiments it also improves rollout fidelity and long-term stability relative to fixed-patch baselines. The stability claim is especially significant for autoregressive PDE surrogates, where patch-boundary error can accumulate across many decoding steps.

In a different line of work, DiffStride replaces fixed strided convolution or pooling by a differentiable Fourier-domain downsampling layer with learnable continuous strides $s=16$ 0. The method constructs a mask $s=16$ 1 from two 1-D masks, applies DFT, low-pass filtering, cropping with stop-gradient through the crop mask, and inverse DFT, and then backpropagates through the mask parameters. It can be inserted after a stride-1 convolution and can be regularized through

$s=16$ 2

so that $s=16$ 3 controls the accuracy–efficiency trade-off (Riad et al., 2022). On ResNet-18, the reported average test accuracies are 92.4% ± 0.2 on CIFAR-10, 73.5% ± 0.3 on CIFAR-100, and 69.3% ± 0.5 / 88.9% ± 0.4 Top-1 / Top-5 on ImageNet, compared with lower reported baselines for standard strided convolution and spectral pooling (Riad et al., 2022). Although later summaries describe this as a “Convolutional Stride Modulator,” it is conceptually distinct from the PDE-surrogate CSM because it learns continuous stride parameters by backpropagation rather than sampling or selecting from a fixed stride set.

A hybrid extension combines DiffStride with Spectral Pooling in ResNet-18. In that formulation, each shortcut block that originally used stride $s=16$ 4 replaces conv+stride with stride-1 convolution followed by DiffStride, and a Spectral Pooling layer is inserted near the network end before global average pooling. The reported mean categorical accuracy is 0.9334 for DiffStride + Spectral Pooling versus 0.9240 for DiffStride on CIFAR-10, and 0.7382 versus 0.7060 on CIFAR-100; the reported computational overhead is approximately 15–20% (Rafif et al., 2024). Here again, the “CSM” label refers to a stride-adaptive downsampling mechanism, but the operative machinery is Fourier masking and spectral truncation rather than stride-modulated patchification.

A third usage appears in a quantum convolutional neural network with flexible stride. There, CSM promotes the classical stride $s=16$ 5 to a quantum register $s=16$ 6, computes shifted indices in superposition according to

$s=16$ 7

and then uncomputes the stride register so that the qubits can be reused (Yu et al., 2024). The convolution subroutine combines this index-recovery block with amplitude loading, parallel quantum amplitude estimation, and basis arithmetic to recover the convolution inner product. The paper reports MNIST/Qiskit simulations on binary tasks “6 vs 9” and “3 vs 6,” with accuracies of 89.06%, 88.28%, and 96.88% for strides $s=16$ 8, $s=16$ 9, and $x \in \mathbb{R}^{B \times H \times W \times T \times C},$ 0 on “6 vs 9,” and 92.97%, 89.84%, and 89.84% on “3 vs 6,” respectively (Yu et al., 2024). This quantum usage shares the central idea of stride as a dynamically selectable control variable, but the computational substrate and formalism are entirely different.

Taken together, these variants suggest that “Convolutional Stride Modulator” is not a single universally standardized object across the literature. Its most sharply specified arXiv usage is the stride-modulated patch encoder/decoder for compute-adaptive PDE surrogate modeling (Mukhopadhyay et al., 12 Jul 2025), while neighboring works use closely related terminology for differentiable Fourier-domain downsampling (Riad et al., 2022), hybrid spectral methods (Rafif et al., 2024), and quantum flexible-stride convolution (Yu et al., 2024). The unifying principle is the elevation of stride from fixed hyperparameter to explicit modulation variable; the implementation, optimization, and target domain differ substantially across these lines of work.