oikan 0.0.1__py3-none-any.whl → 0.0.1.2__py3-none-any.whl

oikan/model.py

@@ -1,28 +1,65 @@
 import torch
 import torch.nn as nn
+from .utils import BSplineBasis, FourierBasis
+
+class AdaptiveBasisLayer(nn.Module):
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.weights = nn.Parameter(torch.randn(input_dim, hidden_dim))
+        self.bias = nn.Parameter(torch.zeros(hidden_dim))
+    
+    def forward(self, x):
+        return torch.matmul(x, self.weights) + self.bias
 
-# 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 __init__(self, input_dim, hidden_units=10, basis_type='bspline'):
+        super().__init__()
+        self.input_dim = input_dim
+        self.hidden_units = hidden_units
+        self.basis_type = basis_type
+        
+        if basis_type == 'bspline':
+            self.basis_functions = nn.ModuleList([BSplineBasis(hidden_units) for _ in range(input_dim)])
+            self.basis_output_dim = input_dim * (hidden_units - 4)  # Adjusted for BSpline output
+        elif basis_type == 'fourier':
+            self.basis_functions = nn.ModuleList([FourierBasis(hidden_units//2) for _ in range(input_dim)])
+            self.basis_output_dim = input_dim * hidden_units
+            
+        # Grid-based interaction layer
+        self.interaction_weights = nn.Parameter(torch.randn(input_dim, input_dim))
     
     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)
+        # Transform each feature using basis functions
+        transformed_features = [bf(x[:, i].unsqueeze(1)) for i, bf in enumerate(self.basis_functions)]
+        basis_output = torch.cat(transformed_features, dim=1)
+        
+        # Compute feature interactions - fixed matrix multiplication
+        batch_size = x.size(0)
+        x_reshaped = x.view(batch_size, self.input_dim, 1)  # [batch_size, input_dim, 1]
+        interaction_matrix = torch.sigmoid(self.interaction_weights)  # [input_dim, input_dim]
+        interaction_features = torch.bmm(x_reshaped.transpose(1, 2), 
+                                       x_reshaped * interaction_matrix.unsqueeze(0))  # [batch_size, 1, 1]
+        interaction_features = interaction_features.view(batch_size, -1)  # [batch_size, 1]
+        
+        return torch.cat([basis_output, interaction_features], dim=1)
+    
+    def get_output_dim(self):
+        return self.basis_output_dim + self.input_dim
 
-# OIKAN Model
 class OIKAN(nn.Module):
     def __init__(self, input_dim, output_dim, hidden_units=10):
-        super(OIKAN, self).__init__()
+        super().__init__()
         self.efficientkan = EfficientKAN(input_dim, hidden_units)
-        self.mlp = nn.Sequential(
-            nn.Linear(input_dim * hidden_units, 32),
+        
+        # Get actual feature dimension after transformation
+        feature_dim = self.efficientkan.get_output_dim()
+        
+        self.interpretable_layers = nn.Sequential(
+            AdaptiveBasisLayer(feature_dim, 32),
             nn.ReLU(),
-            nn.Linear(32, output_dim)
+            AdaptiveBasisLayer(32, output_dim)
         )
     
     def forward(self, x):
         transformed_x = self.efficientkan(x)
-        return self.mlp(transformed_x)
+        return self.interpretable_layers(transformed_x)

oikan/regularization.py

@@ -0,0 +1,30 @@
+import torch
+import torch.nn as nn
+
+class RegularizedLoss:
+    def __init__(self, base_criterion, model, l1_lambda=0.01, gradient_lambda=0.01):
+        self.base_criterion = base_criterion
+        self.model = model
+        self.l1_lambda = l1_lambda
+        self.gradient_lambda = gradient_lambda
+    
+    def __call__(self, pred, target, inputs):
+        base_loss = self.base_criterion(pred, target)
+        
+        # L1 regularization
+        l1_loss = 0
+        for param in self.model.parameters():
+            l1_loss += torch.norm(param, p=1)
+            
+        # Gradient penalty
+        grad_penalty = 0
+        inputs.requires_grad_(True)
+        outputs = self.model(inputs)
+        gradients = torch.autograd.grad(
+            outputs=outputs.sum(),
+            inputs=inputs,
+            create_graph=True
+        )[0]
+        grad_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
+        
+        return base_loss + self.l1_lambda * l1_loss + self.gradient_lambda * grad_penalty

oikan/symbolic.py

@@ -1,36 +1,21 @@
 import torch
-from sympy import symbols, simplify, Add
+import numpy as np
 
-# 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])])
-    
+def extract_symbolic_formula_regression(model, X):
+    """Simple coefficient-based formula extraction"""
+    model.eval()
     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)
+        # Get weights from the first adaptive layer
+        weights = model.interpretable_layers[0].weights.numpy()
+        # Simplified representation
+        terms = []
+        for i in range(X.shape[1]):
+            coef = np.abs(weights[i]).mean()
+            if coef > 0.1:  # threshold for significance
+                terms.append(f"{coef:.2f}*x{i+1}")
+    
+    return " + ".join(terms) if terms else "0"
 
-# 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)
+def extract_symbolic_formula_classification(model, X):
+    """Extract classification boundary formula"""
+    return extract_symbolic_formula_regression(model, X) + " = 0"

oikan/trainer.py

@@ -1,34 +1,37 @@
-import torch.optim as optim
+import torch
 import torch.nn as nn
+from .regularization import RegularizedLoss
 
-# Regression training
-def train(model, train_loader, epochs=100, lr=0.01):
+def train(model, train_data, epochs=100, lr=0.01):
+    X_train, y_train = train_data
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
     criterion = nn.MSELoss()
-    optimizer = optim.LBFGS(model.parameters(), lr=lr)
-
-    def closure():
+    reg_loss = RegularizedLoss(criterion, model)
+    
+    model.train()
+    for epoch in range(epochs):
         optimizer.zero_grad()
-        outputs = model(train_loader[0])
-        loss = criterion(outputs, train_loader[1])
+        outputs = model(X_train)
+        loss = reg_loss(outputs, y_train, X_train)
         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}")
+        optimizer.step()
         
-# Classification training
-def train_classification(model, train_loader, epochs=100, lr=0.01):
+        if (epoch + 1) % 10 == 0:
+            print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
+
+def train_classification(model, train_data, epochs=100, lr=0.01):
+    X_train, y_train = train_data
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
     criterion = nn.CrossEntropyLoss()
-    optimizer = optim.Adam(model.parameters(), lr=lr)
+    reg_loss = RegularizedLoss(criterion, model)
     
+    model.train()
     for epoch in range(epochs):
         optimizer.zero_grad()
-        outputs = model(train_loader[0])
-        loss = criterion(outputs, train_loader[1])
+        outputs = model(X_train)
+        loss = reg_loss(outputs, y_train, X_train)
         loss.backward()
         optimizer.step()
+        
         if (epoch + 1) % 10 == 0:
-            print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.item()}")
+            print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')

