oikan 0.0.2.2__py3-none-any.whl → 0.0.2.4__py3-none-any.whl

oikan/model.py

@@ -30,7 +30,10 @@ class KANLayer(nn.Module):
             for _ in range(input_dim)
         ])
         
-        self.combination_weights = nn.Parameter(torch.randn(input_dim, output_dim) * 0.1)
+        # Updated initialization using Xavier uniform initialization
+        self.combination_weights = nn.Parameter(
+            nn.init.xavier_uniform_(torch.empty(input_dim, output_dim))
+        )
     
     def forward(self, x):
         x_split = x.split(1, dim=1)  # list of (batch, 1) tensors for each input feature
@@ -49,7 +52,8 @@ class KANLayer(nn.Module):
             for i in range(self.input_dim):
                 weight = self.combination_weights[i, j].item()
                 if abs(weight) > 1e-4:
-                    edge_formula = self.edges[i][j].get_symbolic_repr()
+                    # Pass lower threshold for improved precision
+                    edge_formula = self.edges[i][j].get_symbolic_repr(threshold=1e-6)
                     if edge_formula != "0":
                         terms.append(f"({weight:.4f} * ({edge_formula}))")
             formulas.append(" + ".join(terms) if terms else "0")
@@ -57,15 +61,13 @@ class KANLayer(nn.Module):
 
 class BaseOIKAN(BaseEstimator):
     """Base OIKAN model implementing common functionality"""
-    def __init__(self, hidden_dims=[64, 32], num_basis=10, degree=3, dropout=0.1):
+    def __init__(self, hidden_dims=[32, 16], dropout=0.1):
         self.hidden_dims = hidden_dims
-        self.num_basis = num_basis
-        self.degree = degree
         self.dropout = dropout  # Dropout probability for uncertainty quantification
         self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # Auto device chooser
         self.model = None
         self._is_fitted = False
-        self.__name = "OIKAN v0.0.2" # Version info (manually configured)
+        self.__name = "OIKAN v0.0.2"  # Manual configured version
         self.loss_history = []  # <-- new attribute to store loss values
         
     def _build_network(self, input_dim, output_dim):
@@ -73,7 +75,9 @@ class BaseOIKAN(BaseEstimator):
         prev_dim = input_dim
         for hidden_dim in self.hidden_dims:
             layers.append(KANLayer(prev_dim, hidden_dim))
-            layers.append(nn.Dropout(self.dropout))  # Apply dropout for uncertainty quantification
+            layers.append(nn.BatchNorm1d(hidden_dim))  # Added batch normalization
+            layers.append(nn.ReLU())                  # Added activation function
+            layers.append(nn.Dropout(self.dropout))   # Apply dropout for uncertainty quantification
             prev_dim = hidden_dim
         layers.append(KANLayer(prev_dim, output_dim))
         return nn.Sequential(*layers).to(self.device)
@@ -85,6 +89,25 @@ class BaseOIKAN(BaseEstimator):
             y = torch.FloatTensor(y)
         return X.to(self.device), (y.to(self.device) if y is not None else None)
 
+    def _process_edge_formula(self, edge_formula, weight):
+        """Helper to scale symbolic formula terms by a given weight"""
+        terms = []
+        for term in edge_formula.split(" + "):
+            if term and term != "0":
+                if "*" in term:
+                    coef_str, rest = term.split("*", 1)
+                    try:
+                        coef = float(coef_str)
+                        terms.append(f"{(coef * weight):.4f}*{rest}")
+                    except Exception:
+                        terms.append(term)  # fallback
+                else:
+                    try:
+                        terms.append(f"{(float(term) * weight):.4f}")
+                    except Exception:
+                        terms.append(term)
+        return " + ".join(terms) if terms else "0"
+
     def get_symbolic_formula(self):
         """Generate and cache symbolic formulas for production‐ready inference."""
         if not self._is_fitted:
@@ -100,17 +123,9 @@ class BaseOIKAN(BaseEstimator):
                 for j in range(n_classes):
                     weight = first_layer.combination_weights[i, j].item()
                     if abs(weight) > 1e-4:
