dragon-ml-toolbox 20.2.0__py3-none-any.whl → 20.4.0__py3-none-any.whl

ml_tools/ML_datasetmaster/_datasetmaster.py

@@ -35,7 +35,8 @@ class DragonDataset(_BaseDatasetMaker):
                  validation_size: float = 0.2,
                  test_size: float = 0.1,
                  class_map: Optional[dict[str,int]]=None,
-                 random_state: int = 42):
+                 random_state: int = 42,
+                 verbose: int = 2):
         """
         Args:
             pandas_df (pandas.DataFrame): 
@@ -59,6 +60,11 @@ class DragonDataset(_BaseDatasetMaker):
                 - "none": Do not scale data (e.g., for TabularTransformer).
                 - DragonScaler instance: Use a pre-fitted scaler to transform data.
             target_scaler: Strategy for target scaling. ONLY applies for "regression" tasks.
+            verbose (int): Verbosity level for logging.
+                - 0: Errors only
+                - 1: Warnings
+                - 2: Info
+                - 3: Detailed process info
         """
         super().__init__()
         
@@ -130,10 +136,11 @@ class DragonDataset(_BaseDatasetMaker):
 
         if _apply_f_scaling:
             X_train_final, X_val_final, X_test_final = self._prepare_feature_scaler(
-                X_train, y_train, X_val, X_test, label_dtype, schema
+                X_train, y_train, X_val, X_test, label_dtype, schema, verbose=verbose
             )
         else:
-            _LOGGER.info("Features have not been scaled as specified.")
+            if verbose >= 2:
+                _LOGGER.info("Features have not been scaled as specified.")
             X_train_final, X_val_final, X_test_final = X_train.to_numpy(), X_val.to_numpy(), X_test.to_numpy()
 
         # --- 5. Scale Targets (Regression Only) ---
@@ -152,7 +159,7 @@ class DragonDataset(_BaseDatasetMaker):
                 raise ValueError()
 
             if _apply_t_scaling:
-                y_train_final, y_val_final, y_test_final = self._prepare_target_scaler(y_train, y_val, y_test)
+                y_train_final, y_val_final, y_test_final = self._prepare_target_scaler(y_train, y_val, y_test, verbose=verbose)
             else:
                 y_train_final = y_train.to_numpy() if isinstance(y_train, (pandas.Series, pandas.DataFrame)) else y_train
                 y_val_final = y_val.to_numpy() if isinstance(y_val, (pandas.Series, pandas.DataFrame)) else y_val
@@ -174,6 +181,8 @@ class DragonDataset(_BaseDatasetMaker):
         # --- 8. Set class map if classification ---
         if self.kind != MLTaskKeys.REGRESSION:
             if class_map is None:
+                if verbose >= 1:
+                    _LOGGER.warning("No class map provided for classification task at initialization. Use `.set_class_map()`.")
                 self.class_map = dict()
             else:
                 self.set_class_map(class_map)
@@ -239,7 +248,8 @@ class DragonDatasetMulti(_BaseDatasetMaker):
                  target_scaler: Union[Literal["fit"], Literal["none"], DragonScaler] = "fit",
                  validation_size: float = 0.2,
                  test_size: float = 0.1,
-                 random_state: int = 42):
+                 random_state: int = 42,
+                 verbose: int = 2):
         """
         Args:
             pandas_df (pandas.DataFrame): 
@@ -264,6 +274,11 @@ class DragonDatasetMulti(_BaseDatasetMaker):
                 - "none": Do not scale data (e.g., for TabularTransformer).
                 - DragonScaler instance: Use a pre-fitted scaler to transform data.
             target_scaler: Strategy for target scaling (Regression only).
+            verbose (int): Verbosity level for logging.
+                - 0: Errors only
+                - 1: Warnings
+                - 2: Info
+                - 3: Detailed process info
         """
         super().__init__()
         
@@ -296,7 +311,8 @@ class DragonDatasetMulti(_BaseDatasetMaker):
 
         schema_plus_targets = feature_cols_set.union(target_cols_set)
         if (all_cols_set - schema_plus_targets):
-            _LOGGER.warning(f"Columns in DataFrame but not in schema or targets: {list(all_cols_set - schema_plus_targets)}")
+            if verbose >= 1:
+                _LOGGER.warning(f"Columns in DataFrame but not in schema or targets: {list(all_cols_set - schema_plus_targets)}")
             
         if (schema_plus_targets - all_cols_set):
             _LOGGER.error(f"Columns in schema/targets but not in DataFrame: {list(schema_plus_targets - all_cols_set)}")
@@ -335,10 +351,11 @@ class DragonDatasetMulti(_BaseDatasetMaker):
 
         if _apply_f_scaling:
             X_train_final, X_val_final, X_test_final = self._prepare_feature_scaler(
-                X_train, y_train, X_val, X_test, label_dtype, schema
+                X_train, y_train, X_val, X_test, label_dtype, schema, verbose=verbose
             )
         else:
