Kolmogorov-Arnold Fourier Networks

## Abstract

Abstract Although Kolmogorov-Arnold (Kolmogorov, 1933 ) based interpretable networks (KAN) have strong theoretical expressiveness, they face significant parameter explosion and high-frequency feature capture challenges in high-dimensional tasks. To address this issue, we propose the Kolmogorov-Arnold-Fourier Network (KAF), which effectively integrates trainable Random Fourier Features (RFF (Tancik et al., 2020 ; Bracewell & Bracewell, 1986 ) ) and a novel hybrid GELU-Fourier activation mechanism to balance parameter efficiency and spectral representation capabilities. Our key technical contributions include: (1) merging KAN’s dual-matrix structure through matrix association properties to substantially reduce parameters; (2) introducing learnable RFF initialization strategies to eliminate spectral distortion in high-dimensional approximation tasks; (3) implementing an adaptive hybrid activation function that progressively enhances frequency representation during the training process. Comprehensive experiments demonstrate the superiority of our KAF across various domains including vision, NLP, audio processing, and differential equation-solving tasks, effectively combining theoretical interpretability with practical utility and computational efficiency. We will release the source code of our method in accordance with the review policy.

## 1 Introduction

The interpretability of deep neural networks (Howard et al., 2017; Han et al., 2016) has long been one of the core challenges in the field of machine learning. The Kolmogorov-Arnold(Liu et al., 2024; Kolmogorov, 1933) theorem states that any continuous multivariate function can be represelinented through a combination of univariate functions (Mhaskar & Micchelli, 1996; Barron, 1993). This theory provides significant inspiration for the design of interpretable neural network architectures. Based on this theory, Kolmogorov-Arnold Networks (KAN) (Liu et al., 2024; Schmidt-Hieber, 2021) have been proposed, which replace the fixed activation functions in traditional multilayer perceptrons (MLPs (Rumelhart et al., 1986)) with learnable B-spline (De Boor, 1972) basis functions, theoretically demonstrating strong expressive potential and flexibility. By introducing trainable nonlinear activation functions, KAN enables the network to dynamically adjust the shape of the activation functions according to the characteristics of the data, thereby enhancing the adaptability and performance of the model.

However, despite the significant theoretical advantages of KAN, its practical application faces two fundamental issues that severely limit its generalization and adoption in high-dimensional tasks: Inefficient Parameter Utilization:
The dual-matrix architecture of KAN (i.e., the activation function matrix and the B-spline coefficient matrix) leads to a rapid increase in the number of parameters. Compared to traditional MLPs, where the parameter count scales with input × output + bias, KAN’s parameter count grows several times larger. This makes it challenging to apply KAN to high-dimensional tasks such as computer vision. The explosion in parameters (Xu et al., 2019; Mhaskar & Micchelli, 1996; Barron, 1993) not only increases the storage and computational costs of the model but also significantly reduces the efficiency of both training and inference (Tan & Le, 2020, 2021).
The B-spline (De Boor, 1972; Eldar & Unser, 2021; Aziznejad et al., 2023; Li et al., 2023; Wu et al., 2022)basis functions employed by KAN exhibit inherent spectral limitations when performing function approximation in high-dimensional spaces. The smoothness of B-spline basis functions makes it difficult to accurately capture high-frequency components of signals, leading to suboptimal performance when processing data with rich spectral features, such as natural images or audio waveforms. This limitation in spectral representation capability adversely affects the model’s performance and stability in practical applications(Xu et al., 2019). This dilemma creates a paradox between theory and practice: although KAN theoretically encompasses all functionalities of MLPs, its inefficiency and spectral distortion issues force practitioners to make a trade-off between interpretability and scalability.

To address the aforementioned issues, the key challenge is balancing the inherent trade-off between model interpretability and parameter efficiency, which has long plagued traditional neural networks. This paper make an attempt to fundamentally redefine the traditional KAN paradigm (Bracewell & Bracewell, 1986). Specifically, this paper introduces an innovative neural network architecture—Kolmogorov-Arnold-Fourier Networks (KAF), which employs Fourier domain reparameterization and dynamic activation evolution, aiming to bridge the gap between interpretability and parameter efficiency. Our main contributions include:

- •
By leveraging the associative property of matrix multiplication, we merge the two large matrices ($WA$ and $WB$) of KAN, thereby reducing the parameter complexity from $O(d_{\text{in}}\times d_{\text{out}}\times(G+K+3))$ to $O(d_{\text{in}}\times d_{\text{out}})$, while preserving the expressive power of the model (Arora et al., 2018; Chen et al., 2020). This approach not only effectively reduces the number of parameters but also enhances the model’s scalability in high-dimensional tasks.
- •
We replace the traditional B-spline basis functions with trainable Random Fourier Features to eliminate the need for the spline coefficient matrix. An initialization strategy based on the Central Limit Theorem ($\sigma=1.64$) aligns the RFF spectrum with the prior knowledge of natural signals, avoiding spectral leakage issues. This significantly enhances the model’s spectral fidelity and expressive power in high-dimensional spaces.
- •
We design a hybrid GELU-Fourier activation function with learnable coefficients $\{a,b\}$. During training, these coefficients are dynamically adjusted through gradient backpropagation, enabling an automatic transition from fixed activation functions to hybrid Fourier-symbolic representations. This dynamic activation mechanism not only optimizes the model’s learning trajectory but also ensures the stability and efficiency of the final Fourier-driven inference mode.

## 2 Related Work

Multi-Layer Perceptrons and Current Challenges. The design and optimization of deep learning (Touvron et al., 2021)models remain central to machine learning research. Traditional MLPs(Rumelhart et al., 1986), among the earliest neural networks (Han et al., 2016), offer simplicity and scalability, with rich theoretical foundations. While ResNet (He et al., 2015b) and Transformer (Vaswani et al., 2023) models have shown remarkable performance across various tasks, MLPs face challenges in theoretical interpretability and practical bottlenecks. Traditional activation functions like ReLU (Nair & Hinton, 2010; Glorot et al., 2011) and Sigmoid (Elfwing et al., 2017) often fail to adapt to complex data, and despite their efficiency, MLPs struggle with high-frequency features and complex distributions. Improving activation mechanisms and parameter efficiency has become crucial for enhancing MLPs’ adaptability to high-dimensional data.

Kolmogorov-Arnold Networks and Scalability Issues. The Kolmogorov-Arnold (Fan et al., 2019) Theorem underpins networks for approximating continuous multivariable functions. The pioneering KAN replaced fixed activations with B-spline (De Boor, 1972) functions but faces challenges in high-dimensional applications due to parameter explosion and GPU inefficiency. Recent improvements include KAN-Transformer, MLP-KAN with sparse parameters, and FAN(Dong et al., 2024) with Fourier activations, all seeking to balance interpretability with scalability.

Enhancing Spectral Representation with KAF. To address high-frequency modeling challenges, Random Fourier Features (RFF (Rahimi & Recht, 2007b; Yu et al., 2016)) enable spectral domain mapping, with variants like Learnable RFF and SIREN enhancing expressiveness. Our proposed KAF incorporates GELU and learnable Fourier features, with scale factor control and variance initialization. This reduces parameters while improving spectral representation. KAF maintains KAN’s interpretability while enhancing scalability and efficiency, showing superior performance in capturing high-frequency(Sitzmann et al., 2020) details across NLP, vision, audio, and traditional machine learning tasks.

Figure: Figure 1: Compare two models: a standard MLP with GELU activation (left) and a KAF with GELU activation (right). The MLP involves a projection matrix followed by GELU, while the KAF adds Random Fourier Features (RFF) and scale parameters, offering more flexibility in feature transformations.
Refer to caption: x1.png

## 3 Methodology

### 3.1 Kolmogorov-Arnold Theorem

The Kolmogorov-Arnold (Bracewell & Bracewell, 1986; Kolmogorov, 1933) theorem, proposed by Soviet mathematicians Vladimir Arnold and Andrey Kolmogorov in the 1950s, states that any continuous (Kidger & Lyons, 2020; Maiorov & Pinkus, 2021) multivariate function $f:[0,1]^{d}\rightarrow\mathbb{R}$ can be represented as a superposition of univariate functions:

$$ $f(x_{1},x_{2},\dots,x_{d})=\sum_{q=1}^{2d+1}\Phi_{q}\left(\sum_{p=1}^{d}\phi_{q,p}(x_{p})\right),$ $$

where $\Phi_{q}:\mathbb{R}\rightarrow\mathbb{R}$ and $\phi_{q,p}:[0,1]\rightarrow\mathbb{R}$ are univariate continuous functions. This theorem provides a theoretical foundation for dimensionality reduction in high-dimensional function approximation.

In (Berner et al., 2022b; Poggio et al., 2017), the theorem suggests that high-dimensional functions can be captured through low-dimensional (Xu et al., 2019) transformations, resembling the hierarchical structure of neural networks. However, compared to traditional neural networks, the number of parameters required by the Kolmogorov-Arnold theorem may lead to a more lengthy and resource-consuming training process. Due to the non-smoothness of certain low-dimensional functions and the difficulties in training optimization, this theorem has not been practically applied in the field of neural networks for a long time.

### 3.2 Kolmogorov-Arnold Network (KAN)

Although the Kolmogorov-Arnold (Bracewell & Bracewell, 1986)theorem was proposed quite early, (KAN (Liu et al., 2024)) is proposed according to this theorem, demonstrating that this structure can, in a sense, serve as an alternative to traditional MLP models. In the KAN network, each layer can be represented by the following formula:

$$ $f(\mathbf{x})=\Phi\circ\mathbf{x}=\left[\sum_{i=1}^{d_{in}}\phi_{1,i}(x_{i})\quad\cdots\quad\sum_{i=1}^{d_{in}}\phi_{d_{out},i}(x_{i})\right],$ $$

where $\Phi$ is a matrix of basis functions. This formula aligns with the form of the Kolmogorov-Arnold theorem. However, in practical applications, they chose B-spline (Bach, 2016) basis functions as the basis functions $\phi_{q,p}$, and added an external activation function $SILU$ to guide the update of the KAN layer(Ramachandran et al., 2017; Elfwing et al., 2017). The formula can be expressed as

$$ $\phi(x)=w_{h}\text{silu}(x)+w_{s}\text{spline}(x),$ $$

$$ $\text{spline}(x)=\sum_{i}c_{i}B_{i}(x).$ $$

Among them, $\Phi$ represents the basis function matrix, where B-spline basis functions and the SiLU activation function were used. However, KAN suffers from excessive parameter growth, with a parameter count of $d_{\text{out}}\times d_{\text{out}}\times(G+K+3)+d_{\text{out}}$, far exceeding MLP’s $d_{\text{in}}\times d_{\text{out}}+d_{\text{out}}$, while also being computationally inefficient on GPUs and failing to capture high-frequency components, limiting its practical applicability.

### 3.3 KAF: Kolmogorov-Arnold Fourier Network

