dragon-ml-toolbox 1.4.0__py3-none-any.whl → 1.4.2__py3-none-any.whl

ml_tools/particle_swarm_optimization.py

@@ -5,18 +5,23 @@ import xgboost as xgb
 import lightgbm as lgb
 from sklearn.ensemble import HistGradientBoostingClassifier, HistGradientBoostingRegressor
 from sklearn.base import ClassifierMixin
-from sklearn.preprocessing import StandardScaler
-from typing import Literal, Union, Tuple, Dict
-from collections.abc import Sequence
+from typing import Literal, Union, Tuple, Dict, Optional
 import polars as pl
 from functools import partial
+from .utilities import sanitize_filename, _script_info, threshold_binary_values
+
+
+__all__ = [
+    "ObjectiveFunction",
+    "run_pso"
+]
 
 
 class ObjectiveFunction():
     """
-    Callable objective function designed for optimizing continuous outputs from regression models.
+    Callable objective function designed for optimizing continuous outputs from tree-based regression models.
     
-    The trained model must include a 'model' and a 'scaler'. Additionally 'feature_names' and 'target_name' will be parsed if present.
+    The target serialized file (joblib) must include a trained tree-based 'model'. Additionally 'feature_names' and 'target_name' will be parsed if present.
 
     Parameters
     ----------
@@ -29,15 +34,14 @@ class ObjectiveFunction():
     task : Literal, default 'maximization'
         Whether to maximize or minimize the target.
     """
-    def __init__(self, trained_model_path: str, add_noise: bool=True, task: Literal["maximization", "minimization"]="maximization", binary_features: int=0) -> None:
+    def __init__(self, trained_model_path: str, add_noise: bool, task: Literal["maximization", "minimization"], binary_features: int=0) -> None:
         self.binary_features = binary_features
         self.is_hybrid = False if binary_features <= 0 else True
         self.use_noise = add_noise
         self._artifact = joblib.load(trained_model_path)
         self.model = self._get_from_artifact('model')
-        self.scaler = self._get_from_artifact('scaler')
-        self.feature_names: list[str] = self._get_from_artifact('feature_names') # type: ignore
-        self.target_name: str = self._get_from_artifact('target_name') # type: ignore
+        self.feature_names: Optional[list[str]] = self._get_from_artifact('feature_names') # type: ignore
+        self.target_name: Optional[str] = self._get_from_artifact('target_name') # type: ignore
         self.task = task
         self.check_model() # check for classification models and None values
     
@@ -45,16 +49,15 @@ class ObjectiveFunction():
         if self.use_noise:
             features_array = self.add_noise(features_array)
         if self.is_hybrid:
-            features_array = self._handle_hybrid(features_array)
+            features_array = threshold_binary_values(input_array=features_array, binary_features=self.binary_features)
         
         if features_array.ndim == 1:
             features_array = features_array.reshape(1, -1)
         
-        # scale features as the model expects
-        features_array = self.scaler.transform(features_array) # type: ignore
-        
         result = self.model.predict(features_array) # type: ignore
         scalar = result.item()
+        # print(f"[DEBUG] Model predicted: {scalar}")
+        
         # pso minimizes by default, so we return the negative value to maximize
         if self.task == "maximization":
             return -scalar
@@ -62,23 +65,22 @@ class ObjectiveFunction():
             return scalar
     
     def add_noise(self, features_array):