-                        edge_formula = first_layer.edges[i][j].get_symbolic_repr()
-                        terms = []
-                        for term in edge_formula.split(" + "):
-                            if term and term != "0":
-                                if "*" in term:
-                                    coef, rest = term.split("*", 1)
-                                    coef = float(coef) * weight
-                                    terms.append(f"{coef:.4f}*{rest}")
-                                else:
-                                    terms.append(f"{float(term)*weight:.4f}")
-                        formulas[i][j] = " + ".join(terms) if terms else "0"
+                        # Use improved threshold for formula extraction
+                        edge_formula = first_layer.edges[i][j].get_symbolic_repr(threshold=1e-6)
+                        formulas[i][j] = self._process_edge_formula(edge_formula, weight)
                     else:
                         formulas[i][j] = "0"
             self.symbolic_formula = formulas
@@ -119,8 +134,9 @@ class BaseOIKAN(BaseEstimator):
             formulas = []
             first_layer = self.model[0]
             for i in range(first_layer.input_dim):
-                formula = first_layer.edges[i][0].get_symbolic_repr()
-                formulas.append(formula)
+                # Use improved threshold for formula extraction in regressor branch
+                edge_formula = first_layer.edges[i][0].get_symbolic_repr(threshold=1e-6)
+                formulas.append(self._process_edge_formula(edge_formula, 1.0))
             self.symbolic_formula = formulas
             return formulas
 
@@ -131,7 +147,7 @@ class BaseOIKAN(BaseEstimator):
         - A header with the version and timestamp
         - The symbolic formulas for each feature (and class for classification)
         - A general formula, including softmax for classification
