oikan 0.0.1.6__py3-none-any.whl → 0.0.1.8__py3-none-any.whl

oikan/metrics.py

@@ -0,0 +1,23 @@
+import numpy as np
+import torch
+
+def evaluate_regression(model, X, y):
+    '''Evaluate regression performance by computing MSE, MAE, and RMSE.'''
+    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("Mean Squared Error:", mse)
+    print("Mean Absolute Error:", mae)
+    print("Root Mean Squared Error:", rmse)
+    return mse, mae, rmse
+
+def evaluate_classification(model, X, y):
+    '''Evaluate classification accuracy by comparing model predictions and true labels.'''
+    with torch.no_grad():
+        logits = model(torch.FloatTensor(X))
+        y_pred = torch.argmax(logits, dim=1).numpy()
+    accuracy = np.mean(y_pred == y)
+    print("Classification Accuracy:", accuracy)
+    return accuracy

oikan/model.py

@@ -3,15 +3,18 @@ import torch.nn as nn
 from .utils import BSplineBasis, FourierBasis
 
 class AdaptiveBasisLayer(nn.Module):
+    '''Layer that applies a linear transformation as part of interpretable modeling.'''
     def __init__(self, input_dim, hidden_dim):
         super().__init__()
         self.weights = nn.Parameter(torch.randn(input_dim, hidden_dim))
         self.bias = nn.Parameter(torch.zeros(hidden_dim))
     
     def forward(self, x):
+        # Linear transformation for adaptive basis processing
         return torch.matmul(x, self.weights) + self.bias
 
 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='bspline'):
         super().__init__()
         self.input_dim = input_dim
@@ -19,41 +22,48 @@ class EfficientKAN(nn.Module):
         self.basis_type = basis_type
         
         if basis_type == 'bspline':
+            # One BSpline per feature expected 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)  # Adjusted for BSpline output
         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
             
-        # Grid-based interaction layer
+        # Interaction layer: captures pairwise feature interactions
         self.interaction_weights = nn.Parameter(torch.randn(input_dim, input_dim))
     
     def forward(self, x):
-        # Transform each feature using basis functions
+        # Transform each feature using its corresponding basis function
         transformed_features = [bf(x[:, i].unsqueeze(1)) for i, bf in enumerate(self.basis_functions)]
         basis_output = torch.cat(transformed_features, dim=1)
         
-        # Compute feature interactions - fixed matrix multiplication
+        # Compute interaction features via fixed matrix multiplication
         batch_size = x.size(0)
-        x_reshaped = x.view(batch_size, self.input_dim, 1)  # [batch_size, input_dim, 1]
-        interaction_matrix = torch.sigmoid(self.interaction_weights)  # [input_dim, input_dim]
+        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))  # [batch_size, 1, 1]
-        interaction_features = interaction_features.view(batch_size, -1)  # [batch_size, 1]
+                                       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)
     
     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):
-    def __init__(self, input_dim, output_dim, hidden_units=10):
+    '''Main OIKAN model combining nonlinear transformations, SVD-projection, and interpretable layers.'''
+    def __init__(self, input_dim, output_dim, hidden_units=10, reduced_dim=32):
         super().__init__()
         self.efficientkan = EfficientKAN(input_dim, hidden_units)
-        
-        # Get actual feature dimension after transformation
         feature_dim = self.efficientkan.get_output_dim()
         
+        # Apply SVD projection to compress high-dimensional features
+        self.svd_projection = nn.Linear(feature_dim, reduced_dim, bias=False)
+        feature_dim = reduced_dim  # Update feature dimension after projection
+        
+        # Interpretable layers for final mapping
         self.interpretable_layers = nn.Sequential(
             AdaptiveBasisLayer(feature_dim, 32),
             nn.ReLU(),
@@ -62,4 +72,6 @@ class OIKAN(nn.Module):
     
     def forward(self, x):
         transformed_x = self.efficientkan(x)
+        # Compress features prior to final prediction layer
+        transformed_x = self.svd_projection(transformed_x)
         return self.interpretable_layers(transformed_x)

oikan/regularization.py

@@ -3,21 +3,21 @@ 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
+        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)
         
-        # L1 regularization
+        # Calculate L1 regularization to promote sparsity
         l1_loss = 0
         for param in self.model.parameters():
             l1_loss += torch.norm(param, p=1)
             
-        # Gradient penalty
-        grad_penalty = 0
+        # Compute gradient penalty to enforce smoothness
         inputs.requires_grad_(True)
         outputs = self.model(inputs)
         gradients = torch.autograd.grad(

oikan/symbolic.py

@@ -17,9 +17,9 @@ ADVANCED_LIB = {
     'abs':  lambda x: np.abs(x)
 }
 
-# STEP-1: Helper functions
+# Helper functions
 def get_model_predictions(model, X, mode):
-    """Compute model predictions and return target values (and raw preds for classification)."""
+    """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)
@@ -27,16 +27,17 @@ def get_model_predictions(model, X, mode):
         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):
-    """Build the design matrix using the advanced nonlinear bases."""
+    """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))]
+    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]
@@ -46,23 +47,20 @@ def build_design_matrix(X, return_names=False):
                 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