-            _LOGGER.info("Features have not been scaled as specified.")
+            if verbose >= 2:
+                _LOGGER.info("Features have not been scaled as specified.")
             X_train_final, X_val_final, X_test_final = X_train.to_numpy(), X_val.to_numpy(), X_test.to_numpy()
 
         # --- 5. Scale Targets ---
@@ -357,7 +374,7 @@ class DragonDatasetMulti(_BaseDatasetMaker):
                 raise ValueError()
 
             if _apply_t_scaling:
-                y_train_final, y_val_final, y_test_final = self._prepare_target_scaler(y_train, y_val, y_test)
+                y_train_final, y_val_final, y_test_final = self._prepare_target_scaler(y_train, y_val, y_test, verbose=verbose)
             else:
                 y_train_final, y_val_final, y_test_final = y_train.to_numpy(), y_val.to_numpy(), y_test.to_numpy()
         else:

ml_tools/ML_datasetmaster/_sequence_datasetmaster.py

@@ -39,7 +39,8 @@ class DragonDatasetSequence:
                  data: Union[pandas.DataFrame, pandas.Series, numpy.ndarray], 
                  sequence_length: int,
                  validation_size: float = 0.2,
-                 test_size: float = 0.1):
+                 test_size: float = 0.1,
+                 verbose: int = 2):
         """
         Initializes the dataset manager and automatically processes the data.
         
@@ -59,6 +60,11 @@ class DragonDatasetSequence:
             sequence_length (int): The number of time steps in each input window (X).
             validation_size (float): The fraction of data to hold out for validation.
             test_size (float): The fraction of data to hold out for testing.
+            verbose (int): Verbosity level for logging.
+                - 0: Errors only
+                - 1: Warnings
+                - 2: Info
+                - 3: Detailed process info
         """
         self._train_dataset = None
         self._test_dataset = None
@@ -98,23 +104,24 @@ class DragonDatasetSequence:
         self._are_windows_generated = False
         
         # Automation
-        self._split_data(validation_size=validation_size, test_size=test_size)
-        self._normalize_data()
-        self._generate_windows()
+        self._split_data(validation_size=validation_size, test_size=test_size, verbose=verbose)
+        self._normalize_data(verbose=verbose)
+        self._generate_windows(verbose=verbose)
     
-    def _split_data(self, validation_size: float = 0.2, test_size: float = 0.1) -> None:
+    def _split_data(self, validation_size: float = 0.2, test_size: float = 0.1, verbose: int = 3) -> None:
         """
         Splits the sequence chronologically into training, validation, and testing portions.
         
         To prevent windowing errors, the validation and test sets include an overlap of `sequence_length` from the preceding data.
         """
         if self._is_split:
-            _LOGGER.warning("Data has already been split.")
+            if verbose >= 1:
+                _LOGGER.warning("Data has already been split.")
             return
             
         if (validation_size + test_size) >= 1.0:
             _LOGGER.error(f"The sum of validation_size ({validation_size}) and test_size ({test_size}) must be less than 1.0.")
-            raise ValueError("validation_size and test_size sum must be < 1.0")
+            raise ValueError()
 
         total_size = len(self.sequence)
         
@@ -139,9 +146,10 @@ class DragonDatasetSequence:
         self.test_time_axis = self.time_axis[test_split_idx:]
 
         self._is_split = True
-        _LOGGER.info(f"Sequence split into training ({len(self.train_sequence)}), validation ({len(self.val_sequence)}), and testing ({len(self.test_sequence)}) points.")
+        if verbose >= 2:
+            _LOGGER.info(f"Sequence split into training ({len(self.train_sequence)}), validation ({len(self.val_sequence)}), and testing ({len(self.test_sequence)}) points.")
     
-    def _normalize_data(self) -> None:
+    def _normalize_data(self, verbose: int = 3) -> None:
         """
         Normalizes the sequence data using DragonScaler. Must be called AFTER splitting to prevent data leakage from the test set.
         """
@@ -150,7 +158,8 @@ class DragonDatasetSequence:
             raise RuntimeError()
 
         if self.scaler:
-            _LOGGER.warning("Data has already been normalized.")
+            if verbose >= 1:
+                _LOGGER.warning("Data has already been normalized.")
             return
 
         # 1. DragonScaler requires a Dataset to fit. Create a temporary one.
@@ -163,8 +172,9 @@ class DragonDatasetSequence:
 
         # 2. Fit the DragonScaler on the temporary training dataset.
         # The sequence is a single feature, so its index is [0].
