oikan 0.0.2.5__py3-none-any.whl → 0.0.3.1__py3-none-any.whl

oikan/neural.py

@@ -0,0 +1,43 @@
+import torch.nn as nn
+
+class TabularNet(nn.Module):
+    """
+    Feedforward neural network for tabular data.
+    
+    Parameters:
+    -----------
+    input_size : int
+        Number of input features.
+    hidden_sizes : list
+        List of hidden layer sizes.
+    output_size : int
+        Number of output units.
+    activation : str, optional (default='relu')
+        Activation function ('relu', 'tanh', 'leaky_relu', 'elu', 'swish', 'gelu').
+    """
+    def __init__(self, input_size, hidden_sizes, output_size, activation='relu'):
+        super(TabularNet, self).__init__()
+        layers = []
+        in_size = input_size
+        for hidden_size in hidden_sizes:
+            layers.append(nn.Linear(in_size, hidden_size))
+            if activation == 'relu':
+                layers.append(nn.ReLU())
+            elif activation == 'tanh':
+                layers.append(nn.Tanh())
+            elif activation == 'leaky_relu':
+                layers.append(nn.LeakyReLU(negative_slope=0.01))
+            elif activation == 'elu':
+                layers.append(nn.ELU(alpha=1.0))
+            elif activation == 'swish':
+                layers.append(nn.SiLU())
+            elif activation == 'gelu':
+                layers.append(nn.GELU())
+            else:
+                raise ValueError("Unsupported activation function.")
+            in_size = hidden_size
+        layers.append(nn.Linear(in_size, output_size))
+        self.net = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.net(x)

oikan/symbolic.py

@@ -0,0 +1,55 @@
+import numpy as np
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.linear_model import Lasso
+
+def symbolic_regression(X, y, degree=2, alpha=0.1):
+    """
+    Performs symbolic regression on the input data.
+    
+    Parameters:
+    -----------
+    X : array-like of shape (n_samples, n_features)
+        Input data.
+    y : array-like of shape (n_samples,) or (n_samples, n_targets)
+        Target values.
+    degree : int, optional (default=2)
+        Maximum polynomial degree.
+    alpha : float, optional (default=0.1)
+        L1 regularization strength.
+    
+    Returns:
+    --------
+    dict : Contains 'basis_functions', 'coefficients' (or 'coefficients_list'), 'n_features', 'degree'
+    """
+    poly = PolynomialFeatures(degree=degree, include_bias=True)
+    X_poly = poly.fit_transform(X)
+    model = Lasso(alpha=alpha, fit_intercept=False)
+    model.fit(X_poly, y)
+    if len(y.shape) == 1 or y.shape[1] == 1:
+        coef = model.coef_.flatten()
+        selected_indices = np.where(np.abs(coef) > 1e-6)[0]
+        return {
+            'n_features': X.shape[1],
+            'degree': degree,
+            'basis_functions': poly.get_feature_names_out()[selected_indices].tolist(),
+            'coefficients': coef[selected_indices].tolist()
+        }
+    else:
+        coefficients_list = []
+        selected_indices = set()
+        for c in range(y.shape[1]):
+            coef = model.coef_[c]
+            indices = np.where(np.abs(coef) > 1e-6)[0]
+            selected_indices.update(indices)
+        selected_indices = list(selected_indices)
+        basis_functions = poly.get_feature_names_out()[selected_indices].tolist()
+        for c in range(y.shape[1]):
+            coef = model.coef_[c]
+            coef_selected = coef[selected_indices].tolist()
+            coefficients_list.append(coef_selected)
+        return {
+            'n_features': X.shape[1],
+            'degree': degree,
+            'basis_functions': basis_functions,
+            'coefficients_list': coefficients_list
+        }

oikan/utils.py

@@ -1,53 +1,63 @@
-from .exceptions import *
-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: 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)))
-}
+def evaluate_basis_functions(X, basis_functions, n_features):
+    """
+    Evaluates basis functions on the input data.
+    
+    Parameters:
+    -----------
+    X : array-like of shape (n_samples, n_features)
+        Input data.
+    basis_functions : list
+        List of basis function strings (e.g., '1', 'x0', 'x0^2', 'x0 x1').
+    n_features : int
+        Number of input features.
+    
+    Returns:
+    --------
+    X_transformed : ndarray of shape (n_samples, n_basis_functions)
+        Transformed data matrix.
+    """
+    X_transformed = np.zeros((X.shape[0], len(basis_functions)))
+    for i, func in enumerate(basis_functions):
+        if func == '1':
+            X_transformed[:, i] = 1
+        elif '^' in func:
+            var, power = func.split('^')
+            idx = int(var[1:])
+            X_transformed[:, i] = X[:, idx] ** int(power)
+        elif ' ' in func:
+            var1, var2 = func.split(' ')
+            idx1 = int(var1[1:])
+            idx2 = int(var2[1:])
+            X_transformed[:, i] = X[:, idx1] * X[:, idx2]
+        else:
+            idx = int(func[1:])
+            X_transformed[:, i] = X[:, idx]
+    return X_transformed
 
