KANLab: TensorFlow Playground for Kolmogorov-Arnold Networks

AI summary

Overview

Research area: Machine learning education and visualization — specifically interactive tools for understanding Kolmogorov-Arnold Networks (KANs), a proposed alternative to multi-layer perceptrons (MLPs).

Technical level: Intermediate. The paper assumes some familiarity with neural network basics (layers, activations, gradient descent, loss) but explains KAN-specific concepts such as B-spline activations and the Kolmogorov-Arnold Representation Theorem from the ground up.

Scope: This is a tool paper describing KANLab, an open-source browser application forked from TensorFlow Playground that lets users build, train, manually edit, prune, and inspect small two-dimensional KANs in real time.

What This Paper Is About

KANs replace the fixed nonlinear activations of ordinary neural networks with trainable univariate functions (here, B-splines), which makes them more interpretable but also harder to learn about by experimentation. Existing KAN playgrounds run training server-side and represent the architecture as an image refreshed only once per epoch, and modern KAN implementations add residual connections and learnable scaling and shifting parameters that blur the link between what is drawn and what is actually being trained. KANLab's goal is to close the gap between KAN beginners and KAN experts by providing a fully client-side, deliberately simplified playground where every displayed B-spline curve maps directly onto its trainable control points.

Key Contributions

1. A fork of TensorFlow Playground for KANs. KANLab reuses the established educational design of TensorFlow Playground (Smilkov et al., 2017) but replaces MLP layers with KAN layers whose edge functions are trainable B-splines, giving an interactive browser environment for the compact 2D setting.

2. Deliberate simplification for educational clarity. The tool omits residual connections and learnable scaling/shifting parameters found in modern KAN implementations, so that displayed B-spline activation curves correspond directly to their underlying trainable control points.

3. Direct manipulation of trainable parameters. Users can drag individual control points of any activation function during training and watch gradient descent correct the manual disruption in real time — effectively allowing a KAN to be trained by hand.

4. Integrated diagnostic visualizations. The interface shows incoming and outgoing activation distributions per activation function as histograms, encodes activation variance as line thickness on the network diagram, and supports interactive pruning and re-training of individual splines and summation nodes.

Main Findings

• B-spline choice is principled. KANLab uses B-spline-based activations because, among the bases surveyed (B-splines, Chebyshev and Jacobi polynomials, ReLU compositions, Fourier series, Gaussian kernels, wavelets, finite basis partitions, and sinc functions; Noorizadegan et al., 2026), B-splines have the firmest theoretical footing and allow some of the strongest guarantees.

• Activation clipping is required. Because trainable control points are unbounded, a B-spline's outgoing activations can exceed the control-point domain of the next spline; KANLab handles this by clipping incoming activations into the interval [-6, 6], the same interval used for dataset generation in both TensorFlow Playground and KANLab.

• Initialization strongly shapes early behavior. KANLab offers preset uniform initialization variances of [0.1, 0.3, 0.5, 1.0, 5.0], LeCun- and Glorot-inspired variance-preserving schemes (Rigas et al., 2026), and identity initialization. Small-variance initialization yields near-zero activations initially, whereas identity initialization preserves input structure and makes the effect of training on activation shape easier to observe.

• Variance visualizes information flow. In the example network, thicker gray dashed lines indicate higher activation variance; after pruning a spline on the upper path, the loss and classification error increase, and continued training increases activation variance on the lower path while the error decreases — showing the network rerouting information through remaining connections.

• No quantitative benchmarks are reported. The paper presents no accuracy figures, training curves, dataset sizes, or comparisons against MLP baselines; its claims are about pedagogy and usability, not performance.

Methodology in Plain English

The authors built a web application rather than running an empirical study. They took the open-source TensorFlow Playground, which lets users train small neural networks on 2D datasets in the browser, and swapped its fixed activation functions for trainable B-spline functions on each network edge.

A B-spline activation is a weighted sum of fixed basis curves, where only the weights (called control points) are learned. Because those control points are few and visible, the tool can draw them as draggable orange dots on top of the green activation curve, and users can move them by hand. Networks are trained with batched stochastic gradient descent on mean squared error, entirely in the browser.

To keep the picture honest, the authors intentionally left out two features common in modern KAN code — residual connections and learnable scaling/shifting — because those additions would break the one-to-one correspondence between the drawn curve and the learned parameters. Control points are spaced uniformly over [-6, 6] to match the dataset range, and activations that overshoot that range are clipped.

The interface also renders histograms of incoming and outgoing activations for each spline and varies the thickness of connecting lines according to activation variance. Clicking an edge function or a non-output summation node disables it, enabling interactive pruning experiments. All experiment settings are serialized into the URL's GET parameters, so a configuration can be shared by link.

Why This Matters

Impact on research and teaching. KANs are a young architecture with growing interest in classification as well as symbolic formula representation, but their internals are harder to build intuition for than MLPs. A fully client-side, shareable playground lowers the barrier for students and gives KAN researchers a lightweight environment for probing behavior and communicating it to others.

Real-world applications (as contexts where understanding KANs matters):

• Classroom and course instruction in machine learning, where interactive playgrounds complement lecture material; saved URLs let instructors distribute exact setups to students.
• Scientific modeling and symbolic regression, the primary success area cited for KANs, where interpretable univariate functions are the main selling point.
• Classification tasks, where KANs are frequently experimented with as an alternative to MLPs and are claimed to allow more compact architectures.
• Model inspection and ablation studies, where interactive pruning and variance visualization support quick, intuitive experiments before committing to full-scale implementations.

Industry relevance. Practitioners evaluating whether KANs are worth adopting can use the tool as a low-cost sandbox for intuition building without setting up a training stack. The open-source release (https://kanlab.app/) also makes it easy to adapt for internal training or demos.

Future Directions

1. Regularization methods. The conclusion explicitly lists adding regularization methods as future work, which would let users see how sparsity pressures act on B-spline activations.

2. Restoring omitted KAN features as toggles. The authors excluded residual connections and learnable scaling/shifting for clarity; offering them as optional, clearly explained switches would bridge the gap between the teaching tool and real implementations.

3. Systematic evaluation of learning outcomes. The paper reports no user studies or quantitative measurements of whether KANLab actually improves understanding; controlled comparisons against lectures, TensorFlow Playground, or the server-side KAN-Playground would test the pedagogical claims.

4. Scaling beyond the 2D sandbox. It is open whether the direct-manipulation and variance-visualization approach extends to larger architectures, real datasets, or deeper KANs, where the current visual encodings may no longer be legible.

Target Audience

Instructors and students in machine learning courses who want a hands-on entry point to KANs; KAN researchers and practitioners seeking an accessible environment to demonstrate or probe KAN behavior; and developers interested in browser-based, client-side visualization of neural architectures. Readers looking for benchmark results or architectural novelty will not find them here — this is a tool description, not an empirical study.

Authors’ abstract

KANLab is a browser-based visualization tool designed to interactively teach the core concepts of Kolmogorov-Arnold Networks (KAN), forked from the widely successful TensorFlow Playground. To maximize educational clarity, KANLab omits residual connections and learnable scaling parameters found in modern KAN implementations, ensuring that displayed B-spline activation curves directly correspond to their underlying trainable control points. Users can inspect and modify activation functions, initialization schemes and observe gradient descent correcting manual disruptions. Furthermore, user can explore phenomena such as activation variance, interactive pruning, and re\-/training within a compact 2D machine learning setting. KANLab is open-source and available at https://kanlab.app/