-        _LOGGER.info("Fitting DragonScaler on the training data...")
-        self.scaler = DragonScaler.fit(temp_train_ds, continuous_feature_indices=[0])
+        if verbose >= 3:
+            _LOGGER.info("Fitting DragonScaler on the training data...")
+        self.scaler = DragonScaler.fit(temp_train_ds, continuous_feature_indices=[0], verbose=verbose)
 
         # 3. Transform sequences using the fitted scaler.
         # The transform method requires a tensor, so we convert, transform, and convert back.
@@ -177,9 +187,10 @@ class DragonDatasetSequence:
         self.test_sequence = self.scaler.transform(test_tensor).numpy().flatten()
 
         self._is_normalized = True
-        _LOGGER.info("Sequence data normalized using DragonScaler.")
+        if verbose >= 2:
+            _LOGGER.info("Sequence data normalized using DragonScaler.")
 
-    def _generate_windows(self) -> None:
+    def _generate_windows(self, verbose: int = 3) -> None:
         """
         Generates overlapping windows for features and labels.
         """
@@ -192,12 +203,13 @@ class DragonDatasetSequence:
             raise RuntimeError()
         
         if self._are_windows_generated:
-            _LOGGER.warning("Windows have already been generated.")
+            if verbose >= 1:
+                _LOGGER.warning("Windows have already been generated.")
             return
 
-        self._train_dataset = self._create_windowed_dataset(self.train_sequence) # type: ignore
-        self._val_dataset = self._create_windowed_dataset(self.val_sequence) # type: ignore
-        self._test_dataset = self._create_windowed_dataset(self.test_sequence) # type: ignore
+        self._train_dataset = self._create_windowed_dataset(self.train_sequence, verbose=verbose) # type: ignore
+        self._val_dataset = self._create_windowed_dataset(self.val_sequence, verbose=verbose) # type: ignore
+        self._test_dataset = self._create_windowed_dataset(self.test_sequence, verbose=verbose) # type: ignore
         
         # attach feature scaler and target scaler to datasets
         if self.scaler is not None:
@@ -207,13 +219,15 @@ class DragonDatasetSequence:
                     ds._target_scaler = self.scaler # type: ignore
         
         self._are_windows_generated = True
-        _LOGGER.info("Feature and label windows generated for train, validation, and test sets.")
+        if verbose >= 2:
+            _LOGGER.info("Feature and label windows generated for train, validation, and test sets.")
 
-    def _create_windowed_dataset(self, data: numpy.ndarray) -> Dataset:
+    def _create_windowed_dataset(self, data: numpy.ndarray, verbose: int = 3) -> Dataset:
         """Efficiently creates windowed features and labels using numpy."""
         if len(data) <= self.sequence_length:
             # Validation/Test sets of size 0 might be passed
-            _LOGGER.warning(f"Data length ({len(data)}) is not greater than sequence_length ({self.sequence_length}). Cannot create windows. Returning empty dataset.")
+            if verbose >= 1:
+                _LOGGER.warning(f"Data length ({len(data)}) is not greater than sequence_length ({self.sequence_length}). Cannot create windows. Returning empty dataset.")
             return _PytorchDataset(numpy.array([]), numpy.array([]), labels_dtype=torch.float32)
         
         # Define a generic name for the univariate feature
@@ -253,7 +267,7 @@ class DragonDatasetSequence:
                                    feature_names=f_names,
                                    target_names=t_names)
 
-    def plot_splits(self, save_dir: Union[str, Path]):
+    def plot_splits(self, save_dir: Union[str, Path], verbose: int = 3) -> None:
         """Plots the training, validation and testing data."""
         if not self._is_split:
             _LOGGER.error("Cannot plot before splitting data.")
@@ -289,7 +303,8 @@ class DragonDatasetSequence:
         
         plt.tight_layout()
         plt.savefig(full_path)
-        _LOGGER.info(f"📈 Sequence data splits saved as '{full_path.name}'.")
+        if verbose >= 2:
+            _LOGGER.info(f"📈 Sequence data splits saved as '{full_path.name}'.")
         plt.close()
 
     def get_datasets(self) -> tuple[Dataset, Dataset, Dataset]:

ml_tools/ML_evaluation/__init__.py

@@ -28,7 +28,7 @@ from ._vision import (
     object_detection_metrics
 )
 