oikan/utils.py

@@ -0,0 +1,43 @@
+import torch
+import torch.nn as nn
+import numpy as np
+from scipy.interpolate import BSpline
+
+class BSplineBasis(nn.Module):
+    def __init__(self, num_knots=10, degree=3):
+        super().__init__()
+        self.num_knots = max(num_knots, degree + 5)  # Ensure minimum number of knots
+        self.degree = degree
+        
+        # Create knot vector with proper padding
+        inner_knots = np.linspace(0, 1, self.num_knots - 2 * degree)
+        left_pad = np.zeros(degree)
+        right_pad = np.ones(degree)
+        knots = np.concatenate([left_pad, inner_knots, right_pad])
+        
+        self.register_buffer('knots', torch.FloatTensor(knots))
+        
+    def forward(self, x):
+        x_np = x.detach().cpu().numpy()
+        basis_values = np.zeros((x_np.shape[0], self.num_knots - self.degree - 1))
+        
+        # Normalize input to [0,1] range
+        x_normalized = (x_np - x_np.min()) / (x_np.max() - x_np.min() + 1e-8)
+        
+        for i in range(self.num_knots - self.degree - 1):
+            spl = BSpline.basis_element(self.knots[i:i+self.degree+2])
+            basis_values[:, i] = spl(x_normalized.squeeze())
+        
+        # Replace NaN values with 0
+        basis_values = np.nan_to_num(basis_values, 0)
+        return torch.FloatTensor(basis_values).to(x.device)
+
+class FourierBasis(nn.Module):
+    def __init__(self, num_frequencies=5):
+        super().__init__()
+        self.num_frequencies = num_frequencies
+        
+    def forward(self, x):
+        frequencies = torch.arange(1, self.num_frequencies + 1, device=x.device).float()
+        x_expanded = x * frequencies.view(1, -1) * 2 * np.pi
+        return torch.cat([torch.sin(x_expanded), torch.cos(x_expanded)], dim=1)

