Axiomata KAN Creator v1.2 — Universal KAN (Kolmogorov-Arnold Network) concept creation tool. Use when: (1) creating new KAN concepts for monitoring/evaluatio...
---
name: axiomata-kan-creator
description: |
Axiomata KAN Creator v1.2 — Universal KAN (Kolmogorov-Arnold Network) concept creation tool.
Use when: (1) creating new KAN concepts for monitoring/evaluation/control, (2) setting up KAN architecture with learnable basis functions, (3) initializing KAN models with bounded activation functions (Tanh), (4) building KAN pipelines for agent systems.
This skill provides: kan_creator.py (core script), KAN architecture templates, learnable basis layer implementation. Requires PyTorch >= 1.9. NaN-free training guaranteed with bounded activations (Tanh) and small initialization.
triggers:
- "create KAN"
- "KAN concept"
- "KAN architecture"
- "KAN model"
- "build KAN"
- "KAN pipeline"
- "KAN initialization"
- "KAN layer"
date: "2026-05-13"
version: "1.2.0"
tags:
- KAN
- machine-learning
- neural-networks
- axiomata
- deep-learning
- architecture
status: "OK Verified"
requires:
- python: ">= 3.8"
- pytorch: ">= 1.9"
---
# Axiomata KAN Creator v1.0
Universal KAN (Kolmogorov-Arnold Network) concept creation tool.
| Info | Value |
|------|-------|
| **Version** | 1.0.0 |
| **Type** | KAN architecture creation |
| **Architecture** | B-spline basis functions |
| **Requires** | PyTorch >= 1.9 |
---
## 1. Purpose
**Axiomata KAN Creator** creates KAN (Kolmogorov-Arnold Network) concepts for agent systems.
KANs are neural networks that use learnable B-spline basis functions instead of fixed activation functions:
```
Traditional MLP: y = σ(Wx + b) — Fixed activation
KAN: y = Σφᵢₙ(xᵢ) — Learnable activation
```
Each weight is a function (B-spline), not a scalar. This allows KANs to be more interpretable and efficient than MLPs.
---
## 2. When to Use
| Trigger | Action |
|---------|--------|
| "Create a KAN" | Run `kan_creator.py` with name and role |
| "Build KAN architecture" | Create KAN with custom layers |
| "Initialize KAN model" | Generate model structure with B-splines |
| "Create KAN pipeline" | Build multi-KAN system |
---
## 3. Prerequisites
| Requirement | Version | Check |
|------------|---------|-------|
| Python | >= 3.8 | `python3 --version` |
| **PyTorch** | **>= 1.9** | `python3 -c "import torch; print(torch.__version__)"` |
**Note:** PyTorch is required for all KAN operations (model creation, training, inference).
---
## 4. Quick Start
### 4.1 Create Basic KAN
```bash
cd <skill-directory>
python3 scripts/kan_creator.py --name my_kan --role "monitoring"
```
**Expected output:**
```
✅ KAN 'my_kan' created at scripts/my_kan/
📋 Config: scripts/my_kan/config.json
🧠 Model: scripts/my_kan/models/my_kan.py
```
### 4.2 Create KAN with Custom Parameters
```bash
python3 scripts/kan_creator.py \
--name stc_watchdog \
--role "emotional tension" \
--agent morgana \
--input-size 768 \
--output-size 3 \
--hidden-size 32
```
---
## 5. Architecture
### 5.1 KAN Layer Structure
```
╔═══════════════════════════════════════════════════════════╗
║ KAN LAYER — B-Spline Transformation ║
╠═══════════════════════════════════════════════════════════╣
║ ║
║ Input: x ∈ R^input_size ║
║ ↓ ║
║ B-Spline: φ(x) = ΣcᵢBᵢ(x) ║
║ ↓ ║
║ Learnable coefficients: cᵢ ║
║ ↓ ║
║ SiLU activation: σ(x) = x / (1 + e^(-x)) ║
║ ↓ ║
║ Output: y ∈ R^output_size ║
║ ║
╚═══════════════════════════════════════════════════════════╝
```
### 5.2 Default Architecture
| Parameter | Default | Description |
|-----------|---------|-------------|
| `input_size` | 768 | Embedding dimension |
| `hidden_size` | 32 | Hidden layer width |
| `output_size` | 3 | Decision dimension |
| `grid_size` | 5 | B-spline grid points |
| `k` | 3 | B-spline order |
| `layers` | [768, 32, 16, 8, 4, 3] | Layer dimensions |
### 5.3 KAN vs MLP
| Aspect | MLP | KAN |
|--------|-----|-----|
| Weights | Scalar (fixed) | Function (learnable) |
| Activation | Fixed (ReLU/sigmoid) | Learnable (B-spline) |
| Interpretability | Low | High |
| Training efficiency | High | Medium |
| Data efficiency | Medium | High |
---
## 6. Usage
### 6.1 Command Reference
```bash
# Basic creation
python3 scripts/kan_creator.py --name <name> --role <role>
# Full options
python3 scripts/kan_creator.py \
--name <string> \
--role <string> \
--agent <string> \
--input-size <int> \
--output-size <int> \
--hidden-size <int> \
--grid-size <int> \
--layers <list>
```
### 6.2 Parameters
| Parameter | Default | Description |
|-----------|---------|-------------|
| `--name` | required | KAN name (used for directory/files) |
| `--role` | required | KAN role/purpose |
| `--agent` | "system" | Agent owning the KAN |
| `--input-size` | 768 | Input dimension |
| `--output-size` | 3 | Output dimension |
| `--hidden-size` | 32 | Hidden layer width |
| `--grid-size` | 5 | B-spline grid size |
| `--k` | 3 | B-spline order |
| `--layers` | auto | Layer dimensions (auto-generated if not specified) |
### 6.3 Output Structure
```
<name>/
├── config.json # KAN configuration
├── models/
│ └── <name>.py # KAN model class
├── data/
│ └── training/ # Training data directory
└── scripts/
└── train.sh # Training script template
```
---
## 7. Examples
### Example 1: Create Monitoring KAN
```bash
python3 scripts/kan_creator.py \
--name stc_monitor \
--role "emotional tension monitoring" \
--output-size 3
```
**Output:**
```
✅ KAN 'stc_monitor' created
📁 scripts/stc_monitor/
📋 config.json
🧠 models/stc_monitor.py
```
### Example 2: Create Evaluation KAN
```bash
python3 scripts/kan_creator.py \
--name eval_kan \
--role "skill quality evaluation" \
--output-size 3 \
--input-size 768
```
### Example 3: Create Logic Validation KAN
```bash
python3 scripts/kan_creator.py \
--name vls_kan \
--role "logic validation" \
--agent ezekiel \
--output-size 3
```
---
## 8. KAN Classes
### 8.1 KANLayer
Single KAN layer with B-spline basis functions:
```python
class KANLayer(nn.Module):
def __init__(self, in_features, out_features, grid_size=5, k=3):
# B-spline grid: grid_size + k points
# Learnable coefficients per output neuron
```
### 8.2 KANModel
Full KAN model with multiple layers:
```python
class KANModel(nn.Module):
def __init__(self, layers, grid_size=5, k=3):
# Multiple KANLayers
# Forward: input → B-spline → SiLU → output
```
### 8.3 KANWithHead
KAN with classification/regression head:
```python
class KANWithHead(nn.Module):
def __init__(self, kan_backbone, num_classes, mode="classification"):
# KAN backbone + classification head
# Supports: classification, regression, multi-head
```
---
## 9. Configuration
### 9.1 config.json Structure
```json
{
"name": "<name>",
"role": "<role>",
"agent": "<agent>",
"input_size": 768,
"hidden_size": 32,
"output_size": 3,
"grid_size": 5,
"k": 3,
"layers": [768, 32, 16, 8, 4, 3],
"activation": "silu",
"loss_function": "cross_entropy",
"optimizer": "adam",
"learning_rate": 0.001,
"batch_size": 32,
"epochs": 50,
"train_samples": 200,
"num_classes": 4
}
```
### 9.2 Parameter Adjustments
| Use Case | Recommended Settings |
|----------|----------------------|
| Monitoring | output_size=3, epochs=50, batch_size=32 |
| Evaluation | output_size=4, epochs=100, batch_size=32 |
| Validation | output_size=2, epochs=50, batch_size=16 |
| Multi-class | output_size=num_classes, epochs=100 |
---
## 10. Error Handling
| Error | Cause | Solution |
|-------|-------|----------|
| `ModuleNotFoundError: torch` | PyTorch not installed | `pip install torch --index-url https://download.pytorch.org/whl/cpu` |
| `FileExistsError: <name>` | KAN already exists | Use `--force` or choose different name |
| `ValueError: invalid layers` | Layer mismatch | Ensure `layers[0]` == `input_size` and `layers[-1]` == `output_size` |
---
## 11. Constraints
| Constraint | Value | Description |
|------------|-------|-------------|
| Input size | 768 (standard) | Ollama embedding size |
| Output size | 2-10 | Decision/class dimension |
| Grid size | 3-10 | B-spline grid resolution |
| B-spline order | 1-5 | Spline polynomial degree |
| Max layers | 10 | Prevent over-complexity |
---
## 12. Related Skills
| Skill | Purpose |
|-------|---------|
| `axioma-kan-system` | Full KAN lifecycle (create+train+assemble) |
| `axioma-skill-evaluator` | Evaluate KAN model quality |
| `axiomata-cluster-guardian` | Use KAN for cluster lessons |
---
_In Altum Per KAN._
🧠 AXIOMATA KAN CREATOR v1.0 — UNIVERSAL KAN ARCHITECTUREdon't have the plugin yet? install it then click "run inline in claude" again.