Adaptive RBF-KAN Networks

• Adaptive RBF-KAN is an architecture that reformulates Kolmogorov–Arnold Networks by replacing fixed spline-based edge functions with adaptive RBF expansions.
• It leverages tunable kernel families and shape parameters—initialized through LOOCV and refined via gradient descent—to optimize local smoothness and approximation.
• Variants such as FastKAN, Free-RBF-KAN, and Hierarchical RBF-KAN demonstrate significant speedups and improved accuracy on benchmark function approximations.

Searching arXiv for the cited papers and closely related work on Adaptive RBF-KAN. First, I’ll look up the core FastKAN paper that reframes KANs as RBF networks. Looking up “Kolmogorov-Arnold Networks are Radial Basis Function Networks”. Adaptive RBF-KAN designates a line of Kolmogorov–Arnold network research in which the spline-parameterized univariate edge functions of KAN are replaced by radial basis function expansions, and some part of the RBF parameterization is made data-driven. In the narrow sense, the term refers to the model introduced in "Adaptive RBF-KAN: A Comparative Evaluation of Dynamic Shape Parameters in Kolmogorov-Arnold Networks" (Cavoretto et al., 20 May 2026). In a broader sense, it also covers related RBF-based KAN variants that learn kernel scales, kernel families, centers, or hierarchical decompositions while preserving the Kolmogorov–Arnold style separation into univariate inner and outer maps (Li, 2024, Chiu et al., 12 Jan 2026, Xia et al., 1 Jun 2026).

1. Definition and architectural lineage

Kolmogorov–Arnold Networks approximate multivariate functions through compositions of univariate functions. A central representation used in the literature is

$$f(x) = \sum_q \Phi_q\left(\sum_p \phi_{q,p}(x_p)\right).$$

In spline-based KAN implementations, the learnable edge function is typically written as

$$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$

This formulation gives strong local approximation power, but it also ties the model to B-spline basis evaluation and grid management (Cavoretto et al., 20 May 2026).

The RBF-KAN transition begins from the observation that the 3rd-order B-splines used in standard KANs can be closely approximated by Gaussian radial basis functions after a linear transformation of the input. FastKAN adopts this viewpoint and replaces explicit spline evaluation by Gaussian RBF computation, while preserving the additive KAN structure (Li, 2024). Subsequent papers introduce distinct notions of adaptivity: Adaptive RBF-KAN makes the kernel width learnable and enlarges the kernel family beyond Gaussian; Free-RBF-KAN makes both centroids and smoothness trainable; hierarchical RBF-KAN makes centers, scales, and linear parameters trainable inside a multi-block architecture that mirrors the Kolmogorov–Arnold decomposition more explicitly (Cavoretto et al., 20 May 2026, Chiu et al., 12 Jan 2026, Xia et al., 1 Jun 2026).

Variant	Basis choice	Adaptive component
FastKAN	Gaussian RBFs	Learnable coefficients; fixed centers
Adaptive RBF-KAN	Gaussian, Matérn, Wendland	LOOCV-initialized, trainable shape parameter
Free-RBF-KAN	RBF basis with Gaussian in experiments and Matérn discussed	Trainable centroids and smoothness
Hierarchical RBF-KAN	Gaussian RBF activations	Trainable centers, scales, weights, biases

2. RBF reformulation of spline KAN

The conceptual pivot of Adaptive RBF-KAN is the FastKAN claim that "under proper linear transformations, Gaussian RBFs well approximate 3-order B-spline bases." The standard RBF form used in this reformulation is

$f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$

with Gaussian basis

$\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$

Within FastKAN, the learned univariate map on an edge is therefore interpreted as a linear combination of Gaussian bumps located at fixed centers rather than as a spline expansion over a fixed knot grid (Li, 2024).

