🤖 machine learning

KANLib -- An Modular, Extensible and Fast Kolmogorov-Arnold Network Implementation

This paper introduces KANLib, a modular, extensible, and computationally efficient PyTorch-based framework that unifies existing Kolmogorov-Arnold Network implementations to facilitate flexible research and high-performance evaluation of KAN architectures.

Original authors: Julian Hoever, Gregor Schiele

Published 2026-06-17

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Julian Hoever, Gregor Schiele

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a computer to understand the world. For a long time, we've used a standard tool called a Multilayer Perceptron (MLP). Think of an MLP like a factory assembly line where every worker (neuron) takes a bunch of inputs, mixes them together with a fixed recipe (a linear weight), and then passes the result through a single, unchangeable filter (an activation function like ReLU). It works well, but it's rigid. You can't easily see how the factory arrived at a decision because the "recipe" is just a number, and the filter is the same for everyone.

Enter Kolmogorov-Arnold Networks (KANs). The paper introduces a new way of building these factories. Instead of using a fixed filter, KANs give every single connection between workers its own custom, learnable shape-shifting tool. Imagine instead of a static filter, every pipe in the factory has a flexible hose that can stretch, bend, and curve exactly how it needs to to get the job done. This makes the network much more transparent (you can see the shape of the hose) and potentially more powerful at finding complex patterns.

However, there's a catch. Building these flexible hoses is computationally expensive and messy. Different research teams have built their own versions of KANs (like PyKAN, EfficientKAN, and FastKAN), but they all speak different languages, use different tools, and often can't talk to each other. One might be fast but lack features; another might be feature-rich but slow.

The Solution: KANLib

The authors of this paper built KANLib, which they describe as a "universal adapter" or a "Swiss Army Knife" for KANs.

Here is what KANLib does, using simple analogies:

It Unifies the Chaos: Just as a universal power strip lets you plug in devices from different countries, KANLib takes the best ideas from the three major existing KAN frameworks and combines them into one consistent system. You can switch between different types of "hoses" (mathematical functions called B-splines and Gaussian Radial Basis Functions) without having to rewrite your whole code.
It's Modular and Flexible: Think of KANLib as a Lego set. You can snap together different layers, turn specific features on or off (like removing a "residual branch" or a "weight"), and experiment with the architecture easily. It allows researchers to test "what if" scenarios without getting stuck in technical weeds.
It's Fast and Smart: The authors didn't just combine things; they optimized them.
- Grid Rescaling: Imagine you are drawing a map. If you start with a low-resolution grid, you might miss small details. KANLib can automatically "zoom in" (refine the grid) on areas where the data is crowded, making the map more accurate without starting over.
- Grid Extension: It can also add more grid points as it learns, allowing the network to capture finer and finer details over time.

What They Tested

To see if KANLib actually works, the authors ran a race on a standard dataset called California Housing (predicting house prices based on things like income and room count).

The Race: They compared KANLib against the original PyKAN, the faster EfficientKAN, and the very fast FastKAN.
The Results:
- Accuracy: KANLib was just as good as the best existing models. In fact, its B-spline version was the most accurate in their tests, predicting house prices with very little error.
- Speed: KANLib was significantly faster than the original PyKAN (about 30% faster) because it adopted the speed tricks from EfficientKAN.
- The Trade-off: When KANLib used the "Gaussian RBF" method (which is usually the fastest), it was still a bit slower than the dedicated FastKAN tool. The authors admit this is because their version is built to be flexible and support advanced features like "zooming in" on the grid, which adds a tiny bit of extra work.

The Takeaway

The paper concludes that KANLib is a robust, reliable foundation for future research. It proves that you don't have to choose between speed and features. You can have a framework that is:

Modular: Easy to tweak and extend.
Fast: Competitive with the fastest existing tools.
Accurate: Capable of matching or beating the performance of established models.

Essentially, KANLib removes the friction from KAN research, allowing scientists to focus on discovering new, better network architectures rather than fighting with incompatible code. The authors also mention that future work will focus on making the "Gaussian" version even faster and potentially applying these networks to time-based data like heartbeats (ECG) or brain waves (EEG).

Technical Summary: KANLib – A Modular, Extensible, and Fast Kolmogorov-Arnold Network Implementation

Problem Statement

Kolmogorov-Arnold Networks (KANs) have emerged as a promising alternative to traditional Multilayer Perceptrons (MLPs) by replacing fixed linear weights with learnable univariate functions. While KANs offer theoretical advantages in interpretability and expressiveness, their practical adoption is hindered by three primary challenges:

High Computational Costs: Existing implementations often suffer from inefficient basis function evaluations and redundant tensor operations.
Inconsistent Feature Support: Different frameworks (e.g., PyKAN, EfficientKAN, FastKAN) offer disparate feature sets, making rigorous benchmarking and comparison difficult.
Lack of Modularity: Current implementations are often tightly coupled to specific architectural designs or basis functions, limiting the ability to explore novel variations or hybrid architectures.