In the previous discussion, we pointed out that traditional networks based on the Kolmogorov-Arnold theorem (KAN) often face multiple challenges in practical applications. To address these issues, we propose an alternative approach—KAF (Kolmogorov-Arnold Fourier Network). By replacing B-spline basis functions with Random Fourier Features (RFF(Fathony et al., 2021; Tancik et al., 2020; Bracewell & Bracewell, 1986)), which are more efficient for GPU acceleration, and introducing hybrid spectral correction for the activation functions, the network retains the advantages of the Kolmogorov-Arnold theory while achieving training efficiency and inference speed closer to that of MLPs (Rumelhart et al., 1986). This section provides a detailed explanation of the overall architecture of the KAF network, the utilization of Random Fourier Features within the network, the design and scaling principles of the GELU-Fourier hybrid activation function, as well as the RFF weight initialization strategy and the theoretical justification for $\sigma=1.64$.

Overall Architecture.
In the overall framework of KAF, we follow the core idea of the Kolmogorov-Arnold theorem, which approximates high-dimensional target functions through the composition of several low-dimensional learnable functions. Unlike the KAN network, which directly utilizes B-spline basis functions, KAF employs Random Fourier Features (RFF) in each layer to perform a nonlinear mapping of the input, and then uses linear transformations to achieve the composition of the ”outer function” and the ”inner function.” Specifically, the core computational process of each KAF layer can be formulated as:

$$ $\small\mathbf{h}^{(l)}=\underbrace{\mathbf{W}^{(l)}}_{\text{outer function}}\left(\underbrace{\mathbf{a}^{(l)}\odot\text{GELU}(\tilde{\mathbf{x}}^{(l)})+\mathbf{b}^{(l)}\odot\tilde{\phi}(\tilde{\mathbf{x}}^{(l)})}_{\text{inner function composition}}\right)+\mathbf{c}^{(l)},$ (1) $$

where:
$\tilde{\mathbf{x}}^{(l)}=\text{LayerNorm}(\mathbf{x}^{(l)})$ is the normalized input at layer $l$;
$\tilde{\phi}(\cdot)$ represents the nonlinear mapping based on Random Fourier Features (RFF) (detailed in Section 3.3.2);
$\mathbf{a}^{(l)},\mathbf{b}^{(l)}\in\mathbb{R}^{n}$ are learnable scaling parameters, used to modulate the contributions of GELU activation and RFF features, respectively;
$\mathbf{W}^{(l)}\in\mathbb{R}^{m\times n}$ is the linear transformation weight, and $\mathbf{c}^{(l)}\in\mathbb{R}^{m}$ is the bias term.

By stacking multiple layers of the above transformation, the KAF network constructs an efficient multi-layer approximation structure. Since RFF has excellent parallelism on GPUs, this structure avoids the high computational burden of B-spline basis functions, significantly improving training and inference efficiency while maintaining strong function approximation capabilities.

Random Fourier Features (RFF).
Given an input space $\mathcal{X}\subseteq\mathbb{R}^{d}$, we define the Random Fourier Feature (RFF(Tancik et al., 2020)) mapping as a learnable embedding from the input space to a Reproducing Kernel Hilbert Space (RKHS(Werneburg, 2023; Aronszajn, 1950; Schölkopf & Smola, 2018)). For any input vector $x\in\mathcal{X}$, the feature mapping is formally defined as:

$$ $\small z(x;W,b)=\sqrt{\frac{2}{m}}\big{[}\cos(\langle x,W\rangle+b)\oplus\sin(\langle x,W\rangle+b)\big{]}\in\mathbb{R}^{2m},$ (2) $$

