oikan 0.0.1.11__py3-none-any.whl → 0.0.2.1__py3-none-any.whl

oikan/exceptions.py

@@ -0,0 +1,15 @@
+class OikanError(Exception):
+    """Base exception class for OIKAN"""
+    pass
+
+class NotFittedError(OikanError):
+    """Raised when prediction is attempted on unfitted model"""
+    pass
+
+class DataError(OikanError):
+    """Raised when there are issues with input data"""
+    pass
+
+class InitializationError(OikanError):
+    """Raised when model initialization fails"""
+    pass

oikan/model.py

@@ -1,99 +1,438 @@
 import torch
 import torch.nn as nn
-from .utils import BSplineBasis, FourierBasis
+import numpy as np
+from sklearn.base import BaseEstimator, RegressorMixin, ClassifierMixin
+from .utils import ADVANCED_LIB, EdgeActivation
+from .exceptions import *
+from datetime import datetime as dt
 
-class AdaptiveBasisLayer(nn.Module):
-    '''Layer that applies a linear transformation as part of interpretable modeling.'''
-    def __init__(self, input_dim, hidden_dim):
+class SymbolicEdge(nn.Module):
+    """Edge-based activation function learner"""
+    def __init__(self):
         super().__init__()
-        self.weights = nn.Parameter(torch.randn(input_dim, hidden_dim))
-        self.bias = nn.Parameter(torch.zeros(hidden_dim))
+        self.activation = EdgeActivation()
     
     def forward(self, x):
-        # Linear transformation for adaptive basis processing
-        return torch.matmul(x, self.weights) + self.bias
+        return self.activation(x)
+    
+    def get_symbolic_repr(self, threshold=1e-4):
+        return self.activation.get_symbolic_repr(threshold)
 
-class EfficientKAN(nn.Module):
-    '''Module computing feature transformations using nonlinear basis functions and interaction terms.'''
-    def __init__(self, input_dim, hidden_units=10, basis_type='bsplines'):
+class KANLayer(nn.Module):
+    """Kolmogorov-Arnold Network layer with interpretable edges"""
+    def __init__(self, input_dim, output_dim):
         super().__init__()
         self.input_dim = input_dim