This replacement matters computationally because standard KAN implementations rely on the de Boor–Cox recursion to evaluate 3rd-order B-splines and often require additional grid rescaling to keep activations in range during training. FastKAN removes the de Boor–Cox recursion and the spline-grid rescaling used in standard KAN. The paper also uses layer normalization to reduce the chance that activations drift outside the region where the basis approximation is good, thereby avoiding the need for explicit input-domain rescaling during training (Li, 2024).

The reported speed measurements use an NVIDIA V100 GPU and comparable basis capacity: efficient KAN uses 5 grids with 3rd-order splines, totaling 8 parameters per input, and FastKAN uses 8 Gaussian centers. On a layer with 100 inputs and 100 outputs, FastKAN reduces forward-pass time from roughly $742\,\mu s$ to $223\,\mu s$, a $3.33\times$ speedup. For forward + backward, it improves from about $1160\,\mu s$ to $925\,\mu s$, about $1.25\times$ faster. On MNIST with models of shape $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$0 trained for 20 epochs, FastKAN performs equivalently to, and sometimes slightly better than, the efficient KAN baseline (Li, 2024).

A recurring interpretive point follows directly from FastKAN: this is not presented as a theorem of exact equivalence between arbitrary KANs and arbitrary RBF networks. The claim is narrower. The particular spline basis construction used in standard KANs can be reformulated as an RBF expansion with fixed centers, yielding a much cheaper implementation (Li, 2024).

3. Shape-adaptive kernel learning

The model introduced as Adaptive RBF-KAN keeps the FastKAN edgewise RBF formulation,

$$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$1

where $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$2 are fixed centers, $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$3 are learnable coefficients, and $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$4 is the kernel width or shape parameter. Its central modification is that the kernel family is no longer restricted to Gaussian, and the shape parameter is no longer fixed. FastKAN is described as using Gaussian RBFs with the standard value $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$5; Adaptive RBF-KAN instead initializes $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$6 by leave-one-out cross-validation and then refines it by gradient-based training (Cavoretto et al., 20 May 2026).

The paper’s LOOCV procedure is built from an auxiliary interpolation model,

$$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$7

with interpolation matrix

$$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$8

To avoid ill-conditioning, the paper adds

$$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$9

The search for the initial width is coarse-to-fine, and the minimized criterion is

$f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$0

After initialization, positivity is enforced by the log-space reparameterization

$f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$1

with $f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$2, the RBF coefficients $f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$3, and the residual weights $f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$4 all updated by Adam via backpropagation (Cavoretto et al., 20 May 2026).

The paper interprets the shape parameter as the main control knob for locality and smoothness: small $f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$5 yields narrow, highly localized kernels that are more flexible but potentially overfitting; large $f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$6 yields smoother, broader kernels that can underfit or oversmooth. The stated motivation is therefore two-stage: LOOCV addresses the initialization problem, and gradient descent addresses the final task-adapted scale (Cavoretto et al., 20 May 2026).

4. Kernel families and function-class matching

Adaptive RBF-KAN enlarges the kernel family in a way that makes kernel smoothness and support explicit modeling choices. The Gaussian kernel remains

$f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$7

and is described as $f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$8, infinitely smooth, and globally supported. The paper then introduces three Matérn variants into the KAN framework: $f(x) = \sum_{i=1}^N w_i\, \phi(\|x-c_i\|),$9 for Matérn $\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$0,

$\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$1

for Matérn $\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$2, and

$\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$3

for Matérn $\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$4. It also introduces Wendland kernels, which are compactly supported, including

$\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$5

for Wendland $\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$6 and

$\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$7

for Wendland $\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$8 (Cavoretto et al., 20 May 2026).

The main empirical message is that kernel smoothness and locality should match the target function structure. For the very smooth Franke function $\phi(r) = \exp\left(-\frac{r^2}{2h^2}\right).$9, Gaussian performs best. For the circular discontinuity $742\,\mu s$0, Matérn $742\,\mu s$1 performs better than Gaussian. For the oscillatory benchmark

$742\,\mu s$2

