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

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.2.dist-info/METADATA

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: oikan
+Version: 0.0.2.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
+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="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 through interpretable edge transformations
+2. Combining transformed features using learnable weights
+3. Automatically extracting human-readable symbolic 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 implements a novel neuro-symbolic architecture based on Kolmogorov-Arnold representation theory through three specialized components:
+
+1. **Edge Symbolic Layer**: Learns interpretable single-variable transformations
+   - Adaptive basis function composition using 9 core functions:
+     ```python
+     ADVANCED_LIB = {
+         'x':    ('x', lambda x: x),
+         'x^2':  ('x^2', lambda x: x**2),
+         'x^3':  ('x^3', lambda x: x**3),
+         'exp':  ('exp(x)', lambda x: np.exp(x)),
+         'log':  ('log(x)', lambda x: np.log(abs(x) + 1)),
+         'sqrt': ('sqrt(x)', lambda x: np.sqrt(abs(x))),
+         'tanh': ('tanh(x)', lambda x: np.tanh(x)),
+         'sin':  ('sin(x)', lambda x: np.sin(x)),
+         'abs':  ('abs(x)', lambda x: np.abs(x))
+     }
+     ```
+   - Each input feature is transformed through these basis functions
+   - Learnable weights determine the optimal combination
+
+2. **Neural Composition Layer**: Multi-layer feature aggregation
+   - Direct feature-to-feature connections through KAN layers
+   - Dropout regularization (p=0.1 default) for robust learning
+   - Gradient clipping (max_norm=1.0) for stable training
+   - User-configurable hidden layer dimensions
+
+3. **Symbolic Extraction Layer**: Generates production-ready formulas
+   - Weight-based term pruning (threshold=1e-4)
+   - Automatic coefficient optimization
+   - Human-readable mathematical expressions
+   - Exportable to lightweight production code
+
+### Architecture Diagram
+
+![Architecture Diagram](docs/media/oikan_model_architecture_v0.0.2.2.png)
+
+### Key Design Principles
+
+1. **Interpretability First**: All transformations maintain clear mathematical meaning
+2. **Scikit-learn Compatibility**: Familiar `.fit()` and `.predict()` interface
+3. **Production Ready**: Export formulas as lightweight mathematical expressions
+4. **Automatic Simplification**: Remove insignificant terms (|w| < 1e-4)
+
+## Model Components
+
+1. **Symbolic Edge Functions**
+   ```python
+   class EdgeActivation(nn.Module):
+       """Learnable edge activation with basis functions"""
+       def forward(self, x):
+           return sum(self.weights[i] * basis[i](x) for i in range(self.num_basis))
+   ```
+
+2. **KAN Layer Implementation**
+   ```python
+   class KANLayer(nn.Module):
+       """Kolmogorov-Arnold Network layer"""
+       def forward(self, x):
+           edge_outputs = [self.edges[i](x[:,i]) for i in range(self.input_dim)]
+           return self.combine(edge_outputs)
+   ```
+
+3. **Formula Extraction**
+   ```python
+   def get_symbolic_formula(self):
+       """Extract interpretable mathematical expression"""
+       terms = []
+       for i, edge in enumerate(self.edges):
+           if abs(self.weights[i]) > threshold:
+               terms.append(f"{self.weights[i]:.4f} * {edge.formula}")
+       return " + ".join(terms)
+   ```
+
+### Key Design Principles
+
+- **Modular Architecture**: Each component is independent and replaceable
+- **Interpretability First**: All transformations maintain symbolic representations
+- **Automatic Simplification**: Removes insignificant terms and combines similar expressions
+- **Production Ready**: Export formulas for lightweight deployment
+
+## 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.2.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.2.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
+oikan-0.0.2.2.dist-info/METADATA,sha256=VvxfL5IWijk6RJObJL5fORZQFAY55X_oZf00Qk5ATTU,8519
+oikan-0.0.2.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+oikan-0.0.2.2.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.2.2.dist-info/RECORD,,

{oikan-0.0.1.11.dist-info → oikan-0.0.2.2.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}")