-        self.hidden_units = hidden_units
-        self.basis_type = basis_type
-        
-        if basis_type == 'bsplines':
-            # One BSpline per feature with adjusted output dimensions
-            self.basis_functions = nn.ModuleList([BSplineBasis(hidden_units) for _ in range(input_dim)])
-            self.basis_output_dim = input_dim * (hidden_units - 4)
-        elif basis_type == 'fourier':
-            # Use Fourier basis transformation for each feature
-            self.basis_functions = nn.ModuleList([FourierBasis(hidden_units // 2) for _ in range(input_dim)])
-            self.basis_output_dim = input_dim * hidden_units
-        elif basis_type == 'combo':
-            # Combine BSpline and Fourier basis on a per-feature basis
-            self.basis_functions_bspline = nn.ModuleList([BSplineBasis(hidden_units) for _ in range(input_dim)])
-            self.basis_functions_fourier = nn.ModuleList([FourierBasis(hidden_units // 2) for _ in range(input_dim)])
-            self.basis_output_dim = input_dim * ((hidden_units - 4) + hidden_units)
-        else:
-            raise ValueError(f"Unsupported basis_type: {basis_type}")
+        self.output_dim = output_dim
+        
+        self.edges = nn.ModuleList([
+            nn.ModuleList([SymbolicEdge() for _ in range(output_dim)])
+            for _ in range(input_dim)
+        ])
         
-        # Interaction layer: captures pairwise feature interactions
-        self.interaction_weights = nn.Parameter(torch.randn(input_dim, input_dim))
+        self.combination_weights = nn.Parameter(torch.randn(input_dim, output_dim) * 0.1)
     
     def forward(self, x):
-        # Process basis functions per type
-        if self.basis_type == 'combo':
-            transformed_bspline = [bf(x[:, i].unsqueeze(1)) for i, bf in enumerate(self.basis_functions_bspline)]
-            transformed_fourier = [bf(x[:, i].unsqueeze(1)) for i, bf in enumerate(self.basis_functions_fourier)]
-            basis_output = torch.cat(transformed_bspline + transformed_fourier, dim=1)
-        else:
-            transformed_features = [bf(x[:, i].unsqueeze(1)) for i, bf in enumerate(self.basis_functions)]
-            basis_output = torch.cat(transformed_features, dim=1)
-        
-        # Compute interaction features via fixed matrix multiplication
-        batch_size = x.size(0)
-        x_reshaped = x.view(batch_size, self.input_dim, 1)  # Reshape to [batch_size, input_dim, 1]
-        interaction_matrix = torch.sigmoid(self.interaction_weights)  # Normalize interaction weights
-        interaction_features = torch.bmm(x_reshaped.transpose(1, 2), 
-                                       x_reshaped * interaction_matrix.unsqueeze(0))  # Result: [batch_size, 1, 1]
-        interaction_features = interaction_features.view(batch_size, -1)  # Flatten interaction output
-        
-        return torch.cat([basis_output, interaction_features], dim=1)
+        x_split = x.split(1, dim=1)  # list of (batch, 1) tensors for each input feature
+        edge_outputs = torch.stack([
+            torch.stack([edge(x_i).squeeze() for edge in edge_list], dim=1)
+            for x_i, edge_list in zip(x_split, self.edges)
+        ], dim=1)  # shape: (batch, input_dim, output_dim)
+        combined = edge_outputs * self.combination_weights.unsqueeze(0)
+        return combined.sum(dim=1)
     
-    def get_output_dim(self):
-        # Output dimension includes both basis and interaction features
-        return self.basis_output_dim + self.input_dim
-
-class OIKAN(nn.Module):
-    '''Main OIKAN model combining nonlinear transformations, SVD-projection, and interpretable layers.
-       Supports time series forecasting when forecast_mode is True.
-    '''
-    def __init__(self, input_dim, output_dim, hidden_units=10, reduced_dim=32, basis_type='bsplines', forecast_mode=False):
-        super().__init__()
-        self.forecast_mode = forecast_mode
-        if self.forecast_mode:
-            # LSTM encoder for time series forecasting; expects input shape [batch, seq_len, input_dim]
-            self.lstm = nn.LSTM(input_size=input_dim, hidden_size=input_dim, batch_first=True)
-            # Process the last hidden state with EfficientKAN
-            self.efficientkan = EfficientKAN(input_dim, hidden_units, basis_type)
+    def get_symbolic_formula(self):
+        """Extract interpretable formulas for each output"""
+        formulas = []
+        for j in range(self.output_dim):
+            terms = []
+            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()
+                    if edge_formula != "0":
+                        terms.append(f"({weight:.4f} * ({edge_formula}))")
+            formulas.append(" + ".join(terms) if terms else "0")
+        return formulas
+
+class BaseOIKAN(BaseEstimator):
+    """Base OIKAN model implementing common functionality"""
+    def __init__(self, hidden_dims=[64, 32], num_basis=10, degree=3, 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.loss_history = []  # <-- new attribute to store loss values
+        
+    def _build_network(self, input_dim, output_dim):
+        layers = []
+        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
+            prev_dim = hidden_dim
+        layers.append(KANLayer(prev_dim, output_dim))
+        return nn.Sequential(*layers).to(self.device)
+    
+    def _validate_data(self, X, y=None):
+        if not isinstance(X, torch.Tensor):
+            X = torch.FloatTensor(X)
+        if y is not None and not isinstance(y, torch.Tensor):
+            y = torch.FloatTensor(y)
+        return X.to(self.device), (y.to(self.device) if y is not None else None)
+
+    def get_symbolic_formula(self):
+        """Generate and cache symbolic formulas for production‐ready inference."""
+        if not self._is_fitted:
+            raise NotFittedError("Model must be fitted before extracting formulas")
+        if hasattr(self, "symbolic_formula"):
+            return self.symbolic_formula
+        if hasattr(self, 'classes_'):  # Classifier
+            n_features = self.model[0].input_dim
+            n_classes = len(self.classes_)
+            formulas = [[None for _ in range(n_classes)] for _ in range(n_features)]
+            first_layer = self.model[0]
+            for i in range(n_features):
+                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"
+                    else:
+                        formulas[i][j] = "0"
+            self.symbolic_formula = formulas
+            return formulas
+        else:  # Regressor
+            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)
+            self.symbolic_formula = formulas
+            return formulas
+
+    def save_symbolic_formula(self, filename="outputs/symbolic_formula.txt"):
+        """Save the cached symbolic formulas to file for production use.
+        
+        The file will contain:
+        - 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.
+        """
+        header = f"Generated by {self.__name} | Timestamp: {dt.now()}\n\n"
+        header += "Symbolic Formulas:\n"
+        header += "====================\n"
+        formulas = self.get_symbolic_formula()
+        formulas_text = ""
+        if hasattr(self, 'classes_'):
+            # For classifiers: formulas is a 2D list [feature][class]
+            for i, feature in enumerate(formulas):
+                for j, form in enumerate(feature):
+                    formulas_text += f"Feature {i} - Class {j}: {form}\n"
+            general = ("\nGeneral Formula (with softmax):\n"
+                       "For each class j: y_j = softmax( sum_i [ symbolic_formula(feature_i, class_j) ] )\n")
+            recs = ("\nRecommendations:\n"
+                    "• Use the symbolic formulas for streamlined inference in production.\n"
+                    "• Verify predictions with both the neural network and the compiled symbolic predictor.\n")
         else:
-            self.efficientkan = EfficientKAN(input_dim, hidden_units, basis_type)
-        feature_dim = self.efficientkan.get_output_dim()
-        self.svd_projection = nn.Linear(feature_dim, reduced_dim, bias=False)
-        feature_dim = reduced_dim
-        self.interpretable_layers = nn.Sequential(
-            AdaptiveBasisLayer(feature_dim, 32),
-            nn.ReLU(),
-            AdaptiveBasisLayer(32, output_dim)
-        )
+            # For regressors: formulas is a list
+            for i, form in enumerate(formulas):
+                formulas_text += f"Feature {i}: {form}\n"
+            general = ("\nGeneral Formula:\n"
+                       "y = sum_i [ symbolic_formula(feature_i) ]\n")
+            recs = ("\nRecommendations:\n"
+                    "• Consider the symbolic formula for lightweight and interpretable inference.\n"
+                    "• Validate approximation accuracy against the neural model.\n")
+        
+        output = header + formulas_text + general + recs
+        with open(filename, "w") as f:
+            f.write(output)
+        print(f"Symbolic formulas saved to {filename}")
 
-    def forward(self, x):
-        if self.forecast_mode:
-            # x shape: [batch, seq_len, input_dim]
-            lstm_out, (hidden, _) = self.lstm(x)
-            x_in = hidden[-1]  # Use the last hidden state for forecasting
+    def get_feature_scores(self):
+        """Get feature importance scores based on edge weights."""
+        if not self._is_fitted:
+            raise NotFittedError("Model must be fitted before computing scores")
+        
+        weights = self.model[0].combination_weights.detach().cpu().numpy()
+        return np.mean(np.abs(weights), axis=1)
+
+    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
+        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)
+                        break
+            except Exception:
+                continue
+        return 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.
+        predictions = np.zeros((X.shape[0], 1))
+        for i, formula in enumerate(formulas):
+            x = X[:, i]
+            predictions[:, 0] += self._eval_formula(formula, x)
+        return predictions
+
+    def compile_symbolic_formula(self, filename="output/final_symbolic_formula.txt"):
+        import re
+        from .utils import ADVANCED_LIB  # needed to retrieve basis functions
+        with open(filename, "r") as f:
+            content = f.read()
+        # Regex to extract coefficient and function notation.
+        # Matches patterns like: "(-?\d+\.\d+)\*?([\w\(\)\^]+)"
+        matches = re.findall(r"(-?\d+\.\d+)\*?([\w\(\)\^]+)", content)
+        compiled_terms = []
+        for coef_str, func_name in matches:
+            try:
+                coef = float(coef_str)
+                # Search for a matching basis function in ADVANCED_LIB (e.g. 'x', 'x^2', etc.)
+                for key, (notation, func) in ADVANCED_LIB.items():
+                    if notation.strip() == func_name.strip():
+                        compiled_terms.append((coef, func))
+                        break
+            except Exception:
+                continue
+        def prediction_function(x):
+            pred = 0
+            for coef, func in compiled_terms:
+                pred += coef * func(x)
+            return pred
+        return prediction_function
+
+    def save_model(self, filepath="models/oikan_model.pth"):
+        """Save the current model's state dictionary and extra attributes to a file."""
+        if self.model is None:
+            raise NotFittedError("No model to save. Build and train a model first.")
+        save_dict = {'state_dict': self.model.state_dict()}
+        if hasattr(self, "classes_"):
+            # Save classes_ as a list so that it can be reloaded.
+            save_dict['classes_'] = self.classes_.tolist()
+        torch.save(save_dict, filepath)
+        print(f"Model saved to {filepath}")
+    
+    def load_model(self, filepath="models/oikan_model.pth", input_dim=None, output_dim=None):
+        """Load the model's state dictionary and extra attributes from a file.
+        
+        If the model architecture does not exist, it is automatically rebuilt using provided 
+        input_dim and output_dim.
+        """
+        if self.model is None:
+            if input_dim is None or output_dim is None:
+                raise NotFittedError("No model architecture available. Provide input_dim and output_dim to rebuild the model.")
+            self.model = self._build_network(input_dim, output_dim)
+        loaded = torch.load(filepath, map_location=self.device)
+        if isinstance(loaded, dict) and 'state_dict' in loaded:
+            self.model.load_state_dict(loaded['state_dict'])
+            if 'classes_' in loaded:
+                self.classes_ = torch.tensor(loaded['classes_'])
         else:
-            x_in = x
-        transformed_x = self.efficientkan(x_in)
-        transformed_x = self.svd_projection(transformed_x)
-        return self.interpretable_layers(transformed_x)
+            self.model.load_state_dict(loaded)
+        self._is_fitted = True   # Mark model as fitted after loading
+        print(f"Model loaded from {filepath}")
+
+    def get_loss_history(self):
+        """Retrieve training loss history."""
+        return self.loss_history
+
+class OIKANRegressor(BaseOIKAN, RegressorMixin):
+    """OIKAN implementation for regression tasks"""
+    def fit(self, X, y, epochs=100, lr=0.01, batch_size=32, verbose=True):
+        X, y = self._validate_data(X, y)
+        if len(y.shape) == 1:
+            y = y.reshape(-1, 1)
+            
+        if self.model is None:
+            self.model = self._build_network(X.shape[1], y.shape[1])
+            
+        criterion = nn.MSELoss()
+        optimizer = torch.optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-5)
+        
+        self.model.train()
+        self.loss_history = []  # <-- reset loss history at start of training
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            y_pred = self.model(X)
+            loss = criterion(y_pred, y)
+            
+            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)
+                
+            loss.backward()
+            
+            # Clip gradients
+            torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
+            
+            optimizer.step()
+            
+            self.loss_history.append(loss.item())  # <-- save loss value for epoch
+            
+            if verbose and (epoch + 1) % 10 == 0:
+                print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}")
+            
+        self._is_fitted = True
+        return self
+
+    def predict(self, X):
+        if not self._is_fitted:
+            raise NotFittedError("Model must be fitted before prediction")
+            
+        X = self._validate_data(X)[0]
+        self.model.eval()
+        with torch.no_grad():
+            return self.model(X).cpu().numpy()
+
+class OIKANClassifier(BaseOIKAN, ClassifierMixin):
+    """OIKAN implementation for classification tasks"""
+    def fit(self, X, y, epochs=100, lr=0.01, batch_size=32, verbose=True):
+        X, y = self._validate_data(X, y)
+        self.classes_ = torch.unique(y)
+        n_classes = len(self.classes_)
+        
+        if self.model is None:
+            self.model = self._build_network(X.shape[1], 1 if n_classes == 2 else n_classes)
+            
+        criterion = (nn.BCEWithLogitsLoss() if n_classes == 2 
+                    else nn.CrossEntropyLoss())
+        optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
+        
+        self.model.train()
+        self.loss_history = []  # <-- reset loss history at start of training
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            logits = self.model(X)
+            if n_classes == 2:
+                y_tensor = y.float()
+                logits = logits.squeeze()
+            else:
+                y_tensor = y.long()
+            loss = criterion(logits, y_tensor)
+            loss.backward()
+            optimizer.step()
+            
+            self.loss_history.append(loss.item())  # <-- save loss value for epoch
+            
+            if verbose and (epoch + 1) % 10 == 0:
+                print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}")
+            
+        self._is_fitted = True
+        return self
+
+    def predict_proba(self, X):
+        if not self._is_fitted:
+            raise NotFittedError("Model must be fitted before prediction")
+            
+        X = self._validate_data(X)[0]
+        self.model.eval()
+        with torch.no_grad():
+            logits = self.model(X)
+            if len(self.classes_) == 2:
+                probs = torch.sigmoid(logits)
+                return np.column_stack([1 - probs.cpu().numpy(), probs.cpu().numpy()])
+            else:
+                return torch.softmax(logits, dim=1).cpu().numpy()
+
+    def predict(self, X):
+        proba = self.predict_proba(X)
+        return self.classes_[np.argmax(proba, axis=1)]
+
+    def symbolic_predict_proba(self, X):
+        """Predict class probabilities using only the extracted symbolic formula."""
+        if not self._is_fitted:
+            raise NotFittedError("Model must be fitted before prediction")
+            
+        if not isinstance(X, np.ndarray):
+            X = np.array(X)
+            
+        # Scale input data similar to training
+        X_scaled = (X - X.mean(axis=0)) / (X.std(axis=0) + 1e-8)
+            
+        formulas = self.get_symbolic_formula()
+        n_classes = len(self.classes_)
+        predictions = np.zeros((X.shape[0], n_classes))
+        
+        # Evaluate each feature's contribution to each class
+        for i in range(X.shape[1]):  # For each feature
+            x = X_scaled[:, i]  # Use scaled data
+            for j in range(n_classes):  # For each class
+                formula = formulas[i][j]
+                if formula and formula != "0":
+                    predictions[:, j] += self._eval_formula(formula, x)
+        
+        # Apply softmax with temperature for better separation
+        temperature = 1.0
+        exp_preds = np.exp(predictions / temperature)
+        probas = exp_preds / exp_preds.sum(axis=1, keepdims=True)
+        
+        # Clip probabilities to avoid numerical issues
+        probas = np.clip(probas, 1e-7, 1.0)
+        probas = probas / probas.sum(axis=1, keepdims=True)
+        
+        return probas
+    
+    def get_symbolic_formula(self):
+        """Extract symbolic formulas for all features and outputs."""
+        if not self._is_fitted:
+            raise NotFittedError("Model must be fitted before extracting formulas")
+        
+        n_features = self.model[0].input_dim
+        n_classes = len(self.classes_)
+        formulas = [[[] for _ in range(n_classes)] for _ in range(n_features)]
+        
+        first_layer = self.model[0]
+        for i in range(n_features):
+            for j in range(n_classes):
+                edge = first_layer.edges[i][j]
+                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()
+                    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"
+                else:
+                    formulas[i][j] = "0"
+        
+        return formulas
+
+    def symbolic_predict(self, X):
+        """Predict classes using only the extracted symbolic formula."""
+        proba = self.symbolic_predict_proba(X)
+        return self.classes_[np.argmax(proba, axis=1)]

oikan/symbolic.py

@@ -1,129 +1,28 @@
-import torch
-import numpy as np
-import networkx as nx
-import matplotlib.pyplot as plt
+from .utils import ADVANCED_LIB
 
-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)
-}
-
-# Helper functions
-def get_model_predictions(model, X, mode):
-    """Obtain model predictions; returns flattened predictions for regression, raw outputs for classification."""
-    X_tensor = torch.FloatTensor(X)
-    with torch.no_grad():
-        preds = model(X_tensor)
-    if mode == 'regression':
-        return preds.detach().cpu().numpy().flatten(), None
-    elif mode == 'classification':
-        out = preds.detach().cpu().numpy()
-        # In classification, compute a target difference or fallback to flattening
-        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):
-    """Construct the design matrix from advanced nonlinear bases with optional feature names."""
-    X_np = np.array(X)
-    n_samples, d = X_np.shape
-    F_parts = [np.ones((n_samples, 1))]  # Bias term
-    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)
-
-# Main functions using helpers
-def extract_symbolic_formula(model, X, mode='regression'):
+def symbolic_edge_repr(weights, bias=None, threshold=1e-4):
     """
-    Approximate a symbolic formula that represents model behavior using nonlinear bases.
+    Given a list of weights (floats) and an optional bias,
+    returns a list of structured terms (coefficient, basis function string).
     """
