qukan 0.1.0__tar.gz

qukan-0.1.0/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or installing an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  捕捉 "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not governed by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that numbered version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version ever published by
+the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+which future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

qukan-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: qukan
+Version: 0.1.0
+Summary: Official implementation for 'Quantum Kolmogorov Arnold Network' (QuKAN) implementated using PennyLane and PyTorch. Paper: Werner, Y., Malemath, A., Liu, M., Fortes Rey, V., Palaiodimopoulos, N., Lukowicz, P., & Kiefer-Emmanouilidis, M. (2025). QuKAN: A Quantum Circuit Born Machine Approach to Quantum Kolmogorov Arnold Networks. Scientific Reports, 15(1), 35239.
+License-Expression: LGPL-3.0-only
+License-File: LICENSE
+Author: Yannick Werner
+Author-email: yannick.werner@dfki.de
+Requires-Python: >=3.10,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: icecream (>=2.1.0)
+Requires-Dist: matplotlib (>=3.9.0)
+Requires-Dist: numpy (>=1.26.0)
+Requires-Dist: pennylane (>=0.40.0)
+Requires-Dist: torch (>=2.4.0)
+Requires-Dist: tqdm (>=4.66.0)
+Project-URL: Homepage, https://github.com/QuanTUK/QuKAN
+Description-Content-Type: text/markdown
+
+# QuKAN: Quantum Kolmogorov Arnold Network
+
+QuKAN is a Python package for Quantum Kolmogorov Arnold Networks, built on top of [PennyLane](https://pennylane.ai/) and [PyTorch](https://pytorch.org/). It inlcudes hybrid and fully quantum neuron architecture implementations.
+
+## Features
+- Quantum Spline implementation
+- Quantum KAN Neurons
+- Scalable QuKAN architecture
+- Support for QCBM-based spline pretraining
+
+## Installation
+
+```bash
+# Using poetry
+poetry install
+```
+
+## Usage
+
+```python
+import torch
+import torch.nn as nn
+from qukan import QuKAN
+
+# 1. Initialize model
+model = QuKAN(feature_dim=2, num_hlayers=1)
+
+# 2. Setup training components
+optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+criterion = nn.MSELoss()
+
+# 3. Dummy data
+x = torch.rand(10, 2)
+y = torch.rand(10, 1)
+
+# 4. Training loop
+for epoch in range(5):
+    optimizer.zero_grad()
+    output = model(x)
+    loss = criterion(output, y)
+    loss.backward()
+    optimizer.step()
+    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
+```
+
+## License
+LGPL-3.0-only
+

qukan-0.1.0/README.md

@@ -0,0 +1,47 @@
+# QuKAN: Quantum Kolmogorov Arnold Network
+
+QuKAN is a Python package for Quantum Kolmogorov Arnold Networks, built on top of [PennyLane](https://pennylane.ai/) and [PyTorch](https://pytorch.org/). It inlcudes hybrid and fully quantum neuron architecture implementations.
+
+## Features
+- Quantum Spline implementation
+- Quantum KAN Neurons
+- Scalable QuKAN architecture
+- Support for QCBM-based spline pretraining
+
+## Installation
+
+```bash
+# Using poetry
+poetry install
+```
+
+## Usage
+
+```python
+import torch
+import torch.nn as nn
+from qukan import QuKAN
+
+# 1. Initialize model
+model = QuKAN(feature_dim=2, num_hlayers=1)
+
+# 2. Setup training components
+optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+criterion = nn.MSELoss()
+
+# 3. Dummy data
+x = torch.rand(10, 2)
+y = torch.rand(10, 1)
+
+# 4. Training loop
+for epoch in range(5):
+    optimizer.zero_grad()
+    output = model(x)
+    loss = criterion(output, y)
+    loss.backward()
+    optimizer.step()
+    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
+```
+
+## License
+LGPL-3.0-only

qukan-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "qukan"
+version = "0.1.0"
+description = "Official implementation for 'Quantum Kolmogorov Arnold Network' (QuKAN) implementated using PennyLane and PyTorch. Paper: Werner, Y., Malemath, A., Liu, M., Fortes Rey, V., Palaiodimopoulos, N., Lukowicz, P., & Kiefer-Emmanouilidis, M. (2025). QuKAN: A Quantum Circuit Born Machine Approach to Quantum Kolmogorov Arnold Networks. Scientific Reports, 15(1), 35239."
+authors = [
+    {name = "Yannick Werner", email="yannick.werner@dfki.de"},
+    {name = "Akash Malemath"},
+    {name = "Mengxi Liu"},
+    {name = "Vitor Fortes Rey"},
+    {name = "Nik Palaiodimopoulos"},
+    {name = "Paul Lukowicz"},
+    {name = "Maximilian Kiefer-Emmanouilidis"},
+
+]
+license = "LGPL-3.0-only"
+readme = "README.md"
+requires-python = ">=3.10,<3.13"
+dependencies = [
+    "torch>=2.4.0",
+    "pennylane>=0.40.0",
+    "matplotlib>=3.9.0",
+    "icecream>=2.1.0",
+    "numpy>=1.26.0",
+    "tqdm>=4.66.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/QuanTUK/QuKAN"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+packages = [{include = "qukan", from = "src"}]
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.15.9"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "N", "B", "A", "C4", "SIM", "PLE"]
+ignore = ["N801", "N802", "N803", "N806"] # Allow camelCase for models to match existing student code style where appropriate

qukan-0.1.0/src/qukan/__init__.py

@@ -0,0 +1,20 @@
+from .devices import DEFAULT_QML_DEVICE_NAME, DEFAULT_TORCH_DEVICE, get_qml_device
+from .neuron import FQuKANNeuron, QuKANNeuron
+from .qcbm import MMD, QCBM
+from .qukan import FQuKAN, QuKAN
+from .splines import encode_bsplines, encode_bsplinesSILU, trained_splines
+
+__all__ = [
+    "QuKAN",
+    "FQuKAN",
+    "QuKANNeuron",
+    "FQuKANNeuron",
+    "encode_bsplines",
+    "trained_splines",
+    "encode_bsplinesSILU",
+    "QCBM",
+    "MMD",
+    "DEFAULT_TORCH_DEVICE",
+    "DEFAULT_QML_DEVICE_NAME",
+    "get_qml_device",
+]

qukan-0.1.0/src/qukan/devices.py

@@ -0,0 +1,16 @@
+import torch
+import pennylane as qml
+
+# Centralized Torch device (Explicitly locked to CPU for stability)
+DEFAULT_TORCH_DEVICE = torch.device("cpu")
+
+# Centralized PennyLane device configuration
+DEFAULT_QML_DEVICE_NAME = "default.qubit"
+
+def get_qml_device(n_qubits, name=DEFAULT_QML_DEVICE_NAME):
+    """
+    Factory function to create a PennyLane device.
+    Centralizing this allows for easy switching of backends (e.g. to 'lightning.qubit')
+    across the entire library.
+    """
+    return qml.device(name, wires=n_qubits)

qukan-0.1.0/src/qukan/neuron.py

@@ -0,0 +1,118 @@
+import numpy as np
+import pennylane as qml
+import torch
+from torch.nn.functional import silu
+
+from .devices import DEFAULT_TORCH_DEVICE, get_qml_device
+from .splines import encode_bsplines, encode_bsplinesSILU
+
+
+def get_circuit(num_qubits):
+    dev = get_qml_device(num_qubits)
+
+    @qml.qnode(device=dev, interface="torch")
+    def circuit(state, weights):
+        qml.AmplitudeEmbedding(state, wires=range(num_qubits), normalize=True)
+        for layer in range(weights.shape[0]):
+            for qubit in range(weights.shape[1]):
+                qml.RY(phi=weights[layer, qubit], wires=qubit)
+            for qubit in range(weights.shape[1] - 1):
+                qml.CNOT(wires=[qubit, qubit + 1])
+            qml.CNOT(wires=[weights.shape[1] - 1, 0])
+        return qml.probs()
+
+    return circuit
+
+
+def QuKANNeuron(
+    inputs_batch,
+    params,
+    weights,
+    num_splines=4,
+    min_val=0,
+    max_val=1,
+    num_points=64,
+    strat="Mott",
+    state=None,
+    norm=None,
+):
+    # Encoding strategy for the splines
+    if strat == "Mott":
+        state, norm = encode_bsplines(
+            n=num_splines, num_points=num_points, min_v=min_val, max_v=max_val
+        )
+    if strat == "QCBM":
+        state, norm = state, norm
+
+    state.to(dtype=torch.complex64)
+
+    # Adjust interval with the range of the input data
+    if torch.min(inputs_batch) < min_val:
+        min_val = torch.min(inputs_batch)
+    if torch.max(inputs_batch) > max_val:
+        max_val = torch.max(inputs_batch)
+
+    # min_val,max_val = torch.min(inputs_batch),torch.max(inputs_batch)
+    intval = torch.linspace(min_val, max_val, steps=num_points)
+
+    num_qubits = int(np.log2(num_splines * num_points))
+    _circuit = get_circuit(num_qubits)
+    out = _circuit(state, params)
+
+    closest_index = torch.argmin(torch.abs(intval.view(1, -1) - inputs_batch.view(-1, 1)), dim=1)
+    offsets = torch.tensor([i * num_points for i in range(num_splines)])
+    indeces = closest_index.view(-1, 1) + offsets.view(1, -1)
+
+    values = out[indeces]
+    values = values[:, ::2]  # <-- This still needs some changes
+    # values = values[:,1:]
+    qsum = torch.sum(values, dim=1)
+
+    return weights[0] * silu(inputs_batch) + norm * weights[1] * qsum
+
+
+def FQuKANNeuron(
+    inputs_batch,
+    params,
+    weights,
+    num_splines=4,
+    min_val=0,
+    max_val=1,
+    num_points=64,
+    strat="Mott",
+    state=None,
+    norm=None,
+):
+    # Encoding strategy for the splines
+    if strat == "Mott":
+        state, norm = encode_bsplinesSILU(
+            n=num_splines, num_points=num_points, min_v=min_val, max_v=max_val
+        )
+    if strat == "QCBM":
+        state, norm = state, norm
+
+    state.to(dtype=torch.complex64)
+
+    # Adjust interval with the range of the input data
+    if torch.min(inputs_batch) < min_val:
+        min_val = torch.min(inputs_batch)
+    if torch.max(inputs_batch) > max_val:
+        max_val = torch.max(inputs_batch)
+
+    # min_val,max_val = torch.min(inputs_batch),torch.max(inputs_batch)
+    intval = torch.linspace(min_val, max_val, steps=num_points)
+
+    num_qubits = int(np.log2(num_splines * num_points))
+    _circuit = get_circuit(num_qubits)
+    out = _circuit(state, params)
+
+    closest_index = torch.argmin(torch.abs(intval.view(1, -1) - inputs_batch.view(-1, 1)), dim=1)
+    offsets = torch.tensor([i * num_points for i in range(num_splines)])
+    indeces = closest_index.view(-1, 1) + offsets.view(1, -1)
+
+    values = out[indeces]
+    values = values[:, ::2]  # <-- This still needs some changes
+    # values = values[:,1:]
+    qsum = torch.sum(values, dim=1)
+
+    return norm * weights * qsum

qukan-0.1.0/src/qukan/qcbm.py

@@ -0,0 +1,50 @@
+import pennylane as qml
+import torch
+import torch.nn as nn
+from .devices import DEFAULT_TORCH_DEVICE, get_qml_device
+
+class MMD(nn.Module):
+    def __init__(self, scales=None, n_qubits=8):
+        super().__init__()
+        if scales is None:
+            scales = torch.tensor([0.25, 0.5, 1.0])
+        space = torch.arange(2**n_qubits, dtype=torch.float64)
+        gammas = 1.0 / (2.0 * (scales**2))  # RBF kernel widths
+        sq_dists = torch.cdist(space.unsqueeze(1), space.unsqueeze(1), p=2).pow(2)  # shape [n, n]
+        kernel_matrix = sum(torch.exp(-gamma * sq_dists) for gamma in gammas) / len(scales)
+        self.register_buffer("K", kernel_matrix.to(dtype=torch.complex128))
+
+    def k_expval(self, px, py):
+        return px @ self.K @ py
+
+    def forward(self, px, py):
+        px = px / px.sum()
+        py = py / py.sum()
+        return self.k_expval(px - py, px - py).to(dtype=torch.float64)
+    
+def get_circuit(n_qubits):
+    dev = get_qml_device(n_qubits)
+
+    @qml.qnode(device=dev, interface="torch")
+    def circuit(weights):
+        for layer in range(weights.shape[0]):
+            for qubit in range(weights.shape[1]):
+                qml.RY(phi=weights[layer, qubit], wires=qubit)
+            for qubit in range(weights.shape[1] - 1):
+                qml.CNOT(wires=[qubit, qubit + 1])
+            qml.CNOT(wires=[weights.shape[1] - 1, 0])
+        return qml.probs()
+
+    return circuit
+
+
+class QCBM(nn.Module):
+    def __init__(self, n_layers=25, n_qubits=8):
+        super().__init__()
+        self.n_layers = n_layers
+        self.n_qubits = n_qubits
+        self.weights = nn.Parameter(torch.rand(self.n_layers, self.n_qubits))
+        self.circuit = get_circuit(n_qubits)
+
+    def forward(self):
+        return self.circuit(self.weights)

qukan-0.1.0/src/qukan/qukan.py

@@ -0,0 +1,338 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.func import vmap
+
+from .neuron import FQuKANNeuron, QuKANNeuron
+from .splines import trained_splines
+
+
+class QuKAN(nn.Module):
+    def __init__(
+        self,
+        num_hlayers=1,
+        feature_dim=2,
+        circ_layer=3,
+        num_rot=4,
+        num_splines=4,
+        num_points=64,
+        strat="Mott",
+        min_val=0,
+        max_val=1,
+    ):
+        super().__init__()
+        self.feature_dim  = feature_dim
+        self.num_hlayers  = num_hlayers
+        self.circ_layer   = circ_layer
+        self.num_splines  = num_splines
+        self.num_rot = int(np.log2(self.num_splines))
+        self.num_points = num_points
+        self.strat = strat
+        self.state = None
+        self.norm = None
+        if self.strat == 'QCBM':
+            print('Pretraining QCBM ...')
+            self.state, self.norm = trained_splines(
+                n=self.num_splines,
+                min_v=min_val,
+                max_v=max_val,
+                num_points=self.num_points,
+                method="QuKAN",
+            )
+        if self.strat == 'Mott':
+            print('Using Mottonen encoding.')
+
+        # Per-hidden-layer, per-feature params
+        # [L, F, circ_layer, num_rot] and [L, F, 2]
+        self.h_params  = nn.Parameter(torch.rand(num_hlayers, feature_dim, circ_layer, num_rot))
+        self.h_weights = nn.Parameter(torch.rand(num_hlayers, feature_dim, 2) * 0.1)
+
+        # Output head params (global, not tied to a particular feature)
+        self.out_params  = nn.Parameter(torch.rand(circ_layer, num_rot))
+        self.out_weights = nn.Parameter(torch.rand(2) * 0.1)
+
+        # If you really want matmul semantics, keep a ones matrix as a buffer
+        # (not recommended for speed)
+        self.register_buffer("ones_ff", torch.ones(feature_dim, feature_dim))
+
+    def apply_qukan_per_feature(self, H, params_l, weights_l):
+        """
+        H: [B, F]; params_l: [F, circ_layer, num_rot]; weights_l: [F, 2]
+        returns: [B, F]
+        """
+        # Try vectorizing across feature dimension (PyTorch 2.x)
+        try:
+            
+            def neuron(x_1d, p, w):
+                output = QuKANNeuron(
+                    x_1d,
+                    p,
+                    w,
+                    num_splines=self.num_splines,
+                    num_points=self.num_points,
+                    strat=self.strat,
+                    state=self.state,
+                    norm=self.norm,
+                )
+                return output# -> [B]
+            # vmap over features: in_dims (H along dim=1, params/weights along dim=0)
+            #ic(neuron)
+            feats = vmap(neuron, in_dims=(1, 0, 0))(H, params_l, weights_l)  # [F, B]
+            feats_t = feats.transpose(0, 1) 
+            #ic(feats_t)
+            return  feats_t# [B, F]
+        except Exception:
+            # Fallback: Python loop
+            return torch.stack(
+                [
+                    QuKANNeuron(
+                        H[:, i],
+                        params_l[i],
+                        weights_l[i],
+                        num_splines=self.num_splines,
+                        num_points=self.num_points,
+                        strat=self.strat,
+                        state=self.state,
+                        norm=self.norm,
+                    )
+                    for i in range(self.feature_dim)
+                ],
+                dim=1
+            )
+
+    def forward(self, x):
+        """
+        x: [B, F]
+        returns: logits [B, 1]
+        """
+        B, F = x.shape
+        assert self.feature_dim == F, "Input feature_dim mismatch."
+        H = x
+
+        for layer in range(self.num_hlayers):
+            # Featurewise nonlinearity in parallel
+            H = self.apply_qukan_per_feature(H, self.h_params[layer], self.h_weights[layer])
+            #ic(H)
+            #ic(H.shape)
+            # Fixed sum coupling (fast): replicate the sum across all features
+            s = H.sum(dim=1, keepdim=True)         # [B, 1]
+            H = s.expand(-1, self.feature_dim)     # [B, F] view, no copy
+            #ic(H)
+            #ic(H.shape)
+            # If you insist on matmul (slower):
+            # H = H @ self.ones_ff   # O(B·F²)
+
+        # Aggregate to scalar before output neuron
+        out_scalar = H.sum(dim=1)  # use mean for scale stability (sum also works) TAKE A LOOK 
+        logit = QuKANNeuron(
+            out_scalar,
+            self.out_params,
+            self.out_weights,
+            num_splines=self.num_splines,
+            num_points=self.num_points,
+            strat=self.strat,
+            state=self.state,
+            norm=self.norm,
+        )
+        return logit.unsqueeze(1)  # [B,1]
+
+
+
+class FQuKAN(nn.Module):
+    def __init__(
+        self,
+        num_hlayers=1,
+        feature_dim=2,
+        circ_layer=3,
+        num_rot=4,
+        num_splines=4,
+        num_points=64,
+        strat="Mott",
+        min_val=0,
+        max_val=1,
+    ):
+        super().__init__()
+        self.feature_dim  = feature_dim
+        self.num_hlayers  = num_hlayers
+        self.circ_layer   = circ_layer
+        self.num_rot      = num_rot
+        self.num_splines  = num_splines
+        self.num_points = num_points
+        self.strat = strat
+        self.state = None
+        self.norm = None
+        if self.strat == 'QCBM':
+            print('Pretraining QCBM ...')
+            self.state, self.norm = trained_splines(
+                n=self.num_splines,
+                min_v=min_val,
+                max_v=max_val,
+                num_points=self.num_points,
+                method="QuKAN",
+            )
+        if self.strat == 'Mott':
+            print('Using Mottonen encoding.')
+
+        # Per-hidden-layer, per-feature params
+        # [L, F, circ_layer, num_rot] and [L, F, 2]
+        self.h_params  = nn.Parameter(torch.rand(num_hlayers, feature_dim, circ_layer, num_rot))
+        self.h_weights = nn.Parameter(torch.rand(num_hlayers, feature_dim, 1) * 0.1)
+
+        # Output head params (global, not tied to a particular feature)
+        self.out_params  = nn.Parameter(torch.rand(circ_layer, num_rot))
+        self.out_weights = nn.Parameter(torch.rand(1) * 0.1)
+
+        # If you really want matmul semantics, keep a ones matrix as a buffer
+        # (not recommended for speed)
+        self.register_buffer("ones_ff", torch.ones(feature_dim, feature_dim))
+
+    def apply_qukan_per_feature(self, H, params_l, weights_l):
+        """
+        H: [B, F]; params_l: [F, circ_layer, num_rot]; weights_l: [F, 2]
+        returns: [B, F]
+        """
+        # Try vectorizing across feature dimension (PyTorch 2.x)
+        try:
+            
+            def neuron(x_1d, p, w):
+                output = FQuKANNeuron(
+                    x_1d,
+                    p,
+                    w,
+                    num_splines=self.num_splines,
+                    num_points=self.num_points,
+                    strat=self.strat,
+                    state=self.state,
+                    norm=self.norm,
+                )
+                return output# -> [B]
+            # vmap over features: in_dims (H along dim=1, params/weights along dim=0)
+            #ic(neuron)
+            feats = vmap(neuron, in_dims=(1, 0, 0))(H, params_l, weights_l)  # [F, B]
+            feats_t = feats.transpose(0, 1) 
+            #ic(feats_t)
+            return  feats_t# [B, F]
+        except Exception:
+            # Fallback: Python loop
+            return torch.stack(
+                [
+                    FQuKANNeuron(
+                        H[:, i],
+                        params_l[i],
+                        weights_l[i],
+                        num_splines=self.num_splines,
+                        num_points=self.num_points,
+                        strat=self.strat,
+                        state=self.state,
+                        norm=self.norm,
+                    )
+                    for i in range(self.feature_dim)
+                ],
+                dim=1
+            )
+
+    def forward(self, x):
+        """
+        x: [B, F]
+        returns: logits [B, 1]
+        """
+        B, F = x.shape
+        assert self.feature_dim == F, "Input feature_dim mismatch."
+        H = x
+
+        for layer in range(self.num_hlayers):
+            # Featurewise nonlinearity in parallel
+            H = self.apply_qukan_per_feature(H, self.h_params[layer], self.h_weights[layer])
+            #ic(H)
+            #ic(H.shape)
+            # Fixed sum coupling (fast): replicate the sum across all features
+            s = H.sum(dim=1, keepdim=True)         # [B, 1]
+            H = s.expand(-1, self.feature_dim)     # [B, F] view, no copy
+            #ic(H)
+            #ic(H.shape)
+            # If you insist on matmul (slower):
+            # H = H @ self.ones_ff   # O(B·F²)
+
+        # Aggregate to scalar before output neuron
+        out_scalar = H.sum(dim=1)  # use mean for scale stability (sum also works) TAKE A LOOK 
+        logit = FQuKANNeuron(
+            out_scalar,
+            self.out_params,
+            self.out_weights,
+            num_splines=self.num_splines,
+            num_points=self.num_points,
+            strat=self.strat,
+            state=self.state,
+            norm=self.norm,
+        )
+        return logit.unsqueeze(1)  # [B,1]
+    
+
+class GQuKAN(nn.Module):
+    def __init__(self, num_hlayers=1, feature_dim=2, circ_layer=3, num_rot=4, num_splines=4,num_points=64,strat='Mott',min_val=0,max_val=1):
+        super().__init__()
+        self.feature_dim  = feature_dim
+        self.num_hlayers  = num_hlayers
+        self.circ_layer   = circ_layer
+        self.num_rot      = num_rot
+        self.num_splines  = num_splines
+        self.num_points = num_points
+        self.strat = strat
+        self.state = None
+        self.norm = None
+        if self.strat == 'QCBM':
+            print(f'Pretraining QCBM ...')
+            self.state,self.norm = trained_splines(n=self.num_splines,min=min_val,max=max_val,num_points=self.num_points,method='QuKAN')
+        if self.strat == 'Mott':
+            print(f'Using Mottonen encoding.')
+
+        # Per-hidden-layer, per-feature params
+        # [L, F, circ_layer, num_rot] and [L, F, 2]
+        self.h_params  = nn.Parameter(torch.rand(num_hlayers, feature_dim, circ_layer, num_rot))
+        self.h_weights = nn.Parameter(torch.rand(num_hlayers, feature_dim, 2) * 0.1)
+
+        
+        self.register_buffer("ones_ff", torch.ones(feature_dim, feature_dim))
+
+    def apply_qukan_per_feature(self, H, params_l, weights_l):
+        """
+        H: [B, F]; params_l: [F, circ_layer, num_rot]; weights_l: [F, 2]
+        returns: [B, F]
+        """
+        # Try vectorizing across feature dimension (PyTorch 2.x)
+        try:
+            
+            def neuron(x_1d, p, w):
+                output = QuKANNeuron(x_1d, p, w, num_splines=self.num_splines,num_points=self.num_points,strat=self.strat,state=self.state,norm=self.norm)
+                return output# -> [B]
+            # vmap over features: in_dims (H along dim=1, params/weights along dim=0)
+            #ic(neuron)
+            feats = vmap(neuron, in_dims=(1, 0, 0))(H, params_l, weights_l)  # [F, B]
+            feats_t = feats.transpose(0, 1) 
+            #ic(feats_t)
+            return  feats_t# [B, F]
+        except Exception:
+            # Fallback: Python loop
+            return torch.stack(
+                [QuKANNeuron(H[:, i], params_l[i], weights_l[i], num_splines=self.num_splines,num_points=self.num_points,strat=self.strat,state=self.state,norm=self.norm)
+                 for i in range(self.feature_dim)],
+                dim=1
+            )
+
+    def forward(self, x):
+        """
+        x: [B, F]
+        returns: logits [B, 1]
+        """
+        B, F = x.shape
+        assert F == self.feature_dim, "Input feature_dim mismatch."
+        H = x
+
+        for l in range(self.num_hlayers):
+            H = self.apply_qukan_per_feature(H, self.h_params[l], self.h_weights[l])  # [B, F]
+            s = H.sum(dim=1, keepdim=True)         # [B, 1]
+            H = s.expand(-1, self.feature_dim)     # [B, F] view, no copy
+
+        out_scalar = H.sum(dim=1)   
+        return out_scalar.unsqueeze(1)  # [B,1]
+

qukan-0.1.0/src/qukan/splines.py

@@ -0,0 +1,101 @@
+import numpy as np
+import torch
+import torch.optim as optim
+from torch.nn.functional import silu
+from tqdm import tqdm
+
+from .qcbm import MMD, QCBM
+
+from .devices import DEFAULT_TORCH_DEVICE
+
+def bspline_basis_functions(min_val, max_val, n, num_points, deg):
+    x = torch.linspace(min_val, max_val, num_points, device=DEFAULT_TORCH_DEVICE)
+
+    # Number of knots needed
+    num_knots = n + deg + 1
+    knot_vector = torch.linspace(min_val, max_val, num_knots, device=DEFAULT_TORCH_DEVICE)
+
+    # Recursive Cox–de Boor function
+    def cox_de_boor(x, i, k, knots):
+        if k == 0:
+            return ((x >= knots[i]) & (x < knots[i + 1])).float()
+        else:
+            denom1 = knots[i + k] - knots[i]
+            denom2 = knots[i + k + 1] - knots[i + 1]
+
+            term1 = 0.0
+            if denom1 != 0:
+                term1 = (x - knots[i]) / denom1 * cox_de_boor(x, i, k - 1, knots)
+
+            term2 = 0.0
+            if denom2 != 0:
+                term2 = (knots[i + k + 1] - x) / denom2 * cox_de_boor(x, i + 1, k - 1, knots)
+
+            return term1 + term2
+
+    # Stack basis functions
+    basis = torch.stack([cox_de_boor(x, i, deg, knot_vector) for i in range(n)], dim=0)
+    return x, basis
+
+def encode_bsplines(n, deg=3, min_v=0, max_v=1, num_points=64):
+    x, basis = bspline_basis_functions(
+        min_val=min_v, max_val=max_v, n=n, num_points=num_points, deg=deg
+    )
+    res = torch.zeros(n*num_points,dtype=torch.complex64)
+    for i in range(n):
+        res += torch.kron(torch.eye(n,dtype=torch.complex64)[:,i],basis[i])
+    norm = torch.norm(res)
+    res /= norm
+    return res,norm
+
+
+
+def trained_splines(
+    epochs=100,
+    n_layers=20,
+    n=4,
+    deg=3,
+    min_v=0,
+    max_v=1,
+    num_points=64,
+    method="QuKAN",
+):
+    n_qubits = int(np.log2(n)) + int(np.log2(num_points))
+    model = QCBM(n_qubits=n_qubits)
+    criterion = MMD(n_qubits=n_qubits)
+    optimizer = optim.Adam(model.parameters(), lr=0.1)
+
+    if method == "QuKAN":
+        data, norm = encode_bsplines(
+            n=n, deg=deg, min_v=min_v, max_v=max_v, num_points=num_points
+        )
+    if method == "FQuKAN":
+        data, norm = encode_bsplinesSILU(
+            n=n, deg=deg, min_v=min_v, max_v=max_v, num_points=num_points
+        )
+
+    for _ in tqdm(range(epochs)):
+        optimizer.zero_grad()
+        output = model()
+        loss = criterion(output,data)
+        loss.backward()
+        optimizer.step()
+    
+    output = model().detach()
+    output = 1/torch.norm(output) * output
+    return output,norm
+    
+
+def encode_bsplinesSILU(n, deg=3, min_v=0, max_v=1, num_points=64):
+    x, basis = bspline_basis_functions(
+        min_val=min_v, max_val=max_v, n=n, num_points=num_points, deg=deg
+    )
+    Si = silu(x)
+    res = torch.zeros(n * num_points, dtype=torch.complex64)
+    for i in range(n - 1):
+        res += torch.kron(torch.eye(n, dtype=torch.complex64)[:, i], basis[i])
+    res += torch.kron(torch.eye(n, dtype=torch.complex64)[:, -1], Si)
+    norm = torch.norm(res)
+    res /= norm
+    return res, norm
+