where $W\in\mathbb{R}^{d\times m}$ and $b\in\mathbb{R}^{m}$.
Here, $\langle\cdot,\cdot\rangle$ denotes the Euclidean inner product, and $\oplus$ represents the vector concatenation operation. The frequency matrix $W=[w_{1},\dots,w_{m}]$ is initialized according to an input-dimension-adaptive spectral distribution: $w_{ij}\sim\mathcal{N}(0,\sigma^{2}/d)$, where $\sigma^{2}$ represents the empirical variance of the input data. The phase shift $b$ is sampled from a uniform distribution $b_{i}\sim\mathcal{U}[0,2\pi]$, which ensures phase diversity, a crucial property for capturing local features of signals.See Appendix  [B](https://arxiv.org/html/2502.06018v2#A2) for more information on RFF convergence, gradient calculation, and initialization strategies.

This mapping comes with the following theoretical guarantees:

- Translation Invariance: For any $x,y\in\mathcal{X}$, as $m\to\infty$, we have $\mathbb{E}[z(x)^{T}z(y)]\to e^{-\frac{\|x-y\|^{2}}{2\sigma^{2}}}$.

- Differentiability: The partial derivatives $\frac{\partial z}{\partial W}$ and $\frac{\partial z}{\partial b}$ have analytical expressions, enabling end-to-end differentiation.

GELU-Fourier Hybrid Activation.

Design Motivation: To balance low-frequency smoothness and high-frequency representation capability, we propose a hybrid activation function:

$$ $\mathcal{H}(\boldsymbol{x})=\underbrace{\alpha\odot\mathrm{GELU}(\boldsymbol{x})}_{\mathclap{\text{Low-Frequency Basis}}}\mathrel{\hphantom{=}}+\mathrel{\hphantom{=}}\underbrace{\beta\odot\boldsymbol{V}\psi(\boldsymbol{x})}_{\mathclap{\text{High-Frequency Correction}}}$ (3) $$

where $\alpha,\beta\in\mathbb{R}^{d}$ are learnable channel-wise scaling factors, $\boldsymbol{V}\in\mathbb{R}^{d\times 2k}$ is the frequency-domain projection matrix, and $\odot$ represents element-wise multiplication.
Initialization Strategy of KAF:

$$ $\alpha^{(0)}\leftarrow\boldsymbol{1},\quad\beta^{(0)}\leftarrow\epsilon\boldsymbol{1},\quad(\epsilon=10^{-2}),\quad\boldsymbol{V}_{ij}^{(0)}\sim\mathcal{N}(0,0.01)$ (4) $$

The dynamic property of this initialization manifests in the following way: At the early stage of training, the small initialization of the high-frequency component $\beta$ ensures that its norm is much smaller than that of the low-frequency component $\alpha$, prioritizing the learning of low-frequency features. As training progresses, the natural growth of weights allows the norm of $\beta$ to increase approximately proportionally to the training time $t$, thereby gradually enhancing the representation of high-frequency features.

Implementation of the Kolmogorov-Arnold Architecture and RFF Initialization.

Theorem Definition: The Kolmogorov-Arnold representation theorem states that any continuous function $f\in C([0,1]^{d})$ can be expressed as a finite composition of univariate functions:

$$ $f(\boldsymbol{x})=\sum_{q=0}^{2d}\Phi_{q}\left(\sum_{p=1}^{d}\phi_{q,p}(x_{p})\right),$ (5) $$

where $\phi_{q,p}:\mathbb{R}\to\mathbb{R}$ are univariate nonlinear functions, and $\Phi_{q}:\mathbb{R}\to\mathbb{R}$ are composition functions.

Architecture Implementation: We modularize the neural network to efficiently approximate this mapping, establishing the following correspondences:

$$ $\displaystyle\phi_{q,p}(x_{p})$ $\displaystyle\mapsto\underbrace{\mathrm{GELU}\bigl{(}w_{p}^{(q)}x_{p}+b_{p}^{(q)}\bigr{)}}_{\mathclap{\text{Low-Frequency Basis}}}+\boldsymbol{\beta}_{q}^{\top}\mkern-2.0mu\underbrace{\psi_{\text{RFF}}(x_{p})}_{\mathclap{\text{High-Frequency Basis}}},$ (6) $\displaystyle\Phi_{q}(\cdot)$ $\displaystyle\mapsto\boldsymbol{\alpha}_{q}^{\top}\mkern-2.0mu\text{Linear}(\cdot).$ $$

Here, $\psi_{\text{RFF}}(x_{p})=[\cos(\omega_{1}x_{p}+\theta_{1}),\sin(\omega_{1}x_{p}+\theta_{1}),\dots]$ represents the Random Fourier Features (RFF), and $\boldsymbol{\alpha}_{q},\boldsymbol{\beta}_{q}\in\mathbb{R}^{k}$ are learnable modulation parameters.

Spectral Complementarity Mechanism:
- GELU Properties: The activation function $\sigma(wx+b)$ provides a smooth gating effect in the low-frequency domain, satisfying $\mathbb{E}[\sigma(wx)]\propto\mathcal{N}(0,1/\sqrt{2})$.
- RFF Enhancement: The use of mixed-frequency bases $\{\cos(\omega_{m}x+\theta_{m})\}_{m=1}^{M}$ expands spectral coverage.
- Dynamic Balancing: The learnable parameters $\boldsymbol{\alpha},\boldsymbol{\beta}$ enable an adaptive trade-off:

$$ $\tilde{\phi}(x)=\alpha\cdot\mathrm{GELU}(x)+\beta\cdot\psi_{\text{RFF}}(x),$ (7) $$

where the initial values are set to $\alpha^{(0)}=1$ and $\beta^{(0)}=10^{-2}$ to ensure training stability.

RFF Initialization Strategy: To fully leverage spectral complementarity, we adopt a refined initialization scheme:
- Frequency Matrix $\boldsymbol{W}$: To ensure spectral balance and avoid bias towards low or high frequencies, we initialize $\boldsymbol{W}$ using a scaled normal distribution(Glorot & Bengio, 2010; He et al., 2015a):

$$ $\omega_{ij}\sim\mathcal{N}\left(0,\,\frac{\gamma}{\sqrt{d_{\text{in}}\cdot\mathbb{E}[\|\sigma(x)\|^{2}]}}\right),$ (8) $$

This initialization is designed to align with the spectral distribution of the input data. The denominator normalizes the standard deviation based on input dimensionality $d_{\text{in}}$ and the expected squared norm of the activation function $\mathbb{E}[\|\sigma(x)\|^{2}]$, ensuring a stable variance propagation during training. For the GELU activation function, why $\sigma(x)=1.64$ will be proved later in Appendix  [C](https://arxiv.org/html/2502.06018v2#A3).

- Phase Shift $\boldsymbol{b}$: Uniformly sampled to cover a complete period,

$$ $b_{i}\sim\mathcal{U}(0,\,2\pi).$ (9) $$

- Linear Projection Layer: Initialized using Xavier initialization,

$$ $\boldsymbol{V}_{ij}\sim\mathcal{U}\left(-\sqrt{6/(d_{\text{in}}+d_{\text{out}})},\,\sqrt{6/(d_{\text{in}}+d_{\text{out}})}\right).$ (10) $$

Parameter and FLOPs Comparison.
To evaluate the scale of parameters and computational overhead of KAF, we compare the number of parameters and floating-point operations (FLOPs) for KAF, KAN, and MLP in a single layer setting.

Table [3](https://arxiv.org/html/2502.06018v2#A1.T3) summarizes the parameter count and FLOPs for each model. KAN exhibits the highest parameter count due to its recursive B-spline computations, while KAF, by leveraging Random Fourier Features (RFF), achieves a balance between parameter efficiency and spectral representation. MLP remains the simplest in terms of computation.
For the detailed derivation of these calculations, please refer to Appendix  [A](https://arxiv.org/html/2502.06018v2#A1).

## 4 Experiments

The objective of this experiment is to evaluate the performance of mainstream models when their MLP(Rumelhart et al., 1986) or KAN components are replaced with KAF. By maintaining consistent parameters, we conducted experiments across a variety of tasks including simple visual tasks, NLP tasks, audio tasks, and machine learning tasks, utilizing models such as ResNet-18 (He et al., 2015b), DeiT (Touvron et al., 2021) (from the MLP-KAN architecture), MLPmixer (Berner et al., 2022a), and GPT-2 (Brown et al., 2020). Additionally, we tested the performance of KAF in function fitting and solving differential equations. All experiments employed either the Adam (Kingma & Ba, 2014) optimizer, with learning rates appropriately selected according to the specific task. The experimental environment was set up with RTX 4090D GPU.

### 4.1 Comprehensive Evaluation Based on Kanbefair

Based on Kanbefair (Yu et al., 2024), we conducted a comprehensive evaluation of KAF on vision (Dosovitskiy et al., 2021), NLP (Brown et al., 2020), audio, and machine learning tasks to compare its performance with existing models. We selected MLP (with GELU activation), KAN, FAN (Dong et al., 2024), and GPKAN (Yang & Wang, 2024) for experimentation. Note that we use the original input by default in all experiments, leaving layernorm disabled.

#### 4.1.1 Experimental Setup

To account for differences in model convergence speeds, KAN was trained for 100 epochs, while other models were trained for 40 epochs. During training, the maximum test accuracy was recorded as the primary evaluation metric, focusing on classification tasks across 8 vision datasets, 2 NLP datasets, 2 audio datasets, and 4 additional machine learning datasets. For all models, hidden layer sizes were explored in the range of 2, 4, 8, 16, 32, 64, 128, 256, 512, and 1024. For KAF, the key parameters included 9 grids, an activation expectation of 1.64, and GELU as the activation function. For KAN, the number of B-spline grids was set to 3, 5, 10, or 20; B-spline degrees were configured as 2, 3, or 5; and the B-spline range was [-1, 1], [-2, 2], or [-4, 4]. For MLP, we experimented with both GELU (Hendrycks & Gimpel, 2016) and ReLU (Nair & Hinton, 2010; Glorot et al., 2011) activations. FAN’s p_ratio was set to 0.25 to regulate the proportion of preserved information during transformation, and GPKAN used GELU-based initialization for enhanced convergence.

#### 4.1.2 Experimental Results

Figure: Figure 2: Compare the performance of different models (KAN, MLP, GPKAN, FAN, KAF) across several datasets (MNIST, EMNIST, FMNIST, KMNIST, Cifar10, Cifar100, SVHN). The results show that KAF generally achieves higher accuracy with fewer parameters.
Refer to caption: x2.png

As shown in Figure [2](https://arxiv.org/html/2502.06018v2#S4.F2), we conducted a systematic comparison of KAF and several baseline models (e.g., ResNet, ViT, MLP-Mixer) on vision datasets, including MNIST (LeCun et al., 1998), EMNIST (Cohen et al., 2017), KMNIST (Clanuwat et al., 2018), CIFAR 10/100 (Krizhevsky et al., 2009), and SVHN (Netzer et al., 2011).
The results in Figure [2](https://arxiv.org/html/2502.06018v2#S4.F2) demonstrate that KAF consistently achieves the highest accuracy under the same parameter settings across different scales. Notably, on more challenging tasks such as CIFAR10 and SVHN, KAF exhibits significant accuracy improvements compared to other models. These results highlight KAF’s robustness in addressing high-dimensional data challenges.
In addition to vision tasks, Figure [3](https://arxiv.org/html/2502.06018v2#A4.F3)(see Appendix  [D](https://arxiv.org/html/2502.06018v2#A4)) evaluates KAF’s performance on NLP, audio, and traditional machine learning datasets. KAF achieves better results on these three tasks than other models. This shows that KAF is not only suitable for visual tasks but also for text and audio tasks.
The result highlights KAF’s superior versatility and generalization capabilities across different tasks.

**Table 1: Comparison of different models on various datasets with different feature mixers in common vision architectures. Parameters refer to the total model size, and FLOPs are computed for forward propagation. KAN was sometimes excluded due to its excessive parameter size, making training under the same conditions infeasible.**
| Model | Datasets | Feature Mixer | #Param. | FLOPs | Top-1 | Model | Datasets | Feature Mixer | #Param. | FLOPs | Top-1 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ResNet/18 | CIFAR-10 | MLP | 11.1M | 0.56G | 91.19 | MLP_Mixer/S | ImageNet1k | MLP | 18.2M | 3.8G | 63.5 |
| ResNet/18 | CIFAR-10 | KAF | 12.0M | 0.63G | 91.72 | MLP_Mixer/S | ImageNet1k | KAF | 18.8M | 4.2G | 64.7 |
| ResNet/18 | CIFAR-10 | GPKAN | 11.3M | 0.56G | 90.98 | MLP_Mixer/S | ImageNet1k | GPKAN | 18.8M | 4.0G | 62.9 |
| ResNet/18 | CIFAR-10 | FAN | 8M | 0.42G | 90.69 | MLP_Mixer/S | ImageNet1k | FAN | 15.7M | 3.2G | 58.2 |
| ResNet/18 | CIFAR-10 | KAN | Too large | – | – | MLP_Mixer/S | ImageNet1k | KAN | Too large | – | – |
| ViT-T/16 | ImageNet1K | MLP | 5.7M | 1.08G | 72.3 | MLP_KAN(Deit) | Cifar100 | MLP | 1.3M | 0.12G | 49.0 |
| ViT-T/16 | ImageNet1K | KAF | 5.9M | 1.12G | 73.2 | MLP_KAN(Deit) | Cifar100 | KAF | 1.4M | 0.15G | 53.8 |
| ViT-T/16 | ImageNet1K | GPKAN | 5.7M | 1.13G | 74.6 | MLP_KAN(Deit) | Cifar100 | KAN | 1.9M | 0.19G | 51.2 |
| ViT-T/16 | ImageNet1K | FAN | 4.2M | 0.96G | 65.7 | MLP_KAN(Deit) | Cifar100 | GPKAN | 1.4M | 0.14G | 54.3 |
| ViT-T/16 | ImageNet1K | KAN | Too large | – | – | MLP_KAN(Deit) | Cifar100 | FAN | 1.0M | 0.1G | 46.7 |

### 4.2 Experiments on Using KAF Components in Complex Vision Models

To comprehensively evaluate the performance of KAF in large-scale vision models after replacing corresponding layers, we assess its impact on accuracy, computation time, and generalization across various models. In this section, we conduct comparative experiments on commonly used large-scale vision models, including ResNet-18, ViT-Tiny, and MLP-Mixer-S/16, as well as the latest model incorporating KAN components, MLP_KAN (based on DeiT). In each case, we replace the original KAN or MLP modules with KAF, KAN, MLP, GPKAN, and FAN, respectively, to analyze their performance differences.

#### 4.2.1 Experimental Setup

The experiments utilize CIFAR-10, CIFAR-100 (Krizhevsky et al., 2009), and ImageNet-1K for training and testing. ResNet-18 and MLP-Mixer-S/16 are trained for 100 epochs, while ViT-Tiny (He et al., 2024; Dosovitskiy et al., 2021) and MLP_KAN are trained for 300 epochs. All other training hyperparameters follow the official recommended settings for each model.
Both KAF and MLP use GELU as the activation function; for KAN, we set the grid size to 5 and the B-spline degree to 3; FAN’s p_ratio is fixed at 0.25; GPKAN adopts GELU-based initialization; LayerNorm is disabled by default; and Dropout follows each model’s standard setting.

#### 4.2.2 Experimental Results

Table [1](https://arxiv.org/html/2502.06018v2#S4.T1) summarizes performance across multiple datasets when various feature Mixers replace the original modules. KAF generally meets or exceeds baseline accuracy while maintaining a reasonable parameter count and computational cost. For instance, in ResNet-18 on CIFAR-10, KAF achieves 91.72% Top-1 accuracy (compared to MLP’s 91.19%), and on ImageNet-1K, it improves MLP-Mixer from 63.5% to 64.7%. Although compact approaches like FAN can reduce parameters, they often yield lower accuracy (e.g., 58.2% on ImageNet-1K). Similarly, with ViT-T/16, KAF’s moderate parameter increment still outperforms MLP, while in MLP_KAN (DeiT), KAF boosts baseline accuracy from 49.0% to 53.8%.
Overall, KAF demonstrates gains and stable training on challenging tasks and architectures, including attention-rich models. These results highlight its potential as a more efficient and effective Mixer replacement in modern vision networks, balancing parameter overhead with performance improvements.

### 4.3 Experiments on LLMs with KAF Components

To evaluate the potential of KAF in language models, we integrated it into the GPT-2 architecture by replacing the Feed-Forward Network (FFN)’s MLP with KAF or KAN. We then trained and evaluated the models on large-scale text datasets, assessing their impact on language modeling quality and model complexity.

#### 4.3.1 Experimental Setup

We conducted experiments using OpenWebText and WikiText, two widely used text datasets. The base model was GPT-2 (Small version), where the two-layer MLP in the Feed-Forward Network (FFN) was replaced with KAF or KAN while maintaining the same parameter scale.
All other Transformer configurations(Vaswani et al., 2023), including multi-head attention, token embeddings, and positional encoding, remained consistent with the official GPT-2 implementation.

#### 4.3.2 Experimental Results

**Table 2: Comparison of GPT-2 based MLP, KAF, and KAN models on WikiText and OpenWebText: Perplexity, training time, and parameter count.**
| Model | Dataset | PLL | Training Time | #Param. |
| --- | --- | --- | --- | --- |
| MLP | WikiText | 184.53 | 20h 37m | 117M |
| KAF | WikiText | 180.85 | 19h 20m | 128M |
| KAN | WikiText | 39782 | 304h 06m | 478M |
| MLP | OpenWebText | 151.27 | 60h 57m | 117M |
| KAF | OpenWebText | 145.64 | 52h 45m | 128M |
| KAN | OpenWebText | 27832 | 960h 19m | 478M |

Table [2](https://arxiv.org/html/2502.06018v2#S4.T2) presents a comparison of GPT-2 using MLP, KAF, and KAN as the FFN components on the WikiText and OpenWebText datasets. The results show that KAF boosts language modeling performance and training efficiency. On WikiText, it reduces PLL from 184.53 to 180.85 while cutting training time from 20h37m to 19h20m, indicating improved performance without significant overhead. In contrast, KAN converges poorly, with PLL escalating to 39,782 and training time rising sharply due to large parameter scales, revealing severe optimization challenges.
A similar pattern emerges on OpenWebText: KAF again surpasses MLP by lowering PLL from 151.27 to 145.64 and further reducing training time, whereas KAN remains unstable (PLL reaching 27,832), reaffirming its vulnerability in large-scale language modeling. Overall, swapping MLP for KAF in GPT-2 consistently enhances language modeling across WikiText and OpenWebText, while preserving reasonable training costs.
The experiment demonstrates that substituting MLP with KAF in GPT-2’s FFN not only yields measurable improvements in perplexity and training efficiency across datasets of varying scales but also highlights KAF’s robustness compared to large, more unstable alternatives like KAN.

### 4.4 Performance of KAF in Function Approximation and Differential Equation Solving Tasks

To comprehensively validate the capability of KAF in complex function approximation and PDE solving(Raissi et al., 2017), we have carefully designed experiments covering a wide range of complexities, dimensions, and degrees of nonlinearity. First, we constructed eight function approximation tasks to evaluate KAF’s performance in capturing complex nonlinear relationships. Second, we selected four PDE-solving problems involving multiple physical parameters to assess their applicability in scientific computing. Various hyperparameter configurations were employed in the experiments to ensure the reliability and generalization ability of the results.

#### 4.4.1 Experimental Setup

We conducted 8 function approximation and 4 PDE solving(Raissi et al., 2017; Han et al., 2018) tasks, addressing varying complexities, dimensions, and nonlinearities. For function approximation and PDE tasks, we trained models with hidden layer sizes ranging from 8 to 512 for up to 1000 epochs. More detailed experimental settings are detailed in Appendix  [E](https://arxiv.org/html/2502.06018v2#A5).

#### 4.4.2 Function Approximation Tasks

We presents the eight target functions used in the experiments (see Table [4](https://arxiv.org/html/2502.06018v2#A5.T4) in Appendix  [E](https://arxiv.org/html/2502.06018v2#A5)), covering a variety of mathematical properties, including periodicity, non-linearity, high dimensionality, discontinuity, and chaos. The results of the experiment are shown in  [4](https://arxiv.org/html/2502.06018v2#A5.F4)(see Appendix  [E](https://arxiv.org/html/2502.06018v2#A5)). According to the experimental data, KAF’s minimum test RMSE in most function approximation tasks is significantly lower than that of MLP, GPKAN, and FAN, demonstrating superior fitting capability and generalization performance. In the Bessel task, KAF achieves a test RMSE of $2.55\times 10^{-6}$, which is considerably lower than MLP’s $1.43\times 10^{-5}$. For the Highly-Nonlinear and Multi-Scale tasks, KAF attains RMSE values of $3.18\times 10^{-5}$ and $4.98\times 10^{-5}$, while MLP exhibits significantly higher errors of $1.41\times 10^{-4}$ and $1.85\times 10^{-2}$, respectively.

#### 4.4.3 PDE solving tasks

As shown in Figure [5](https://arxiv.org/html/2502.06018v2#A5.F5) in Appendix  [E](https://arxiv.org/html/2502.06018v2#A5), for numerical solving tasks across four types of PDEs (Poisson, 1D Wave, Heat, and Burgers), traditional MLP exhibits higher overall errors or lower stability. In contrast, KAF, which leverages learnable approximation, generally achieves better or comparable accuracy. For Poisson and Heat equations, both KAF and KAN significantly outperform MLP in terms of error reduction, while FAN also maintains a comparable level of accuracy. However, GPKAN, due to its sensitivity to parameter scale and initialization, demonstrates noticeable instability or larger errors, highlighting its challenges in achieving robust performance under these conditions. Overall, KAF, which incorporates learnable grid functions or compact functionals, provides greater flexibility in function approximation for PDE-solving tasks.

### 4.5 Ablation Experiment

In this section, we conducted two ablation experiments: 1) On the CIFAR-10 dataset, we used a single-layer network to study the effectiveness and completeness of each component and strategy. Additionally, we plotted the scaling factor curves to observe the variations of different factors during the experiment. The detailed results are presented in Appendix  [F](https://arxiv.org/html/2502.06018v2#A6); 2) We performed function fitting experiments on sin(x) and cos(x) in comparison with KAN and MLP (GELU/RELU) to demonstrate that our model outperforms traditional methods in fitting periodic and high-frequency signals. The full experimental results are shown in Appendix  [F](https://arxiv.org/html/2502.06018v2#A6).

## 5 Discussions

The Kolmogorov-Arnold-Fourier network (KAF) addresses the scalability and spectral limitations of Kolmogorov-Arnold Networks (KAN) by integrating trainable random Fourier features (RFF) and a hybrid GELU-Fourier activation mechanism. This innovative design improves parameter efficiency and high-frequency function approximation while preserving a degree of interpretability. Experimental results demonstrate KAF’s effectiveness across a diverse range of tasks, including vision, natural language processing (NLP), and solving differential equations, highlighting its practicality in high-dimensional learning scenarios.However, KAF’s reliance on Fourier-based representations introduces certain trade-offs, such as potential challenges in interpretability and increased computational overhead. Furthermore, the learnability of RFF-based mappings is sensitive to initialization and hyperparameter tuning, which can impact convergence stability and model performance.Future research could focus on several promising directions. One avenue is the hybridization of KAF with larger-scale models to further enhance its capacity and scalability. Another is the exploration of more robust initialization schemes and adaptive optimization techniques to improve the stability of RFF-based mappings. Additionally, extending KAF to tackle more complex, real-world problems that demand efficient multi-frequency representation could unlock new applications and broaden its impact.

## References

- Aronszajn (1950)
Aronszajn, N.
Theory of reproducing kernels.
*Transactions of the American Mathematical Society*, 68(3):337–404, 1950.
- Arora et al. (2018)
Arora, S., Ge, R., Neyshabur, B., and Zhang, Y.
A stronger generalization bound for deep nets via a compression approach.
*arXiv preprint arXiv:1802.05296*, 2018.
- Aziznejad et al. (2023)
Aziznejad, S., Gupta, H., and Unser, M.
Deep neural networks with trainable b-spline activation functions.
*IEEE Transactions on Neural Networks and Learning Systems*, 2023.
- Bach (2016)
Bach, F.
Breaking the curse of dimensionality with convex neural networks, 2016.
URL [https://arxiv.org/abs/1412.8690](https://arxiv.org/abs/1412.8690).
- Barron (1993)
Barron, A. R.
Universal approximation bounds for superpositions of a sigmoidal function.
*IEEE Transactions on Information theory*, 39(3):930–945, 1993.
- Baydin et al. (2018)
Baydin, A. G., Pearlmutter, B. A., Radul, A. A., and Siskind, J. M.
Automatic differentiation in machine learning: a survey, 2018.
URL [https://arxiv.org/abs/1502.05767](https://arxiv.org/abs/1502.05767).
- Berner et al. (2022a)
Berner, J., Grohs, P., Kutyniok, G., and Petersen, P.
*The Modern Mathematics of Deep Learning*, pp.  1–111.
Cambridge University Press, December 2022a.
ISBN 9781316516782.
doi: 10.1017/9781009025096.002.
URL [http://dx.doi.org/10.1017/9781009025096.002](http://dx.doi.org/10.1017/9781009025096.002).
- Berner et al. (2022b)
Berner, J., Grohs, P., Kutyniok, G., and Petersen, P.
*The Modern Mathematics of Deep Learning*, pp.  1–111.
Cambridge University Press, December 2022b.
ISBN 9781316516782.
doi: 10.1017/9781009025096.002.
URL [http://dx.doi.org/10.1017/9781009025096.002](http://dx.doi.org/10.1017/9781009025096.002).
- Bracewell & Bracewell (1986)
Bracewell, R. N. and Bracewell, R. N.
The fourier transform and its applications.
*McGraw-Hill New York*, 31999, 1986.
- Brown et al. (2020)
Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., Agarwal, S., Herbert-Voss, A., Krueger, G., Henighan, T., Child, R., Ramesh, A., Ziegler, D. M., Wu, J., Winter, C., Hesse, C., Chen, M., Sigler, E., Litwin, M., Gray, S., Chess, B., Clark, J., Berner, C., McCandlish, S., Radford, A., Sutskever, I., and Amodei, D.
Language models are few-shot learners, 2020.
URL [https://arxiv.org/abs/2005.14165](https://arxiv.org/abs/2005.14165).
- Chen et al. (2020)
Chen, Z., Yang, P., Chen, J., Du, B., and Zhang, L.
Efficient parameter-free rank minimization method via low-rank factorization.
*IEEE Transactions on Neural Networks and Learning Systems*, 2020.
- Clanuwat et al. (2018)
Clanuwat, T., Bober-Irizar, M., Kitamoto, A., Lamb, A., Yamamoto, K., and Ha, D.
Deep learning for classical japanese literature.
*arXiv preprint arXiv:1812.01718*, 2018.
- Cohen et al. (2017)
Cohen, G., Afshar, S., Tapson, J., and Van Schaik, A.
Emnist: Extending mnist to handwritten letters.
*2017 International Joint Conference on Neural Networks (IJCNN)*, pp.  2921–2926, 2017.
- De Boor (1972)
De Boor, C.
On calculating with b-splines.
*Journal of Approximation theory*, 6(1):50–62, 1972.
- Dong et al. (2024)
Dong, Y., Li, G., Tao, Y., Jiang, X., Zhang, K., Li, J., Su, J., Zhang, J., and Xu, J.
Fan: Fourier analysis networks, 2024.
URL [https://arxiv.org/abs/2410.02675](https://arxiv.org/abs/2410.02675).
- Dosovitskiy et al. (2021)
Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer, M., Heigold, G., Gelly, S., Uszkoreit, J., and Houlsby, N.
An image is worth 16x16 words: Transformers for image recognition at scale, 2021.
URL [https://arxiv.org/abs/2010.11929](https://arxiv.org/abs/2010.11929).
- Eldar & Unser (2021)
Eldar, Y. C. and Unser, M.
Deep spline networks: A perfect fit for signals and images.
*IEEE Signal Processing Magazine*, 38(4):15–28, 2021.
- Elfwing et al. (2017)
Elfwing, S., Uchibe, E., and Doya, K.
Sigmoid-weighted linear units for neural network function approximation in reinforcement learning, 2017.
URL [https://arxiv.org/abs/1702.03118](https://arxiv.org/abs/1702.03118).
- Fan et al. (2019)
Fan, Y., Feliu-Fabà, J., Lin, L., Ying, L., and Zepeda-Núñez, L.
Universal approximation of symmetric and anti-symmetric functions.
In *Conference on Neural Information Processing Systems (NeurIPS)*, 2019.
- Fathony et al. (2021)
Fathony, R., Sahu, A. K., Willmott, D., and Kolter, J. Z.
Multiplicative filter networks.
*International Conference on Learning Representations*, 2021.
- Glorot & Bengio (2010)
Glorot, X. and Bengio, Y.
Understanding the difficulty of training deep feedforward neural networks.
*Proceedings of the thirteenth international conference on artificial intelligence and statistics*, pp.  249–256, 2010.
- Glorot et al. (2011)
Glorot, X., Bordes, A., and Bengio, Y.
Deep sparse rectifier neural networks.
*Proceedings of the fourteenth international conference on artificial intelligence and statistics*, pp.  315–323, 2011.
- Gradshteyn & Ryzhik (2014)
Gradshteyn, I. S. and Ryzhik, I. M.
*Table of integrals, series, and products*.
Academic press, 2014.
- Han et al. (2018)
Han, J., Jentzen, A., and E, W.
Solving high-dimensional partial differential equations using deep learning.
*Proceedings of the National Academy of Sciences*, 115(34):8505–8510, 2018.
- Han et al. (2016)
Han, S., Mao, H., and Dally, W. J.
Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding, 2016.
URL [https://arxiv.org/abs/1510.00149](https://arxiv.org/abs/1510.00149).
- He et al. (2015a)
He, K., Zhang, X., Ren, S., and Sun, J.
chushihua.
*Proceedings of the IEEE international conference on computer vision*, pp.  1026–1034, 2015a.
- He et al. (2015b)
He, K., Zhang, X., Ren, S., and Sun, J.
Deep residual learning for image recognition, 2015b.
URL [https://arxiv.org/abs/1512.03385](https://arxiv.org/abs/1512.03385).
- He et al. (2024)
He, Y., Xie, Y., Yuan, Z., and Sun, L.
Mlp-kan: Unifying deep representation and function learning, 2024.
URL [https://arxiv.org/abs/2410.03027](https://arxiv.org/abs/2410.03027).
- Hendrycks & Gimpel (2016)
Hendrycks, D. and Gimpel, K.
Gaussian error linear units (gelus).
*arXiv preprint arXiv:1606.08415*, 2016.
- Howard et al. (2017)
Howard, A. G., Zhu, M., Chen, B., Kalenichenko, D., Wang, W., Weyand, T., Andreetto, M., and Adam, H.
Mobilenets: Efficient convolutional neural networks for mobile vision applications, 2017.
URL [https://arxiv.org/abs/1704.04861](https://arxiv.org/abs/1704.04861).
- Kidger & Lyons (2020)
Kidger, P. and Lyons, T.
Universal approximation with deep narrow networks.
*Mathematics of Computation*, 89(324):2549–2570, 2020.
- Kingma & Ba (2014)
Kingma, D. P. and Ba, J.
Adam: A method for stochastic optimization.
*arXiv preprint arXiv:1412.6980*, 2014.
- Kolmogorov (1933)
Kolmogorov, A. N.
*Grundbegriffe der Wahrscheinlichkeitsrechnung*.
Springer, Berlin, 1933.
- Krizhevsky et al. (2009)
Krizhevsky, A., Hinton, G., et al.
Learning multiple layers of features from tiny images.
*Technical report, University of Toronto*, 1(4), 2009.
- Langley (2000)
Langley, P.
Crafting papers on machine learning.
In Langley, P. (ed.), *Proceedings of the 17th International Conference on Machine Learning (ICML 2000)*, pp.  1207–1216, Stanford, CA, 2000. Morgan Kaufmann.
- LeCun et al. (1998)
LeCun, Y., Bottou, L., Bengio, Y., and Haffner, P.
shouxieshuzi.
*Proceedings of the IEEE*, 86(11):2278–2324, 1998.
- Li et al. (2023)
Li, H., Wang, J., and Zhang, Q.
Adaptive b-spline neural networks for nonlinear system identification.
*IEEE Transactions on Neural Networks and Learning Systems*, 2023.
- Liu et al. (2024)
Liu, Z., Wang, Y., Vaidya, S., Ruehle, F., Halverson, J., Soljačić, M., Hou, T. Y., and Tegmark, M.
Kan: Kolmogorov-arnold networks, 2024.
URL [https://arxiv.org/abs/2404.19756](https://arxiv.org/abs/2404.19756).
- Maiorov & Pinkus (2021)
Maiorov, V. and Pinkus, A.
Kolmogorov’s superposition theorem and its applications to deep learning.
*Neural Networks*, 144:343–356, 2021.
- Mhaskar & Micchelli (1996)
Mhaskar, H. N. and Micchelli, C. A.
Neural networks for optimal approximation of smooth and analytic functions.
*Neural computation*, 8(1):164–177, 1996.
- Nair & Hinton (2010)
Nair, V. and Hinton, G. E.
Rectified linear units improve restricted boltzmann machines.
In *ICML*, 2010.
- Netzer et al. (2011)
Netzer, Y., Wang, T., Coates, A., Bissacco, A., Wu, B., and Ng, A. Y.
Reading digits in natural images with unsupervised feature learning.
In *NIPS workshop on deep learning and unsupervised feature learning*, volume 2011, pp.  5, 2011.
- Poggio et al. (2017)
Poggio, T., Mhaskar, H., Rosasco, L., Miranda, B., and Liao, Q.
Deep learning: Mathematics and neuroscience.
*Views and Reviews*, 2017.
- Rahimi & Recht (2007a)
Rahimi, A. and Recht, B.
Random features for large-scale kernel machines.
*Advances in Neural Information Processing Systems*, 20:1177–1184, 2007a.
- Rahimi & Recht (2007b)
Rahimi, A. and Recht, B.
Random features for large-scale kernel machines.
*Advances in Neural Information Processing Systems (NeurIPS)*, 20:1177–1184, 2007b.
- Raissi et al. (2017)
Raissi, M., Perdikaris, P., and Karniadakis, G. E.
Physics informed deep learning (part i): Data-driven solutions of nonlinear partial differential equations, 2017.
URL [https://arxiv.org/abs/1711.10561](https://arxiv.org/abs/1711.10561).
- Ramachandran et al. (2017)
Ramachandran, P., Zoph, B., and Le, Q. V.
Searching for activation functions, 2017.
URL [https://arxiv.org/abs/1710.05941](https://arxiv.org/abs/1710.05941).
- Rumelhart et al. (1986)
Rumelhart, D. E., Hinton, G. E., and Williams, R. J.
Learning representations by back-propagating errors.
*Nature*, 323(6088):533–536, 1986.
- Schmidt-Hieber (2021)
Schmidt-Hieber, J.
The kolmogorov-arnold representation theorem revisited, 2021.
URL [https://arxiv.org/abs/2007.15884](https://arxiv.org/abs/2007.15884).
- Schölkopf & Smola (2018)
Schölkopf, B. and Smola, A. J.
*Learning with kernels: support vector machines, regularization, optimization, and beyond*.
MIT press, 2018.
- Sitzmann et al. (2020)
Sitzmann, V., Martel, J. N., Bergman, A., Lindell, D. B., and Wetzstein, G.
Implicit neural representations with periodic activation functions.
*Advances in Neural Information Processing Systems (NeurIPS)*, 33:7462–7473, 2020.
- Tan & Le (2020)
Tan, M. and Le, Q. V.
Efficientnet: Rethinking model scaling for convolutional neural networks, 2020.
URL [https://arxiv.org/abs/1905.11946](https://arxiv.org/abs/1905.11946).
- Tan & Le (2021)
Tan, M. and Le, Q. V.
Efficientnetv2: Smaller models and faster training, 2021.
URL [https://arxiv.org/abs/2104.00298](https://arxiv.org/abs/2104.00298).
- Tancik et al. (2020)
Tancik, M., Srinivasan, P. P., Mildenhall, B., Fridovich-Keil, S., Raghavan, N., Singhal, U., Ramamoorthi, R., Barron, J. T., and Ng, R.
Fourier features let networks learn high frequency functions in low dimensional domains.
In *Advances in Neural Information Processing Systems*, pp.  7537–7547, 2020.
- Tang et al. (2018)
Tang, R., Adhikari, A., and Lin, J.
Flops as a direct optimization objective for learning sparse neural networks, 2018.
URL [https://arxiv.org/abs/1811.03060](https://arxiv.org/abs/1811.03060).
- Touvron et al. (2021)
Touvron, H., Cord, M., Douze, M., Massa, F., Sablayrolles, A., and Jégou, H.
Training data-efficient image transformers & distillation through attention, 2021.
URL [https://arxiv.org/abs/2012.12877](https://arxiv.org/abs/2012.12877).
- Vaswani et al. (2023)
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L., and Polosukhin, I.
Attention is all you need, 2023.
URL [https://arxiv.org/abs/1706.03762](https://arxiv.org/abs/1706.03762).
- Werneburg (2023)
Werneburg, E. A.
Training neural networks using reproducing kernel space interpolation and model reduction, 2023.
URL [https://arxiv.org/abs/2308.16754](https://arxiv.org/abs/2308.16754).
- Wu et al. (2022)
Wu, J., Wang, Z., and Wang, H.
Spectral analysis of b-spline wavelets and their applications in signal processing.
*Digital Signal Processing*, 123:103411, 2022.
- Xu et al. (2019)
Xu, Z.-Q. J., Zhang, Y., and Xiao, Y.
On the frequency bias of neural networks with relu activations.
*arXiv preprint arXiv:1905.09263*, 2019.
- Yang & Wang (2024)
Yang, X. and Wang, X.
Kolmogorov-arnold transformer, 2024.
URL [https://arxiv.org/abs/2409.10594](https://arxiv.org/abs/2409.10594).
- Yu et al. (2016)
Yu, F. X., Kumar, S., Rowley, H., and Chang, S.-F.
On the design of orthogonal random features.
*Advances in Neural Information Processing Systems (NeurIPS)*, 29:1975–1983, 2016.
- Yu et al. (2024)
Yu, R., Yu, W., and Wang, X.
Kan or mlp: A fairer comparison, 2024.
URL [https://arxiv.org/abs/2407.16674](https://arxiv.org/abs/2407.16674).

## Appendix A Detailed derivation of parameter quantities and FLOPs calculations

### A.1 KAN with B-splines: Parameter Counting

Number of B-spline Basis Parameters.

Let the B-spline(De Boor, 1972) order be $K$, and divide the domain into $G$ segments. Then:
- Each segment needs $K+1$ control points, total $(G+K+1)$.
- Boundary smoothness of order $K-1$ adds $2(K-1)$ virtual points.
- Total per univariate spline: $G+3K-1$. (Sometimes simplified to $G+K+3$.)

Single-Layer Parameter Decomposition in KAN.

For dimension $d_{\mathrm{in}}\to d_{\mathrm{out}}$:
- *Internal function (B-spline projection)*:
$d_{\mathrm{in}}\times d_{\mathrm{out}}$ splines, each with $(G+K+3)$ parameters.

Hence,

$$ $\text{Params}_{\mathrm{KAN}}=d_{\mathrm{in}}\,d_{\mathrm{out}}\,(G+K+3)+d_{\mathrm{out}}.$ (11) $$

### A.2 KAF with RFF: FLOPs Decomposition

Single-layer KAF.
- *Random Fourier Feature (RFF(Rahimi & Recht, 2007b)) mapping*:
$\cos(W^{\top}x+b)$ and $\sin(W^{\top}x+b)$ each require one matrix multiplication.
Total FLOPs(Tang et al., 2018):

$$ $2\times(d_{\mathrm{in}}\times M)\times 2=4d_{\mathrm{in}}M.$ (12) $$

- *Linear combination (GELU + RFF)*:
Element-wise scaling of $\mathbf{a}\odot\text{GELU}(x)$ and $\mathbf{b}\odot\phi_{\text{RFF}}(x)$.
Total FLOPs:

$$ $2\times(d_{\mathrm{in}}\times M)\times 2=4d_{\mathrm{in}}M.$ (13) $$

- *Final linear projection*:
Matrix multiplication $\mathbf{W}^{(l)}\cdot(\cdot)$ and bias addition.
Total FLOPs:

$$ $2d_{\mathrm{in}}d_{\mathrm{out}}.$ (14) $$

- *Activation function*:
GELU activation requires $5d_{\mathrm{in}}$ FLOPs.

Total FLOPs:

$$ $\text{FLOPs}_{\text{KAF}}=4d_{\mathrm{in}}M+2d_{\mathrm{in}}+2d_{\mathrm{in}}d_{\mathrm{out}}+5d_{\mathrm{in}}.$ (15) $$

### A.3 MLP FLOPs Computation

Standard MLP.
- *Linear layer* $\mathbf{W}\in\mathbb{R}^{d_{\mathrm{out}}\times d_{\mathrm{in}}}$:
$2\,d_{\mathrm{in}}\,d_{\mathrm{out}}$ FLOPs (multiply+add).
- *Activation*:
- ReLU: $1$ FLOP per output (comparison), total $d_{\mathrm{out}}$.
- GELU: about $5\,d_{\mathrm{out}}$ FLOPs.

Hence, for a GELU-MLP:

$$ $\text{FLOPs}_{\mathrm{MLP}}=2\,d_{\mathrm{in}}\,d_{\mathrm{out}}+5\,d_{\mathrm{out}}.$ (16) $$

### A.4 Summary Comparison

**Table 3: Comparison of parameter count and FLOPs per layer for KAN, KAF, and MLP models.**
| Model | Param Count (Single Layer) | FLOPs (Single Layer) |
| --- | --- | --- |
| KAN | $d_{\mathrm{in}}d_{\mathrm{out}}(G+K+3)+d_{\mathrm{out}}$ | $7d_{\mathrm{in}}+(d_{\mathrm{in}}d_{\mathrm{out}})\left[9K(G+1.5K)+2G-2.5K+3\right]$ |
| KAF | $d_{\mathrm{in}}M+M+2d_{\mathrm{in}}+d_{\mathrm{in}}d_{\mathrm{out}}+d_{\mathrm{out}}$ | $4d_{\mathrm{in}}M+2d_{\mathrm{in}}+2d_{\mathrm{in}}d_{\mathrm{out}}+5d_{\mathrm{in}}$ |
| MLP | $d_{\mathrm{in}}d_{\mathrm{out}}+d_{\mathrm{out}}$ | $2d_{\mathrm{in}}d_{\mathrm{out}}+5d_{\mathrm{out}}$ |

- KAN: Param and FLOPs scale with spline order $K$ and segment count $G$.
- KAF: RFF-based expansion is more GPU-friendly than B-spline recursion.
- MLP: Minimal overhead with no extra basis expansions.

## Appendix B Kernel Approximation and Gradient Derivation of Random Fourier Features (RFF)

### B.1 Convergence Proof of RFF Kernel Approximation

#### B.1.1 Bochner’s Theorem and the Fourier Duality of Kernel Functions

According to Bochner’s(Rahimi & Recht, 2007a; Gradshteyn & Ryzhik, 2014) theorem , any translation-invariant positive definite kernel function $k(x,y)=k(x-y)$ can be expressed as the Fourier transform of a Gaussian measure:

$$ $k(x-y)=\int_{\mathbb{R}^{d}}e^{i\omega^{\top}(x-y)}p(\omega)d\omega$ (17) $$

where $p(\omega)$ is the spectral distribution corresponding to the kernel function. For the Gaussian kernel $k(x,y)=e^{-\|x-y\|^{2}/(2\sigma^{2})}$, its spectral distribution is:

$$ $p(\omega)=\mathcal{N}(\omega;0,\sigma^{-2}I_{d}).$ (18) $$

#### B.1.2 Expectation of Inner Product of Random Fourier Features

Define the RFF mapping:

$$ $z(x)=\sqrt{\frac{2}{m}}\left[\cos(\omega_{1}^{\top}x+b_{1}),\sin(\omega_{1}^{\top}x+b_{1}),\dots,\cos(\omega_{m}^{\top}x+b_{m}),\sin(\omega_{m}^{\top}x+b_{m})\right]^{\top},$ (19) $$

where $\omega_{i}\sim p(\omega)$, $b_{i}\sim\mathcal{U}[0,2\pi]$. The expectation of the inner product is:

$$ $\displaystyle\mathbb{E}\left[z(x)^{\top}z(y)\right]$ $\displaystyle=\frac{2}{m}\sum_{i=1}^{m}\mathbb{E}\left[\cos(\omega_{i}^{\top}x+b_{i})\cos(\omega_{i}^{\top}y+b_{i})+\sin(\omega_{i}^{\top}x+b_{i})\sin(\omega_{i}^{\top}y+b_{i})\right]$ (20) $\displaystyle=\frac{2}{m}\sum_{i=1}^{m}\mathbb{E}\left[\cos(\omega_{i}^{\top}(x-y))\right]\quad(\text{using trigonometric identity})$ $\displaystyle=\mathbb{E}_{\omega\sim p(\omega)}\left[2\cos(\omega^{\top}(x-y))\right]\quad(m\to\infty\text{ converges by law of large numbers})$ $\displaystyle=\mathbb{E}_{\omega\sim p(\omega)}\left[e^{i\omega^{\top}(x-y)}+e^{-i\omega^{\top}(x-y)}\right]$ $\displaystyle=2\cdot\text{Re}\left(\mathbb{E}_{\omega\sim p(\omega)}\left[e^{i\omega^{\top}(x-y)}\right]\right)$ $\displaystyle=2\cdot\text{Re}\left(k(x-y)\right)=2k(x-y)\quad(\text{since }k(x-y)\text{ is a real-valued symmetric function}).$ $$

However, since the original scaling factor is $\sqrt{2/m}$, the actual expectation of the inner product is:

$$ $\mathbb{E}\left[z(x)^{\top}z(y)\right]=k(x-y).$ (21) $$

#### B.1.3 Error Bound and Convergence Rate

According to Rahimi & Recht (Rahimi & Recht, 2007a), when using $m$ random frequencies, for any $x,y\in\mathcal{X}$, we have:

$$ $\mathbb{P}\left(\sup_{x,y}\bigl{|}z(x)^{\top}z(y)-k(x,y)\bigr{|}\geq\epsilon\right)\leq 2^{8}\left(\frac{\sigma_{p}\operatorname{diam}(\mathcal{X})}{\epsilon}\right)^{2}\exp\left(-\frac{m\epsilon^{2}}{4(d+2)}\right).$ (22) $$

where $\sigma_{p}$ is the variance of $p(\omega)$, and $\text{diam}(\mathcal{X})$ is the diameter of the input space. Thus, the convergence rate is:

$$ $\mathcal{O}(1/\sqrt{m})$ (23) $$

### B.2 Differentiability and Gradient Computation of RFF

#### B.2.1 Analytical Gradient Expressions

Let $\omega\in\mathbb{R}^{d}$ be a row of the frequency matrix $W$, and $b$ be the corresponding phase shift. For an input $x\in\mathbb{R}^{d}$:

- Gradient of the cosine term:

$$ $\frac{\partial}{\partial\omega}\cos(\omega^{\top}x+b)=-x\sin(\omega^{\top}x+b),\quad\frac{\partial}{\partial b}\cos(\omega^{\top}x+b)=-\sin(\omega^{\top}x+b)$ (24) $$

- Gradient of the sine term:

$$ $\frac{\partial}{\partial\omega}\sin(\omega^{\top}x+b)=x\cos(\omega^{\top}x+b),\quad\frac{\partial}{\partial b}\sin(\omega^{\top}x+b)=\cos(\omega^{\top}x+b)$ (25) $$

For a matrix $W\in\mathbb{R}^{d\times m}$, gradients accumulate row-wise. For $W_{ij}$ (the $i$-th row, $j$-th column):

$$ $\frac{\partial\cos(W_{j}^{\top}x+b_{j})}{\partial W_{ij}}=-x_{i}\sin(W_{j}^{\top}x+b_{j})$ (26) $$

where $W_{j}$ is the $j$-th column of $W$.

#### B.2.2 Implementation in Backpropagation

In automatic differentiation frameworks(Baydin et al., 2018) (e.g., PyTorch), the gradient computation for RFF follows these steps:
1. Forward pass: Compute $\cos(W^{\top}x+b)$ and $\sin(W^{\top}x+b)$.
2. Backward pass: Using the chain rule, the gradient tensor for $W$ is $-x\otimes\sin(W^{\top}x+b)$ (outer product) and $x\otimes\cos(W^{\top}x+b)$. The gradient for $b$ is directly $-\sin(W^{\top}x+b)$ and $\cos(W^{\top}x+b)$.
3. Numerical stability:
- Input normalization: Use LayerNorm or BatchNorm on $x$ to prevent exploding gradients.
- Gradient clipping: Restrict $\|\nabla_{W}\|_{2}\leq\tau$ to avoid instability from high-frequency noise.

### B.3 RFF Initialization Strategy Derivation

#### B.3.1 Frequency Sampling and Kernel Bandwidth Correspondence

The spectral distribution of the Gaussian kernel $k(x,y)=e^{-\|x-y\|^{2}/(2\sigma^{2})}$ is $p(\omega)=\mathcal{N}(0,\sigma^{-2}I_{d})$. Hence, frequencies should be sampled as $\omega\sim\mathcal{N}(0,\sigma^{-2}I_{d})$. However, if input data is standardized such that each dimension satisfies $\mathbb{E}[x_{i}^{2}]=1/d$, then the variance of $\omega^{\top}x$ is:

$$ $\mathbb{V}[\omega^{\top}x]=\mathbb{E}[x^{\top}\omega\omega^{\top}x]=\text{Tr}(\mathbb{E}[\omega\omega^{\top}]\mathbb{E}[xx^{\top}])=\sigma^{-2}\cdot\text{Tr}(I_{d}/d)=\sigma^{-2}.$ (27) $$

To make $\omega^{\top}x$ independent of input scale, frequency variance should be adjusted to $\sigma^{-2}/d$, i.e., $\omega_{ij}\sim\mathcal{N}(0,\sigma^{-2}/d)$.

#### B.3.2 Determination of Scaling Factor γ \gamma

Assuming the activation function $\sigma(x)$ has an output variance of $\mathbb{E}[\|\sigma(x)\|^{2}]=c$, the frequency matrix should be initialized such that:

$$ $\frac{\sigma^{-2}}{d}\cdot\mathbb{E}[\|W\|_{F}^{2}]=\gamma^{2}\implies\gamma=\frac{\sigma^{-1}}{\sqrt{d}}.$ (28) $$

Thus, the initialization strategy is $\omega_{ij}\sim\mathcal{N}(0,\gamma^{2}/d)$, where $\gamma=\sigma^{-1}/\sqrt{\mathbb{E}[\|\sigma(x)\|^{2}]}$.

## Appendix C Fourier theory proof of GELU activation function initialization factor σ = 1.64 \sigma=1.64

### C.1 Definition and Assumptions

Consider an input signal $x\sim\mathcal{N}(0,\sigma^{2})$, whose Fourier transform is:

$$ $\mathcal{F}\{x\}(\omega)=\int_{-\infty}^{\infty}xe^{-i\omega x}dx.$ (29) $$

The GELU activation function is defined as:

$$ $\text{GELU}(x)=x\cdot\Phi(x),$ (30) $$

where $\Phi(x)$ is the cumulative distribution function (CDF) of a standard normal distribution.

### C.2 Fourier Transform of GELU

Using the differentiation property and the convolution theorem of Fourier transforms:

$$ $\mathcal{F}\{\text{GELU}(x)\}(\omega)=\mathcal{F}\{x\Phi(x)\}(\omega)=i\frac{d}{d\omega}\mathcal{F}\{\Phi(x)\}(\omega).$ (31) $$

The Fourier transform of $\Phi(x)$ is known:

$$ $\mathcal{F}\{\Phi(x)\}(\omega)=\sqrt{\frac{\pi}{2}}e^{-\omega^{2}/2}\left(1+\text{erf}\left(\frac{i\omega}{\sqrt{2}}\right)\right).$ (32) $$

Taking its derivative yields:

$$ $\mathcal{F}\{\text{GELU}(x)\}(\omega)=\sqrt{\frac{\pi}{2}}\left[-\omega e^{-\omega^{2}/2}\left(1+\text{erf}\left(\frac{i\omega}{\sqrt{2}}\right)\right)+\frac{i}{\sqrt{2}}e^{-\omega^{2}}\right].$ (33) $$

### C.3 Spectral Energy Distribution

The spectral energy density of GELU is:

$$ $S(\omega)=\left|\mathcal{F}\{\text{GELU}(x)\}(\omega)\right|^{2}.$ (34) $$

Through numerical integration, it can be observed that most energy is concentrated in the low-frequency region ($|\omega|<\omega_{c}$), and the high-frequency components decay exponentially with increasing $\omega$.

### C.4 Scaling Factor α \alpha Optimization in Frequency Spectrum

#### C.4.1 Objective Function Definition

To minimize the spectral distortion of the scaled activation function, we define:

$$ $\mathcal{L}(\alpha)=\int_{-\infty}^{\infty}\left|S_{\text{target}}(\omega)-\alpha^{2}S_{\text{GELU}}(\omega)\right|^{2}d\omega.$ (35) $$

Assuming the target spectrum follows white noise, i.e., $S_{\text{target}}(\omega)=1$.

#### C.4.2 Optimization Solution

Expanding the objective function:

$$ $\mathcal{L}(\alpha)=\int_{-\infty}^{\infty}\left(1-\alpha^{2}S_{\text{GELU}}(\omega)\right)^{2}d\omega.$ (36) $$

Taking the derivative with respect to $\alpha$ and setting it to zero:

$$ $\frac{d\mathcal{L}}{d\alpha}=-4\alpha\int_{-\infty}^{\infty}S_{\text{GELU}}(\omega)\left(1-\alpha^{2}S_{\text{GELU}}(\omega)\right)d\omega=0.$ (37) $$

Solving for the optimal $\alpha$:

$$ $\alpha_{\text{opt}}=\sqrt{\frac{\int_{-\infty}^{\infty}S_{\text{GELU}}(\omega)d\omega}{\int_{-\infty}^{\infty}S_{\text{GELU}}^{2}(\omega)d\omega}}.$ (38) $$

#### C.4.3 Numerical Integration Results

Using Monte Carlo integration, we compute:

$$ $\int_{-\infty}^{\infty}S_{\text{GELU}}(\omega)d\omega\approx 0.168,\quad\int_{-\infty}^{\infty}S_{\text{GELU}}^{2}(\omega)d\omega\approx 0.062.$ (39) $$

Substituting these values:

$$ $\alpha_{\text{opt}}=\sqrt{\frac{0.168}{0.062}}\approx 1.64.$ (40) $$

### C.5 Dynamic Adaptation of Fourier Characteristics

#### C.5.1 Spectrum Matching Mechanism

Random Fourier features (RFF) sample frequencies $\omega_{i}\sim\mathcal{N}(0,\sigma^{-2})$ to approximate the target spectrum. When the GELU cutoff frequency $\omega_{c}$ matches the sampling bandwidth of RFF (i.e., $\sigma\approx 1.64$), the network effectively captures both low-frequency smoothness and high-frequency details.

#### C.5.2 Dynamic Balance in Training

Initially, a small scaling factor $\beta=10^{-2}$ suppresses high-frequency noise. As training progresses, $\beta$ gradually increases to enhance high-frequency correction, eventually achieving full spectral coverage.

## Appendix D ML&NLP&audio tasks

We show here the experimental results [3](https://arxiv.org/html/2502.06018v2#A4.F3)of the NLP&audio& ML experiment based on kanbefair in 4.2

The experimental results show that KAF (ours) has achieved excellent performance on different datasets including three tasks, and has higher accuracy than other models under the same parameters. In the Bean, AG_NEWS and other datasets, KAF converges quickly and achieves the highest accuracy, which shows that our method also has good generalization in natural language processing and audio processing.

Figure: Figure 3: Compare the performance of various models (KAN, GPKAN, MLP, FAN, KAF) across NLP,audio and ML datasets. KAF consistently outperforms other models, achieving higher accuracy with fewer parameters, especially in datasets like Bean, Rice, and AG News. KAF’s efficiency and accuracy make it a strong choice across a wide range of tasks.
Refer to caption: x3.png

## Appendix E Function approximation and differential equation solving tasks

In this section, we will supplement Experiment 4.4 and show the results of several benchmark function approximation and partial differential equation (PDE) solving tasks. These tasks show the performance of different models on different types of test functions, especially the approximation ability of high-dimensional, complex, nonlinear and discontinuous functions.

### E.1 Function Approximation Tasks

**Table 4: Types of Test Functions and Their Mathematical Expressions**
| Function Name | Mathematical Expression |
| --- | --- |
| Bessel Function | $f(x)=J_{0}(20x)$ |
| Chaotic | $f(x,y)=e^{\sin(\pi x)+y^{2}}$ |
| Simple Product | $f(x,y)=x\cdot y$ |
| High-Freq-Sum | $f(x)=\sum_{k=1}^{100}\sin\left(\frac{kx}{100}\right)$ |
| Highly-Nonlinear | $f(x_{1},x_{2},x_{3},x_{4})=e^{\sin(x_{1}^{2}+x_{2}^{2})+\sin(x_{3}^{2}+x_{4}^{2})}$ |
| Discontinuous | $f(x)=\begin{cases}-1,&x<-0.5\\<br>x^{2},&-0.5\leq x<0\\<br>\sin(4\pi x),&0\leq x<0.5\\<br>1,&x\geq 0.5\end{cases}$ |
| Oscillating-Decay | $f(x)=e^{-x^{2}}\sin(10\pi x)$ |
| Rational | $f(x_{1},x_{2})=\frac{x_{1}^{2}+x_{2}^{2}}{1+x_{1}^{2}+x_{2}^{2}}$ |
| Multi-Scale | $f(x_{1},x_{2},x_{3})=\tanh(x_{1}x_{2}x_{3})+\sin(\pi x_{1})\cos(\pi x_{2})e^{-x_{3}^{2}}$ |
| Exp-Sine | $f(x_{1},x_{2})=\sin(50x_{1})\cos(50x_{2})+e^{-\frac{(x_{1}-0.5)^{2}+(x_{2}-0.5)^{2}}{0.1}}$ |

First, Figure [4](https://arxiv.org/html/2502.06018v2#A5.F4) shows the approximation effect of different test functions. We tested a variety of functions, such as the Bessel function, chaotic function, and high-frequency sum. The mathematical expression of each function is listed in the table [4](https://arxiv.org/html/2502.06018v2#A5.T4). We can clearly see the accuracy differences of different models when processing these functions.

Figure: Figure 4: This experiment compares different models (KAN, GPKAN, MLP, FAN, KAF) on various function approximation tasks, analyzing test RMSE versus the number of parameters. KAF consistently achieves lower RMSE across all tasks, outperforming other models like MLP with fewer parameters. Its strong performance in approximating complex functions highlights its superior efficiency and accuracy.
Refer to caption: x4.png

For example, for the high-frequency sum (High-Freq-Sum) function, KAF (kernel approximation method based on RFF) shows good approximation ability and also shows strong fitting ability when processing high-dimensional complex nonlinear functions (such as Highly-Nonlinear). Figure [4](https://arxiv.org/html/2502.06018v2#A5.F4) shows that KAF has relatively good performance on different types of functions.

### E.2 PDE Solving Tasks

Next, Figure [5](https://arxiv.org/html/2502.06018v2#A5.F5) shows the performance of different models in solving partial differential equations (PDEs). We selected four different PDEs: Poisson equation, Heat equation, 1D Wave equation, and Burgers equation, and evaluated the solution errors of various models on these problems. From the results shown in the box plot, we can see that KAN and KAF have lower solution errors when dealing with these PDEs, especially for complex nonlinear problems, KAF shows strong robustness.

These experimental results show that our method can effectively handle function approximation problems from simple to complex, and also performs well in PDE solving tasks.

Figure: Figure 5: This experiment compares different models (MLP, KAN, KAF, FAN, GPKAN) in solving Poisson, 1D Wave, Heat, and Burgers equations. KAF consistently delivers strong performance across all tasks, demonstrating its efficiency and effectiveness in solving complex PDEs.
Refer to caption: x5.png

## Appendix F Ablation Experiment

### F.1 Ablation on Cifar10

We use a single-layer KAF trained on CIFAR-10 as the baseline model, with a hidden layer size of 128.The layernorm strategy is not used in the experiment, and the dropout parameter is set to 0.1 We evaluate the following strategies:

- 1.
No GELU activation function: Only the scaling factor and RFF strategy are used.
- 2.
No scaling factor strategy: The model is trained without the scaling factor.
- 3.
No RFF strategy: The model uses the scaling factor and GELU activation instead.
- 4.
Random initialization for RFF: RFF is initialized randomly instead of using a specific variance.
- 5.
Effect of different $\sigma$ values: We report the highest test accuracy for different selections of $\sigma$.
- 6.
Effect of different num_grids values: We report the highest test accuracy for different selections of $\text{num_grids}=9$.

Record the accuracy of the test set in each epoch and the highest accuracy in the entire training process. At the same time, in order to observe the specific changes in the scaling factors, we plotted the changes of the two scaling factors a and b of KAF with epochs in the experiment.

**Table 5: Performance of Different $\sigma$ Values on Cifar10**
| $\sigma$ | 0.1 | 0.5 | 1 | 1.5 | 1.6 | 1.64(defult) | 1.7 | 1.8 | 2 | 2.5 | 3 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ACC (%) | 46.83 | 52.50 | 54.02 | 54.41 | 54.32 | 54.96 | 54.64 | 54.68 | 54.36 | 54.07 | 53.21 |

**Table 6: Performance of Different num_grids Values on Cifar10**
| $\sigma$ | 2 | 4 | 6 | 8 | 9 (default) | 10 | 12 | 14 | 16 | 18 | 20 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ACC (%) | 54.23 | 54.67 | 54.41 | 54.80 | 54.96 | 54.87 | 54.94 | 54.82 | 54.76 | 54.79 | 55.01 |

The results of strategies 1-4 are shown in  [6](https://arxiv.org/html/2502.06018v2#A6.F6), and the experimental results of strategies 5 and 6 are in  [5](https://arxiv.org/html/2502.06018v2#A6.T5) and  [6](https://arxiv.org/html/2502.06018v2#A6.T6). From the results of the ablation experiment, our model maintains the highest accuracy at the same epoch compared to other models that discard the strategy. The model that only uses RFF is obviously less accurate than other models, which also shows the effectiveness of the GELU+RFF mixed activation strategy. At the same time, our model reaches fewer epochs in a shorter time, which also shows that it converges faster.

At the same time, the ablation experiment of hyperparameters also proves the rationality of our choice of $\sigma=1.64,num_grids=9$ as the default model configuration. When $\sigma=1.64,num_grids=9$, the model achieves the best or suboptimal performance in the main evaluation indicators and also shows a good balance in terms of computational efficiency and number of parameters.

Figure: Figure 6: The curve of the test set accuracy of different strategies in the ablation experiment on Cifar10 changes with epoch. KAF (original) demonstrates the effectiveness of our model design, consistently achieving higher test accuracy compared to other strategies across epochs.
Refer to caption: x6.png

Figure: Figure 7: Evolution of activation scaling factors over time: Base Scale (a) and Spline Scale (b).
Refer to caption: x7.png

In Figure [7](https://arxiv.org/html/2502.06018v2#A6.F7), we show how the Base Scale and Spline Scale inside KAF change with training during 40 epochs of training on Cifar10. Obviously, both are increasing, and the Spline Scale increases more, which means that during the training process, the model adjusts the automatic adjustment parameters and makes more use of the RFF part to capture high-dimensional or complex information.

### F.2 Fitting experiment of sin(x) and cos(x)

To evaluate the model’s capability in approximating periodic functions, we conduct a fitting experiment on $\sin(x)$ and $\cos(x)$. Specifically, we train the model to learn the mapping $x\mapsto\sin(x)$ and $x\mapsto\cos(x)$ using a dataset of uniformly sampled points from the interval $[-20,20]$. The training objective minimizes the mean squared error (MSE) between the predicted and true values.

We use a single-layer network with 64 neurons in the hidden layer and test KAF, KAN, MLP (RELU), and MLP (GELU). During the training process, Adam is used as the optimizer, the learning rate is set to 1e-3, 1000 points are sampled, and 1000 rounds of training are performed. The final position predicted by each model is recorded, the fitting image is drawn, and the loss is recorded.

Figure [8](https://arxiv.org/html/2502.06018v2#A6.F8) illustrates the fitting results of different models for $\sin(x)$ and $\cos(x)$. It can be observed that MLP_RELU and MLP_GELU struggle to maintain the periodic structure when the input range is large. While KAN performs relatively well in certain regions, it still exhibits significant deviations in the low-frequency range. In contrast, the KAF model more accurately captures the periodicity of the target functions and provides superior fitting performance across most regions.

Figure [9](https://arxiv.org/html/2502.06018v2#A6.F9) presents the frequency spectrum analysis of different models on $\sin(x)$ and $\cos(x)$. The true signal’s spectral energy is primarily concentrated in the low-frequency region, and the spectral distribution of the KAF model closely matches the true signal, effectively preserving the spectral characteristics of the target function. On the other hand, MLP_RELU and MLP_GELU exhibit significant deviations in the high-frequency components, indicating their difficulty in accurately representing high-frequency features. Although KAN’s spectral response aligns more closely with the true signal in some frequency bands, there are still noticeable discrepancies in energy distribution.

Figure: Figure 8: Images of the four models fitted on the standard sin/cos function after training for 1000 epochs
Refer to caption: x8.png

Figure: Figure 9: Frequency spectrum analysis of different models for $sin(x)$ and $cos(x)$, showing the magnitude distribution across different frequency components.
Refer to caption: x9.png

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 4
presentation: 3
questions: The main question to address is formulated in Weaknesses part. 

Comparison of MLP and KAF: From Table 1 and Table 2, it is hard to make a conclusion, which one is better, since the parameter budget on KAF is systematically larger. 

Minor: (Bracewell & Bracewell, 1986)-->(Bracewell, 1986)
soundness: 2
strengths: KANs typically grow in parameter count as $O(d_{in} d_{out} (G + K + 3))$, which scales poorly. The proposed hybrid GELU–Fourier activation (with learnable coefficients) adds a smooth transition mechanism from standard activation-based networks to Fourier-driven symbolic representations. This activation concept is novel and could be applied beyond KANs.
summary: The authors propose KAF, which retains the structural form of KAN (univariate function composition) but replaces the costly spline-based parameterization with learnable Fourier components.
weaknesses: The paper argues that Random Fourier Features mitigate KAN’s limited ability to represent high-frequency components. However, RFFs derived from the Gaussian kernel correspond to elements of a very smooth RKHS, whose spectral density decays rapidly. It remains unclear how this construction enhances high-frequency expressiveness. The authors should clarify whether the frequency distribution in their trainable RFFs deviates from the Gaussian kernel case, and if so, how this affects the underlying function space.

---

confidence: 4
contribution: 3
initial_rating: 4
presentation: 3
questions: 1. If time allows for revision, please conduct a full hyperparameter sweep and report updated experimental results.
2. Report inference latency (ms/image for vision or ms/token for language tasks) alongside parameter counts to substantiate efficiency claims.
3. Does KAF follow neural scaling laws? Provide log-log plots of test loss vs. parameter count with fitted power-law trends.
4. For function approximation tasks, this method is tested only on simple functions, not on complex cases (high-dimensional, non-smooth, or multi-frequency). Such limitations in computational complexity are critical, I expect the scaling law slope to flatten considerably as the input dimension increases or when 1D functions exhibit varying local frequencies. Focusing on KANs may not be appropriate, because the uniform grids of KAN raise these core issues. I suggest that the author read some recent MLP variants that have solved these problems using the multi-scale mesh (a standard data structure in the finite element method).
soundness: 3
strengths: 1. By integrating Fourier transforms and trainable RFF, KAF significantly reduces the number of parameters while preserving expressiveness, as proven in Appendix B.1. 
2. The Experiments span diverse domains: vision accuracies up to >91% on CIFAR10 (Table 1); lower perplexity on NLP tasks (Table 2); superior RMSE on function approximation (Fig. 5) and PDEs like Poisson/Heat (Fig. 6, Table 5 for noise robustness). These experiments show a significant improvement in KAN. 
3. The mathematical expression is detailed (e.g., RFF projection in Sec. 3.3, hybrid activation), and appendices for the preliminary section are easy to understand (e.g., F for function approximations, K for ablation studies), aiding replication.
summary: This paper introduces Kolmogorov-Arnold-Fourier Networks (KAF), an extension of Kolmogorov-Arnold Networks (KAN) that replaces B-spline activations with trainable Random Fourier Features (RFF) and a hybrid GELU-Fourier activation to mitigate parameter explosion and improve high-frequency capture in high-dimensional tasks. Evaluated across vision (e.g., MNIST, CIFAR), NLP (e.g., Wikitext-103, AG News), audio, machine learning tasks, function approximation, and PDE solving, KAF shows competitive or superior performance to baselines like MLP, KAN, GPKAN, and FAN, often with fewer parameters and better noise robustness.
weaknesses: 1. The experimental results on CIFAR-10 and ImageNet1K should be improved. I read the paper in references, the accuracy of ResNet-18 on CIFAR-10 is 93.02% [1], the top-1 accuracy of ViT-Tiny on ImageNet-1K is 79.1% [2], and the perplexity of GPT-2 on wikitext-103 is 19.89 [3]. However, in Table 1 and Table 2, KAF shows better accuracy than MLP when performing as a feature mixer. I guess such a conflict is caused by insufficient hyperparameter tuning (e.g., learning rate schedule, batch size, etc.).
2. Inference times should be reported, despite claims of efficiency from compact features. 
3. Figure 5 shows the analysis test RMSE versus the number of parameters. But it seems that KAF does not satisfy the scaling law?
4. As a feature-mixture, KAF can improve model performance when replacing the neural network head. However, in the standalone scenario without a neural network as a feature extractor, it still performs poorly on function approximation tasks (see Figure 9).


References:

[1] https://github.com/kuangliu/pytorch-cifar

[2] https://github.com/microsoft/Cream/tree/main/TinyViT

[3] https://huggingface.co/Graphcore/gpt2-wikitext-103

---

confidence: 5
contribution: 2
initial_rating: 6
presentation: 3
questions: any failure modes of RFF KAN?
soundness: 3
strengths: 1. Clear Motivation and Novel Angle

The paper correctly identifies KAN’s bottlenecks — parameter inefficiency and poor high-frequency capture — and links them to B-spline smoothness and dense parameterization.
The proposed RFF-based architecture is a natural and elegant evolution: Fourier expansions can model oscillatory components efficiently while maintaining GPU-friendly structure.

2. Hybrid GELU–Fourier Design
3. Solid Experimental Breadth

The experimental section is comprehensive:

Image classification (MNIST, CIFAR, SVHN, ImageNet).

Text modeling (GPT-2 on Wikitext-103, OpenWebText).

PDEs and function approximation.
summary: The paper proposes Kolmogorov-Arnold-Fourier Networks (KAF), a modification of Kolmogorov-Arnold Networks (KANs) that replaces B-spline activations with trainable Random Fourier Features (RFFs) and a hybrid GELU–Fourier activation.
The goal is to:

Reduce the parameter explosion in KANs.

Improve high-frequency representation.

Preserve interpretability and expressiveness.
weaknesses: 1. Innovation is not sufficient; more like engineering tricks
2. lack fo lit rev on kans; for example the kan 2.0 paper (Kan 2.0: Kolmogorov-arnold networks meet science), also the paper on KAN's spectral bias (On the expressiveness and spectral bias of KANs) among other advances on kans.