-    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)
-    # Only include terms with significant coefficients
-    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 symbolic approximation against the model by computing error metrics."""
-    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
+    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 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(" + ")
-    # Add nodes for each term with coefficient information
-    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))
-    # Position nodes for visualization
-    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_latex_formula(model, X, mode='regression'):
-    """Return the extracted symbolic formula formatted 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)
-        # Balance parentheses if required
-        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} $$"
+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"

oikan/utils.py

@@ -1,44 +1,47 @@
+from .exceptions import *
 import torch
 import torch.nn as nn
 import numpy as np
-from scipy.interpolate import BSpline
 
-class BSplineBasis(nn.Module):
-    '''Module to compute B-Spline basis values for input features.'''
-    def __init__(self, num_knots=10, degree=3):
-        super().__init__()
-        # Ensure ample knots relative to degree
-        self.num_knots = max(num_knots, degree + 5)
-        self.degree = degree
-        # Create inner knots uniformly in [0,1]
-        inner_knots = np.linspace(0, 1, self.num_knots - 2 * degree)
-        left_pad = np.zeros(degree)
-        right_pad = np.ones(degree)
-        knots = np.concatenate([left_pad, inner_knots, right_pad])
-        self.register_buffer('knots', torch.FloatTensor(knots))
-        
-    def forward(self, x):
-        # Convert tensor to numpy for BSpline evaluation
-        x_np = x.detach().cpu().numpy()
-        basis_values = np.zeros((x_np.shape[0], self.num_knots - self.degree - 1))
-        # Normalize input for stable spline evaluation
-        x_min, x_max = x_np.min(), x_np.max()
-        x_normalized = (x_np - x_min) / (x_max - x_min + 1e-8)
-        for i in range(self.num_knots - self.degree - 1):
-            # Create BSpline basis function for a subset of knots
-            spl = BSpline.basis_element(self.knots[i:i+self.degree+2])
-            basis_values[:, i] = spl(x_normalized.squeeze())
-        basis_values = np.nan_to_num(basis_values, 0)
-        return torch.FloatTensor(basis_values).to(x.device)
+# 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))
+}
 
