oikan 0.0.1__py3-none-any.whl

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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,9 @@
+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,,

oikan-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

oikan-0.0.1.dist-info/top_level.txt

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