oikan 0.0.2.4__tar.gz → 0.0.2.5__tar.gz

{oikan-0.0.2.4 → oikan-0.0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oikan
-Version: 0.0.2.4
+Version: 0.0.2.5
 Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
 Author: Arman Zhalgasbayev
 License: MIT
@@ -66,6 +66,17 @@ OIKAN implements the Kolmogorov-Arnold Representation Theorem through a novel ne
            return combine_weighted_outputs(edge_outputs, self.weights)
    ```
 
+3. **Basis functions**
+```python
+# Edge activation contains interpretable basis functions
+ADVANCED_LIB = {
+      'x': (lambda x: x),          # Linear
+      'x^2': (lambda x: x**2),     # Quadratic
+      'sin(x)': np.sin,            # Periodic
+      'tanh(x)': np.tanh          # Bounded
+}
+```
+
 ## Quick Start
 
 ### Installation
@@ -126,36 +137,6 @@ model.save_symbolic_formula("classification_formula.txt")
 
 *Example of the saved symbolic formula instructions: [outputs/classification_symbolic_formula.txt](outputs/classification_symbolic_formula.txt)*
 
-
-### Key Design Principles
-
-1. **Interpretability by Design**
-   ```python
-   # Edge activation contains interpretable basis functions
-   ADVANCED_LIB = {
-       'x': (lambda x: x),          # Linear
-       'x^2': (lambda x: x**2),     # Quadratic
-       'sin(x)': np.sin,            # Periodic
-       'tanh(x)': np.tanh          # Bounded
-   }
-   ```
-
-2. **Automatic Simplification**
-   ```python
-   def simplify_formula(terms, threshold=1e-4):
-       return [term for term in terms if abs(term.coefficient) > threshold]
-   ```
-
-3. **Research-Oriented Architecture**
-   ```python
-   class SymbolicEdge:
-       def forward(self, x):
-           return sum(w * f(x) for w, f in zip(self.weights, self.basis_functions))
-           
-       def get_formula(self):
-           return format_symbolic_terms(self.weights, self.basis_functions)
-   ```
-
 ### Architecture Diagram
 
 ![Architecture Diagram](https://raw.githubusercontent.com/silvermete0r/oikan/main/docs/media/oikan_model_architecture_v0.0.2.2.png)

{oikan-0.0.2.4 → oikan-0.0.2.5}/README.md

@@ -49,6 +49,17 @@ OIKAN implements the Kolmogorov-Arnold Representation Theorem through a novel ne
            return combine_weighted_outputs(edge_outputs, self.weights)
    ```
 
+3. **Basis functions**
+```python
+# Edge activation contains interpretable basis functions
+ADVANCED_LIB = {
+      'x': (lambda x: x),          # Linear
+      'x^2': (lambda x: x**2),     # Quadratic
+      'sin(x)': np.sin,            # Periodic
+      'tanh(x)': np.tanh          # Bounded
+}
+```
+
 ## Quick Start
 
 ### Installation
@@ -109,36 +120,6 @@ model.save_symbolic_formula("classification_formula.txt")
 
 *Example of the saved symbolic formula instructions: [outputs/classification_symbolic_formula.txt](outputs/classification_symbolic_formula.txt)*
 
-
-### Key Design Principles
-
-1. **Interpretability by Design**
-   ```python
-   # Edge activation contains interpretable basis functions
-   ADVANCED_LIB = {
-       'x': (lambda x: x),          # Linear
-       'x^2': (lambda x: x**2),     # Quadratic
-       'sin(x)': np.sin,            # Periodic
-       'tanh(x)': np.tanh          # Bounded
-   }
-   ```
-
-2. **Automatic Simplification**
-   ```python
-   def simplify_formula(terms, threshold=1e-4):
-       return [term for term in terms if abs(term.coefficient) > threshold]
-   ```
-
-3. **Research-Oriented Architecture**
-   ```python
-   class SymbolicEdge:
-       def forward(self, x):
-           return sum(w * f(x) for w, f in zip(self.weights, self.basis_functions))
-           
-       def get_formula(self):
-           return format_symbolic_terms(self.weights, self.basis_functions)
-   ```
-
 ### Architecture Diagram
 
 ![Architecture Diagram](https://raw.githubusercontent.com/silvermete0r/oikan/main/docs/media/oikan_model_architecture_v0.0.2.2.png)

{oikan-0.0.2.4 → oikan-0.0.2.5}/oikan/model.py

@@ -196,30 +196,51 @@ class BaseOIKAN(BaseEstimator):
     def _eval_formula(self, formula, x):
         """Helper to evaluate a symbolic formula for an input vector x using ADVANCED_LIB basis functions."""
         import re
-        total = 0
+        from .utils import ensure_tensor  
+        
+        if isinstance(x, (list, tuple)):
+            x = np.array(x)
+        
+        total = torch.zeros_like(ensure_tensor(x))
         pattern = re.compile(r"(-?\d+\.\d+)\*?([\w\(\)\^]+)")
         matches = pattern.findall(formula)
+        
         for coef_str, func_name in matches:
             try:
                 coef = float(coef_str)
                 for key, (notation, func) in ADVANCED_LIB.items():
                     if notation.strip() == func_name.strip():
-                        total += coef * func(x)
+                        result = func(x)
+                        if isinstance(result, torch.Tensor):
+                            total += coef * result
+                        else:
+                            total += coef * ensure_tensor(result)
                         break
-            except Exception:
+            except Exception as e:
+                print(f"Warning: Error evaluating term {coef_str}*{func_name}: {str(e)}")
                 continue
-        return total
+        
+        return total.cpu().numpy() if isinstance(total, torch.Tensor) else total
 
     def symbolic_predict(self, X):
         """Predict using only the extracted symbolic formula (regressor)."""
         if not self._is_fitted:
             raise NotFittedError("Model must be fitted before prediction")
+        
         X = np.array(X) if not isinstance(X, np.ndarray) else X
-        formulas = self.get_symbolic_formula()  # For regressor: list of formula strings.
+        formulas = self.get_symbolic_formula()
         predictions = np.zeros((X.shape[0], 1))
-        for i, formula in enumerate(formulas):
-            x = X[:, i]
-            predictions[:, 0] += self._eval_formula(formula, x)
+        
+        try:
+            for i, formula in enumerate(formulas):
+                x = X[:, i]
+                pred = self._eval_formula(formula, x)
+                if isinstance(pred, torch.Tensor):
+                    pred = pred.cpu().numpy()
+                predictions[:, 0] += pred
+        except Exception as e:
+            raise RuntimeError(f"Error in symbolic prediction: {str(e)}")
+            
         return predictions
 
     def compile_symbolic_formula(self, filename="output/final_symbolic_formula.txt"):

{oikan-0.0.2.4 → oikan-0.0.2.5}/oikan/utils.py

@@ -3,35 +3,47 @@ import torch
 import torch.nn as nn
 import numpy as np
 
+def ensure_tensor(x):
+    """Helper function to ensure input is a PyTorch tensor."""
+    if isinstance(x, np.ndarray):
+        return torch.from_numpy(x).float()
+    elif isinstance(x, (int, float)):
+        return torch.tensor([x], dtype=torch.float32)
+    elif isinstance(x, torch.Tensor):
+        return x.float()
+    else:
+        raise ValueError(f"Unsupported input type: {type(x)}")
+
+# Updated to handle numpy arrays and scalars
 ADVANCED_LIB = {
-    'x':    ('x', lambda x: x),
-    'x^2':  ('x^2', lambda x: x**2),
-    'sin':  ('sin(x)', lambda x: np.sin(x)),
-    'tanh': ('tanh(x)', lambda x: np.tanh(x))
+    'x': ('x', lambda x: ensure_tensor(x)),
+    'x^2': ('x^2', lambda x: torch.pow(ensure_tensor(x), 2)),
+    'sin': ('sin(x)', lambda x: torch.sin(ensure_tensor(x))),
+    'tanh': ('tanh(x)', lambda x: torch.tanh(ensure_tensor(x)))
 }
 
 class EdgeActivation(nn.Module):
-    """Learnable edge-based activation function."""
+    """Learnable edge-based activation function with improved gradient flow."""
     def __init__(self):
         super().__init__()
         self.weights = nn.Parameter(torch.randn(len(ADVANCED_LIB)))
         self.bias = nn.Parameter(torch.zeros(1))
         
     def forward(self, x):
+        x_tensor = ensure_tensor(x)
         features = []
         for _, func in ADVANCED_LIB.values():
-            feat = torch.tensor(func(x.detach().cpu().numpy()), 
-                              dtype=torch.float32).to(x.device)
+            feat = func(x_tensor)
             features.append(feat)
         features = torch.stack(features, dim=-1)
         return torch.matmul(features, self.weights.unsqueeze(0).T) + self.bias
     
     def get_symbolic_repr(self, threshold=1e-4):
         """Get symbolic representation of the activation function."""
+        weights_np = self.weights.detach().cpu().numpy()
         significant_terms = []
         
-        for (notation, _), weight in zip(ADVANCED_LIB.values(), 
-                                       self.weights.detach().cpu().numpy()):
+        for (notation, _), weight in zip(ADVANCED_LIB.values(), weights_np):
             if abs(weight) > threshold:
                 significant_terms.append(f"{weight:.4f}*{notation}")
                 

{oikan-0.0.2.4 → oikan-0.0.2.5}/oikan.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oikan
-Version: 0.0.2.4
+Version: 0.0.2.5
 Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
 Author: Arman Zhalgasbayev
 License: MIT
@@ -66,6 +66,17 @@ OIKAN implements the Kolmogorov-Arnold Representation Theorem through a novel ne
            return combine_weighted_outputs(edge_outputs, self.weights)
    ```
 
+3. **Basis functions**
+```python
+# Edge activation contains interpretable basis functions
+ADVANCED_LIB = {
+      'x': (lambda x: x),          # Linear
+      'x^2': (lambda x: x**2),     # Quadratic
+      'sin(x)': np.sin,            # Periodic
+      'tanh(x)': np.tanh          # Bounded
+}
+```
+
 ## Quick Start
 
 ### Installation
@@ -126,36 +137,6 @@ model.save_symbolic_formula("classification_formula.txt")
 
 *Example of the saved symbolic formula instructions: [outputs/classification_symbolic_formula.txt](outputs/classification_symbolic_formula.txt)*
 
-
-### Key Design Principles
-
-1. **Interpretability by Design**
-   ```python
-   # Edge activation contains interpretable basis functions
-   ADVANCED_LIB = {
-       'x': (lambda x: x),          # Linear
-       'x^2': (lambda x: x**2),     # Quadratic
-       'sin(x)': np.sin,            # Periodic
-       'tanh(x)': np.tanh          # Bounded
-   }
-   ```
-
-2. **Automatic Simplification**
-   ```python
-   def simplify_formula(terms, threshold=1e-4):
-       return [term for term in terms if abs(term.coefficient) > threshold]
-   ```
-
-3. **Research-Oriented Architecture**
-   ```python
-   class SymbolicEdge:
-       def forward(self, x):
-           return sum(w * f(x) for w, f in zip(self.weights, self.basis_functions))
-           
-       def get_formula(self):
-           return format_symbolic_terms(self.weights, self.basis_functions)
-   ```
-
 ### Architecture Diagram
 
 ![Architecture Diagram](https://raw.githubusercontent.com/silvermete0r/oikan/main/docs/media/oikan_model_architecture_v0.0.2.2.png)

{oikan-0.0.2.4 → oikan-0.0.2.5}/oikan.egg-info/SOURCES.txt

@@ -5,7 +5,6 @@ setup.py
 oikan/__init__.py
 oikan/exceptions.py
 oikan/model.py
-oikan/symbolic.py
 oikan/utils.py
 oikan.egg-info/PKG-INFO
 oikan.egg-info/SOURCES.txt

{oikan-0.0.2.4 → oikan-0.0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oikan"
-version = "0.0.2.4"
+version = "0.0.2.5"
 description = "OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks"
 authors = [{name = "Arman Zhalgasbayev"}]
 dependencies = [

oikan-0.0.2.4/oikan/symbolic.py

@@ -1,28 +0,0 @@
-from .utils import ADVANCED_LIB
-
-def symbolic_edge_repr(weights, bias=None, threshold=1e-4):
-    """
-    Given a list of weights (floats) and an optional bias,
-    returns a list of structured terms (coefficient, basis function string).
-    """
-    terms = []
-    # weights should be in the same order as ADVANCED_LIB.items()
-    for (_, (notation, _)), w in zip(ADVANCED_LIB.items(), weights):
-        if abs(w) > threshold:
-            terms.append((w, notation))
-    if bias is not None and abs(bias) > threshold:
-        # use "1" to represent the constant term
-        terms.append((bias, "1"))
-    return terms
-
-def format_symbolic_terms(terms):
-    """
-    Formats a list of structured symbolic terms (coef, basis) to a string.
-    """
-    formatted_terms = []
-    for coef, basis in terms:
-        if basis == "1":
-            formatted_terms.append(f"{coef:.4f}")
-        else:
-            formatted_terms.append(f"{coef:.4f}*{basis}")
-    return " + ".join(formatted_terms) if formatted_terms else "0"