-class EdgeActivation(nn.Module):
-    """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 = 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_features_involved(basis_function):
+    """
+    Extracts the feature indices involved in a basis function string.
+    
+    Parameters:
+    -----------
+    basis_function : str
+        String representation of the basis function, e.g., 'x0', 'x0^2', 'x0 x1'.
     
-    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(), weights_np):
-            if abs(weight) > threshold:
-                significant_terms.append(f"{weight:.4f}*{notation}")
-                
-        if abs(self.bias.item()) > threshold:
-            significant_terms.append(f"{self.bias.item():.4f}")
-                
-        return " + ".join(significant_terms) if significant_terms else "0"
+    Returns:
+    --------
+    set : Set of feature indices involved.
+    """
+    if basis_function == '1':  # Constant term involves no features
+        return set()
+    features = set()
+    for part in basis_function.split():  # Split by space for interaction terms
+        if part.startswith('x'):
+            if '^' in part:  # Handle powers, e.g., 'x0^2'
+                var = part.split('^')[0]  # Take 'x0'
+            else:
+                var = part  # Take 'x0' as is
+            idx = int(var[1:])  # Extract index, e.g., 0
+            features.add(idx)
+    return features

oikan-0.0.3.1.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: oikan
+Version: 0.0.3.1
+Summary: OIKAN: Neuro-Symbolic ML for Scientific Discovery
+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
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: tqdm
+Dynamic: license-file
+
+<!-- logo in the center -->
+<div align="center">
+<img src="https://raw.githubusercontent.com/silvermete0r/oikan/main/docs/media/oikan_logo.png" alt="OIKAN Logo" width="200"/>
+
+<h1>OIKAN: Neuro-Symbolic ML for Scientific Discovery</h1>
+</div>
+
+## Overview
+
+OIKAN is a neuro-symbolic machine learning framework inspired by Kolmogorov-Arnold representation theorem. It combines the power of modern neural networks with techniques for extracting clear, interpretable symbolic formulas from data. OIKAN is designed to make machine learning models both accurate and Interpretable.
+
+[![PyPI version](https://badge.fury.io/py/oikan.svg)](https://badge.fury.io/py/oikan)
+[![PyPI Downloads per month](https://img.shields.io/pypi/dm/oikan.svg)](https://pypistats.org/packages/oikan)
+[![PyPI Total Downloads](https://static.pepy.tech/badge/oikan)](https://pepy.tech/projects/oikan)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![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
+- 🔬 **Research-Focused**: Designed for academic exploration and experimentation
+- 📈 **Multi-Task**: Supports both regression and classification problems
+
+## Scientific Foundation
+
+OIKAN implements a modern interpretation of the Kolmogorov-Arnold Representation Theorem through a hybrid neural architecture:
+
+1. **Theoretical Foundation**: The Kolmogorov-Arnold theorem states that any continuous n-dimensional function can be decomposed into a combination of single-variable functions:
+
+   ```
+   f(x₁,...,xₙ) = ∑(j=0 to 2n){ φⱼ( ∑(i=1 to n) ψᵢⱼ(xᵢ) ) }
+   ```
+
+   where φⱼ and ψᵢⱼ are continuous univariate functions.
+
+2. **Neural Implementation**: OIKAN uses a specialized architecture combining:
+   - Feature transformation layers with interpretable basis functions
+   - Symbolic regression for formula extraction
+   - Automatic pruning of insignificant terms
+   
+   ```python
+   class OIKANRegressor:
+       def __init__(self, hidden_sizes=[64, 64], activation='relu',
+                    polynomial_degree=2, alpha=0.1):
+           # Neural network for learning complex patterns
+           self.neural_net = TabularNet(input_size, hidden_sizes, activation)
+           # Symbolic regression for interpretable formulas
+           self.symbolic_model = None
+
+   ```
+
+3. **Basis Functions**: Core set of interpretable transformations:
+   ```python
+   SYMBOLIC_FUNCTIONS = {
+       'linear': 'x',           # Direct relationships
+       'quadratic': 'x^2',      # Non-linear patterns
+       'interaction': 'x_i x_j', # Feature interactions
+       'higher_order': 'x^n'    # Polynomial terms
+   }
+   ```
+
+4. **Formula Extraction Process**:
+   - Train neural network on raw data
+   - Generate augmented samples for better coverage
+   - Perform L1-regularized symbolic regression
+   - Prune terms with coefficients below threshold
+   - Export human-readable mathematical expressions
+
+## Quick Start
+
+### Installation
+
+#### Method 1: Via PyPI (Recommended)
+```bash
+pip install -qU oikan
+```
+
+#### Method 2: Local Development
+```bash
+git clone https://github.com/silvermete0r/OIKAN.git
+cd OIKAN
+pip install -e .  # Install in development mode
+```
+
+### Regression Example
+```python
+from oikan.model import OIKANRegressor
+from sklearn.metrics import mean_squared_error
+
+# Initialize model
+model = OIKANRegressor(
+    hidden_sizes=[32, 32], # Hidden layer sizes
+    activation='relu', # Activation function (other options: 'tanh', 'leaky_relu', 'elu', 'swish', 'gelu')
+    augmentation_factor=5, # Augmentation factor for data generation
+    polynomial_degree=2, # Degree of polynomial basis functions
+    alpha=0.1, # L1 regularization strength
+    sigma=0.1, # Standard deviation of Gaussian noise for data augmentation
+    epochs=100, # Number of training epochs
+    lr=0.001, # Learning rate
+    batch_size=32, # Batch size for training
+    verbose=True # Verbose output during training
+)
+
+# Fit the model
+model.fit(X_train, y_train)
+
+# Make predictions
+y_pred = model.predict(X_test)
+
+# Evaluate performance
+mse = mean_squared_error(y_test, y_pred)
+print("Mean Squared Error:", mse)
+
+# Get symbolic formula
+formula = model.get_formula()
+print("Symbolic Formula:", formula)
+
+# Get feature importances
+importances = model.feature_importances()
+print("Feature Importances:", importances)
+
+# Save the model (optional)
+model.save("outputs/model.json")
+
+# Load the model (optional)
+loaded_model = OIKANRegressor()
+loaded_model.load("outputs/model.json")
+```
+
+*Example of the saved symbolic formula (regression model): [outputs/california_housing_model.json](outputs/california_housing_model.json)*
+
+
+### Classification Example
+```python
+from oikan.model import OIKANClassifier
+from sklearn.metrics import accuracy_score
+
+# Initialize model
+model = OIKANClassifier(
+    hidden_sizes=[32, 32], # Hidden layer sizes
+    activation='relu', # Activation function (other options: 'tanh', 'leaky_relu', 'elu', 'swish', 'gelu')
+    augmentation_factor=10, # Augmentation factor for data generation
+    polynomial_degree=2, # Degree of polynomial basis functions
+    alpha=0.1, # L1 regularization strength
+    sigma=0.1, # Standard deviation of Gaussian noise for data augmentation
+    epochs=100, # # Number of training epochs
+    lr=0.001, # Learning rate
+    batch_size=32, # Batch size for training
+    verbose=True # Verbose output during training
+)
+
+# Fit the model
+model.fit(X_train, y_train)
+
+# Make predictions
+y_pred = model.predict(X_test)
+
+# Evaluate performance
+accuracy = model.score(X_test, y_test)
+print("Accuracy:", accuracy)
+
+# Get symbolic formulas for each class
+formulas = model.get_formula()
+for i, formula in enumerate(formulas):
+    print(f"Class {i} Formula:", formula)
+   
+# Get feature importances
+importances = model.feature_importances()
+print("Feature Importances:", importances)
+
+# Save the model (optional)
+model.save("outputs/model.json")
+
+# Load the model (optional)
+loaded_model = OIKANClassifier()
+loaded_model.load("outputs/model.json")
+```
+
+*Example of the saved symbolic formula (classification model): [outputs/iris_model.json](outputs/iris_model.json)*
+
+### Architecture Diagram
+
+*Will be updated soon..*
+
+## Contributing
+
+We welcome contributions! Key areas of interest:
+
+- Model architecture improvements
+- Novel basis function implementations
+- Improved symbolic extraction algorithms
+- Real-world case studies and applications
+- Performance optimizations
+
+Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## Citation
+
+If you use OIKAN in your research, please cite:
+
+```bibtex
+@software{oikan2025,
+  title = {OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks},
+  author = {Zhalgasbayev, Arman},
+  year = {2025},
+  url = {https://github.com/silvermete0r/OIKAN}
+}
+```
+
+## License
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

oikan-0.0.3.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+oikan/__init__.py,sha256=zEzhm1GYLT4vNaIQ4CgZcNpUk3uo8SWnoaHYtHW_XSQ,628
+oikan/exceptions.py,sha256=Is0jG4apxO8QJQREIiJQYMjANYWibWeS-103q9KWbfg,192
+oikan/model.py,sha256=-LuvcljM5fqQsqwmhfol_e-_zVQzTAfq8SedQ3HYQQQ,14032
+oikan/neural.py,sha256=wxmGgzmtpwJ3lvH6u6D4i4BiAzg018czrIdw49phSCY,1558
+oikan/symbolic.py,sha256=3gtBndqFFC9ny2-PekKkUgr_t1HEpfkbk68e94yPpbI,2083
+oikan/utils.py,sha256=xMGRa1qhn8BWn9UxpVeJIuGb-UvQmbjiFSsvAdF0bMU,2095
+oikan-0.0.3.1.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
+oikan-0.0.3.1.dist-info/METADATA,sha256=BAYWIvUqQ-al4TPraOnx0tx6eGSFUOvl4_Mxfxo61Qw,8335
+oikan-0.0.3.1.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+oikan-0.0.3.1.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.3.1.dist-info/RECORD,,

{oikan-0.0.2.5.dist-info → oikan-0.0.3.1.dist-info}/WHEEL

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

oikan-0.0.2.5.dist-info/METADATA

@@ -1,195 +0,0 @@
-Metadata-Version: 2.4
-Name: oikan
-Version: 0.0.2.5
-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
-License-File: LICENSE
-Requires-Dist: torch
-Requires-Dist: numpy
-Requires-Dist: scikit-learn
-Dynamic: license-file
-
-<!-- logo in the center -->
-<div align="center">
-<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>
-
-## Overview
-OIKAN (Optimized Interpretable Kolmogorov-Arnold Networks) is a neuro-symbolic ML framework that combines modern neural networks with classical Kolmogorov-Arnold representation theory. It provides interpretable machine learning solutions through automatic extraction of symbolic mathematical formulas from trained models.
-
-[![PyPI version](https://badge.fury.io/py/oikan.svg)](https://badge.fury.io/py/oikan)
-[![PyPI Downloads per month](https://img.shields.io/pypi/dm/oikan.svg)](https://pypistats.org/packages/oikan)
-[![PyPI Total Downloads](https://static.pepy.tech/badge/oikan)](https://pepy.tech/projects/oikan)
-[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![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
-- 🔬 **Research-Focused**: Designed for academic exploration and experimentation
-- 📈 **Multi-Task**: Supports both regression and classification problems
-
-## Scientific Foundation
-
-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.
-
-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)
-   ```
-
-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
-
-#### Method 1: Via PyPI (Recommended)
-```bash
-pip install -qU oikan
-```
-
-#### Method 2: Local Development
-```bash
-git clone https://github.com/silvermete0r/OIKAN.git
-cd OIKAN
-pip install -e .  # Install in development mode
-```
-
-### Regression Example
-```python
-from oikan.model import OIKANRegressor
-from sklearn.model_selection import train_test_split
-
-# Initialize model 
-model = OIKANRegressor()
-
-# Fit model (sklearn-style)
-model.fit(X_train, y_train, epochs=100, lr=0.01)
-
-# Get predictions
-y_pred = model.predict(X_test)
-
-# Save interpretable formula to file with auto-generated guidelines
-# The output file will contain:
-# - Detailed symbolic formulas for each feature
-# - Instructions for practical implementation
-# - Recommendations for testing and validation
-model.save_symbolic_formula("regression_formula.txt")
-```
-
-*Example of the saved symbolic formula instructions: [outputs/regression_symbolic_formula.txt](outputs/regression_symbolic_formula.txt)*
-
-
-### Classification Example
-```python
-from oikan.model import OIKANClassifier
-
-# Similar sklearn-style interface for classification
-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
-# - 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 Diagram
-
-![Architecture Diagram](https://raw.githubusercontent.com/silvermete0r/oikan/main/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. **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
-
-We welcome contributions! Key areas of interest:
-
-- Model architecture improvements
-- Novel basis function implementations
-- Improved symbolic extraction algorithms
-- Real-world case studies and applications
-- Performance optimizations
-
-Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
-
-## Citation
-
-If you use OIKAN in your research, please cite:
-
-```bibtex
-@software{oikan2025,
-  title = {OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks},
-  author = {Zhalgasbayev, Arman},
-  year = {2025},
-  url = {https://github.com/silvermete0r/OIKAN}
-}
-```
-
-## License
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

oikan-0.0.2.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oikan/exceptions.py,sha256=UqT3uTtfiB8QA_3AMvKdHOme9WL9HZD_d7GHIk00LJw,394
-oikan/model.py,sha256=O5ozMUNCG-d7y5du1uG96psEgwMsN6H9CLQDtCg-AmM,21580
-oikan/utils.py,sha256=nLbzycmtNCj8806delPsLcKMaBuFhTHtrKXCf1NDMb0,2062
-oikan-0.0.2.5.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
-oikan-0.0.2.5.dist-info/METADATA,sha256=3AgQFr8-ihylBaSKlYBDbRnU8yAajf_fRW8fJVOAGCM,7283
-oikan-0.0.2.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-oikan-0.0.2.5.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.2.5.dist-info/RECORD,,