-        noise_range = np.random.uniform(0.95, 1.05, size=features_array.shape)
-        new_feature_values = features_array * noise_range
-        return new_feature_values
-    
-    def _handle_hybrid(self, features_array):
-        feat_continuous = features_array[:self.binary_features]
-        feat_binary = (features_array[self.binary_features:] > 0.5).astype(int) #threshold binary values
-        new_feature_values = np.concatenate([feat_continuous, feat_binary])
-        return new_feature_values
+        if self.binary_features > 0:
+            split_idx = -self.binary_features
+            cont_part = features_array[:split_idx]
+            bin_part = features_array[split_idx:]
+            noise = np.random.uniform(0.95, 1.05, size=cont_part.shape)
+            cont_noised = cont_part * noise
+            return np.concatenate([cont_noised, bin_part])
+        else:
+            noise = np.random.uniform(0.95, 1.05, size=features_array.shape)
+            return features_array * noise 
     
     def check_model(self):
         if isinstance(self.model, ClassifierMixin) or isinstance(self.model, xgb.XGBClassifier) or isinstance(self.model, lgb.LGBMClassifier):
             raise ValueError(f"[Model Check Failed] ❌\nThe loaded model ({type(self.model).__name__}) is a Classifier.\nOptimization is not suitable for standard classification tasks.")
         if self.model is None:
             raise ValueError("Loaded model is None")
-        if self.scaler is None:
-            raise ValueError("Loaded scaler is None")
 
     def _get_from_artifact(self, key: str):
         val = self._artifact.get(key)
@@ -89,10 +91,10 @@ class ObjectiveFunction():
         return result
     
     def __repr__(self):
-        return (f"<ObjectiveFunction(model={type(self.model).__name__}, scaler={type(self.scaler).__name__}, use_noise={self.use_noise}, is_hybrid={self.is_hybrid}, task='{self.task}')>")
+        return (f"<ObjectiveFunction(model={type(self.model).__name__}, use_noise={self.use_noise}, is_hybrid={self.is_hybrid}, task='{self.task}')>")
 
 
-def _set_boundaries(lower_boundaries: Sequence[float], upper_boundaries: Sequence[float]):
+def _set_boundaries(lower_boundaries: list[float], upper_boundaries: list[float]):
     assert len(lower_boundaries) == len(upper_boundaries), "Lower and upper boundaries must have the same length."
     assert len(lower_boundaries) >= 1, "At least one boundary pair is required."
     lower = np.array(lower_boundaries)
@@ -112,31 +114,40 @@ def _save_results(*dicts, save_dir: str, target_name: str):
     combined_dict = dict()
     for single_dict in dicts:
         combined_dict.update(single_dict)
-        
-    full_path = os.path.join(save_dir, f"results_{target_name}.csv")
+    
+    sanitized_target_name = sanitize_filename(target_name)
+    
+    full_path = os.path.join(save_dir, f"Optimization_{sanitized_target_name}.csv")
     pl.DataFrame(combined_dict).write_csv(full_path)
 
 
