dragon-ml-toolbox 5.2.0__tar.gz → 5.2.2__tar.gz

{dragon_ml_toolbox-5.2.0/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-5.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 5.2.0
+Version: 5.2.2
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: Karl Loza <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-5.2.0 → dragon_ml_toolbox-5.2.2/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 5.2.0
+Version: 5.2.2
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: Karl Loza <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-5.2.0 → dragon_ml_toolbox-5.2.2}/ml_tools/ML_callbacks.py

@@ -6,6 +6,8 @@ from .keys import LogKeys
 from ._logger import _LOGGER
 from typing import Optional
 from ._script_info import _script_info
+from typing import Union, Literal
+from pathlib import Path
 
 
 __all__ = [
@@ -122,7 +124,7 @@ class EarlyStopping(Callback):
                     inferred from the name of the monitored quantity.
         verbose (int): Verbosity mode.
     """
-    def __init__(self, monitor: str=LogKeys.VAL_LOSS, min_delta=0.0, patience=3, mode='auto', verbose=1):
+    def __init__(self, monitor: str=LogKeys.VAL_LOSS, min_delta=0.0, patience=3, mode: Literal['auto', 'min', 'max']='auto', verbose: int=1):
         super().__init__()
         self.monitor = monitor
         self.patience = patience
@@ -146,13 +148,13 @@ class EarlyStopping(Callback):
             else: # Default to min mode for loss or other metrics
                 self.monitor_op = np.less
         
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
 
     def on_train_begin(self, logs=None):
         # Reset state at the beginning of training
         self.wait = 0
         self.stopped_epoch = 0
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
                     
     def on_epoch_end(self, epoch, logs=None):
         current = logs.get(self.monitor) # type: ignore
@@ -199,10 +201,10 @@ class ModelCheckpoint(Callback):
         mode (str): One of {'auto', 'min', 'max'}.
         verbose (int): Verbosity mode.
     """
-    def __init__(self, save_dir: str, monitor: str = LogKeys.VAL_LOSS,
-                 save_best_only: bool = False, mode: str = 'auto', verbose: int = 1):
+    def __init__(self, save_dir: Union[str,Path], monitor: str = LogKeys.VAL_LOSS,
+                 save_best_only: bool = False, mode: Literal['auto', 'min', 'max']= 'auto', verbose: int = 1):
         super().__init__()
-        self.save_dir = make_fullpath(save_dir, make=True)
+        self.save_dir = make_fullpath(save_dir, make=True, enforce="directory")
         if not self.save_dir.is_dir():
             _LOGGER.error(f"{save_dir} is not a valid directory.")
             raise IOError()
@@ -226,17 +228,16 @@ class ModelCheckpoint(Callback):
         else:
             self.monitor_op = np.less if 'loss' in self.monitor else np.greater
         
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
 
     def on_train_begin(self, logs=None):
         """Reset state when training starts."""
-        self.best = np.Inf if self.monitor_op == np.less else -np.Inf
+        self.best = np.Inf if self.monitor_op == np.less else -np.Inf # type: ignore
         self.saved_checkpoints = []
         self.last_best_filepath = None
 
     def on_epoch_end(self, epoch, logs=None):
         logs = logs or {}
-        self.save_dir.mkdir(parents=True, exist_ok=True)
 
         if self.save_best_only:
             self._save_best_model(epoch, logs)
@@ -250,7 +251,7 @@ class ModelCheckpoint(Callback):
             return
 
         if self.monitor_op(current, self.best):
-            old_best_str = f"{self.best:.4f}" if self.best not in [np.Inf, -np.Inf] else "inf"
+            old_best_str = f"{self.best:.4f}" if self.best not in [np.Inf, -np.Inf] else "inf" # type: ignore
             
             # Create a descriptive filename
             filename = f"epoch_{epoch}-{self.monitor}_{current:.4f}.pth"

{dragon_ml_toolbox-5.2.0 → dragon_ml_toolbox-5.2.2}/ml_tools/ML_datasetmaster.py

@@ -386,23 +386,21 @@ class SimpleDatasetMaker:
                            test split.
         random_state (int): The seed for the random number generator for
                             reproducibility.
-        id (str | None): An optional object identifier.
     """
-    def __init__(self, pandas_df: pandas.DataFrame, test_size: float = 0.2, random_state: int = 42, id: Optional[str]=None):
-        """          
+    def __init__(self, pandas_df: pandas.DataFrame, test_size: float = 0.2, random_state: int = 42):
+        """
         Attributes:
             `train_dataset` -> PyTorch Dataset
             `test_dataset`  -> PyTorch Dataset
             `feature_names` -> list[str]
             `target_name`   -> str
             `id` -> str | None
+            
+        The ID can be manually set to any string if needed, it is `None` by default.
         """
         
         if not isinstance(pandas_df, pandas.DataFrame):
-            raise TypeError("Input must be a pandas.DataFrame.")
-        
-        #set id
-        self._id = id
+            raise TypeError("Input must be a pandas.DataFrame.")        
 
         # 1. Identify features and target
         features = pandas_df.iloc[:, :-1]
@@ -410,6 +408,9 @@ class SimpleDatasetMaker:
 
         self._feature_names = features.columns.tolist()
         self._target_name = target.name
+        
+        #set id
+        self._id: Optional[str] = None
 
         # 2. Split the data
         X_train, X_test, y_train, y_test = train_test_split(
@@ -449,6 +450,13 @@ class SimpleDatasetMaker:
     def id(self) -> Optional[str]:
         """Returns the object identifier if any."""
         return self._id
+    
+    @id.setter
+    def id(self, dataset_id: str):
+        """Sets the ID value"""
+        if not isinstance(dataset_id, str):
+            raise ValueError(f"Dataset ID '{type(dataset_id)}' is not a string.")
+        self._id = dataset_id
 
     def dataframes_info(self) -> None:
         """Prints the shape information of the split pandas DataFrames."""

{dragon_ml_toolbox-5.2.0 → dragon_ml_toolbox-5.2.2}/ml_tools/ML_models.py

@@ -66,6 +66,21 @@ class MultilayerPerceptron(nn.Module):
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         """Defines the forward pass of the model."""
         return self._layers(x)
+    
+    def __repr__(self) -> str:
+        """Returns the developer-friendly string representation of the model."""
+        # Extracts the number of neurons from each nn.Linear layer
+        layer_sizes = [layer.in_features for layer in self._layers if isinstance(layer, nn.Linear)]
+        
+        # Get the last layer and check its type before accessing the attribute
+        last_layer = self._layers[-1]
+        if isinstance(last_layer, nn.Linear):
+            layer_sizes.append(last_layer.out_features)
+        
+        # Creates a string like: 10 -> 40 -> 80 -> 40 -> 2
+        arch_str = ' -> '.join(map(str, layer_sizes))
+        
+        return f"MultilayerPerceptron(arch: {arch_str})"
 
 
 class SequencePredictorLSTM(nn.Module):
@@ -128,6 +143,14 @@ class SequencePredictorLSTM(nn.Module):
         predictions = self.linear(lstm_out)
         
         return predictions
+    
+    def __repr__(self) -> str:
+        """Returns the developer-friendly string representation of the model."""
+        return (
+            f"SequencePredictorLSTM(features={self.lstm.input_size}, "
+            f"hidden_size={self.lstm.hidden_size}, "
+            f"recurrent_layers={self.lstm.num_layers})"
+        )
 
 
 def info():

{dragon_ml_toolbox-5.2.0 → dragon_ml_toolbox-5.2.2}/ml_tools/ML_optimization.py

@@ -1,5 +1,5 @@
 import torch
-import numpy
+import numpy    #handling torch to numpy
 import evotorch
 from evotorch.algorithms import CMAES, SteadyStateGA
 from evotorch.logging import StdOutLogger
@@ -32,7 +32,7 @@ def create_pytorch_problem(
     algorithm: Literal["CMAES", "GA"] = "CMAES",
     verbose: bool = False,
     **searcher_kwargs
-) -> Tuple[evotorch.Problem, evotorch.Searcher]:
+) -> Tuple[evotorch.Problem, evotorch.Searcher]: # type: ignore
     """
     Creates and configures an EvoTorch Problem and Searcher for a PyTorch model.
 
@@ -62,22 +62,11 @@ def create_pytorch_problem(
     device = handler.device
 
     # Define the fitness function that EvoTorch will call.
-    @evotorch.decorators.to_tensor
+    @evotorch.decorators.to_tensor # type: ignore
     @evotorch.decorators.on_aux_device(device)
     def fitness_func(solution_tensor: torch.Tensor) -> torch.Tensor:
-        # Make a mutable copy of the solutions from the optimizer
-        processed_tensor = solution_tensor.clone()
-
-        # Apply thresholding if binary features are present
-        if binary_features > 0:
-            # Isolate the binary part of the tensor (the last n columns)
-            binary_part = processed_tensor[:, -binary_features:]
-            
-            # Apply rounding to snap values to 0.0 or 1.0
-            processed_tensor[:, -binary_features:] = torch.round(binary_part)
-
-        # Use the processed tensor (with thresholded values) for prediction
-        predictions = handler.predict_batch(processed_tensor)[PyTorchInferenceKeys.PREDICTIONS]
+        # Directly use the continuous-valued tensor from the optimizer for prediction
+        predictions = handler.predict_batch(solution_tensor)[PyTorchInferenceKeys.PREDICTIONS]
         return predictions.flatten()
 
     # Create the Problem instance.
@@ -107,7 +96,7 @@ def create_pytorch_problem(
 
 def run_optimization(
     problem: evotorch.Problem,
-    searcher: evotorch.Searcher,
+    searcher: evotorch.Searcher, # type: ignore
     num_generations: int,
     target_name: str,
     binary_features: int,
@@ -168,7 +157,7 @@ def run_optimization(
     
     # preprocess feature names
     if feature_names is None:
-        feature_names = [f"feature_{i}" for i in range(problem.solution_length)]
+        feature_names = [f"feature_{i}" for i in range(problem.solution_length)] # type: ignore
     
     # --- SINGLE RUN LOGIC ---
     if repetitions <= 1:

{dragon_ml_toolbox-5.2.0 → dragon_ml_toolbox-5.2.2}/ml_tools/ML_trainer.py

@@ -108,6 +108,8 @@ class MyTrainer:
     def fit(self, epochs: int = 10, batch_size: int = 10, shuffle: bool = True):
         """
         Starts the training-validation process of the model.
+        
+        Returns the "History" callback dictionary.
 
         Args:
             epochs (int): The total number of epochs to train for.

{dragon_ml_toolbox-5.2.0 → dragon_ml_toolbox-5.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dragon-ml-toolbox"
-version = "5.2.0"
+version = "5.2.2"
 description = "A collection of tools for data science and machine learning projects."
 authors = [
     { name = "Karl Loza", email = "luigiloza@gmail.com" }