oikan 0.0.3.10__py3-none-any.whl → 0.0.3.12__py3-none-any.whl

oikan/elasticnet.py

@@ -3,7 +3,7 @@ import torch
 import numpy as np
 
 class ElasticNet(nn.Module):
-    def __init__(self, alpha=1.0, l1_ratio=0.5, fit_intercept=False, max_iter=5000, tol=1e-4, random_state=None):
+    def __init__(self, alpha=1.0, l1_ratio=0.5, fit_intercept=False, max_iter=5000, tol=1e-4, random_state=42):
         super().__init__()
         self.alpha = alpha
         self.l1_ratio = l1_ratio
@@ -21,10 +21,9 @@ class ElasticNet(nn.Module):
         if y.ndim == 1:
             y = y.reshape(-1, 1)
         n_targets = y.shape[1]
-
-        if self.random_state is not None:
-            torch.manual_seed(self.random_state)
-            np.random.seed(self.random_state)
+        
+        torch.manual_seed(self.random_state)
+        np.random.seed(self.random_state)
 
         X_tensor = torch.tensor(X, dtype=torch.float32)
         y_tensor = torch.tensor(y, dtype=torch.float32)
@@ -64,8 +63,9 @@ class ElasticNet(nn.Module):
         X = np.asarray(X, dtype=np.float32)
         if self.coef_ is None:
             raise RuntimeError("Model not fitted yet.")
-        W = self.coef_.T if self.coef_.ndim == 2 else self.coef_
-        y_pred = X @ W
-        if self.intercept_ is not None:
-            y_pred += self.intercept_
+        with torch.no_grad():
+            W = self.coef_.T if self.coef_.ndim == 2 else self.coef_
+            y_pred = X @ W
+            if self.intercept_ is not None:
+                y_pred += self.intercept_
         return y_pred

oikan/model.py

@@ -2,17 +2,17 @@ import numpy as np
 import torch
 import torch.nn as nn
 import torch.optim as optim
-from sklearn.preprocessing import PolynomialFeatures
-from abc import ABC, abstractmethod
+from tqdm import tqdm
 import json
+import sys
+from abc import ABC, abstractmethod
+from typing import List, Optional, Union
 from .elasticnet import ElasticNet
 from .neural import TabularNet
 from .utils import evaluate_basis_functions, get_features_involved, sympify_formula, get_latex_formula
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import r2_score, accuracy_score
 from .exceptions import *
-import sys
-from tqdm import tqdm
 
 class OIKAN(ABC):
     """
@@ -24,7 +24,7 @@ class OIKAN(ABC):
         List of hidden layer sizes for the neural network.
     activation : str, optional (default='relu')
         Activation function for the neural network ('relu', 'tanh', 'leaky_relu', 'elu', 'swish', 'gelu').
-    augmentation_factor : int, optional (default=10)
+    augmentation_factor : int, optional (default=1)
         Number of augmented samples per original sample.
     alpha : float, optional (default=1.0)
         ElasticNet regularization strength.
@@ -45,33 +45,34 @@ class OIKAN(ABC):
         Whether to display training progress.
     evaluate_nn : bool, optional (default=False)
         Whether to evaluate neural network performance before full training.
-    random_state: int, optional (default=None)
+    random_state: int, optional (default=42)
         Random seed for reproducibility.
     """
-    def __init__(self, hidden_sizes=[64, 64], activation='relu', augmentation_factor=10, 
-                 alpha=1.0, l1_ratio=0.5, sigma=5.0, epochs=100, lr=0.001, batch_size=32, 
-                 verbose=False, evaluate_nn=False, top_k=5, random_state=None):
+    def __init__(
+        self,
+        hidden_sizes: List[int] = [64, 64],
+        activation: str = 'relu',
+        augmentation_factor: int = 1,
+        alpha: float = 1.0,
+        l1_ratio: float = 0.5,
+        sigma: float = 5.0,
+        epochs: int = 100,
+        lr: float = 0.001,
+        batch_size: int = 32,
+        verbose: bool = False,
+        evaluate_nn: bool = False,
+        top_k: int = 5,
+        random_state: int = 42
+    ) -> None:
         if not isinstance(hidden_sizes, list) or not all(isinstance(x, int) and x > 0 for x in hidden_sizes):
             raise InvalidParameterError("hidden_sizes must be a list of positive integers")
         if activation not in ['relu', 'tanh', 'leaky_relu', 'elu', 'swish', 'gelu']:
             raise InvalidParameterError(f"Unsupported activation function: {activation}")