-def run_pso(lower_boundaries: Sequence[float], upper_boundaries: Sequence[float], objective_function: ObjectiveFunction,
-            save_results_dir: str, 
+def run_pso(lower_boundaries: list[float], 
+            upper_boundaries: list[float], 
+            objective_function: ObjectiveFunction,
+            save_results_dir: str,
+            auto_binary_boundaries: bool=True,
             target_name: Union[str, None]=None, 
             feature_names: Union[list[str], None]=None,
-            swarm_size: int=100, max_iterations: int=100,
+            swarm_size: int=200, 
+            max_iterations: int=400,
             inequality_constrain_function=None, 
-            post_hoc_analysis: Union[int, None]=None) -> Tuple[Dict[str, float | list[float]], Dict[str, float | list[float]]]:
+            post_hoc_analysis: Optional[int]=3,
+            workers: int=3) -> Tuple[Dict[str, float | list[float]], Dict[str, float | list[float]]]:
     """
-    Executes Particle Swarm Optimization (PSO) to optimize a given objective function and saves the results.
+    Executes Particle Swarm Optimization (PSO) to optimize a given objective function and saves the results as a CSV file.
 
     Parameters
     ----------
-    lower_boundaries : Sequence[float]
-        Lower bounds for each feature in the search space.
-    upper_boundaries : Sequence[float]
-        Upper bounds for each feature in the search space.
+    lower_boundaries : list[float]
+        Lower bounds for each feature in the search space (as many as features expected by the model).
+    upper_boundaries : list[float]
+        Upper bounds for each feature in the search space (as many as features expected by the model).
     objective_function : ObjectiveFunction
-        A callable object encapsulating a regression model and its scaler.
+        A callable object encapsulating a tree-based regression model.
     save_results_dir : str
         Directory path to save the results CSV file.
+    auto_binary_boundaries : bool
+        Use `ObjectiveFunction.binary_features` to append as many binary boundaries as needed to `lower_boundaries` and `upper_boundaries` automatically.
     target_name : str or None, optional
         Name of the target variable. If None, attempts to retrieve from the ObjectiveFunction object.
     feature_names : list[str] or None, optional
@@ -147,32 +158,39 @@ def run_pso(lower_boundaries: Sequence[float], upper_boundaries: Sequence[float]
         Maximum number of iterations for the optimization algorithm.
     inequality_constrain_function : callable or None, optional
         Optional function defining inequality constraints to be respected by the optimization.
-    post_hoc_analysis : int or None, optional
+    post_hoc_analysis : int or None
         If specified, runs the optimization multiple times to perform post hoc analysis. The value indicates the number of repetitions.
+    workers : int
+        Number of parallel processes to use.
 
     Returns
     -------
     Tuple[Dict[str, float | list[float]], Dict[str, float | list[float]]]
         If `post_hoc_analysis` is None, returns two dictionaries:
-            - best_features_named: Feature values (after inverse scaling) that yield the best result.
-            - best_target_named: Best result obtained for the target variable.
+            - feature_names: Feature values (after inverse scaling) that yield the best result.
+            - target_name: Best result obtained for the target variable.
 
         If `post_hoc_analysis` is an integer, returns two dictionaries:
-            - all_best_features_named: Lists of best feature values (after inverse scaling) for each repetition.
-            - all_best_targets_named: List of best target values across repetitions.
+            - feature_names: Lists of best feature values (after inverse scaling) for each repetition.
+            - target_name: List of best target values across repetitions.
 
     Notes
     -----
     - PSO minimizes the objective function by default; if maximization is desired, it should be handled inside the ObjectiveFunction.
-    - Feature values are scaled before being passed to the model and inverse-transformed before result saving.
     """
+    # Append binary boundaries
+    binary_number = objective_function.binary_features
+    if auto_binary_boundaries and binary_number > 0:
+        lower_boundaries.extend([0] * binary_number)
+        upper_boundaries.extend([1] * binary_number)
+
     lower, upper = _set_boundaries(lower_boundaries, upper_boundaries)
-    
+
     # feature names
     if feature_names is None and objective_function.feature_names is not None:
         feature_names = objective_function.feature_names
     names = _set_feature_names(size=len(lower_boundaries), names=feature_names)
-        
+
     # target name
     if target_name is None and objective_function.target_name is not None:
         target_name = objective_function.target_name
@@ -186,20 +204,25 @@ def run_pso(lower_boundaries: Sequence[float], upper_boundaries: Sequence[float]
             "f_ieqcons": inequality_constrain_function,
             "swarmsize": swarm_size,
             "maxiter": max_iterations,
-            "processes": 1,
-            "particle_output": True
+            "processes": workers,
+            "particle_output": False
     }
     
-    if post_hoc_analysis is None:
-        # best_features, best_target = pso(**arguments)
-        best_features, best_target, _particle_positions, _target_values_per_position = pso(**arguments)
+    os.makedirs(save_results_dir, exist_ok=True)
+    
+    if post_hoc_analysis is None or post_hoc_analysis == 1:
+        best_features, best_target, *_ = _pso(**arguments)
+        # best_features, best_target, _particle_positions, _target_values_per_position = _pso(**arguments)
         
-        # inverse transformation
-        best_features = np.array(best_features).reshape(1, -1)
-        best_features_real = objective_function.scaler.inverse_transform(best_features).flatten() # type: ignore
+        # flip best_target if maximization was used
+        if objective_function.task == "maximization":
+            best_target = -best_target
+        
+        # threshold binary features
+        best_features_threshold = threshold_binary_values(best_features, binary_number)
         
         # name features