-class FourierBasis(nn.Module):
-    '''Module to compute Fourier basis representations for input features.'''
-    def __init__(self, num_frequencies=5):
+class EdgeActivation(nn.Module):
+    """Learnable edge-based activation function."""
+    def __init__(self):
         super().__init__()
-        self.num_frequencies = num_frequencies
+        self.weights = nn.Parameter(torch.randn(len(ADVANCED_LIB)))
+        self.bias = nn.Parameter(torch.zeros(1))
         
     def forward(self, x):
-        # Create a range of frequencies and compute sine and cosine transforms.
-        frequencies = torch.arange(1, self.num_frequencies + 1, device=x.device, dtype=torch.float)
-        x_expanded = x * frequencies.view(1, -1) * 2 * np.pi
-        return torch.cat([torch.sin(x_expanded), torch.cos(x_expanded)], dim=1)
+        features = []
+        for _, func in ADVANCED_LIB.values():
+            feat = torch.tensor(func(x.detach().cpu().numpy()), 
+                              dtype=torch.float32).to(x.device)
+            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."""
+        significant_terms = []
+        
+        for (notation, _), weight in zip(ADVANCED_LIB.values(), 
+                                       self.weights.detach().cpu().numpy()):
+            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"

oikan-0.0.2.1.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: oikan
+Version: 0.0.2.1
+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/)
+
+## 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
+- 📈 **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:
+
+1. Using neural networks to learn optimal basis functions
+2. Employing SVD projection for dimensionality reduction
+3. Applying symbolic regression to extract interpretable formulas
+
+## 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 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
+)
+
+# Fit model (sklearn-style)
+model.fit(X_train, y_train, epochs=200, 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 production deployment
+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(hidden_dims=[16, 8])
+model.fit(X_train, y_train)
+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
+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's architecture consists of three main components:
+
+1. **Basis Function Layer**: Learns optimal single-variable transformations
+   - B-spline bases for smooth function approximation
+   - Trigonometric bases for periodic patterns
+   - Polynomial bases for algebraic relationships
+
+2. **Neural Composition Layer**: Combines transformed features
+   - SVD projection for dimensionality reduction
+   - Dropout for regularization
+   - Skip connections for gradient flow
+
+3. **Symbolic Extraction Layer**: Generates interpretable formulas
+   - L1 regularization for sparse representations
+   - Symbolic regression for formula extraction
+   - LaTeX export for documentation
+
+## 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.1.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=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.1.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
+oikan-0.0.2.1.dist-info/METADATA,sha256=vQao-ZUR4BXdu1RgnC7RZQ4na1vGhYU1vmpVttOb2LM,5978
+oikan-0.0.2.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+oikan-0.0.2.1.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.2.1.dist-info/RECORD,,

{oikan-0.0.1.11.dist-info → oikan-0.0.2.1.dist-info}/WHEEL

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

oikan/metrics.py

@@ -1,48 +0,0 @@
-import numpy as np
-import torch
-from sklearn.metrics import precision_score, recall_score, f1_score, hamming_loss
-
-def evaluate_regression(model, X, y):
-    '''Evaluate regression performance by computing MSE, MAE, and RMSE, and print in table format.'''
-    with torch.no_grad():
-        y_pred = model(torch.FloatTensor(X)).numpy().ravel()
-    mse = np.mean((y - y_pred)**2)
-    mae = np.mean(np.abs(y - y_pred))
-    rmse = np.sqrt(mse)
-    
-    # Print table
-    header = f"+{'-'*23}+{'-'*12}+"
-    print(header)
-    print(f"| {'Metric':21} | {'Value':9} |")
-    print(header)
-    print(f"| {'Mean Squared Error':21} | {mse:9.4f} |")
-    print(f"| {'Mean Absolute Error':21} | {mae:9.4f} |")
-    print(f"| {'Root Mean Squared Error':21} | {rmse:9.4f} |")
-    print(header)
-    
-    return mse, mae, rmse
-
-def evaluate_classification(model, X, y):
-    '''Evaluate classification performance by computing accuracy, precision, recall, f1-score, and hamming_loss, and printing in table format.'''
-    with torch.no_grad():
-        logits = model(torch.FloatTensor(X))
-        y_pred = torch.argmax(logits, dim=1).numpy()
-    accuracy = np.mean(y_pred == y)
-    precision = precision_score(y, y_pred, average='weighted', zero_division=0)
-    recall = recall_score(y, y_pred, average='weighted', zero_division=0)
-    f1 = f1_score(y, y_pred, average='weighted', zero_division=0)
-    h_loss = hamming_loss(y, y_pred)
-    
-    # Print table
-    header = f"+{'-'*15}+{'-'*12}+"
-    print(header)
-    print(f"| {'Metric':13} | {'Value':9} |")
-    print(header)
-    print(f"| {'Accuracy':13} | {accuracy:9.4f} |")
-    print(f"| {'Precision':13} | {precision:9.4f} |")
-    print(f"| {'Recall':13} | {recall:9.4f} |")
-    print(f"| {'F1-score':13} | {f1:9.4f} |")
-    print(f"| {'Hamming Loss':13} | {h_loss:9.4f} |")
-    print(header)
-    
-    return accuracy, precision, recall, f1, h_loss

oikan/regularization.py

@@ -1,30 +0,0 @@
-import torch
-import torch.nn as nn
-
-class RegularizedLoss:
-    def __init__(self, base_criterion, model, l1_lambda=0.01, gradient_lambda=0.01):
-        self.base_criterion = base_criterion  # Primary loss (e.g. MSE, CrossEntropy)
-        self.model = model
-        self.l1_lambda = l1_lambda
-        self.gradient_lambda = gradient_lambda
-    
-    def __call__(self, pred, target, inputs):
-        # Compute the standard loss
-        base_loss = self.base_criterion(pred, target)
-        
-        # Calculate L1 regularization to promote sparsity
-        l1_loss = 0
-        for param in self.model.parameters():
-            l1_loss += torch.norm(param, p=1)
-            
-        # Compute gradient penalty to enforce smoothness
-        inputs.requires_grad_(True)
-        outputs = self.model(inputs)
-        gradients = torch.autograd.grad(
-            outputs=outputs.sum(),
-            inputs=inputs,
-            create_graph=True
-        )[0]
-        grad_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
-        
-        return base_loss + self.l1_lambda * l1_loss + self.gradient_lambda * grad_penalty

oikan/trainer.py

@@ -1,49 +0,0 @@
-import torch
-import torch.nn as nn
-from .regularization import RegularizedLoss
-
-def train(model, train_data, epochs=100, lr=0.01, save_path=None, verbose=True):
-    '''Train regression model using MSE loss with regularization.
-    Optionally save the model when training is finished if save_path is provided.
-    '''
-    X_train, y_train = train_data
-    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
-    criterion = nn.MSELoss()
-    reg_loss = RegularizedLoss(criterion, model)
-    
-    model.train()
-    for epoch in range(epochs):
-        optimizer.zero_grad()  # Reset gradients
-        outputs = model(X_train)
-        loss = reg_loss(outputs, y_train, X_train)
-        loss.backward()  # Backpropagate errors
-        optimizer.step()  # Update parameters
-        
-        if (epoch + 1) % 10 == 0 and verbose:
-            print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
-    if save_path is not None:
-        torch.save(model.state_dict(), save_path)
-        print(f"Model saved to {save_path}")
-
-def train_classification(model, train_data, epochs=100, lr=0.01, save_path=None, verbose=True):
-    '''Train classification model using CrossEntropy loss with regularization.
-    Optionally save the model when training is finished if save_path is provided.
-    '''
-    X_train, y_train = train_data
-    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
-    criterion = nn.CrossEntropyLoss()
-    reg_loss = RegularizedLoss(criterion, model)
-    
-    model.train()
-    for epoch in range(epochs):
-        optimizer.zero_grad()  # Reset gradients each epoch
-        outputs = model(X_train)
-        loss = reg_loss(outputs, y_train, X_train)
-        loss.backward()  # Backpropagation
-        optimizer.step()  # Parameter update
-        
-        if (epoch + 1) % 10 == 0 and verbose:
-            print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
-    if save_path is not None:
-        torch.save(model.state_dict(), save_path)
-        print(f"Model saved to {save_path}")

oikan/visualize.py

@@ -1,69 +0,0 @@
-import torch
-import numpy as np
-import matplotlib.pyplot as plt
-
-def visualize_regression(model, X, y):
-    '''Visualize regression results using true vs predicted scatter plots.'''
-    model.eval()
-    with torch.no_grad():
-        y_pred = model(torch.FloatTensor(X)).numpy()
-    plt.figure(figsize=(10, 6))
-    plt.scatter(X[:, 0], y, color='blue', label='True')
-    plt.scatter(X[:, 0], y_pred, color='red', label='Predicted')
-    plt.legend()
-    plt.show()
-
-def visualize_classification(model, X, y):
-    '''Visualize classification decision boundaries. For high-dimensional data, uses SVD projection.'''
-    model.eval()
-    if X.shape[1] > 2:
-        X_mean = np.mean(X, axis=0)
-        X_centered = X - X_mean
-        _, _, Vt = np.linalg.svd(X_centered, full_matrices=False)
-        principal = Vt[:2]
-        X_proj = (X - X_mean) @ principal.T
-        x_min, x_max = X_proj[:, 0].min() - 1, X_proj[:, 0].max() + 1
-        y_min, y_max = X_proj[:, 1].min() - 1, X_proj[:, 1].max() + 1
-        xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
-                             np.linspace(y_min, y_max, 100))
-        grid_2d = np.c_[xx.ravel(), yy.ravel()]
-        X_grid = X_mean + grid_2d @ principal
-        with torch.no_grad():
-            Z = model(torch.FloatTensor(X_grid))
-            Z = torch.argmax(Z, dim=1).numpy().reshape(xx.shape)
-        plt.figure(figsize=(10, 8))
-        plt.contourf(xx, yy, Z, alpha=0.4)
-        plt.scatter(X_proj[:, 0], X_proj[:, 1], c=y, alpha=0.8)
-        plt.title("Classification Visualization (SVD Projection)")
-        plt.show()
-    else:
-        x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
-        y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
-        xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
-                             np.linspace(y_min, y_max, 100))
-        grid_2d = np.c_[xx.ravel(), yy.ravel()]
-        with torch.no_grad():
-            Z = model(torch.FloatTensor(grid_2d))
-            Z = torch.argmax(Z, dim=1).numpy().reshape(xx.shape)
-        plt.figure(figsize=(10, 8))
-        plt.contourf(xx, yy, Z, alpha=0.4)
-        plt.scatter(X[:, 0], X[:, 1], c=y, alpha=0.8)
-
-def visualize_time_series_forecasting(model, X, y):
-    '''
-    Visualize time series forecasting results by plotting true vs predicted values.
-    Expected X shape: [samples, seq_len, features] and y: true targets.
-    '''
-    model.eval()
-    with torch.no_grad():
-        y_pred = model(X).detach().cpu().numpy()
-    if isinstance(y, torch.Tensor):
-        y = y.detach().cpu().numpy()
-    plt.figure(figsize=(10, 5))
-    plt.plot(y, label='True', marker='o', linestyle='-')
-    plt.plot(y_pred, label='Predicted', marker='x', linestyle='--')
-    plt.xlabel("Time Step")
-    plt.ylabel("Value")
-    plt.title("Time Series Forecasting Visualization")
-    plt.legend()
-    plt.show()

oikan-0.0.1.11.dist-info/METADATA

@@ -1,105 +0,0 @@
-Metadata-Version: 2.2
-Name: oikan
-Version: 0.0.1.11
-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: 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 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/)
-
-## Key Features
-- 🚀 Efficient Implementation ~ Optimized KAN architecture with SVD projection
-- 📊 Advanced Basis Functions ~ B-spline and Fourier basis transformations
-- 🎯 Multi-Task Support ~ Both regression and classification capabilities
-- 🔍 Interpretability Tools ~ Extract and visualize symbolic formulas
-- 📈 Interactive Visualizations ~ Built-in plotting and analysis tools
-- 🧮 Symbolic Mathematics ~ LaTeX formula extraction and symbolic approximations
-
-## Installation
-
-### Method 1: Via PyPI (Recommended)
-```bash
-pip install oikan
-```
-
-### Method 2: Local Development
-```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.visualize import visualize_regression
-from oikan.symbolic import extract_symbolic_formula, plot_symbolic_formula, extract_latex_formula
-
-model = OIKAN(input_dim=2, output_dim=1)
-train(model, (X_train, y_train))
-
-visualize_regression(model, X, y)
-
-formula = extract_symbolic_formula(model, X_test, mode='regression')
-print("Extracted formula:", formula)
-
-plot_symbolic_formula(model, X_test, mode='regression')
-
-latex_formula = extract_latex_formula(model, X_test, mode='regression')
-print("LaTeX:", latex_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.11.dist-info/RECORD

@@ -1,13 +0,0 @@
-oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oikan/metrics.py,sha256=IF13bW3evsyKfZC2jhI-MPRu2Rl77Elo3of68OF_JW8,1928
-oikan/model.py,sha256=blpTiAFQ-LxhvWedP5Yf5TgdwlOb4t1BuBMe9d-kJZ0,5342
-oikan/regularization.py,sha256=xt8JNnPdHRAQgzF_vnyme005hWLunz9Vo2qw6m08NMM,1145
-oikan/symbolic.py,sha256=RRYHOCOCJr5KXRhdcCPvT_OqyNcCnWCWt7fOtos8rRI,5765
-oikan/trainer.py,sha256=PwA8PnVUiv5wYlQqj3DTplCAUZljZ4iWJUKUDvmIvX0,2062
-oikan/utils.py,sha256=xbVgrbhXYj57RdD3uNPchjyfmP6Kur7tngoZPa3qWOw,2094
-oikan/visualize.py,sha256=ZZiRf0P8cuBiC0reBBGVnSTotBq5oxQIRIEgqSrN6u8,2916
-oikan-0.0.1.11.dist-info/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
-oikan-0.0.1.11.dist-info/METADATA,sha256=5EpY9clgm3iQ2nLrtLesX-H8sUhZU_lL7bTEPDFj54U,3848
-oikan-0.0.1.11.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-oikan-0.0.1.11.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.1.11.dist-info/RECORD,,