An Embedded RISC-V Evaluation of Kolmogorov--Arnold Networks in Hard-Constrained Recurrent Physics-Informed Models

Technical Summary: Embedded RISC-V Evaluation of Kolmogorov–Arnold Networks in Hard-Constrained Recurrent Physics-Informed Models

Problem Statement
Hard-constrained recurrent physics-informed neural networks (HRPINNs) embed known physical dynamics into a recurrent numerical integrator, restricting the neural component to learning only the residual dynamics. While Kolmogorov–Arnold Networks (KANs) have been proposed as parameter-efficient alternatives to Multilayer Perceptrons (MLPs) for these residual branches, their execution profile differs significantly due to learnable B-spline activations. Prior work established that KANs can match or underperform MLPs in discovery accuracy but did not evaluate their computational efficiency or dependability in deployment. This paper investigates whether the parameter efficiency of KANs translates to deployment cost on scalar embedded cores, specifically addressing three hypotheses: (H1) KANs incur higher per-step execution latency than accuracy-comparable MLPs; (H2) this latency difference results in higher energy consumption per integration step; and (H3) KANs lose trajectory fidelity earlier than MLPs under post-training quantization within a closed recurrent loop.

Methodology
The study evaluates identical trained weights of MLP and KAN residual branches deployed on a StarFive VisionFive 2 platform (SiFive U74, RV64GC), a RISC-V core without vector extensions. This hardware choice ensures that both architectures compile to scalar instruction sequences, isolating the performance difference to the operation mix and memory access patterns of the topologies themselves.

• Models and Benchmarks: The evaluation uses two benchmark systems: the Duffing oscillator (additively separable residual) and the Van der Pol oscillator (multiplicatively coupled residual). The HRPINN architecture uses an explicit Euler integrator.
• Implementation: An allocation-free, scalar inference engine was developed in C++17. The engine supports both FP32 and post-training static quantization (INT16, INT8, INT6, INT4). Two KAN variants were tested: a default implementation matching PyTorch numerics and an optimized variant precomputing knot-difference reciprocals.
• Metrics:
  • Latency: Measured as median per-call time for the residual branch and the full HRPINN step.
  • Energy: Measured via an inline USB coulomb counter over a 120-second execution window, calculating differential energy per step ($E_{step} = (P_{load} - P_{idle}) / \text{steps/s}$).
  • Dependability: Assessed by running 2,000-step closed-loop rollouts from 20 initial conditions. Divergence is defined as the step where the Euclidean distance between the quantized rollout and the FP32 baseline exceeds 0.1.
  • Attribution: The impact of quantization was isolated by quantizing specific components (weights, activations, state, or inputs) individually.

Key Results
The experiments confirmed all three hypotheses:

1. Latency (H1): KANs are significantly slower than MLPs. For accuracy-comparable pairs, the KAN residual branch executed 13.5× and 8.0× slower than their MLP counterparts. Across all four parameter-matched size tiers, the latency ratio ranged from 4.7× to 14.5×. Normalized per parameter, KANs spent 41–93 ns per parameter compared to 6.2–8.0 ns for MLPs. The optimized reciprocal variant recovered only 6–18% of this latency, leaving a substantial gap.
2. Energy (H2): Energy consumption scales directly with latency. The KAN pairs consumed 11.3× and 5.6× more energy per integration step than the MLPs (e.g., 3.7 µJ vs. 0.33 µJ for the smallest pair). The incremental active power difference between architectures was indistinguishable from zero, confirming that the energy penalty is driven entirely by execution time rather than higher power draw per cycle.
3. Dependability under Quantization (H3): KANs diverge much earlier than MLPs under quantization. In full INT8 quantization mode, the Duffing KAN Very Small diverged at a median of 6.5 steps, whereas the matched MLP Tiny diverged at 282 steps (a 43× difference).
   • Attribution Analysis: The divergence is primarily caused by weight quantization, not input-side knot-interval misassignment. Quantizing only inputs had negligible effect. However, quantizing weights caused a severe drop in KAN discovery accuracy (e.g., Duffing $R^2$ dropping from 0.90 to -0.10 at INT8), while MLPs remained stable. The heterogeneous distribution of KAN spline coefficients makes them highly sensitive to per-tensor scaling, which compresses small coefficients disproportionately.

Significance and Conclusions
The paper concludes that the parameter efficiency reported for KANs on separable residuals does not transfer to deployment cost on scalar embedded cores. The B-spline formulation introduces execution and precision-level costs that offset parameter savings.

• Deployment Guidance: For embedded HRPINN deployment, an MLP residual branch is the more dependable default unless specific quantization co-design is employed.
• Limitations of Optimization: Classical kernel engineering (e.g., lookup tables for transcendental functions or precomputed reciprocals) can only close a fraction of the latency gap. A fully optimized scalar kernel would still remain an order of magnitude behind MLPs.
• Future Directions: The authors suggest that future work should focus on co-designed quantization schemes (e.g., per-edge or per-channel scaling for spline weights) and evaluate these architectures on vector-capable cores, though the KAN's gather-heavy, branchy recursion is inherently harder to vectorize than dense matrix products.

The study emphasizes that while KANs may be defensible where memory footprint is the binding constraint and execution remains at FP32 or INT16, they currently lack the robustness and efficiency required for general embedded CPS deployment under standard post-training quantization.