+# Main functions using helpers
 def extract_symbolic_formula(model, X, mode='regression'):
     """
-    Approximate a symbolic formula from the model using advanced nonlinear bases.
+    Approximate a symbolic formula that represents model behavior using 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)
+    # 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 extracted symbolic formula against model outputs.
-    """
-    n_samples = np.array(X).shape[0]
+    """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)
@@ -83,19 +81,19 @@ def test_symbolic_formula(model, X, mode='regression'):
         return accuracy
 
 def plot_symbolic_formula(model, X, mode='regression'):
-    """
-    Plot a graph representation of the extracted symbolic formula.
-    """
+    """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)
@@ -112,9 +110,7 @@ def plot_symbolic_formula(model, X, mode='regression'):
     plt.show()
 
 def extract_latex_formula(model, X, mode='regression'):
-    """
-    Return the extracted symbolic formula as LaTeX code.
-    """
+    """Return the extracted symbolic formula formatted as LaTeX code."""
     formula = extract_symbolic_formula(model, X, mode)
     terms = formula.split(" + ")
     latex_terms = []
@@ -122,6 +118,7 @@ def extract_latex_formula(model, X, mode='regression'):
         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

oikan/trainer.py

@@ -3,6 +3,7 @@ import torch.nn as nn
 from .regularization import RegularizedLoss
 
 def train(model, train_data, epochs=100, lr=0.01):
+    '''Train regression model using MSE loss with regularization.'''
     X_train, y_train = train_data
     optimizer = torch.optim.Adam(model.parameters(), lr=lr)
     criterion = nn.MSELoss()
@@ -10,16 +11,18 @@ def train(model, train_data, epochs=100, lr=0.01):
     
     model.train()
     for epoch in range(epochs):
-        optimizer.zero_grad()
+        optimizer.zero_grad()  # Reset gradients
         outputs = model(X_train)
+        # Compute loss including regularization penalties
         loss = reg_loss(outputs, y_train, X_train)
-        loss.backward()
-        optimizer.step()
+        loss.backward()  # Backpropagate errors
+        optimizer.step()  # Update parameters
         
         if (epoch + 1) % 10 == 0:
             print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
 
 def train_classification(model, train_data, epochs=100, lr=0.01):
+    '''Train classification model using CrossEntropy loss with regularization.'''
     X_train, y_train = train_data
     optimizer = torch.optim.Adam(model.parameters(), lr=lr)
     criterion = nn.CrossEntropyLoss()
@@ -27,11 +30,12 @@ def train_classification(model, train_data, epochs=100, lr=0.01):
     
     model.train()
     for epoch in range(epochs):
-        optimizer.zero_grad()
+        optimizer.zero_grad()  # Reset gradients each epoch
         outputs = model(X_train)
+        # Loss includes both cross-entropy and regularization terms
         loss = reg_loss(outputs, y_train, X_train)
-        loss.backward()
-        optimizer.step()
+        loss.backward()  # Backpropagation
+        optimizer.step()  # Parameter update
         
         if (epoch + 1) % 10 == 0:
             print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')

oikan/utils.py

@@ -4,40 +4,41 @@ 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__()
-        self.num_knots = max(num_knots, degree + 5)  # Ensure minimum number of knots
+        # Ensure ample knots relative to degree
+        self.num_knots = max(num_knots, degree + 5)
         self.degree = degree
-        
-        # Create knot vector with proper padding
+        # 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 to [0,1] range
-        x_normalized = (x_np - x_np.min()) / (x_np.max() - x_np.min() + 1e-8)
-        
+        # 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())
-        
-        # Replace NaN values with 0
         basis_values = np.nan_to_num(basis_values, 0)
         return torch.FloatTensor(basis_values).to(x.device)
 
 class FourierBasis(nn.Module):
+    '''Module to compute Fourier basis representations for input features.'''
     def __init__(self, num_frequencies=5):
         super().__init__()
         self.num_frequencies = num_frequencies
         
     def forward(self, x):
-        frequencies = torch.arange(1, self.num_frequencies + 1, device=x.device).float()
+        # 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)

oikan/visualize.py

@@ -3,67 +3,37 @@ import matplotlib.pyplot as plt
 import torch
 
 def visualize_regression(model, X, y):
+    '''Visualize regression results via a scatter plot, comparing true vs predicted values.'''
     model.eval()
     with torch.no_grad():
-        X_tensor = torch.FloatTensor(X)
-        y_pred = model(X_tensor).numpy()
-    
+        y_pred = model(torch.FloatTensor(X)).numpy()
     plt.figure(figsize=(10, 6))
+    # Plot true values vs predictions
     plt.scatter(X[:, 0], y, color='blue', label='True')
     plt.scatter(X[:, 0], y_pred, color='red', label='Predicted')
     plt.legend()
+    plt.title("Regression: True vs Predicted")
+    plt.xlabel("Feature 1")
+    plt.ylabel("Output")
     plt.show()
 
 def visualize_classification(model, X, y):
+    '''Visualize classification decision boundaries for 2D input data.'''
     model.eval()