Wendland $742\,\mu s$3 performs best. For the singularity-like benchmark $742\,\mu s$4, Wendland $742\,\mu s$5 gives the best reported result (Cavoretto et al., 20 May 2026).

The benchmark setup is uniform across models: 2000 samples total, 80/20 train-test split, input dimension 2, output dimension 1, Adam optimizer, learning rate $742\,\mu s$6, 2000 epochs, FP64 precision, and the same hardware across comparisons. The adaptive FastKAN uses $742\,\mu s$7 for $742\,\mu s$8, $742\,\mu s$9, and $223\,\mu s$0, and $223\,\mu s$1 for $223\,\mu s$2; the standard KAN uses deeper spline-based architectures such as $223\,\mu s$3, which are much slower (Cavoretto et al., 20 May 2026).

Benchmark	Best kernel	Relative $223\,\mu s$4
Franke function $223\,\mu s$5	Gaussian	$223\,\mu s$6
Circular discontinuity $223\,\mu s$7	Matérn $223\,\mu s$8	$223\,\mu s$9
Oscillatory $3.33\times$0	Wendland $3.33\times$1	$3.33\times$2
Singularity-like $3.33\times$3	Wendland $3.33\times$4	$3.33\times$5

A particularly explicit comparison is reported for $3.33\times$6: $3.33\times$7 For $3.33\times$8, the Wendland kernel improves over Gaussian by about $3.33\times$9. This suggests that the term “adaptive” in this paper is primarily about shape adaptation and kernel-family selection rather than center relocation (Cavoretto et al., 20 May 2026).

5. Learned grids, trainable centers, and hierarchical structure

Other RBF-KAN variants extend adaptivity beyond a single global shape parameter. Free-RBF-KAN defines a multilayer RBF-KAN recursively by

$1160\,\mu s$0

with each output component represented as a sum of kernel responses

$1160\,\mu s$1

The architectural distinction is explicit: standard RBF-KAN uses fixed centroids and fixed smoothness, whereas Free-RBF-KAN makes both trainable. Each centroid is reparameterized so that it remains in a prescribed interval,

$1160\,\mu s$2

with $1160\,\mu s$3, $1160\,\mu s$4, and $1160\,\mu s$5. Smoothness is learned through

$1160\,\mu s$6

which ensures positivity. The paper characterizes this as adaptive grid learning plus trainable smoothness, allowing the representation to remesh itself around regions of high variation without spline recursion (Chiu et al., 12 Jan 2026).

Free-RBF-KAN also states a universality result for RBF-KANs. If $1160\,\mu s$7 is continuous and non-polynomial, then for any $1160\,\mu s$8 and any $1160\,\mu s$9, there exists an NP-KAN of the form

$925\,\mu s$0

such that

$925\,\mu s$1

Gaussian RBF-KAN is then universal as a corollary because the Gaussian kernel is continuous and non-polynomial (Chiu et al., 12 Jan 2026).

Hierarchical RBF-KAN develops a different extension. Rather than using uniform fully connected layers, it uses hierarchical blocks consisting of two activation layers: the first approximates the inner univariate functions $925\,\mu s$2, and the second approximates the outer functions $925\,\mu s$3. The number of neurons in the first post-activation layer is chosen to be $925\,\mu s$4 times the number in the second post-activation layer, reflecting the Kolmogorov–Arnold representation

$925\,\mu s$5

Its trainable parameters include RBF centers $925\,\mu s$6, RBF scales $925\,\mu s$7, linear-layer weights $925\,\mu s$8, and biases $925\,\mu s$9; ResNet-style skip connections are optional (Xia et al., 1 Jun 2026).

The theoretical results for hierarchical RBF-KAN are correspondingly stronger. Theorem 1 states that for any $1.25\times$0, if $1.25\times$1 admits the Kolmogorov–Arnold representation, then there exists a hierarchical RBF-KAN such that

$1.25\times$2

The quantitative approximation estimate is described as having right-hand side of order at most

$1.25\times$3

