oikan 0.0.1__tar.gz

oikan-0.0.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.2
+Name: oikan
+Version: 0.0.1
+Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
+Author: Arman Zhalgasbayev
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: sympy
+Requires-Dist: scipy
+Requires-Dist: matplotlib

oikan-0.0.1/README.md

@@ -0,0 +1,48 @@
+# OIKAN Library
+
+[![PyPI version](https://badge.fury.io/py/oikan.svg)](https://badge.fury.io/py/oikan)
+[![PyPI downloads](https://img.shields.io/pypi/dm/oikan.svg)](https://pypistats.org/packages/oikan)
+
+OIKAN (Optimized Implementation of Kolmogorov-Arnold Networks) is a PyTorch-based library for creating interpretable neural networks. It implements the KAN architecture to provide both accurate predictions and interpretable results.
+
+## Key Features
+
+- EfficientKAN layer implementation
+- Built-in visualization tools
+- Support for both regression and classification tasks
+- Symbolic formula extraction
+- Easy-to-use training interface
+
+## Installation
+
+```bash
+git clone https://github.com/silvermete0r/OIKAN.git
+cd OIKAN
+pip install -r requirements.txt
+```
+
+## Quick Start
+
+### Regression Example
+```python
+from oikan.model import OIKAN
+from oikan.trainer import train
+
+# Create and train model
+model = OIKAN(input_dim=2, output_dim=1)
+train(model, train_loader)
+
+# Extract interpretable formula
+formula = extract_symbolic_formula_regression(model, X)
+```
+
+### Classification Example
+```python
+model = OIKAN(input_dim=2, output_dim=2)
+train_classification(model, train_loader)
+visualize_classification(model, X, y)
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

oikan-0.0.1/oikan/model.py

@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+
+# EfficientKAN Layer
+class EfficientKAN(nn.Module):
+    def __init__(self, input_dim, hidden_units=10):
+        super(EfficientKAN, self).__init__()
+        self.basis_functions = nn.ModuleList([nn.Linear(1, hidden_units) for _ in range(input_dim)])
+        self.activations = nn.ReLU()
+    
+    def forward(self, x):
+        transformed_features = [self.activations(bf(x[:, i].unsqueeze(1))) for i, bf in enumerate(self.basis_functions)]
+        return torch.cat(transformed_features, dim=1)
+
+# OIKAN Model
+class OIKAN(nn.Module):
+    def __init__(self, input_dim, output_dim, hidden_units=10):
+        super(OIKAN, self).__init__()
+        self.efficientkan = EfficientKAN(input_dim, hidden_units)
+        self.mlp = nn.Sequential(
+            nn.Linear(input_dim * hidden_units, 32),
+            nn.ReLU(),
+            nn.Linear(32, output_dim)
+        )
+    
+    def forward(self, x):
+        transformed_x = self.efficientkan(x)
+        return self.mlp(transformed_x)

oikan-0.0.1/oikan/symbolic.py

@@ -0,0 +1,36 @@
+import torch
+from sympy import symbols, simplify, Add
+
+# Regression symbolic extraction
+def extract_symbolic_formula_regression(model, input_data):
+    symbolic_vars = symbols([f'x{i}' for i in range(input_data.shape[1])])
+    
+    with torch.no_grad():
+        weights = model.mlp[0].weight.cpu().numpy()
+        if weights.size == 0:
+            print("Warning: Extracted weights are empty.")
+            return "NaN"
+
+    formula = sum(weights[0, i] * symbolic_vars[i] for i in range(len(symbolic_vars)))
+    return simplify(formula)
+
+# Classification symbolic extraction
+def extract_symbolic_formula_classification(model, input_data):
+    """
+    Extracts a symbolic decision boundary for a two-class classifier.
+    Approximates:
+      decision = (w[0] - w[1]) · x + (b[0] - b[1])
+    where w and b are from the model's final linear layer.
+    """
+    symbolic_vars = symbols([f'x{i}' for i in range(input_data.shape[1])])
+    with torch.no_grad():
+        final_layer = model.mlp[-1]
+        w = final_layer.weight.cpu().numpy()
+        b = final_layer.bias.cpu().numpy()
+        if w.shape[0] < 2:
+            print("Classification symbolic extraction requires at least 2 classes.")
+            return "NaN"
+        w_diff = w[0] - w[1]
+        b_diff = b[0] - b[1]
+    formula = sum(w_diff[i] * symbolic_vars[i] for i in range(len(symbolic_vars))) + b_diff
+    return simplify(formula)

oikan-0.0.1/oikan/trainer.py

@@ -0,0 +1,34 @@
+import torch.optim as optim
+import torch.nn as nn
+
+# Regression training
+def train(model, train_loader, epochs=100, lr=0.01):
+    criterion = nn.MSELoss()
+    optimizer = optim.LBFGS(model.parameters(), lr=lr)
+
+    def closure():
+        optimizer.zero_grad()
+        outputs = model(train_loader[0])
+        loss = criterion(outputs, train_loader[1])
+        loss.backward()
+        print(f"Loss: {loss.item()}")
+        return loss
+
+    for epoch in range(epochs):
+        optimizer.step(closure)
+        if epoch % 10 == 0:
+            print(f"Epoch {epoch+1}/{epochs}")
+        
+# Classification training
+def train_classification(model, train_loader, epochs=100, lr=0.01):
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=lr)
+    
+    for epoch in range(epochs):
+        optimizer.zero_grad()
+        outputs = model(train_loader[0])
+        loss = criterion(outputs, train_loader[1])
+        loss.backward()
+        optimizer.step()
+        if (epoch + 1) % 10 == 0:
+            print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.item()}")

oikan-0.0.1/oikan/visualize.py

@@ -0,0 +1,20 @@
+import matplotlib.pyplot as plt
+import torch
+
+# Regression Visualization Function
+def visualize_regression(model, X, y):
+    with torch.no_grad():
+        y_pred = model(torch.tensor(X, dtype=torch.float32)).numpy()
+    plt.scatter(X[:, 0], y, label='True Data')
+    plt.scatter(X[:, 0], y_pred, label='OIKAN Predictions', color='r')
+    plt.legend()
+    plt.show()
+
+# Classification visualization
+def visualize_classification(model, X, y):
+    with torch.no_grad():
+        outputs = model(torch.tensor(X, dtype=torch.float32))
+        preds = torch.argmax(outputs, dim=1).numpy()
+    plt.scatter(X[:, 0], X[:, 1], c=preds, cmap='viridis', edgecolor='k')
+    plt.title("Classification Results")
+    plt.show()

oikan-0.0.1/oikan.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.2
+Name: oikan
+Version: 0.0.1
+Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
+Author: Arman Zhalgasbayev
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: sympy
+Requires-Dist: scipy
+Requires-Dist: matplotlib

oikan-0.0.1/oikan.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+oikan/__init__.py
+oikan/model.py
+oikan/symbolic.py
+oikan/trainer.py
+oikan/visualize.py
+oikan.egg-info/PKG-INFO
+oikan.egg-info/SOURCES.txt
+oikan.egg-info/dependency_links.txt
+oikan.egg-info/requires.txt
+oikan.egg-info/top_level.txt

oikan-0.0.1/oikan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

oikan-0.0.1/oikan.egg-info/requires.txt

@@ -0,0 +1,5 @@
+torch
+numpy
+sympy
+scipy
+matplotlib

oikan-0.0.1/oikan.egg-info/top_level.txt

@@ -0,0 +1 @@
+oikan

oikan-0.0.1/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oikan"
+version = "0.0.1"
+description = "OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks"
+authors = [{name = "Arman Zhalgasbayev"}]
+dependencies = [
+    "torch",
+    "numpy",
+    "sympy",
+    "scipy",
+    "matplotlib"
+]

oikan-0.0.1/setup.cfg

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