-        if not isinstance(augmentation_factor, int) or augmentation_factor < 1:
-            raise InvalidParameterError("augmentation_factor must be a positive integer")
-        if not isinstance(top_k, int) or top_k < 1:
-            raise InvalidParameterError("top_k must be a positive integer")
-        if not 0 < lr < 1:
-            raise InvalidParameterError("Learning rate must be between 0 and 1")
-        if not isinstance(batch_size, int) or batch_size < 1:
-            raise InvalidParameterError("batch_size must be a positive integer")
-        if not isinstance(epochs, int) or epochs < 1:
-            raise InvalidParameterError("epochs must be a positive integer")
-        if not 0 <= alpha <= 1:
-            raise InvalidParameterError("alpha must be between 0 and 1")
-        if not 0 <= l1_ratio <= 1:
-            raise InvalidParameterError("l1_ratio must be between 0 and 1")
-        if sigma <= 0:
-            raise InvalidParameterError("sigma must be positive")
-        
+        if augmentation_factor < 1 or top_k < 1 or batch_size < 1 or epochs < 1:
+            raise InvalidParameterError("augmentation_factor, top_k, batch_size, and epochs must be positive integers")
+        if not 0 < lr < 1 or not 0 <= alpha <= 1 or not 0 <= l1_ratio <= 1 or sigma <= 0:
+            raise InvalidParameterError("Invalid values for lr, alpha, l1_ratio, or sigma")
+
         self.hidden_sizes = hidden_sizes
         self.activation = activation
         self.augmentation_factor = augmentation_factor
@@ -84,24 +85,24 @@ class OIKAN(ABC):
         self.verbose = verbose
         self.evaluate_nn = evaluate_nn
         self.top_k = top_k
-        self.neural_net = None
-        self.symbolic_model = None
+        self.neural_net: Optional[TabularNet] = None
+        self.symbolic_model: Optional[dict] = None
         self.evaluation_done = False
         self.random_state = random_state
-        
-        if self.random_state is not None:
-            torch.manual_seed(self.random_state)
-            np.random.seed(self.random_state)
+        self.__version__ = '0.0.3'
+
+        torch.manual_seed(self.random_state)
+        np.random.seed(self.random_state)
 
     @abstractmethod
-    def fit(self, X, y):
+    def fit(self, X: np.ndarray, y: np.ndarray) -> None:
         pass
 
     @abstractmethod
-    def predict(self, X):
+    def predict(self, X: np.ndarray) -> np.ndarray:
         pass
 
-    def get_formula(self, type='original'): 
+    def get_formula(self, type: str = 'original') -> Union[str, List[str]]:
         """
         Returns the symbolic formula(s) as a string (regression) or list of strings (classification). 
         
@@ -149,19 +150,24 @@ class OIKAN(ABC):
                     formulas.append(f"Class {self.classes_[c]}: {formula}")
                 return formulas
 
-    def feature_importances(self):
+    def feature_importances(self, column_names: Optional[List[str]] = None) -> Union[np.ndarray, tuple]:
         """
         Computes the importance of each original feature based on the symbolic model.
         
         Returns:
         --------