-        - Recommendations for production use.
+        - Recommendations and performance results.
         """
         header = f"Generated by {self.__name} | Timestamp: {dt.now()}\n\n"
         header += "Symbolic Formulas:\n"
@@ -157,8 +173,14 @@ class BaseOIKAN(BaseEstimator):
             recs = ("\nRecommendations:\n"
                     "• Consider the symbolic formula for lightweight and interpretable inference.\n"
                     "• Validate approximation accuracy against the neural model.\n")
+       
+        # Disclaimer regarding experimental usage
+        disclaimer = ("\nDisclaimer:\n"
+                      "This experimental model is intended for research purposes only and is not production-ready. "
+                      "Feel free to fork and build your own project based on this research: "
+                      "https://github.com/silvermete0r/oikan\n")
         
-        output = header + formulas_text + general + recs
+        output = header + formulas_text + general + recs + disclaimer
         with open(filename, "w") as f:
             f.write(output)
         print(f"Symbolic formulas saved to {filename}")
@@ -263,7 +285,7 @@ class BaseOIKAN(BaseEstimator):
 
 class OIKANRegressor(BaseOIKAN, RegressorMixin):
     """OIKAN implementation for regression tasks"""
-    def fit(self, X, y, epochs=100, lr=0.01, batch_size=32, verbose=True):
+    def fit(self, X, y, epochs=100, lr=0.01, verbose=True):
         X, y = self._validate_data(X, y)
         if len(y.shape) == 1:
             y = y.reshape(-1, 1)
@@ -284,7 +306,7 @@ class OIKANRegressor(BaseOIKAN, RegressorMixin):
             if torch.isnan(loss):
                 print("Warning: NaN loss detected, reinitializing model...")
                 self.model = None
-                return self.fit(X, y, epochs, lr/10, batch_size, verbose)
+                return self.fit(X, y, epochs, lr/10, verbose)
                 
             loss.backward()
             
@@ -312,7 +334,7 @@ class OIKANRegressor(BaseOIKAN, RegressorMixin):
 
 class OIKANClassifier(BaseOIKAN, ClassifierMixin):
     """OIKAN implementation for classification tasks"""
-    def fit(self, X, y, epochs=100, lr=0.01, batch_size=32, verbose=True):
+    def fit(self, X, y, epochs=100, lr=0.01, verbose=True):
         X, y = self._validate_data(X, y)
         self.classes_ = torch.unique(y)
         n_classes = len(self.classes_)
@@ -414,8 +436,8 @@ class OIKANClassifier(BaseOIKAN, ClassifierMixin):
                 weight = first_layer.combination_weights[i, j].item()
                 
                 if abs(weight) > 1e-4:
-                    # Get the edge formula and scale by the weight
-                    edge_formula = edge.get_symbolic_repr()
+                    # Improved precision by using a lower threshold
+                    edge_formula = edge.get_symbolic_repr(threshold=1e-6)
                     terms = []
                     for term in edge_formula.split(" + "):
                         if term and term != "0":

oikan/utils.py

@@ -3,17 +3,11 @@ import torch
 import torch.nn as nn
 import numpy as np
 
-# Core basis functions with explicit variable notation
 ADVANCED_LIB = {
     'x':    ('x', lambda x: x),
-    'x^2':  ('x^2', lambda x: np.clip(x**2, -100, 100)),
-    'x^3':  ('x^3', lambda x: np.clip(x**3, -100, 100)),
-    'exp':  ('exp(x)', lambda x: np.exp(np.clip(x, -10, 10))),
-    'log':  ('log(x)', lambda x: np.log(np.abs(x) + 1)),
-    'sqrt': ('sqrt(x)', lambda x: np.sqrt(np.abs(x))),
-    'tanh': ('tanh(x)', lambda x: np.tanh(x)),
-    'sin':  ('sin(x)', lambda x: np.sin(np.clip(x, -10*np.pi, 10*np.pi))),
-    'abs':  ('abs(x)', lambda x: np.abs(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))
 }
 
 class EdgeActivation(nn.Module):

{oikan-0.0.2.2.dist-info → oikan-0.0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oikan
-Version: 0.0.2.2
+Version: 0.0.2.4
 Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
 Author: Arman Zhalgasbayev
 License: MIT
@@ -17,7 +17,7 @@ Dynamic: license-file
 
 <!-- logo in the center -->
 <div align="center">
-<img src="docs/media/oikan_logo.png" alt="OIKAN Logo" width="200"/>
+<img src="https://raw.githubusercontent.com/silvermete0r/oikan/main/docs/media/oikan_logo.png" alt="OIKAN Logo" width="200"/>
 
 <h1>OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks</h1>
 </div>
@@ -32,20 +32,39 @@ OIKAN (Optimized Interpretable Kolmogorov-Arnold Networks) is a neuro-symbolic M
 [![GitHub issues](https://img.shields.io/github/issues/silvermete0r/OIKAN.svg)](https://github.com/silvermete0r/oikan/issues)
 [![Docs](https://img.shields.io/badge/docs-passing-brightgreen)](https://silvermete0r.github.io/oikan/)
 
+> **Important Disclaimer**: OIKAN is an experimental research project. It is not intended for production use or real-world applications. This framework is designed for research purposes, experimentation, and academic exploration of neuro-symbolic machine learning concepts.
+
 ## Key Features
 - 🧠 **Neuro-Symbolic ML**: Combines neural network learning with symbolic mathematics
 - 📊 **Automatic Formula Extraction**: Generates human-readable mathematical expressions
 - 🎯 **Scikit-learn Compatible**: Familiar `.fit()` and `.predict()` interface
-- 🚀 **Production-Ready**: Export symbolic formulas for lightweight deployment
+- 🔬 **Research-Focused**: Designed for academic exploration and experimentation
 - 📈 **Multi-Task**: Supports both regression and classification problems
 
 ## Scientific Foundation
 
-OIKAN is based on Kolmogorov's superposition theorem, which states that any multivariate continuous function can be represented as a composition of single-variable functions. We leverage this theory by:
+OIKAN implements the Kolmogorov-Arnold Representation Theorem through a novel neural architecture:
+
+1. **Theorem Background**: Any continuous multivariate function f(x1,...,xn) can be represented as:
+   ```
+   f(x1,...,xn) = ∑(j=0 to 2n){ φj( ∑(i=1 to n) ψij(xi) ) }
+   ```
+   where φj and ψij are continuous single-variable functions.
 
-1. Using neural networks to learn optimal basis functions through interpretable edge transformations
-2. Combining transformed features using learnable weights
-3. Automatically extracting human-readable symbolic formulas
+2. **Neural Implementation**:
+   ```python
+   # Pseudo-implementation of KAN architecture
+   class KANLayer:
+       def __init__(self, input_dim, output_dim):
+           self.edges = [SymbolicEdge() for _ in range(input_dim * output_dim)]
+           self.weights = initialize_weights(input_dim, output_dim)
+   
+       def forward(self, x):
+           # Transform each input through basis functions
+           edge_outputs = [edge(x_i) for x_i, edge in zip(x, self.edges)]
+           # Combine using learned weights
+           return combine_weighted_outputs(edge_outputs, self.weights)
+   ```
 
 ## Quick Start
 
@@ -68,16 +87,11 @@ pip install -e .  # Install in development mode
 from oikan.model import OIKANRegressor
 from sklearn.model_selection import train_test_split
 
-# Initialize model with optimal architecture
-model = OIKANRegressor(
-    hidden_dims=[16, 8],  # Network architecture
-    num_basis=10,         # Number of basis functions
-    degree=3,             # Polynomial degree
-    dropout=0.1           # Regularization
-)
+# Initialize model 
+model = OIKANRegressor()
 
 # Fit model (sklearn-style)
-model.fit(X_train, y_train, epochs=200, lr=0.01)
+model.fit(X_train, y_train, epochs=100, lr=0.01)
 
 # Get predictions
 y_pred = model.predict(X_test)
@@ -86,7 +100,7 @@ y_pred = model.predict(X_test)
 # The output file will contain:
 # - Detailed symbolic formulas for each feature
 # - Instructions for practical implementation
-# - Recommendations for production deployment
+# - Recommendations for testing and validation
 model.save_symbolic_formula("regression_formula.txt")
 ```
 
@@ -98,101 +112,78 @@ model.save_symbolic_formula("regression_formula.txt")
 from oikan.model import OIKANClassifier
 
 # Similar sklearn-style interface for classification
-model = OIKANClassifier(hidden_dims=[16, 8])
-model.fit(X_train, y_train)
+model = OIKANClassifier()
+model.fit(X_train, y_train, epochs=100, lr=0.01)
 probas = model.predict_proba(X_test)
 
 # Save classification formulas with implementation guidelines
 # The output file will contain:
 # - Decision boundary formulas for each class
 # - Softmax application instructions
-# - Production deployment recommendations
+# - Recommendations for testing and validation
 model.save_symbolic_formula("classification_formula.txt")
 ```
 
 *Example of the saved symbolic formula instructions: [outputs/classification_symbolic_formula.txt](outputs/classification_symbolic_formula.txt)*
 
-## Architecture Details
-
-OIKAN implements a novel neuro-symbolic architecture based on Kolmogorov-Arnold representation theory through three specialized components:
-
-1. **Edge Symbolic Layer**: Learns interpretable single-variable transformations
-   - Adaptive basis function composition using 9 core functions:
-     ```python
-     ADVANCED_LIB = {
-         'x':    ('x', lambda x: x),
-         'x^2':  ('x^2', lambda x: x**2),
-         'x^3':  ('x^3', lambda x: x**3),
-         'exp':  ('exp(x)', lambda x: np.exp(x)),
-         'log':  ('log(x)', lambda x: np.log(abs(x) + 1)),
-         'sqrt': ('sqrt(x)', lambda x: np.sqrt(abs(x))),
-         'tanh': ('tanh(x)', lambda x: np.tanh(x)),
-         'sin':  ('sin(x)', lambda x: np.sin(x)),
-         'abs':  ('abs(x)', lambda x: np.abs(x))
-     }
-     ```
-   - Each input feature is transformed through these basis functions
-   - Learnable weights determine the optimal combination
-
-2. **Neural Composition Layer**: Multi-layer feature aggregation
-   - Direct feature-to-feature connections through KAN layers
-   - Dropout regularization (p=0.1 default) for robust learning
-   - Gradient clipping (max_norm=1.0) for stable training
-   - User-configurable hidden layer dimensions
-
-3. **Symbolic Extraction Layer**: Generates production-ready formulas
-   - Weight-based term pruning (threshold=1e-4)
-   - Automatic coefficient optimization
-   - Human-readable mathematical expressions
-   - Exportable to lightweight production code
-
-### Architecture Diagram
-
-![Architecture Diagram](docs/media/oikan_model_architecture_v0.0.2.2.png)
 
 ### Key Design Principles
 
-1. **Interpretability First**: All transformations maintain clear mathematical meaning
-2. **Scikit-learn Compatibility**: Familiar `.fit()` and `.predict()` interface
-3. **Production Ready**: Export formulas as lightweight mathematical expressions
-4. **Automatic Simplification**: Remove insignificant terms (|w| < 1e-4)
-
-## Model Components
-
-1. **Symbolic Edge Functions**
+1. **Interpretability by Design**
    ```python
-   class EdgeActivation(nn.Module):
-       """Learnable edge activation with basis functions"""
-       def forward(self, x):
-           return sum(self.weights[i] * basis[i](x) for i in range(self.num_basis))
+   # 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. **KAN Layer Implementation**
+2. **Automatic Simplification**
    ```python
-   class KANLayer(nn.Module):
-       """Kolmogorov-Arnold Network layer"""
-       def forward(self, x):
-           edge_outputs = [self.edges[i](x[:,i]) for i in range(self.input_dim)]
-           return self.combine(edge_outputs)
+   def simplify_formula(terms, threshold=1e-4):
+       return [term for term in terms if abs(term.coefficient) > threshold]
    ```
 
-3. **Formula Extraction**
+3. **Research-Oriented Architecture**
    ```python
-   def get_symbolic_formula(self):
-       """Extract interpretable mathematical expression"""
-       terms = []
-       for i, edge in enumerate(self.edges):
-           if abs(self.weights[i]) > threshold:
-               terms.append(f"{self.weights[i]:.4f} * {edge.formula}")
-       return " + ".join(terms)
+   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)
+
 ### Key Design Principles
 
-- **Modular Architecture**: Each component is independent and replaceable
-- **Interpretability First**: All transformations maintain symbolic representations
-- **Automatic Simplification**: Removes insignificant terms and combines similar expressions
-- **Production Ready**: Export formulas for lightweight deployment
+1. **Interpretability First**: All transformations maintain clear mathematical meaning
+2. **Scikit-learn Compatibility**: Familiar `.fit()` and `.predict()` interface
+3. **Symbolic Formula Exporting**: Export formulas as lightweight mathematical expressions
+4. **Automatic Simplification**: Remove insignificant terms (|w| < 1e-4)
+
+
+### Key Model Components
+
+1. **EdgeActivation Layer**:
+   - Implements interpretable basis function transformations
+   - Automatically prunes insignificant terms
+   - Maintains mathematical transparency
+
+2. **Formula Extraction**:
+   - Combines edge transformations with learned weights
+   - Applies symbolic simplification
+   - Generates human-readable expressions
+
+3. **Training Process**:
+   - Gradient-based optimization of edge weights
+   - Automatic feature importance detection
+   - Complexity control through regularization
 
 ## Contributing
 

oikan-0.0.2.4.dist-info/RECORD

@@ -0,0 +1,10 @@
+oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oikan/exceptions.py,sha256=UqT3uTtfiB8QA_3AMvKdHOme9WL9HZD_d7GHIk00LJw,394
+oikan/model.py,sha256=nPQcP5TYeuL29pjc9nIKd1tak-Bmh0d0LdRZz6LwcTo,20779
+oikan/symbolic.py,sha256=TtalmSpBecf33_g7yE3q-RPuCVRWQNaXWE4LsCNZmfg,1040
+oikan/utils.py,sha256=GpwAHjPpq3lHvUIS0sKSxJzaLBIkyDxe0aiYRrOqL90,1581
+oikan-0.0.2.4.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
+oikan-0.0.2.4.dist-info/METADATA,sha256=DXQFc4HCNY7hVk_UGXLN43qwmEf0OZFIredbEE6Uq5I,7850
+oikan-0.0.2.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+oikan-0.0.2.4.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.2.4.dist-info/RECORD,,

oikan-0.0.2.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oikan/exceptions.py,sha256=UqT3uTtfiB8QA_3AMvKdHOme9WL9HZD_d7GHIk00LJw,394
-oikan/model.py,sha256=iHWKjk_n0Kkw47UO2XFTc0faqGYBrQBJhmmRn1Po4qw,19604
-oikan/symbolic.py,sha256=TtalmSpBecf33_g7yE3q-RPuCVRWQNaXWE4LsCNZmfg,1040
-oikan/utils.py,sha256=sivt_8jzATH-eUZ3-P-tsdmyIgKsayibSZeP_MtLTfU,1969
-oikan-0.0.2.2.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
-oikan-0.0.2.2.dist-info/METADATA,sha256=VvxfL5IWijk6RJObJL5fORZQFAY55X_oZf00Qk5ATTU,8519
-oikan-0.0.2.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-oikan-0.0.2.2.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.2.2.dist-info/RECORD,,