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

oikan/metrics.py

@@ -1,23 +1,48 @@
 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.'''
+    '''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("Mean Squared Error:", mse)
-    print("Mean Absolute Error:", mae)
-    print("Root Mean Squared Error:", rmse)
+    
+    # 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 accuracy by comparing model predictions and true labels.'''
+    '''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)
-    print("Classification Accuracy:", accuracy)
-    return accuracy
+    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/model.py

@@ -15,28 +15,40 @@ class AdaptiveBasisLayer(nn.Module):
 
 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'):
+    def __init__(self, input_dim, hidden_units=10, basis_type='bsplines'):
         super().__init__()
         self.input_dim = input_dim
         self.hidden_units = hidden_units
         self.basis_type = basis_type
         
-        if basis_type == 'bspline':
-            # One BSpline per feature expected with adjusted output dimensions
+        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)  # Adjusted for BSpline output
+            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_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}")
+        
         # 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 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)
+        # 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)
@@ -53,25 +65,35 @@ class EfficientKAN(nn.Module):
         return self.basis_output_dim + self.input_dim
 
 class OIKAN(nn.Module):
-    '''Main OIKAN model combining nonlinear transformations, SVD-projection, and interpretable layers.'''
-    def __init__(self, input_dim, output_dim, hidden_units=10, reduced_dim=32):
+    '''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.efficientkan = EfficientKAN(input_dim, hidden_units)
+        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)
+        else:
+            self.efficientkan = EfficientKAN(input_dim, hidden_units, basis_type)
         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
+        feature_dim = reduced_dim
         self.interpretable_layers = nn.Sequential(
             AdaptiveBasisLayer(feature_dim, 32),
             nn.ReLU(),
             AdaptiveBasisLayer(32, output_dim)
         )
-    
+
     def forward(self, x):
-        transformed_x = self.efficientkan(x)
-        # Compress features prior to final prediction layer
+        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
+        else:
+            x_in = x
+        transformed_x = self.efficientkan(x_in)
         transformed_x = self.svd_projection(transformed_x)
         return self.interpretable_layers(transformed_x)

oikan/trainer.py

@@ -2,7 +2,7 @@ import torch
 import torch.nn as nn
 from .regularization import RegularizedLoss
 
-def train(model, train_data, epochs=100, lr=0.01, save_path=None):
+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.
     '''
@@ -19,13 +19,13 @@ def train(model, train_data, epochs=100, lr=0.01, save_path=None):
         loss.backward()  # Backpropagate errors
         optimizer.step()  # Update parameters
         
-        if (epoch + 1) % 10 == 0:
+        if (epoch + 1) % 10 == 0 and verbose:
             print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
-    if save_path:
+    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):
+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.
     '''
@@ -42,8 +42,8 @@ def train_classification(model, train_data, epochs=100, lr=0.01, save_path=None)
         loss.backward()  # Backpropagation
         optimizer.step()  # Parameter update
         
-        if (epoch + 1) % 10 == 0:
+        if (epoch + 1) % 10 == 0 and verbose:
             print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
-    if save_path:
+    if save_path is not None:
         torch.save(model.state_dict(), save_path)
         print(f"Model saved to {save_path}")

oikan/visualize.py

@@ -7,8 +7,6 @@ def visualize_regression(model, X, y):
     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')
@@ -18,9 +16,7 @@ def visualize_regression(model, X, y):
 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)
@@ -28,42 +24,46 @@ def visualize_classification(model, X, y):
         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)
+        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.9.dist-info → oikan-0.0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: oikan
-Version: 0.0.1.9
+Version: 0.0.1.11
 Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
 Author: Arman Zhalgasbayev
 License: MIT

oikan-0.0.1.11.dist-info/RECORD

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

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

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

oikan-0.0.1.9.dist-info/RECORD

@@ -1,13 +0,0 @@
-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=M7F5FLCXB5HUKhMRJiX92o0DB9NHWZIb25bGgyYwXrM,1986
-oikan/utils.py,sha256=xbVgrbhXYj57RdD3uNPchjyfmP6Kur7tngoZPa3qWOw,2094
-oikan/visualize.py,sha256=sA__nLB35y6tuWDAM3aoC7VezxJAvdSlwzmoPfrnFhQ,2249
-oikan-0.0.1.9.dist-info/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
-oikan-0.0.1.9.dist-info/METADATA,sha256=ZyH9i_F8ymdalTVQxVbyyEFUa0xPLt7byLXP5zVfjO0,3847
-oikan-0.0.1.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-oikan-0.0.1.9.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.1.9.dist-info/RECORD,,