-        numpy.ndarray : Normalized feature importances.
+        numpy.ndarray : Normalized feature importances. If column_names was provided, also returns a dict mapping feature name -> feature label (symbolic)
         """
         if self.symbolic_model is None:
             raise ValueError("Model not fitted yet.")
         basis_functions = self.symbolic_model['basis_functions']
         n_features = self.symbolic_model['n_features']
         importances = np.zeros(n_features)
+
+        # Validation of column names
+        if column_names is not None:
+            if not hasattr(column_names, '__len__') or len(column_names) != n_features:
+                raise InvalidParameterError("column_names must be a sequence with length equal to number of features")
         
         # Handle regression case
         if 'coefficients' in self.symbolic_model:
@@ -170,7 +176,8 @@ class OIKAN(ABC):
                 if coefficients[i] != 0:
                     features_involved = get_features_involved(func)
                     for idx in features_involved:
-                        importances[idx] += np.abs(coefficients[i])
+                        if 0 <= idx < n_features:
+                            importances[idx] += np.abs(coefficients[i])
         # Handle classification case with multiple coefficient sets
         else:
             for coef in self.symbolic_model['coefficients_list']:
@@ -178,12 +185,22 @@ class OIKAN(ABC):
                     if coef[i] != 0:
                         features_involved = get_features_involved(func)
                         for idx in features_involved:
-                            importances[idx] += np.abs(coef[i])
+                            if 0 <= idx < n_features:
+                                importances[idx] += np.abs(coef[i])
         
         total = importances.sum()
-        return importances / total if total > 0 else importances
+        normalized = importances / total if total > 0 else importances
+        
+        if column_names is not None:
+            feature_map = dict()
+            # map feature name -> formula label
+            for idx, feature_name in enumerate(column_names):
+                feature_map[feature_name] = f'x{idx}'
+            return normalized, feature_map
+
+        return normalized
 
-    def save(self, path):
+    def save(self, path: str) -> None:
         """
         Saves the symbolic model to a .json file.
         
@@ -220,7 +237,7 @@ class OIKAN(ABC):
         if self.verbose:
             print(f"Model saved to {path}")
 
-    def load(self, path):
+    def load(self, path: str) -> None:
         """
         Loads the symbolic model from a .json file.
         
@@ -253,9 +270,9 @@ class OIKAN(ABC):
         if self.verbose:
             print(f"Model loaded from {path}")
 
-    def _evaluate_neural_net(self, X, y, output_size, loss_fn):
+    def _evaluate_neural_net(self, X: np.ndarray, y: np.ndarray, output_size: int, loss_fn: nn.Module) -> None:
         """Evaluates neural network performance on train-test split."""
-        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=self.random_state)
         
         input_size = X.shape[1]
         self.neural_net = TabularNet(input_size, self.hidden_sizes, output_size, self.activation)
@@ -289,7 +306,7 @@ class OIKAN(ABC):
         # Retrain on full dataset
         self._train_neural_net(X, y, output_size, loss_fn)
 
-    def _train_neural_net(self, X, y, output_size, loss_fn):
+    def _train_neural_net(self, X: np.ndarray, y: np.ndarray, output_size: int, loss_fn: nn.Module) -> None:
         """Trains the neural network on the input data."""
         if self.evaluate_nn and not self.evaluation_done:
             self.evaluation_done = True
@@ -300,8 +317,10 @@ class OIKAN(ABC):
         if self.neural_net is None:
             self.neural_net = TabularNet(input_size, self.hidden_sizes, output_size, self.activation)
         optimizer = optim.Adam(self.neural_net.parameters(), lr=self.lr)
-        dataset = torch.utils.data.TensorDataset(torch.tensor(X, dtype=torch.float32), 
-                                         y.clone().detach())
+        dataset = torch.utils.data.TensorDataset(
+            torch.tensor(X, dtype=torch.float32), 
+            torch.tensor(y, dtype=torch.float32) 
+        )
         loader = torch.utils.data.DataLoader(dataset, batch_size=self.batch_size, shuffle=True)
         self.neural_net.train()
 
@@ -324,7 +343,7 @@ class OIKAN(ABC):
             if self.verbose:
                 epoch_iterator.set_postfix({'loss': f'{total_loss/len(loader):.4f}'})
 
-    def _generate_augmented_data(self, X):
+    def _generate_augmented_data(self, X: np.ndarray) -> np.ndarray:
         """Generates augmented data by adding Gaussian noise."""
         if self.augmentation_factor == 1:
             return np.array([]).reshape(0, X.shape[1])
@@ -337,7 +356,7 @@ class OIKAN(ABC):
 
         return np.vstack(X_aug)
 
-    def _perform_symbolic_regression(self, X, y):
+    def _perform_symbolic_regression(self, X: np.ndarray, y: np.ndarray) -> None:
         """
         Performs hierarchical symbolic regression using a two-stage approach.
         
@@ -362,14 +381,32 @@ class OIKAN(ABC):
 
         if self.verbose:
             print("\nStage 1: Coarse Model Fitting")
-            
-        coarse_degree = 2  # Fixed low degree for coarse model
-        poly_coarse = PolynomialFeatures(degree=coarse_degree, include_bias=True)
         
+        # Generate polynomial features
         if self.verbose:
             print("Generating polynomial features...")