oikan/visualize.py

@@ -1,20 +1,37 @@
+import numpy as np
 import matplotlib.pyplot as plt
 import torch
 
-# Regression Visualization Function
 def visualize_regression(model, X, y):
+    model.eval()
     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')
+        X_tensor = torch.FloatTensor(X)
+        y_pred = model(X_tensor).numpy()
+    
+    plt.figure(figsize=(10, 6))
+    plt.scatter(X[:, 0], y, color='blue', label='True')
+    plt.scatter(X[:, 0], y_pred, color='red', label='Predicted')
     plt.legend()
     plt.show()
 
-# Classification visualization
 def visualize_classification(model, X, y):
+    model.eval()
+    
+    # Create a mesh grid
+    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
+    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
+    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
+                        np.linspace(y_min, y_max, 100))
+    
+    # Make predictions
     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")
+        X_grid = torch.FloatTensor(np.c_[xx.ravel(), yy.ravel()])
+        Z = model(X_grid)
+        Z = torch.argmax(Z, dim=1).numpy()
+        Z = Z.reshape(xx.shape)
+    
+    # Plot
+    plt.figure(figsize=(10, 8))
+    plt.contourf(xx, yy, Z, alpha=0.4)
+    plt.scatter(X[:, 0], X[:, 1], c=y, alpha=0.8)
     plt.show()

oikan-0.0.1.2.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.2
+Name: oikan
+Version: 0.0.1.2
+Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
+Author: Arman Zhalgasbayev
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: sympy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+
+# 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 -e .  # Install in development mode
+```
+
+## 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.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oikan/model.py,sha256=9_U3jh1YwASbLOgHpFm4F80J3QGEhzIgQHNkqbZCPJs,2920
+oikan/regularization.py,sha256=D0Xc2lr5X5ORdA5ltvWDbNDuN8z0hkyoGzFo7pum2XE,1033
+oikan/symbolic.py,sha256=a2W-D_KH7jtcdS1NjXEXQykt11cvCRcfT41th2Dq_is,786
+oikan/trainer.py,sha256=itFCHSR_T6KHqa0D5RLRCmqFHa4lUIamsFGWKHmUZuI,1258
+oikan/utils.py,sha256=XwY6pgAgfYlUI9SOjdop91wh0_t6LfPLCiHretlw2Wg,1754
+oikan/visualize.py,sha256=8Dlk-tsqGZb63NyZBpZsLSlcsC51m2nXblQaS2Jf1y0,1142
+oikan-0.0.1.2.dist-info/METADATA,sha256=7JYAgeNO_Y6Sl_D9tjZSJ8B5Cu1cc-AdcfxEWqQ0ImU,1872
+oikan-0.0.1.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+oikan-0.0.1.2.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.1.2.dist-info/RECORD,,

oikan-0.0.1.dist-info/METADATA

@@ -1,10 +0,0 @@
-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.dist-info/RECORD

@@ -1,9 +0,0 @@
-oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oikan/model.py,sha256=LTWlXTlmeTwNe70Q7vjGOG6MUukCuWoHryvHB_yPzjc,1035
-oikan/symbolic.py,sha256=QjNGWU6LpPzZ35b-WYmSEYPM5FH9tKMS5pKgCujFd64,1431
-oikan/trainer.py,sha256=4CWcBCRLhMXEtnEevVt2qe3lNXzoS0HUH6weHE2GwUw,1111
-oikan/visualize.py,sha256=J58pbWYaqV5vWkkRNUem0Jse5gHjQ-rRDKQDPIJouW0,729
-oikan-0.0.1.dist-info/METADATA,sha256=zNk3LtgHe5TIYBy49l4t5tYDgQdUOHu0Jh1a56bTym4,263
-oikan-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-oikan-0.0.1.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.1.dist-info/RECORD,,