-from ._imprimir import info
+from .._core import _imprimir_disponibles
 
 
 __all__ = [
@@ -51,3 +51,7 @@ __all__ = [
     "segmentation_metrics",
     "object_detection_metrics",
 ]
+
+
+def info():
+    _imprimir_disponibles(__all__)

ml_tools/ML_evaluation/_classification.py

@@ -329,7 +329,11 @@ def classification_metrics(save_dir: Union[str, Path],
             fig_roc, ax_roc = plt.subplots(figsize=CLASSIFICATION_PLOT_SIZE, dpi=DPI_value)
             ax_roc.plot(fpr, tpr, label=f'AUC = {auc:.2f}', color=format_config.ROC_PR_line)
             ax_roc.plot([0, 1], [0, 1], 'k--')
-            ax_roc.set_title(f'Receiver Operating Characteristic{plot_title}', pad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size + 2)
+            # use "ROC" if extra title, else use "Receiver Operating Characteristic" title
+            if plot_title.strip():
+                ax_roc.set_title(f'ROC{plot_title}', pad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size + 2)
+            else:
+                ax_roc.set_title(f'Receiver Operating Characteristic', pad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size + 2)
             ax_roc.set_xlabel('False Positive Rate', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size)
             ax_roc.set_ylabel('True Positive Rate', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size)
             
@@ -351,7 +355,11 @@ def classification_metrics(save_dir: Union[str, Path],
             ap_score = average_precision_score(y_true_binary, y_score)
             fig_pr, ax_pr = plt.subplots(figsize=CLASSIFICATION_PLOT_SIZE, dpi=DPI_value)
             ax_pr.plot(recall, precision, label=f'Avg Precision = {ap_score:.2f}', color=format_config.ROC_PR_line)
-            ax_pr.set_title(f'Precision-Recall Curve{plot_title}', pad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size + 2)
+            # Use "PR Curve" if extra title, else use "Precision-Recall Curve" title
+            if plot_title.strip():
+                ax_pr.set_title(f'PR Curve{plot_title}', pad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size + 2)
+            else:
+                ax_pr.set_title(f'Precision-Recall Curve', pad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size + 2)
             ax_pr.set_xlabel('Recall', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size)
             ax_pr.set_ylabel('Precision', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=format_config.font_size)
             

ml_tools/ML_evaluation_captum/__init__.py

@@ -4,7 +4,7 @@ from ._ML_evaluation_captum import (
     captum_segmentation_heatmap
 )
 
-from ._imprimir import info
+from .._core import _imprimir_disponibles
 
 
 __all__ = [
@@ -12,3 +12,7 @@ __all__ = [
     "captum_image_heatmap",
     "captum_segmentation_heatmap"
 ]
+
+
+def info():
+    _imprimir_disponibles(__all__)

ml_tools/ML_finalize_handler/__init__.py

@@ -2,9 +2,13 @@ from ._ML_finalize_handler import (
     FinalizedFileHandler
 )
 
-from ._imprimir import info
+from .._core import _imprimir_disponibles
 
 
 __all__ = [
     "FinalizedFileHandler"
 ]
+
+
+def info():
+    _imprimir_disponibles(__all__)

ml_tools/ML_inference/__init__.py

@@ -11,7 +11,7 @@ from ._multi_inference import (
     multi_inference_classification,
 )
 
-from ._imprimir import info
+from .._core import _imprimir_disponibles
 
 
 __all__ = [
@@ -20,3 +20,7 @@ __all__ = [
     "multi_inference_regression",
     "multi_inference_classification"
 ]
+
+
+def info():
+    _imprimir_disponibles(__all__)

ml_tools/ML_inference_sequence/__init__.py

@@ -2,9 +2,13 @@ from ._sequence_inference import (
     DragonSequenceInferenceHandler
 )
 
-from ._imprimir import info
+from .._core import _imprimir_disponibles
 
 
 __all__ = [
     "DragonSequenceInferenceHandler"
 ]
+
+
+def info():
+    _imprimir_disponibles(__all__)

ml_tools/ML_inference_vision/__init__.py

@@ -2,9 +2,13 @@ from ._vision_inference import (
     DragonVisionInferenceHandler
 )
 
-from ._imprimir import info
+from .._core import _imprimir_disponibles
 
 
 __all__ = [
     "DragonVisionInferenceHandler",
 ]
+
+
+def info():
+    _imprimir_disponibles(__all__)

ml_tools/ML_models/__init__.py

@@ -4,16 +4,27 @@ from ._mlp_attention import (
     DragonMultiHeadAttentionNet
 )
 
-from ._advanced_models import (
-    DragonGateModel,
-    DragonNodeModel,
-    DragonAutoInt,
+from ._dragon_gate import (
+    DragonGateModel
+)
+
+from ._dragon_node import (
+    DragonNodeModel
+)
+
+from ._dragon_autoint import (
+    DragonAutoInt
+)
+
+from ._dragon_tabnet import (
     DragonTabNet
 )
 
-from ._dragon_tabular import DragonTabularTransformer
+from ._dragon_tabular import (
+    DragonTabularTransformer
+)
 
-from ._imprimir import info
+from .._core import _imprimir_disponibles
 
 
 __all__ = [
@@ -30,3 +41,7 @@ __all__ = [
     "DragonTabNet",
 ]
 
+
+def info():
+    _imprimir_disponibles(__all__)
+