-    
-    if X.shape[1] > 2:
-        # SVD projection for high-dimensional inputs.
-        X_mean = np.mean(X, axis=0)
-        X_centered = X - X_mean
-        _, _, Vt = np.linalg.svd(X_centered, full_matrices=False)
-        principal = Vt[:2]  # shape: (2, D)
-        X_proj = (X - X_mean) @ principal.T
-        
-        x1, x2 = X_proj[:, 0], X_proj[:, 1]
-        x_min, x_max = x1.min() - 1, x1.max() + 1
-        y_min, y_max = x2.min() - 1, x2.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()]
-        # Inverse transform grid points to original space.
-        X_grid = X_mean + grid_2d @ principal
-        
-        with torch.no_grad():
-            X_grid_tensor = torch.FloatTensor(X_grid)
-            Z = model(X_grid_tensor)
-            Z = torch.argmax(Z, dim=1).numpy()
-            Z = Z.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:
-        x1 = X[:, 0]
-        x2 = X[:, 1]
-        x_min, x_max = x1.min() - 1, x1.max() + 1
-        y_min, y_max = x2.min() - 1, x2.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 = grid_2d
-
-        with torch.no_grad():
-            X_grid_tensor = torch.FloatTensor(X_grid)
-            Z = model(X_grid_tensor)
-            Z = torch.argmax(Z, dim=1).numpy()
-            Z = Z.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)
-        plt.title("Classification Visualization")
-        plt.show()
+    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():
+        # Compute prediction for each point in the grid
+        Z = model(torch.FloatTensor(grid_2d))
+        Z = torch.argmax(Z, dim=1).numpy().reshape(xx.shape)
+    plt.figure(figsize=(10, 8))
+    # Draw decision boundaries and scatter the data
+    plt.contourf(xx, yy, Z, alpha=0.4)
+    plt.scatter(X[:, 0], X[:, 1], c=y, alpha=0.8)
+    plt.title("Classification Visualization")
+    plt.xlabel("Feature 1")
+    plt.ylabel("Feature 2")
+    plt.show()

{oikan-0.0.1.6.dist-info → oikan-0.0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: oikan
-Version: 0.0.1.6
+Version: 0.0.1.8
 Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
 Author: Arman Zhalgasbayev
 License: MIT
@@ -23,17 +23,26 @@ A deep learning framework for interpretable neural networks using advanced basis
 
 [![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)
+[![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
-- 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
+- 🚀 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
@@ -46,7 +55,8 @@ pip install -e .  # Install in development mode
 ```python
 from oikan.model import OIKAN
 from oikan.trainer import train
-from oikan.symbolic import extract_symbolic_formula
+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))

oikan-0.0.1.8.dist-info/RECORD

@@ -0,0 +1,13 @@
+oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oikan/metrics.py,sha256=65txPbjhTz7lCXCLtTAJTS4E5Hx42wzZ3jKar3lH_bY,860
+oikan/model.py,sha256=zlw_4HbSK3IiQhE8M4NitvrXa7vffBWsOR-HLRSJADA,3944
+oikan/regularization.py,sha256=xt8JNnPdHRAQgzF_vnyme005hWLunz9Vo2qw6m08NMM,1145
+oikan/symbolic.py,sha256=RRYHOCOCJr5KXRhdcCPvT_OqyNcCnWCWt7fOtos8rRI,5765
+oikan/trainer.py,sha256=S-23uwmQ3Kx1FnE-dKd76zTZjvaV0VUZoChUsNzjcwk,1672
+oikan/utils.py,sha256=xbVgrbhXYj57RdD3uNPchjyfmP6Kur7tngoZPa3qWOw,2094
+oikan/visualize.py,sha256=VpIzWpwoZihQ0gPSRjsEuKSxqHf1SiKxLynOzZ4P6HE,1539
+oikan-0.0.1.8.dist-info/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
+oikan-0.0.1.8.dist-info/METADATA,sha256=aDbshPny4TxIE_tZt0I8I_T_9tRwkomC6zC1BHT4knw,3738
+oikan-0.0.1.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+oikan-0.0.1.8.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.1.8.dist-info/RECORD,,

oikan-0.0.1.6.dist-info/RECORD

@@ -1,12 +0,0 @@
-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=K1aI5JEPgKFu8dyjXxWDA-UZm8Gvfp0lU1M7c2NAPLY,5517
-oikan/trainer.py,sha256=itFCHSR_T6KHqa0D5RLRCmqFHa4lUIamsFGWKHmUZuI,1258
-oikan/utils.py,sha256=XwY6pgAgfYlUI9SOjdop91wh0_t6LfPLCiHretlw2Wg,1754
-oikan/visualize.py,sha256=7GTvfeFxrezHKMM9QmYaax75rMnTxMH0KYi_fbAw4-M,2501
-oikan-0.0.1.6.dist-info/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
-oikan-0.0.1.6.dist-info/METADATA,sha256=GOWOqXAAezQYOHMgxFn8sI2wlJotgesFA_8Yaiu2XS8,2962
-oikan-0.0.1.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-oikan-0.0.1.6.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.1.6.dist-info/RECORD,,