Continuous Kernel Parameterization

137 concepts92 papers2 proposals

Traditional convolutional neural networks (CNNs) treat weights as discrete tensors—static grids of numbers indexed by integers (such as a $3 \times 3$ or $7 \times 7$ matrix). While highly optimized for modern hardware, this discrete representation tightly couples a model to a specific spatial or temporal resolution. If a network is trained on data sampled at a specific frequency, deploying it on a different grid size or an irregular sampling rate typically requires destructive interpolation or complete retraining.

Continuous kernel parameterization fundamentally re-imagines this paradigm. Instead of storing weights as discrete grid entries, the network parameterizes weights as a continuous function over a coordinate space:

$$W = f(\mathbf{x})$$

where $\mathbf{x}$ represents spatial, temporal, or frequency coordinates. By optimizing the underlying function $f$ rather than individual pixel values, neural networks decouple their internal representations from the discretization of the input data.


Shifting from Grids to Coordinate Functions

To construct a continuous kernel, a model must map continuous coordinates to weight values. The literature primarily uses two strategies to parameterize this mapping:

  1. Implicit Neural Representations (INRs): A small auxiliary neural network (often a multi-layer perceptron) acts as the function $f$. It takes coordinates as inputs and outputs the corresponding filter weights. This approach is leveraged by David W. Romero et al. in CKConv and Adrian V Dalca et al. in Hyper-Convolution Networks for Biomedical Image Segmentation to generate dynamic, dense receptive fields from coordinate inputs.
  2. Continuous Basis Functions: The kernel is expressed as a linear combination of mathematically defined basis functions. Examples include orthogonal polynomials introduced by Yan Ru Pei et al. in PLEIADES, Hermite polynomials with Gaussian envelopes used by Ivan Sosnovik et al. in Scale-Equivariant Steerable Networks, and Fourier series applied by Rene Winchenbach in Symmetric Basis Convolutions.

More recently, alternative architectures like Kolmogorov-Arnold Networks have been adapted to this paradigm; the authors of Core-KAN map coordinates to weights using learnable univariate functions to achieve smooth geometric adaptations.


Why It Works: Resolution and Sampling Invariance

The core reason continuous kernels work across varying data formats is that discretization is deferred to the forward pass. Because the kernel exists as an analytical function, it can be evaluated at any arbitrary set of coordinates on the fly.

Discrete Kernel:   [W1] [W2] [W3]  --> Locked to fixed grid spacing

Continuous Kernel:   f(x) ---------> Can be evaluated at x = 0.1, 0.15, 0.92...

In sequential analysis and time-series processing, data is frequently plagued by missing values or irregular sampling rates. As shown by David W. Romero et al. in CKConv, a continuous model can be trained on a regular grid and deployed directly on irregularly sampled data. The network simply queries the continuous kernel function at the exact timestamps of the incoming data points. To handle varying temporal resolutions even more cleanly, Yan Ru Pei et al. calculate the analytical antiderivative of the continuous kernel over specific time bins, allowing the model to adapt to changing sensor frequencies without retraining.

This resolution independence applies equally to the frequency domain. In SONIC, Gijs Joppe Moens defines filters as continuous functions of frequency coordinates. When the target image resolution changes at inference time, the continuous filter is simply re-sampled onto the new frequency grid, preserving the model's underlying mathematical behavior without performance degradation.

Beyond input resolution, this functional representation can even be applied to the network architecture itself. Kirill Solodskikh et al. demonstrate in Integral Neural Networks that representing weight matrices as continuous functions over a parameter space allows a network to be evaluated at any arbitrary layer width, enabling zero-shot structural pruning without fine-tuning.


Decoupling Receptive Fields from Parameter Explosion

In standard CNNs, expanding the receptive field to capture long-range dependencies requires increasing the size of the weight grid. This creates a polynomial explosion in parameter count, which triggers heavy memory overhead and severe overfitting risks.

Continuous parameterization completely decouples the spatial size of the receptive field from the model's parameter footprint. The parameter count of the coordinate-mapping network (or the number of basis coefficients) remains entirely fixed, regardless of how large the sampled kernel becomes.

  • Adrian V Dalca et al. exploit this property in Hyper-Convolution Networks to generate large, dense kernels that provide broad contextual awareness for biomedical image segmentation without inflating the weight budget.
  • The authors of HyenaPixel scale this concept to deploy massive convolutional kernels (up to $191 \times 191$) that encompass global image contexts with sub-quadratic computational complexity.
  • To prevent large kernels from introducing unnecessary noise, David W. Romero et al. introduce FlexConv, which multiplies the continuous kernel by a learnable Gaussian mask. This allows the network to dynamically optimize its own receptive field size via standard backpropagation.

Operating Natively on Irregular and Geometric Domains

Standard discrete convolutions fail on non-Euclidean domains like point clouds or graphs because these structures lack a uniform grid. Continuous kernels naturally bypass this limitation by evaluating the filter function directly on relative coordinates or positional encodings.

For 3D point clouds, Wenxuan Wu in PointConv and Yifan Xu et al. in SpiderCNN model convolutional filters as continuous functions evaluated at the exact relative 3D coordinates of neighboring points. This allows the network to extract hierarchical features directly from irregular, unordered point sets without requiring voxelization. Similarly, in the graph domain, Liheng Ma et al. introduce CKGConv, which parameterizes graph convolution kernels as continuous functions over relative positional encodings to learn complex, non-linear filter shapes.

Exact Geometric Transformations

Continuous representations also make it possible to enforce strict geometric symmetries, such as rotation and scale equivariance. Instead of rotating a discrete pixel grid—which introduces interpolation artifacts and blurriness—one can analytically transform the coordinate space passed into the continuous function.

Discrete Rotation:    [Grid] -> Interpolate/Rotate -> [Distorted Grid]
Continuous Rotation:  f( Rotation_Matrix * Coordinates ) -> Perfect Analytical Filter

Yifan Pu et al. utilize this in Adaptive Rotated Convolution to dynamically orient kernels along the bounding boxes of rotated objects via bilinear coordinate sampling. For mathematically rigorous symmetry constraints, Maksim Zhdanov parameterizes steerable CNN kernels using explicitly equivariant MLPs in Implicit Convolutional Kernels for Steerable CNNs.

Going further into continuous transformation groups, Mircea Mironenco et al. demonstrate in Lie Group Decompositions for Equivariant Neural Networks that parameterizing kernels over a Lie algebra using implicit neural representations allows networks to natively handle complex, continuous geometric transformations like shearing and non-uniform scaling without being restricted to a discrete pixel coordinate system.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 99 papers
  2. Version 1 · 2026-10-04 · 154 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_continuous_kernel_parameterization_3c64c198,
  title = {continuous kernel parameterization},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/continuous-kernel-parameterization/rdr_3c64c1983a434b2fb0fa423021c00bba},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 2, frozen text):

@misc{lacuna_continuous_kernel_parameterization_3c64c198_v2,
  title = {continuous kernel parameterization},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/continuous-kernel-parameterization/rdr_3c64c1983a434b2fb0fa423021c00bba/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake