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

oikan/symbolic.py

@@ -1,21 +1,132 @@
 import torch
 import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
 
-def extract_symbolic_formula_regression(model, X):
-    """Simple coefficient-based formula extraction"""
-    model.eval()
+ADVANCED_LIB = {
+    'x':    lambda x: x,
+    'x^2':  lambda x: x**2,
+    'x^3':  lambda x: x**3,
+    'x^4':  lambda x: x**4,
+    'x^5':  lambda x: x**5,
+    'exp':  lambda x: np.exp(x),
+    'log':  lambda x: np.log(np.abs(x) + 1e-8),
+    'sqrt': lambda x: np.sqrt(np.abs(x)),
+    'tanh': lambda x: np.tanh(x),
+    'sin':  lambda x: np.sin(x),
+    'abs':  lambda x: np.abs(x)
+}
+
+# STEP-1: Helper functions
+def get_model_predictions(model, X, mode):
+    """Compute model predictions and return target values (and raw preds for classification)."""
+    X_tensor = torch.FloatTensor(X)
     with torch.no_grad():
-        # 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"
+        preds = model(X_tensor)
+    if mode == 'regression':
+        return preds.detach().cpu().numpy().flatten(), None
+    elif mode == 'classification':
+        out = preds.detach().cpu().numpy()
+        target = (out[:, 0] - out[:, 1]).flatten() if (out.ndim > 1 and out.shape[1] > 1) else out.flatten()
+        return target, out
+    else:
+        raise ValueError("Unknown mode")
+
+def build_design_matrix(X, return_names=False):
+    """Build the design matrix using the advanced nonlinear bases."""
+    X_np = np.array(X)
+    n_samples, d = X_np.shape
+    F_parts = [np.ones((n_samples, 1))]
+    names = ['1'] if return_names else None
+    for j in range(d):
+        xj = X_np[:, j:j+1]
+        for key, func in ADVANCED_LIB.items():
+            F_parts.append(func(xj))
+            if return_names:
+                names.append(f"{key}(x{j+1})")
+    return (np.hstack(F_parts), names) if return_names else np.hstack(F_parts)
+
+# STEP-2: Main functions using helpers
+def extract_symbolic_formula(model, X, mode='regression'):
+    """
+    Approximate a symbolic formula from the model using advanced nonlinear bases.
+    """
+    n_samples = np.array(X).shape[0]
+    y_target, _ = get_model_predictions(model, X, mode)
+    F, func_names = build_design_matrix(X, return_names=True)
+    beta, _, _, _ = np.linalg.lstsq(F, y_target, rcond=None)
+    terms = [f"({c:.2f}*{name})" for c, name in zip(beta, func_names) if abs(c) > 1e-4]
+    return " + ".join(terms)
+
+def test_symbolic_formula(model, X, mode='regression'):
+    """
+    Evaluate the extracted symbolic formula against model outputs.
+    """
+    n_samples = np.array(X).shape[0]
+    y_target, out = get_model_predictions(model, X, mode)
+    F = build_design_matrix(X, return_names=False)
+    beta, _, _, _ = np.linalg.lstsq(F, y_target, rcond=None)
+    symbolic_vals = F.dot(beta)
+    if mode == 'regression':
+        mse = np.mean((symbolic_vals - y_target) ** 2)
+        mae = np.mean(np.abs(symbolic_vals - y_target))
+        rmse = np.sqrt(mse)
+        print(f"(Advanced) MSE: {mse:.4f}, MAE: {mae:.4f}, RMSE: {rmse:.4f}")
+        return mse, mae, rmse
+    elif mode == 'classification':
+        sym_preds = np.where(symbolic_vals >= 0, 0, 1)
+        model_classes = np.argmax(out, axis=1) if (out.ndim > 1) else (out >= 0.5).astype(int)
+        if model_classes.shape[0] != sym_preds.shape[0]:
+            raise ValueError("Shape mismatch between symbolic and model predictions.")
+        accuracy = np.mean(sym_preds == model_classes)
+        print(f"(Advanced) Accuracy: {accuracy:.4f}")
+        return accuracy
+
+def plot_symbolic_formula(model, X, mode='regression'):
+    """
+    Plot a graph representation of the extracted symbolic formula.
+    """
+    formula = extract_symbolic_formula(model, X, mode)
+    G = nx.DiGraph()
+    G.add_node("Output")
+    terms = formula.split(" + ")
+    for term in terms:
+        expr = term.strip("()")
+        coeff_str, basis = expr.split("*", 1) if "*" in expr else (expr, "unknown")
+        node_label = f"{basis}\n({float(coeff_str):.2f})"
+        G.add_node(node_label)
+        G.add_edge(node_label, "Output", weight=float(coeff_str))
+    left_nodes = [n for n in G.nodes() if n != "Output"]
+    pos = {}
+    n_left = len(left_nodes)
+    for i, node in enumerate(sorted(left_nodes)):
+        pos[node] = (0, 1 - (i / max(n_left - 1, 1)))
+    pos["Output"] = (1, 0.5)
+    plt.figure(figsize=(12, 8))
+    nx.draw(G, pos, with_labels=True, node_color="skyblue", node_size=2500, font_size=10,
+            arrows=True, arrowstyle='->', arrowsize=20)
+    edge_labels = {(u, v): f"{d['weight']:.2f}" for u, v, d in G.edges(data=True)}
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red', font_size=10)
+    plt.title("OIKAN Symbolic Formula Graph")
+    plt.axis("off")
+    plt.show()
 
-def extract_symbolic_formula_classification(model, X):
-    """Extract classification boundary formula"""
-    return extract_symbolic_formula_regression(model, X) + " = 0"
+def extract_latex_formula(model, X, mode='regression'):
+    """
+    Return the extracted symbolic formula as LaTeX code.
+    """
+    formula = extract_symbolic_formula(model, X, mode)
+    terms = formula.split(" + ")
+    latex_terms = []
+    for term in terms:
+        expr = term.strip("()")
+        coeff_str, basis = expr.split("*", 1) if "*" in expr else (expr, "")
+        coeff = float(coeff_str)
+        missing = basis.count("(") - basis.count(")")
+        if missing > 0:
+            basis = basis + ")" * missing
+        coeff_latex = f"{abs(coeff):.2f}".rstrip("0").rstrip(".")
+        term_latex = coeff_latex if basis.strip() == "1" else f"{coeff_latex} \\cdot {basis.strip()}"
+        latex_terms.append(f"- {term_latex}" if coeff < 0 else f"+ {term_latex}")
+    latex_formula = " ".join(latex_terms).lstrip("+ ").strip()
+    return f"$$ {latex_formula} $$"

oikan-0.0.1.4.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.2
+Name: oikan
+Version: 0.0.1.4
+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
+
+Optimized Interpretable Kolmogorov-Arnold Networks (OIKAN)  
+A deep learning framework for interpretable neural networks using advanced basis functions.
+
+[![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)
+
+## Key Features
+- EfficientKAN layer implementation
+- Built-in visualization tools
+- Support for both regression and classification tasks
+- Symbolic formula extraction
+- Easy-to-use training interface
+- LaTeX-formatted formula extraction
+
+## 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
+from oikan.symbolic import extract_symbolic_formula
+
+model = OIKAN(input_dim=2, output_dim=1)
+train(model, (X_train, y_train))
+formula = extract_symbolic_formula(model, X_test, mode='regression')
+print("Extracted formula:", formula)
+```
+
+### Classification Example
+```python
+from oikan.model import OIKAN
+from oikan.trainer import train_classification
+from oikan.visualize import visualize_classification
+from oikan.symbolic import extract_symbolic_formula, plot_symbolic_formula, extract_latex_formula
+
+model = OIKAN(input_dim=2, output_dim=2)
+train_classification(model, (X_train, y_train))
+visualize_classification(model, X_test, y_test)
+formula = extract_symbolic_formula(model, X_test, mode='classification')
+print("Extracted formula:", formula)
+plot_symbolic_formula(model, X_test, mode='classification')
+latex_formula = extract_latex_formula(model, X_test, mode='classification')
+print("LaTeX:", latex_formula)
+```
+
+## Usage
+- Explore the `oikan/` folder for model architectures, training routines, and symbolic extraction.
+- Check the `examples/` directory for complete usage examples for both regression and classification.
+
+## Contributing
+Contributions are welcome! Submit a Pull Request with your improvements.
+
+## License
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

{oikan-0.0.1.2.dist-info → oikan-0.0.1.4.dist-info}/RECORD

@@ -1,11 +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/symbolic.py,sha256=K1aI5JEPgKFu8dyjXxWDA-UZm8Gvfp0lU1M7c2NAPLY,5517
 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.4.dist-info/METADATA,sha256=G-HWX8CkuSzPWDLDIdn_NYVehCfVrEfuLbnaSuQbsxw,2726
+oikan-0.0.1.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+oikan-0.0.1.4.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.1.4.dist-info/RECORD,,

oikan-0.0.1.2.dist-info/METADATA

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