-        best_features_named = {name: value for name, value in zip(names, best_features_real)}
+        best_features_named = {name: value for name, value in zip(names, best_features_threshold)}
         best_target_named = {target_name: best_target}
         
         # save results
@@ -209,15 +232,18 @@ def run_pso(lower_boundaries: Sequence[float], upper_boundaries: Sequence[float]
     else:
         all_best_targets = list()
         all_best_features = [[] for _ in range(len(lower_boundaries))]
-        for  _ in range(post_hoc_analysis):
-            # best_features, best_target = pso(**arguments)
-            best_features, best_target, _particle_positions, _target_values_per_position = pso(**arguments)
+        for _ in range(post_hoc_analysis):
+            best_features, best_target, *_ = _pso(**arguments)
+            # best_features, best_target, _particle_positions, _target_values_per_position = _pso(**arguments)
+            
+            # flip best_target if maximization was used
+            if objective_function.task == "maximization":
+                best_target = -best_target
             
-            # inverse transformation
-            best_features = np.array(best_features).reshape(1, -1)
-            best_features_real = objective_function.scaler.inverse_transform(best_features).flatten() # type: ignore
+            # threshold binary features
+            best_features_threshold = threshold_binary_values(best_features, binary_number)
             
-            for i, best_feature in enumerate(best_features_real):
+            for i, best_feature in enumerate(best_features_threshold):
                 all_best_features[i].append(best_feature)
             all_best_targets.append(best_target)
         
@@ -231,6 +257,8 @@ def run_pso(lower_boundaries: Sequence[float], upper_boundaries: Sequence[float]
         return all_best_features_named, all_best_targets_named # type: ignore
 
 
+def info():
+    _script_info(__all__)
 
 
 ### SOURCE CODE FOR PSO ###
@@ -249,7 +277,7 @@ def _cons_ieqcons_wrapper(ieqcons, args, kwargs, x):
 def _cons_f_ieqcons_wrapper(f_ieqcons, args, kwargs, x):
     return np.array(f_ieqcons(x, *args, **kwargs))
     
-def pso(func, lb, ub, ieqcons=[], f_ieqcons=None, args=(), kwargs={}, 
+def _pso(func, lb, ub, ieqcons=[], f_ieqcons=None, args=(), kwargs={}, 
         swarmsize=100, omega=0.5, phip=0.5, phig=0.5, maxiter=100, 
         minstep=1e-8, minfunc=1e-8, debug=False, processes=1,
         particle_output=False):
@@ -377,7 +405,7 @@ def pso(func, lb, ub, ieqcons=[], f_ieqcons=None, args=(), kwargs={},
         for i in range(S):
             fx[i] = obj(x[i, :])
             fs[i] = is_feasible(x[i, :])
-       
+    
     # Store particle's best position (if constraints are satisfied)
     i_update = np.logical_and((fx < fp), fs)
     p[i_update, :] = x[i_update, :].copy()

ml_tools/pytorch_models.py

@@ -1,5 +1,12 @@
 import torch
 from torch import nn
+from .utilities import _script_info
+
+
+__all__ = [
+    "MyNeuralNetwork",
+    "MyLSTMNetwork"
+]
 
 
 class MyNeuralNetwork(nn.Module):
@@ -73,9 +80,11 @@ class MyNeuralNetwork(nn.Module):
         return X
 
 
-class MyConvolutionalNetwork(nn.Module):
+class _MyConvolutionalNetwork(nn.Module):
     def __init__(self, outputs: int, color_channels: int=3, img_size: int=256, drop_out: float=0.2):
         """
+        - EDUCATIONAL PURPOSES ONLY, not optimized and requires lots of memory.
+        
         Create a basic Convolutional Neural Network with two convolution layers with a pooling layer after each convolution.
 
         Args:
@@ -225,3 +234,6 @@ class MyLSTMNetwork(nn.Module):
         else:
             return output
 
+
+def info():
+    _script_info(__all__)

ml_tools/trainer.py

@@ -6,6 +6,12 @@ import matplotlib.pyplot as plt
 import torch
 from torch import nn
 from sklearn.metrics import mean_squared_error, classification_report, ConfusionMatrixDisplay, roc_curve, roc_auc_score, r2_score, median_absolute_error
+from .utilities import _script_info
+
+
+__all__ = [
+    "MyTrainer"
+]
 
 
 class MyTrainer():
@@ -288,36 +294,6 @@ class MyTrainer():
                 print(f"Area under the curve score: {area_under_curve:4.2f}")
         else:
             print("Error encountered while retrieving 'model.kind' attribute.")
-            
-
-    def forecast(self, samples_list: list[torch.Tensor], view_as: tuple[int,int]=(1,-1)):
-        """
-            DEPRECATED - Use `helpers.model_predict()` instead
-        
-        Returns a list containing lists of predicted values, one for each sample. 
-        
-        Each sample must be a tensor and have the same shape and normalization expected by the model 
-        (this method will add the batch dimension automatically).
-
-        Args:
-            `samples_list`: list of tensors.
-            
-            `view_as`: reshape each output, default is (1,-1).
-
-        Returns: List of lists.
-        """
-        self.model.eval()
-        results = list()
-        with torch.no_grad():
-            for data_point in samples_list:
-                data_point = data_point.unsqueeze(0).to(self.device)
-                output = self.model(data_point)
-                if self.kind == "classification":
-                    results.append(output.argmax(dim=1).view(view_as).cpu().tolist())
-                else:  #regression
-                    results.append(output.view(view_as).cpu().tolist())
-        
-        return results
     
     
     def rnn_forecast(self, sequence: torch.Tensor, steps: int):
@@ -364,3 +340,7 @@ class MyTrainer():
         # Cast to array and return
         predictions = numpy.array(predictions)
         return predictions
+
+
+def info():
+    _script_info(__all__)

ml_tools/utilities.py

@@ -4,6 +4,20 @@ import pandas as pd
 import os
 from pathlib import Path
 import re
+from typing import Literal, Union, Sequence
+
+
+# Keep track of available tools
+__all__ = [
+    "list_csv_paths",
+    "load_dataframe",
+    "yield_dataframes_from_dir",
+    "merge_dataframes",
+    "save_dataframe",
+    "normalize_mixed_list",
+    "sanitize_filename",
+    "threshold_binary_values"
+]
 
 
 def list_csv_paths(directory: str) -> dict[str, str]:
@@ -76,11 +90,93 @@ def yield_dataframes_from_dir(datasets_dir: str):
     for df_name, df_path in list_csv_paths(datasets_dir).items():
         df, _ = load_dataframe(df_path)
         yield df, df_name
+
+
+def merge_dataframes(
+    *dfs: pd.DataFrame,
+    reset_index: bool = False,
+    direction: Literal["horizontal", "vertical"] = "horizontal"
+) -> pd.DataFrame:
+    """
+    Merges multiple DataFrames either horizontally or vertically.
+
+    Parameters:
+        *dfs (pd.DataFrame): Variable number of DataFrames to merge.
+        reset_index (bool): Whether to reset index in the final merged DataFrame.
+        direction (["horizontal" | "vertical"]):
+            - "horizontal": Merge on index, adding columns.
+            - "vertical": Append rows; all DataFrames must have identical columns.
+
+    Returns:
+        pd.DataFrame: A single merged DataFrame.
+
+    Raises:
+        ValueError:
+            - If fewer than 2 DataFrames are provided.
+            - If indexes do not match for horizontal merge.
+            - If column names or order differ for vertical merge.
+    """
+    if len(dfs) < 2:
+        raise ValueError("At least 2 DataFrames must be provided.")
+    
+    for i, df in enumerate(dfs, start=1):
+        print(f"DataFrame {i} shape: {df.shape}")
+    
+
+    if direction == "horizontal":
+        reference_index = dfs[0].index
+        for i, df in enumerate(dfs, start=1):
+            if not df.index.equals(reference_index):
+                raise ValueError(f"Indexes do not match: Dataset 1 and Dataset {i}.")
+        merged_df = pd.concat(dfs, axis=1)
+
+    elif direction == "vertical":
+        reference_columns = dfs[0].columns
+        for i, df in enumerate(dfs, start=1):
+            if not df.columns.equals(reference_columns):
+                raise ValueError(f"Column names/order do not match: Dataset 1 and Dataset {i}.")
+        merged_df = pd.concat(dfs, axis=0)
+
+    else:
+        raise ValueError(f"Invalid merge direction: {direction}")
+
+    if reset_index:
+        merged_df = merged_df.reset_index(drop=True)
+
+    print(f"Merged DataFrame shape: {merged_df.shape}")
+
+    return merged_df
+
+
+def save_dataframe(df: pd.DataFrame, save_dir: str, filename: str) -> None:
+    """
+    Save a pandas DataFrame to a CSV file.
+
+    Parameters:
+        df: pandas.DataFrame to save
+        save_dir: str, directory where the CSV file will be saved.
+        filename: str, CSV filename, extension will be added if missing.
+    """
+    if df.empty:
+        print(f"⚠️ Attempting to save an empty DataFrame: '{filename}'. Process Skipped.")
+        return
+    
+    os.makedirs(save_dir, exist_ok=True)
+    
+    filename = sanitize_filename(filename)
+    
+    if not filename.endswith('.csv'):
+        filename += '.csv'
         
+    output_path = os.path.join(save_dir, filename)
         
+    df.to_csv(output_path, index=False, encoding='utf-8')
+    print(f"✅ Saved file: '{filename}'")
+
+
 def normalize_mixed_list(data: list, threshold: int = 2) -> list[float]:
     """
-    Normalize a mixed list of numeric values and strings so that the sum of the values equals 1.0,
+    Normalize a mixed list of numeric values and strings casted to floats so that the sum of the values equals 1.0,
     applying heuristic adjustments to correct for potential data entry scale mismatches.
 
     Parameters:
@@ -168,27 +264,46 @@ def sanitize_filename(filename: str) -> str:
     return sanitized
 
 
-def save_dataframe(df: pd.DataFrame, save_dir: str, filename: str) -> None:
+def threshold_binary_values(
+    input_array: Union[Sequence[float], np.ndarray],
+    binary_features: int
+) -> np.ndarray:
     """
-    Save a pandas DataFrame to a CSV file.
+    Thresholds binary features in a 1D numeric sequence. Binary features must be located at the end of the sequence.
+
+    Converts binary elements to values (0 or 1) using a threshold of 0.5. The rest of the array (assumed to be continuous features) is returned unchanged.
 
     Parameters:
-        df: pandas.DataFrame to save
-        save_dir: str, directory where the CSV file will be saved.
-        filename: str, CSV filename, extension will be added if missing.
+        input_array (Union[Sequence[float], np.ndarray]) : A one-dimensional collection of numeric values. The binary features must be located at the end of the array.
+
+        binary_features (int) : Number of binary features to threshold from the end of the array. Must be between 0 and the total number of elements.
+
+    Returns:
+        np.ndarray : A 1D NumPy array where the final `binary_features` values have been binarized.
     """
-    if df.empty:
-        print(f"⚠️ Attempting to save an empty DataFrame: '{filename}'. Process Skipped.")
-        return
+    array = np.asarray(input_array).flatten()
+    total = array.shape[0]
     
-    os.makedirs(save_dir, exist_ok=True)
+    if binary_features < 0 or binary_features > total:
+        raise ValueError("Binary features must be between 0 and the total number of features.")
     
-    filename = sanitize_filename(filename)
+    if binary_features == 0:
+        return array
+
+    cont_part = array[:-binary_features]
+    bin_part = (array[-binary_features:] > 0.5).astype(int)
     
-    if not filename.endswith('.csv'):
-        filename += '.csv'
-        
-    output_path = os.path.join(save_dir, filename)
-        
-    df.to_csv(output_path, index=False, encoding='utf-8')
-    print(f"✅ Saved file: '{filename}'")
+    return np.concatenate([cont_part, bin_part])
+
+
+def _script_info(all_data: list[str]):
+    """
+    List available names.
+    """
+    print("Available functions and objects:")
+    for i, name in enumerate(all_data, start=1):
+            print(f"{i} - {name}")
+
+
+def info():
+    _script_info(__all__)

ml_tools/vision_helpers.py

@@ -4,9 +4,18 @@ from PIL import Image, ImageOps
 from typing import Literal
 from torchvision import transforms
 import torch
+from .utilities import _script_info
+
+
+__all__ = [
+    "inspect_images",
+    "image_augmentation",
+    "ResizeAspectFill",
+    "is_image",
+    "model_predict"
+]
 
 
-# --- Helper Functions ---
 def inspect_images(path: str):
     """
     Prints out the types, sizes and channels of image files found in the directory and its subdirectories.
@@ -216,3 +225,7 @@ def model_predict(model: torch.nn.Module, kind: Literal["regression", "classific
                 results.append(output.view(view_as).cpu().tolist())
     
     return results
+
+
+def info():
+    _script_info(__all__)

dragon_ml_toolbox-1.4.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-dragon_ml_toolbox-1.4.0.dist-info/licenses/LICENSE,sha256=2uUFNy7D0TLgHim1K5s3DIJ4q_KvxEXVilnU20cWliY,1066
-dragon_ml_toolbox-1.4.0.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=e1Hg5ZtaBpDV7ZvxhLe1ac28l7nMjvi1MSE5YvB1s-o,1472
-ml_tools/MICE_imputation.py,sha256=4kqZiesk8vyh4MBLnNE9grflG4fDusqzuYBElsbk4LY,9484
-ml_tools/VIF_factor.py,sha256=rHSAxQcXLrG8dIjCXBAvETsSkCBfYus9NqimOnm2Bvk,9559
-ml_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ml_tools/data_exploration.py,sha256=qtkGumckC2PmTpj3brVFi072ewX0OI6dwUF4Or7Yikg,21341
-ml_tools/datasetmaster.py,sha256=VUneKshnmjOGbtqVVGTFcIMRKF3s6ZDYrosIYKDjD80,28956
-ml_tools/ensemble_learning.py,sha256=wK6mtOE4v9AWlxkcWhJj5XZjREChxb46kE0i2IxS-OE,28372
-ml_tools/handle_excel.py,sha256=IR0VQc3hYdmjwC31E5YxDnRcWig4jSIx7Y_7to-KZz4,11969
-ml_tools/logger.py,sha256=XwSpCUzw2Le24fJHyljBxNLgw63SwjZ0pMjTJqf0ylI,4622
-ml_tools/particle_swarm_optimization.py,sha256=jpkje4OETC9fyISxxUTx4XGrImSU6gDEcwz46ZDs2bQ,19250
-ml_tools/pytorch_models.py,sha256=Oykw02sOZLCjvSadQd64UGesBN7kq0x1EGXHusvYiQI,9908
-ml_tools/trainer.py,sha256=Zd7AaHeoNd8dEas2JChWoHaCUpWUVRDUMybuHaKJ0XY,16740
-ml_tools/utilities.py,sha256=gr1cyRUfZcRo9fjWpCaQkrvWY0-xJnDJdrE8JEsOi8o,6309
-ml_tools/vision_helpers.py,sha256=lBAW6dzAK-HOswAt1fU_tfP9hkNLY5D8c_I_7hhEXno,7528
-dragon_ml_toolbox-1.4.0.dist-info/METADATA,sha256=V7Y96iAbgX6Xl6RWzEt4nGfKMZe4cuLs0BrFQghXxX8,2335
-dragon_ml_toolbox-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dragon_ml_toolbox-1.4.0.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
-dragon_ml_toolbox-1.4.0.dist-info/RECORD,,