and the paper emphasizes that this convergence rate does not explicitly depend on the dimension $1.25\times$4, suggesting partial mitigation of the curse of dimensionality. A stochastic extension, hierarchical RBF-SKAN, is formulated for random field learning under the Wasserstein-2 metric (Xia et al., 1 Jun 2026).

6. Empirical profile, limitations, and terminological boundaries

Across the current literature, adaptive RBF-KAN methods are presented as a compromise between the accuracy of spline KAN and the computational simplicity of RBF evaluation. Free-RBF-KAN is the clearest example of this tradeoff. In nonsmooth 2D function approximation,

$1.25\times$5

the reported test MSE is $1.25\times$6 for Free-RBF-KAN, versus $1.25\times$7 for standard RBF-KAN and $1.25\times$8 for KAN. On MNIST with shared $1.25\times$9 architecture, the reported test loss is $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$00 for Free-RBF-KAN, compared with $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$01 for standard RBF-KAN and $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$02 for KAN. In a 2D heat equation benchmark, the reported $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$03 error and training time are $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$04 and 138 s for Free-RBF-KAN, versus $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$05 and 124 s for RBF-KAN and $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$06 and 267 s for KAN. For a 2D Helmholtz problem, the reported $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$07 loss is $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$08 for Free-RBF-KAN, versus $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$09 for RBF-KAN and $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$10 for KAN. In DeepONet trunk learning for a reaction–diffusion PDE, the reported relative error is $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$11 for Free-RBF-KAN, lower than MLP trunk $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$12, KAN trunk $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$13, and RBF-KAN trunk $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$14 (Chiu et al., 12 Jan 2026).

Hierarchical RBF-KAN reports a more structural conclusion: naive RBF-KAN with uniform widths performs poorly in many cases, whereas the hierarchical design plus ResNet gives the best stability. The model maintains good accuracy as dimension increases from 1 to 6 on an oscillatory benchmark, gives the smallest trajectory and dynamics errors in Lorenz system reconstruction when using the two-block ResNet variant, and in the stochastic setting hierarchical RBF-SKAN outperforms CNF and CVAE baselines, especially in standard deviation prediction (Xia et al., 1 Jun 2026).

Several boundaries on the term “adaptive” are explicit in the literature. FastKAN does not introduce fully adaptive center-learning or width-learning; it uses fixed centers and is best understood as an efficient RBF surrogate for spline KAN rather than a new adaptive basis-learning framework (Li, 2024). Adaptive RBF-KAN, in the 2026 sense, adapts the kernel family and the shape parameter $$\psi_{k,m,n}(x)=\sum_{j=0}^{H+J-1} c_{k,m,n,j} B_{j,J}(x)+w_{k,m,n}\cdot \mathrm{SiLU}(x).$$15, but still keeps the centers fixed (Cavoretto et al., 20 May 2026). Hierarchical RBF-KAN learns centers and scales, but does not introduce input-dependent centers, online basis relocation, adaptive basis growth or pruning, attention-like gating of RBFs, or a specialized adaptation rule beyond standard backpropagation (Xia et al., 1 Jun 2026). Free-RBF-KAN goes furthest toward geometric adaptivity by learning centroids and smoothness jointly, but it still remains within the standard end-to-end optimization regime (Chiu et al., 12 Jan 2026).

Related adaptive RBF models should be distinguished from canonical RBF-KANs. HyResPINNs introduces adaptive hybrid residual blocks that mix a neural branch and an RBF branch through trainable scalar gates inside a PINN, but it is described as an adaptive hybrid PINN architecture rather than a KAN (Cooley et al., 2024). "A Novel Adaptive Kernel for the RBF Neural Networks" learns fusion weights between Euclidean and cosine kernels in a classical RBF network, which is conceptually related to adaptive kernel design but not a KAN implementation (Khan et al., 2019). This suggests that “Adaptive RBF-KAN” is best reserved for architectures that preserve the Kolmogorov–Arnold decomposition while making the RBF parameterization itself trainable.