-        X_poly_coarse = poly_coarse.fit_transform(X)
-        
+        n_samples, n_features = X.shape
+
+        bias = np.ones((n_samples, 1)) 
+        features = X 
+        powers_of_2 = X ** 2  
+
+        X_poly_coarse = np.hstack([bias, features, powers_of_2])
+        basis_functions_coarse = ['1'] + [f'x{i}' for i in range(n_features)] + [f'x{i}^2' for i in range(n_features)]
+
+        # Generate random interaction features (O(N^2) -> O(N)) 
+        if self.verbose:
+            print("Generating random interaction features...")
+        rng = np.random.default_rng(self.random_state)
+        random_pairs = rng.choice(n_features, size=(n_features // 2, 2), replace=False)
+        interaction_features = np.array([X[:, i] * X[:, j] for i, j in random_pairs]).T
+        interaction_feature_names = [f"x{i} x{j}" for i, j in random_pairs]
+
+        # Combine all features
+        X_poly_coarse = np.hstack([X_poly_coarse, interaction_features])
+        basis_functions_coarse.extend(interaction_feature_names)
+
+        # Fit coarse elastic net model
         if self.verbose:
             print("Fitting coarse elastic net model...")
         model_coarse = ElasticNet(alpha=self.alpha, l1_ratio=self.l1_ratio, fit_intercept=False, random_state=self.random_state)
@@ -377,7 +414,7 @@ class OIKAN(ABC):
 
         if self.verbose:
             print("Computing feature importances...")
-        basis_functions_coarse = poly_coarse.get_feature_names_out()
+            
         if len(y.shape) == 1 or y.shape[1] == 1:
             coef_coarse = model_coarse.coef_.flatten()
         else:
@@ -443,7 +480,7 @@ class OIKAN(ABC):
                 coef = model_refined.coef_[c]
                 indices = np.where(np.abs(coef) > 1e-6)[0]
                 selected_indices.update(indices)
-            selected_indices = list(selected_indices)
+            selected_indices = [i for i in selected_indices if i < len(basis_functions_refined)]
             basis_functions = [basis_functions_refined[i] for i in selected_indices]
             for c in range(y.shape[1]):
                 coef = model_refined.coef_[c]
@@ -454,10 +491,26 @@ class OIKAN(ABC):
                 'basis_functions': basis_functions,
                 'coefficients_list': coefficients_list
             }
+    
+    def _print_system_info(self) -> None:
+        """Prints system information (for debugging purposes)."""
+        import platform
+        import os
+        print("\n" + "="*30)
+        print("System Information:")
+        print(f"OIKAN version: {self.__version__}")
+        print(f"Python version: {platform.python_version()}")
+        print(f"NumPy version: {np.__version__}")
+        print(f"Torch version: {torch.__version__}")
+        print(f"Device: {'CUDA' if torch.cuda.is_available() else 'CPU'}")
+        print(f"Number of CPU cores: {os.cpu_count()}")
+        print(f"Memory Usage: {torch.cuda.memory_allocated() / (1024 ** 2) if torch.cuda.is_available() else 'N/A'} MB")
+        print(f"Architecture: {platform.machine()}")
+        print("="*30 + "\n")
 
 class OIKANRegressor(OIKAN):
     """OIKAN model for regression tasks."""
-    def fit(self, X, y):
+    def fit(self, X: np.ndarray, y: np.ndarray) -> None:
         """
         Fits the regressor to the data.
         
@@ -468,6 +521,9 @@ class OIKANRegressor(OIKAN):
         y : array-like of shape (n_samples,)
             Target values.
         """
+        if self.verbose:
+            self._print_system_info()
+
         X = np.asarray(X)
         y = np.asarray(y).reshape(-1, 1)
         
@@ -499,7 +555,7 @@ class OIKANRegressor(OIKAN):
         if self.verbose:
             print("OIKANRegressor model training completed successfully!")
 
-    def predict(self, X):
+    def predict(self, X: np.ndarray) -> np.ndarray:
         """
         Predicts target values for the input data.
         
@@ -522,7 +578,7 @@ class OIKANRegressor(OIKAN):
 
 class OIKANClassifier(OIKAN):
     """OIKAN model for classification tasks."""
-    def fit(self, X, y):
+    def fit(self, X: np.ndarray, y: np.ndarray) -> None:
         """
         Fits the classifier to the data.
         
@@ -533,6 +589,9 @@ class OIKANClassifier(OIKAN):
         y : array-like of shape (n_samples,)
             Target labels.
         """
+        if self.verbose:
+            self._print_system_info()
+
         X = np.asarray(X)
         from sklearn.preprocessing import LabelEncoder
         le = LabelEncoder()
@@ -569,7 +628,7 @@ class OIKANClassifier(OIKAN):
         if self.verbose:
             print("OIKANClassifier model training completed successfully!")
 
-    def predict(self, X):
+    def predict(self, X: np.ndarray) -> np.ndarray:
         """
         Predicts class labels for the input data.
         

{oikan-0.0.3.10.dist-info → oikan-0.0.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oikan
-Version: 0.0.3.10
+Version: 0.0.3.12
 Summary: OIKAN: Neuro-Symbolic ML for Scientific Discovery
 Author: Arman Zhalgasbayev
 License: MIT
@@ -9,7 +9,7 @@ Project-URL: Bug Tracker, https://github.com/silvermete0r/oikan/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: torch
@@ -62,12 +62,9 @@ OIKAN is a neuro-symbolic machine learning framework inspired by Kolmogorov-Arno
     class OIKAN:
         def __init__(self, hidden_sizes=[64, 64], activation='relu',
                     polynomial_degree=2, alpha=0.1):
-            # Neural network for learning complex patterns
-            self.neural_net = TabularNet(input_size, hidden_sizes, activation)
-            # Data augmentation for better coverage
-            self.augmented_data = self.augment_data(X, y, augmentation_factor=5)
-            # Symbolic regression for interpretable formulas
-            self.symbolic_regression = SymbolicRegression(alpha=alpha)
+            self.neural_net = TabularNet(input_size, hidden_sizes, activation) # NN for predicting values in Data Augmentation (Additional)
+            self.augmented_data = self.augment_data(X, y, augmentation_factor=5) # Generate augmented samples (Additional)
+            self.symbolic_regression = SymbolicRegression(alpha=alpha, l1_ratio=0.5) # ElasticNet for symbolic regression (Main part)
    ```
 
 2. **Basis Functions**: Core set of interpretable transformations:
@@ -111,7 +108,7 @@ pip install -e .  # Install in development mode
 
 | Requirement       | Details                              |
 |-------------------|--------------------------------------|
-| Python            | Version 3.7 or higher               |
+| Python            | Version 3.11 or higher               |
 | Operating System  | Platform independent (Windows/macOS/Linux) |
 | Memory            | Recommended minimum 4GB RAM         |
 | Disk Space        | ~100MB for installation (including dependencies) |
@@ -120,7 +117,7 @@ pip install -e .  # Install in development mode
 
 ### Regression Example
 
-> **Suggestion:** Please ensure that the data is normalized using standard scaling (or another suitable normalization method), as Elastic Net assumes that the model intercept has already been accounted for.
+> **Suggestion:** Please ensure that the data is normalized using standard scaling (or another suitable normalization method), as ElasticNet assumes that the model intercept has already been accounted for.
 
 ```python
 from oikan import OIKANRegressor
@@ -130,7 +127,7 @@ from sklearn.metrics import mean_squared_error
 model = OIKANRegressor(
     hidden_sizes=[32, 32], # Hidden layer sizes
     activation='relu', # Activation function (other options: 'tanh', 'leaky_relu', 'elu', 'swish', 'gelu')
-    augmentation_factor=5, # Augmentation factor for data generation
+    augmentation_factor=5, # Augmentation factor for data generation (default: 1)
     alpha=1.0, # ElasticNet regularization strength (Symbolic regression)
     l1_ratio=0.5, # ElasticNet mixing parameter (0 <= l1_ratio <= 1). 0 is equivalent to Ridge regression, 1 is equivalent to Lasso (Symbolic regression)
     sigma=5, # Standard deviation of Gaussian noise for data augmentation
@@ -140,7 +137,7 @@ model = OIKANRegressor(
     batch_size=32, # Batch size for training
     verbose=True, # Verbose output during training
     evaluate_nn=True, # Validate neural network performance before full process
-    random_state=42 # Random seed for reproducibility
+    random_state=42 # Random seed for reproducibility (default: 42)
 )
 
 # Fit the model
@@ -174,7 +171,7 @@ loaded_model.load("outputs/model.json")
 
 ### Classification Example
 
-> **Suggestion:** Please ensure that the data is normalized using standard scaling (or another suitable normalization method), as Elastic Net assumes that the model intercept has already been accounted for.
+> **Suggestion:** Please ensure that the data is normalized using standard scaling (or another suitable normalization method), as ElasticNet assumes that the model intercept has already been accounted for.
 
 ```python
 from oikan import OIKANClassifier
@@ -184,7 +181,7 @@ from sklearn.metrics import accuracy_score
 model = OIKANClassifier(
     hidden_sizes=[32, 32], # Hidden layer sizes
     activation='relu', # Activation function (other options: 'tanh', 'leaky_relu', 'elu', 'swish', 'gelu')
-    augmentation_factor=10, # Augmentation factor for data generation
+    augmentation_factor=10, # Augmentation factor for data generation (default: 1)
     alpha=1.0, # ElasticNet regularization strength (Symbolic regression)
     l1_ratio=0.5, # ElasticNet mixing parameter (0 <= l1_ratio <= 1). 0 is equivalent to Ridge regression, 1 is equivalent to Lasso (Symbolic regression)
     sigma=5, # Standard deviation of Gaussian noise for data augmentation
@@ -194,7 +191,7 @@ model = OIKANClassifier(
     batch_size=32, # Batch size for training
     verbose=True, # Verbose output during training
     evaluate_nn=True, # Validate neural network performance before full process
-    random_state=42 # Random seed for reproducibility
+    random_state=42 # Random seed for reproducibility (default: 42)
 )
 
 # Fit the model

oikan-0.0.3.12.dist-info/RECORD

@@ -0,0 +1,11 @@
+oikan/__init__.py,sha256=Dh1Rf9ONRdm75B6tFiv9Y9P6NNiHAiKPCGDMuag6TTE,724
+oikan/elasticnet.py,sha256=37vy1eCtzME7RQzcYWQ_VNCwLF4Vg6cW7-qJFpLgqKg,2616
+oikan/exceptions.py,sha256=GhHWqy2Q5LVBcteTy4ngnqxr7FOoLNyD8dNt1kfRXyw,901
+oikan/model.py,sha256=C-ykucsDEIc6Zejw8_0Wn2K2SlhpZ853j1CNiAqIpgw,28846
+oikan/neural.py,sha256=PZjaffSuABuCNxu-7PinU1GR6ji0Y6xRgSQ3n5HRDxI,1572
+oikan/utils.py,sha256=7UCm9obO-8Q2zhetdAkukMDOZvGSBWUL_dSF04XqM7k,8808
+oikan-0.0.3.12.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
+oikan-0.0.3.12.dist-info/METADATA,sha256=WJq7-4Q8zA0o90pdlQL-X8WM91q6xkz_bFmlr9PIXNo,13172
+oikan-0.0.3.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+oikan-0.0.3.12.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.3.12.dist-info/RECORD,,

oikan-0.0.3.10.dist-info/RECORD

@@ -1,11 +0,0 @@
-oikan/__init__.py,sha256=Dh1Rf9ONRdm75B6tFiv9Y9P6NNiHAiKPCGDMuag6TTE,724
-oikan/elasticnet.py,sha256=eeuK4lJ-7lsGZIyiXNH6NKYxhbbKbPp1kp8vLe4t7_4,2614
-oikan/exceptions.py,sha256=GhHWqy2Q5LVBcteTy4ngnqxr7FOoLNyD8dNt1kfRXyw,901
-oikan/model.py,sha256=lI5YTJr7a9ohVQv4B4lDcOueNIC5NARbuap3OKIr_gs,26213
-oikan/neural.py,sha256=PZjaffSuABuCNxu-7PinU1GR6ji0Y6xRgSQ3n5HRDxI,1572
-oikan/utils.py,sha256=7UCm9obO-8Q2zhetdAkukMDOZvGSBWUL_dSF04XqM7k,8808
-oikan-0.0.3.10.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
-oikan-0.0.3.10.dist-info/METADATA,sha256=aVF1sUBOPHZeaiIebwFvpIwIw9W-XXqI13B0kkXK3X8,13127
-oikan-0.0.3.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-oikan-0.0.3.10.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.3.10.dist-info/RECORD,,