inkan 0.1.0__tar.gz

inkan-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Naveen Mysore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

inkan-0.1.0/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: inkan
+Version: 0.1.0
+Summary: Fast B-spline KAN layers — 6-15x faster than Cox-de Boor, exact B-spline values
+Author: Naveen Mysore
+License: MIT
+Project-URL: Homepage, https://github.com/naveenmysore/flashkan
+Project-URL: Repository, https://github.com/naveenmysore/flashkan
+Keywords: kan,kolmogorov-arnold,b-spline,neural-network,deep-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: torchvision>=0.15; extra == "dev"
+Requires-Dist: matplotlib>=3.5; extra == "dev"
+Dynamic: license-file
+
+# FlashKAN
+
+Fast B-spline [Kolmogorov-Arnold Network](https://arxiv.org/abs/2404.19756) layers for PyTorch.
+
+**6-15x faster** than standard Cox-de Boor implementations (PyKAN, efficient-kan), **faster than Gaussian RBF** alternatives (FastKAN) — while producing **exact B-spline basis values** with compact support, C2 continuity, and partition of unity.
+
+## How it works
+
+Standard KAN implementations compute B-spline basis functions using the Cox-de Boor recursion — 3 sequential passes for cubic splines, each creating intermediate tensors. FlashKAN replaces this with the truncated power closed form:
+
+```
+N(u) = (1/6) [relu(u)³ - 4·relu(u-1)³ + 6·relu(u-2)³ - 4·relu(u-3)³ + relu(u-4)³]
+```
+
+This single expression computes exact B-spline values with no recursion, no span lookups, and no gather operations. `torch.compile` fuses all elementwise ops into one GPU kernel.
+
+## Installation
+
+```bash
+pip install flashkan
+```
+
+**Requirements:** Python >= 3.9, PyTorch >= 2.0
+
+**Supported devices:** CPU, CUDA (NVIDIA), MPS (Apple Silicon)
+
+### From source
+
+```bash
+git clone https://github.com/NAVEENMN/flashkan.git
+cd flashkan
+pip install -e .
+```
+
+## Quick start
+
+```python
+import torch
+from flashkan import KANLayer, KANNetwork
+
+# Drop-in replacement for nn.Linear
+layer = KANLayer(784, 64)
+x = torch.randn(32, 784)
+y = layer(x)  # [32, 64]
+
+# Multi-layer network
+net = KANNetwork([784, 64, 10])
+y = net(torch.randn(32, 784))  # [32, 10]
+```
+
+### MNIST example
+
+```python
+import torch
+import torch.nn as nn
+from flashkan import KANNetwork
+
+model = KANNetwork([784, 64, 10])
+optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
+criterion = nn.CrossEntropyLoss()
+
+# Standard PyTorch training loop
+for images, labels in train_loader:
+    output = model(images.view(-1, 784))
+    loss = criterion(output, labels)
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+```
+
+See [`examples/`](examples/) for complete runnable scripts.
+
+## Visualization
+
+FlashKAN includes built-in visualization for learned activation functions — similar to PyKAN's `model.plot()`.
+
+```python
+from flashkan import KANNetwork, plot_basis, plot_activations, plot_network
+
+model = KANNetwork([784, 32, 10], grid_size=8)
+# ... train on MNIST ...
+
+plot_basis(model.layers[0])          # B-spline basis bumps
+plot_activations(model.layers[1])    # learned curves per edge
+plot_network(model)                  # full network diagram
+```
+
+### B-spline basis functions
+
+The 8 basis bumps (grid_size=5, degree=3) — compact support, smooth overlap:
+
+![Basis functions](assets/basis.png)
+
+### Learned activation functions
+
+After training on MNIST, each edge learns a unique activation curve.
+Cyan = total, red dashed = spline component, green dotted = SiLU base:
+
+![Learned activations](assets/activations.png)
+
+### Network diagram
+
+Full [784 → 32 → 10] network with learned curves on edges:
+
+![Network diagram](assets/network.png)
+
+## API
+
+### `KANLayer(in_features, out_features, grid_size=5, spline_order=3)`
+
+A single KAN layer. Drop-in replacement for `nn.Linear`.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `in_features` | — | Input dimension |
+| `out_features` | — | Output dimension |
+| `grid_size` | 5 | Number of knot intervals (more = finer approximation) |
+| `spline_order` | 3 | B-spline degree (3 = cubic, recommended) |
+| `grid_range` | (-1, 1) | Input range for the spline grid |
+
+### `KANNetwork(layer_dims, grid_size=5, spline_order=3)`
+
+Stack of KAN layers.
+
+```python
+# 3-layer KAN: 784 -> 128 -> 64 -> 10
+net = KANNetwork([784, 128, 64, 10])
+```
+
+## Benchmarks
+
+Forward pass time (ms) on Apple M-series GPU (MPS), batch=256:
+
+| Layer | MNIST (784→64) | FashionMNIST (784→64) | CIFAR-10 (3072→64) |
+|---|---|---|---|
+| **FlashKAN (compiled)** | **0.27** | **0.20** | **0.39** |
+| FastKAN (Gaussian RBF) | 0.38 | 0.31 | 0.99 |
+| NoGather (unrolled) | 0.99 | 1.02 | 4.85 |
+| Vanilla (Cox-de Boor) | 1.69 | 1.67 | 5.98 |
+
+FlashKAN is **6.3x faster** than vanilla Cox-de Boor on MNIST and **15.3x faster** on CIFAR-10.
+
+### Why it's fast
+
+91% of a standard KAN forward pass is spent computing B-spline basis functions. FlashKAN eliminates this bottleneck:
+
+| Approach | Basis cost | Why |
+|---|---|---|
+| Cox-de Boor (PyKAN) | 3 sequential GPU passes | Each pass depends on previous |
+| Gaussian RBF (FastKAN) | 1 `exp()` call | Fast but not a true B-spline |
+| **Truncated power (FlashKAN)** | **1 fused kernel** | `clamp + multiply` is cheaper than `exp()` |
+
+## B-spline properties preserved
+
+Unlike Gaussian RBF approximations, FlashKAN computes **exact** B-spline basis values:
+
+- **Compact support** — each basis function is exactly zero outside its knot span window
+- **C2 continuity** — second derivatives are continuous at every knot
+- **Partition of unity** — basis values sum to 1 at every point in the interior
+- **Non-negativity** — all basis values are >= 0
+
+Verified: max difference vs Cox-de Boor reference is < 5e-5 in float32.
+
+## Project structure
+
+```
+src/flashkan/
+├── __init__.py      # Public API
+├── basis.py         # Truncated power B-spline + torch.compile (core math)
+├── layer.py         # KANLayer
+├── network.py       # KANNetwork
+└── visualize.py     # plot_basis, plot_activations, plot_network
+```
+
+5 source files. The core innovation is in `basis.py` — 30 lines of math.
+
+## Citation
+
+If you use FlashKAN in your research, please cite:
+
+```bibtex
+@software{flashkan2026,
+  title={FlashKAN: Fast B-spline KAN Layers via Truncated Power Basis},
+  author={Mysore, Naveen},
+  year={2026},
+  url={https://github.com/NAVEENMN/flashkan}
+}
+```
+
+## License
+
+MIT

inkan-0.1.0/README.md

@@ -0,0 +1,192 @@
+# FlashKAN
+
+Fast B-spline [Kolmogorov-Arnold Network](https://arxiv.org/abs/2404.19756) layers for PyTorch.
+
+**6-15x faster** than standard Cox-de Boor implementations (PyKAN, efficient-kan), **faster than Gaussian RBF** alternatives (FastKAN) — while producing **exact B-spline basis values** with compact support, C2 continuity, and partition of unity.
+
+## How it works
+
+Standard KAN implementations compute B-spline basis functions using the Cox-de Boor recursion — 3 sequential passes for cubic splines, each creating intermediate tensors. FlashKAN replaces this with the truncated power closed form:
+
+```
+N(u) = (1/6) [relu(u)³ - 4·relu(u-1)³ + 6·relu(u-2)³ - 4·relu(u-3)³ + relu(u-4)³]
+```
+
+This single expression computes exact B-spline values with no recursion, no span lookups, and no gather operations. `torch.compile` fuses all elementwise ops into one GPU kernel.
+
+## Installation
+
+```bash
+pip install flashkan
+```
+
+**Requirements:** Python >= 3.9, PyTorch >= 2.0
+
+**Supported devices:** CPU, CUDA (NVIDIA), MPS (Apple Silicon)
+
+### From source
+
+```bash
+git clone https://github.com/NAVEENMN/flashkan.git
+cd flashkan
+pip install -e .
+```
+
+## Quick start
+
+```python
+import torch
+from flashkan import KANLayer, KANNetwork
+
+# Drop-in replacement for nn.Linear
+layer = KANLayer(784, 64)
+x = torch.randn(32, 784)
+y = layer(x)  # [32, 64]
+
+# Multi-layer network
+net = KANNetwork([784, 64, 10])
+y = net(torch.randn(32, 784))  # [32, 10]
+```
+
+### MNIST example
+
+```python
+import torch
+import torch.nn as nn
+from flashkan import KANNetwork
+
+model = KANNetwork([784, 64, 10])
+optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
+criterion = nn.CrossEntropyLoss()
+
+# Standard PyTorch training loop
+for images, labels in train_loader:
+    output = model(images.view(-1, 784))
+    loss = criterion(output, labels)
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+```
+
+See [`examples/`](examples/) for complete runnable scripts.
+
+## Visualization
+
+FlashKAN includes built-in visualization for learned activation functions — similar to PyKAN's `model.plot()`.
+
+```python
+from flashkan import KANNetwork, plot_basis, plot_activations, plot_network
+
+model = KANNetwork([784, 32, 10], grid_size=8)
+# ... train on MNIST ...
+
+plot_basis(model.layers[0])          # B-spline basis bumps
+plot_activations(model.layers[1])    # learned curves per edge
+plot_network(model)                  # full network diagram
+```
+
+### B-spline basis functions
+
+The 8 basis bumps (grid_size=5, degree=3) — compact support, smooth overlap:
+
+![Basis functions](assets/basis.png)
+
+### Learned activation functions
+
+After training on MNIST, each edge learns a unique activation curve.
+Cyan = total, red dashed = spline component, green dotted = SiLU base:
+
+![Learned activations](assets/activations.png)
+
+### Network diagram
+
+Full [784 → 32 → 10] network with learned curves on edges:
+
+![Network diagram](assets/network.png)
+
+## API
+
+### `KANLayer(in_features, out_features, grid_size=5, spline_order=3)`
+
+A single KAN layer. Drop-in replacement for `nn.Linear`.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `in_features` | — | Input dimension |
+| `out_features` | — | Output dimension |
+| `grid_size` | 5 | Number of knot intervals (more = finer approximation) |
+| `spline_order` | 3 | B-spline degree (3 = cubic, recommended) |
+| `grid_range` | (-1, 1) | Input range for the spline grid |
+
+### `KANNetwork(layer_dims, grid_size=5, spline_order=3)`
+
+Stack of KAN layers.
+
+```python
+# 3-layer KAN: 784 -> 128 -> 64 -> 10
+net = KANNetwork([784, 128, 64, 10])
+```
+
+## Benchmarks
+
+Forward pass time (ms) on Apple M-series GPU (MPS), batch=256:
+
+| Layer | MNIST (784→64) | FashionMNIST (784→64) | CIFAR-10 (3072→64) |
+|---|---|---|---|
+| **FlashKAN (compiled)** | **0.27** | **0.20** | **0.39** |
+| FastKAN (Gaussian RBF) | 0.38 | 0.31 | 0.99 |
+| NoGather (unrolled) | 0.99 | 1.02 | 4.85 |
+| Vanilla (Cox-de Boor) | 1.69 | 1.67 | 5.98 |
+
+FlashKAN is **6.3x faster** than vanilla Cox-de Boor on MNIST and **15.3x faster** on CIFAR-10.
+
+### Why it's fast
+
+91% of a standard KAN forward pass is spent computing B-spline basis functions. FlashKAN eliminates this bottleneck:
+
+| Approach | Basis cost | Why |
+|---|---|---|
+| Cox-de Boor (PyKAN) | 3 sequential GPU passes | Each pass depends on previous |
+| Gaussian RBF (FastKAN) | 1 `exp()` call | Fast but not a true B-spline |
+| **Truncated power (FlashKAN)** | **1 fused kernel** | `clamp + multiply` is cheaper than `exp()` |
+
+## B-spline properties preserved
+
+Unlike Gaussian RBF approximations, FlashKAN computes **exact** B-spline basis values:
+
+- **Compact support** — each basis function is exactly zero outside its knot span window
+- **C2 continuity** — second derivatives are continuous at every knot
+- **Partition of unity** — basis values sum to 1 at every point in the interior
+- **Non-negativity** — all basis values are >= 0
+
+Verified: max difference vs Cox-de Boor reference is < 5e-5 in float32.
+
+## Project structure
+
+```
+src/flashkan/
+├── __init__.py      # Public API
+├── basis.py         # Truncated power B-spline + torch.compile (core math)
+├── layer.py         # KANLayer
+├── network.py       # KANNetwork
+└── visualize.py     # plot_basis, plot_activations, plot_network
+```
+
+5 source files. The core innovation is in `basis.py` — 30 lines of math.
+
+## Citation
+
+If you use FlashKAN in your research, please cite:
+
+```bibtex
+@software{flashkan2026,
+  title={FlashKAN: Fast B-spline KAN Layers via Truncated Power Basis},
+  author={Mysore, Naveen},
+  year={2026},
+  url={https://github.com/NAVEENMN/flashkan}
+}
+```
+
+## License
+
+MIT

inkan-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "inkan"
+version = "0.1.0"
+description = "Fast B-spline KAN layers — 6-15x faster than Cox-de Boor, exact B-spline values"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "Naveen Mysore"},
+]
+keywords = ["kan", "kolmogorov-arnold", "b-spline", "neural-network", "deep-learning"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "torch>=2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "torchvision>=0.15",
+    "matplotlib>=3.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/naveenmysore/flashkan"
+Repository = "https://github.com/naveenmysore/flashkan"
+
+[tool.setuptools.packages.find]
+where = ["src"]

inkan-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

inkan-0.1.0/src/inkan/__init__.py

@@ -0,0 +1,24 @@
+"""InKAN — Fast B-spline KAN layers using the truncated power basis.
+
+Computes exact B-spline basis functions via a closed-form formula
+that torch.compile fuses into a single GPU kernel. 6-15x faster
+than Cox-de Boor recursion, faster than Gaussian RBF alternatives,
+while maintaining true B-spline properties (compact support, C2
+continuity, partition of unity).
+
+Example:
+    >>> import torch
+    >>> from inkan import KANLayer
+    >>> layer = KANLayer(784, 64)
+    >>> x = torch.randn(32, 784)
+    >>> y = layer(x)  # [32, 64]
+"""
+
+__version__ = "0.2.0"
+
+from inkan.layer import KANLayer
+from inkan.network import KANNetwork
+from inkan.visualize import plot_basis, plot_activations, plot_network
+
+__all__ = ["KANLayer", "KANNetwork",
+           "plot_basis", "plot_activations", "plot_network"]

inkan-0.1.0/src/inkan/basis.py

@@ -0,0 +1,53 @@
+"""B-spline basis computation via the truncated power closed form.
+
+The cubic B-spline basis function can be expressed exactly as:
+
+    N(u) = (1/6) * [relu(u)^3 - 4*relu(u-1)^3 + 6*relu(u-2)^3
+                    - 4*relu(u-3)^3 + relu(u-4)^3]
+
+where u = (x - grid_start_i) / h.
+
+This eliminates Cox-de Boor recursion (3 sequential passes),
+span lookups, and scatter/gather operations. torch.compile fuses
+all elementwise ops into a single GPU kernel.
+
+For uniform grids, this produces bit-identical results to Cox-de Boor
+(verified max diff < 5e-5 in float32).
+"""
+
+import torch
+
+
+def _bspline_basis(x: torch.Tensor, grid_starts: torch.Tensor,
+                   inv_h: float) -> torch.Tensor:
+    """Compute B-spline basis values for all inputs and all basis functions.
+
+    Args:
+        x: Input tensor [batch, in_features].
+        grid_starts: Start position of each basis function's support [n_bases].
+        inv_h: Reciprocal of knot spacing (1/h).
+
+    Returns:
+        Basis values [batch, in_features, n_bases].
+    """
+    # u[b, i, j] = (x[b,i] - grid_starts[j]) / h
+    u = (x.unsqueeze(-1) - grid_starts) * inv_h
+
+    # Truncated power form: sum of relu(u-k)^3 with binomial coefficients
+    # Coefficients: C(4,k) * (-1)^k / 3! = [1, -4, 6, -4, 1] / 6
+    r0 = torch.clamp(u, min=0.0)
+    r1 = torch.clamp(u - 1.0, min=0.0)
+    r2 = torch.clamp(u - 2.0, min=0.0)
+    r3 = torch.clamp(u - 3.0, min=0.0)
+    r4 = torch.clamp(u - 4.0, min=0.0)
+
+    return (r0*r0*r0 - 4.0*r1*r1*r1 + 6.0*r2*r2*r2
+            - 4.0*r3*r3*r3 + r4*r4*r4) * 0.16666667
+
+
+# torch.compile fuses all elementwise ops into a single GPU kernel.
+# Works on CUDA, MPS, and CPU.
+bspline_basis = torch.compile(_bspline_basis)
+
+# Export the unfused version for testing/debugging
+bspline_basis_eager = _bspline_basis

inkan-0.1.0/src/inkan/layer.py

@@ -0,0 +1,112 @@
+"""KANLayer — the core building block.
+
+Drop-in replacement for nn.Linear in KAN networks:
+    nn.Linear(in_features, out_features)
+    KANLayer(in_features, out_features)
+
+Each edge (i→j) has a learnable B-spline activation function
+plus a SiLU residual connection, following the KAN paper.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from inkan.basis import bspline_basis
+
+
+class KANLayer(nn.Module):
+    """Kolmogorov-Arnold Network layer with fast B-spline activations.
+
+    Uses the truncated power closed form + torch.compile for basis
+    computation. Produces exact B-spline values with compact support,
+    C2 continuity, and partition of unity.
+
+    Args:
+        in_features: Size of each input sample.
+        out_features: Size of each output sample.
+        grid_size: Number of interior knot intervals. More = finer
+            approximation. Default: 5.
+        spline_order: Degree of the B-spline. Default: 3 (cubic).
+        base_activation: Residual activation function. Default: SiLU.
+        grid_range: Range of the input grid. Default: (-1, 1).
+
+    Shape:
+        - Input: (batch, in_features)
+        - Output: (batch, out_features)
+
+    Example:
+        >>> layer = KANLayer(784, 64, grid_size=10)
+        >>> x = torch.randn(32, 784)
+        >>> y = layer(x)  # [32, 64]
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        grid_size: int = 5,
+        spline_order: int = 3,
+        base_activation: type = nn.SiLU,
+        grid_range: tuple = (-1.0, 1.0),
+    ):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.grid_size = grid_size
+        self.spline_order = spline_order
+
+        n_bases = grid_size + spline_order
+        h = (grid_range[1] - grid_range[0]) / grid_size
+        self.inv_h = 1.0 / h
+
+        # Grid start positions for each basis function
+        grid_starts = (torch.arange(n_bases).float() * h
+                       + grid_range[0] - spline_order * h)
+        self.register_buffer("grid_starts", grid_starts)
+
+        # Learnable spline coefficients: one per (output, input, basis)
+        self.spline_weight = nn.Parameter(
+            torch.empty(out_features, in_features, n_bases)
+        )
+
+        # Learnable residual weights
+        self.base_weight = nn.Parameter(
+            torch.empty(out_features, in_features)
+        )
+
+        self.base_activation = base_activation()
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        """Initialize parameters with scaled random values."""
+        # Kaiming-style init scaled for spline basis
+        nn.init.trunc_normal_(self.spline_weight, std=0.1)
+        nn.init.trunc_normal_(self.base_weight, std=0.1)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Forward pass.
+
+        Args:
+            x: Input tensor of shape (batch, in_features).
+
+        Returns:
+            Output tensor of shape (batch, out_features).
+        """
+        # Spline activation: φ(x) = Σ_k c_k * N_k(x)
+        bases = bspline_basis(x, self.grid_starts, self.inv_h)
+        spline_out = torch.einsum("bin,oin->bo", bases, self.spline_weight)
+
+        # Residual: b(x) * w
+        base_out = torch.einsum(
+            "bi,oi->bo", self.base_activation(x), self.base_weight
+        )
+
+        return spline_out + base_out
+
+    def extra_repr(self) -> str:
+        return (f"in_features={self.in_features}, "
+                f"out_features={self.out_features}, "
+                f"grid_size={self.grid_size}, "
+                f"spline_order={self.spline_order}")