Methodology

The paper introduces KANLib, a unified software framework designed to synthesize the core innovations of three prominent KAN implementations: PyKAN (the official implementation by Liu et al.), EfficientKAN, and FastKAN.

Architectural Design

KANLib is built upon a modular architecture that supports two primary basis function types:

B-splines: Following the original KAN formulation, where learnable functions are weighted combinations of B-spline basis functions and a residual branch (typically SiLU).
Gaussian Radial Basis Functions (GRBFs): Adopted from FastKAN to reduce computational complexity by avoiding recursive B-spline calculations.

Key Technical Features

To address the fragmentation in existing tools, KANLib unifies the following capabilities within a single PyTorch-based environment:

Unified Linear Layers: A consistent interface for both B-spline and GRBF layers, allowing for direct architectural comparisons.
Fine-Grained Control: Users can selectively enable or disable components defined in the standard KAN equation, such as the residual branch ( $w_b b(x)$ ) or the spline weighting ( $w_s$ ).
Adaptive Grid Rescaling: Extends the adaptive grid mechanism found in PyKAN/EfficientKAN to both B-spline and GRBF layers (the latter restricted to equidistant grids).
Grid Extension: Supports increasing spline resolution during training without losing learned information, a feature previously omitted in EfficientKAN and FastKAN.
Normalization Strategies: Integrates Layer Normalization to map inputs to the active range of basis functions, compensating for the lack of adaptive rescaling in certain configurations.

Key Contributions

Framework Unification: KANLib consolidates the feature sets of PyKAN, EfficientKAN, and FastKAN into a single, extensible codebase, facilitating rigorous benchmarking across different basis functions and optimization strategies.
Computational Efficiency: By integrating optimizations from EfficientKAN (e.g., avoiding input tensor expansion) and FastKAN (e.g., direct GRBF computation), KANLib achieves competitive inference speeds while maintaining feature richness.
Architectural Flexibility: The framework enables the systematic exploration of KAN variations (e.g., removing residual branches or spline weights) with minimal code changes, supporting research beyond standard formulations.
Reproducibility: The framework is designed to reproduce the predictive behavior of established reference implementations, serving as a reliable baseline for future research.

Experimental Results

The authors evaluated KANLib on the California Housing dataset (a regression task with 20,640 samples and 8 input features), comparing it against PyKAN, EfficientKAN, and FastKAN.

Predictive Performance

B-spline Variants: KANLib (B-spline) achieved the best performance among B-spline implementations, with an RMSE of 0.5376 ± 0.0044 and an $R^2$ of 0.7852 ± 0.0035. This outperformed PyKAN (RMSE 0.5434) and EfficientKAN (RMSE 0.5463), demonstrating that KANLib successfully reproduces and slightly improves upon existing spline-based behaviors.
GRBF Variants: KANLib (GRBF) achieved an RMSE of 0.5471 ± 0.0078, closely matching FastKAN (RMSE 0.5506), confirming the framework's ability to replicate Gaussian RBF-based KANs.

Computational Efficiency

Inference Time:
- PyKAN was the slowest (212.19 ms).
- EfficientKAN and KANLib (B-spline) reduced inference time by approximately 32.7% compared to PyKAN (~142 ms).
- KANLib (GRBF) achieved 80.58 ms, a 62.0% improvement over PyKAN.
- FastKAN remained the fastest (41.02 ms) due to its highly specialized, less flexible implementation.
Parameter Count: KANLib models generally contained 4,050 parameters (including spline coefficients, residual weights, and spline weights), whereas FastKAN had fewer (3,811) due to the omission of the spline weighting mechanism.

Architectural Exploration

Experiments varying the layer structure (e.g., "No Residual," "No Spline Weight," "Plain") showed that:

Removing the residual branch or spline weights reduced parameter counts (down to 3,510) and inference times (up to ~16.8% faster for GRBF models).
Predictive performance remained competitive across these variations, with RMSE deviations generally remaining small, indicating that KANLib supports flexible architectural design without significant loss in accuracy.

Significance and Claims

The paper positions KANLib not as a model that achieves state-of-the-art predictive accuracy over all existing methods, but as a robust foundation for future research. Its primary significance lies in:

Bridging the Gap: It connects the theoretical potential of KANs with practical, scalable application by unifying fragmented implementations.
Enabling Extensibility: By providing a modular architecture, it lowers the barrier for researchers to test new basis functions, grid strategies, and hybrid architectures.
Standardization: It offers a consistent environment for evaluating KANs, addressing the issue of inconsistent feature support that currently hinders comparative studies.

The authors conclude that while KANLib currently incurs a slight computational overhead compared to the highly specialized FastKAN (specifically in GRBF computation due to the inclusion of adaptive grid logic), it provides the necessary flexibility for exploring the full spectrum of KAN architectures. Future work is identified as optimizing the Gaussian RBF computation to close the speed gap and extending support to 1D convolutions for time-dependent sensor data.