dragon-ml-toolbox 19.13.0__py3-none-any.whl → 20.0.0__py3-none-any.whl

ml_tools/ML_inference/_base_inference.py

@@ -0,0 +1,166 @@
+import torch
+from torch import nn
+import numpy as np
+from pathlib import Path
+from typing import Union, Optional
+from abc import ABC, abstractmethod
+
+from ..ML_finalize_handler import FinalizedFileHandler
+from ..ML_scaler import DragonScaler
+
+from .._core import get_logger
+from ..path_manager import make_fullpath
+from ..keys._keys import PyTorchCheckpointKeys, ScalerKeys, MagicWords
+
+
+_LOGGER = get_logger("Inference Handler")
+
+
+__all__ = [
+    "_BaseInferenceHandler",
+]
+
+
+class _BaseInferenceHandler(ABC):
+    """
+    Abstract base class for PyTorch inference handlers.
+
+    Manages common tasks like loading a model's state dictionary via FinalizedFileHandler,
+    validating the target device, and preprocessing input features.
+    """
+    def __init__(self,
+                 model: nn.Module,
+                 state_dict: Union[str, Path],
+                 device: str = 'cpu',
+                 scaler: Optional[Union[str, Path]] = None,
+                 task: Optional[str] = None):
+        """
+        Initializes the handler.
+
+        Args:
+            model (nn.Module): An instantiated PyTorch model.
+            state_dict (str | Path): Path to the saved .pth model state_dict file.
+            device (str): The device to run inference on ('cpu', 'cuda', 'mps').
+            scaler (str | Path | None): An optional scaler or path to a saved scaler state.
+            task (str | None): The specific machine learning task. If None, it attempts to read it from the finalized-file.
+        """
+        self.model = model
+        self.device = self._validate_device(device)
+        self._classification_threshold = 0.5
+        self._loaded_threshold: bool = False
+        self._loaded_class_map: bool = False
+        self._class_map: Optional[dict[str,int]] = None
+        self._idx_to_class: Optional[dict[int, str]] = None
+        
+        # --- 1. Load File Handler ---
+        # This loads the content on CPU and validates structure
+        self._file_handler = FinalizedFileHandler(state_dict)
+        
+        # Silence warnings of the filehandler internally
+        self._file_handler._verbose = False
+        
+        # --- 2. Task Resolution ---
+        file_task = self._file_handler.task
+        
+        if task is None:
+            # User didn't provide task, must be in file
+            if file_task == MagicWords.UNKNOWN:
+                _LOGGER.error(f"Task not specified in arguments and not found in file '{make_fullpath(state_dict).name}'.")
+                raise ValueError()
+            self.task = file_task
+            _LOGGER.info(f"Task '{self.task}' detected from file.")
+        else:
+            # User provided task
+            if file_task != MagicWords.UNKNOWN and file_task != task:
+                _LOGGER.warning(f"Provided task '{task}' differs from file metadata task '{file_task}'. Using provided task '{task}'.")
+            self.task = task
+
+        # --- 3. Load Model Weights ---
+        # Weights are already loaded in file_handler (on CPU)
+        try:
+            self.model.load_state_dict(self._file_handler.model_state_dict)
+        except RuntimeError as e:
+            _LOGGER.error(f"State dict mismatch: {e}")
+            raise
+
+        # --- 4. Load Metadata (Thresholds, Class Maps) ---
+        if self._file_handler.classification_threshold is not None:
+            self._classification_threshold = self._file_handler.classification_threshold
+            self._loaded_threshold = True
+            
+        if self._file_handler.class_map is not None:
+            self.set_class_map(self._file_handler.class_map)
+            # set_class_map sets _loaded_class_map to True
+        
+        # --- 5. Move to Device ---
+        self.model.to(self.device)
+        self.model.eval()
+        _LOGGER.info(f"Model loaded and moved to {self.device} in evaluation mode.")
+
+        # --- 6. Load Scalers ---
+        self.feature_scaler: Optional[DragonScaler] = None
+        self.target_scaler: Optional[DragonScaler] = None
+
+        if scaler is not None:
+            if isinstance(scaler, (str, Path)):
+                path_obj = make_fullpath(scaler, enforce="file")
+                loaded_scaler_data = torch.load(path_obj)
+                
+                if isinstance(loaded_scaler_data, dict) and (ScalerKeys.FEATURE_SCALER in loaded_scaler_data or ScalerKeys.TARGET_SCALER in loaded_scaler_data):
+                    if ScalerKeys.FEATURE_SCALER in loaded_scaler_data:
+                        self.feature_scaler = DragonScaler.load(loaded_scaler_data[ScalerKeys.FEATURE_SCALER], verbose=False)
+                        _LOGGER.info("Loaded DragonScaler state for feature scaling.")
+                    if ScalerKeys.TARGET_SCALER in loaded_scaler_data:
+                        self.target_scaler = DragonScaler.load(loaded_scaler_data[ScalerKeys.TARGET_SCALER], verbose=False)
+                        _LOGGER.info("Loaded DragonScaler state for target scaling.")
+                else:
+                    _LOGGER.warning("Loaded scaler file does not contain separate feature/target scalers. Assuming it is a feature scaler (legacy format).")
+                    self.feature_scaler = DragonScaler.load(loaded_scaler_data)
+            else:
+                _LOGGER.error("Scaler must be a file path (str or Path) to a saved DragonScaler state file.")
+                raise ValueError()
+
+    def _validate_device(self, device: str) -> torch.device:
+        """Validates the selected device and returns a torch.device object."""
+        device_lower = device.lower()
+        if "cuda" in device_lower and not torch.cuda.is_available():
+            _LOGGER.warning("CUDA not available, switching to CPU.")
+            device_lower = "cpu"
+        elif device_lower == "mps" and not torch.backends.mps.is_available():
+            _LOGGER.warning("Apple Metal Performance Shaders (MPS) not available, switching to CPU.")
+            device_lower = "cpu"
+        return torch.device(device_lower)
+    
+    def set_class_map(self, class_map: dict[str, int], force_overwrite: bool = False):
+        """
+        Sets the class name mapping to translate predicted integer labels back into string names.
+        
+        Args:
+            class_map (Dict[str, int]): The class_to_idx dictionary.
+            force_overwrite (bool): If True, allows overwriting a map that was loaded from a configuration file.
+        """
+        if self._loaded_class_map:
+            warning_message = f"A '{PyTorchCheckpointKeys.CLASS_MAP}' was loaded from the model configuration file."
+            if not force_overwrite:
+                warning_message += " Use 'force_overwrite=True' if you are sure you want to modify it. This will not affect the value from the file."
+                _LOGGER.warning(warning_message)
+                return
+            else:
+                warning_message += " Overwriting it for this inference instance."
+                _LOGGER.warning(warning_message)
+        
+        self._class_map = class_map
+        self._idx_to_class = {v: k for k, v in class_map.items()}
+        self._loaded_class_map = True
+        _LOGGER.info("InferenceHandler: Class map set for label-to-name translation.")
+
+    @abstractmethod
+    def predict_batch(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, torch.Tensor]:
+        """Core batch prediction method. Must be implemented by subclasses."""
+        pass
+
+    @abstractmethod
+    def predict(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, torch.Tensor]:
+        """Core single-sample prediction method. Must be implemented by subclasses."""
+        pass
+

ml_tools/{_core/_ML_chaining_inference.py → ML_inference/_chain_inference.py}

@@ -1,14 +1,14 @@
 import torch
 import numpy as np
-from typing import List, Dict, Union, Any
+from typing import Union, Any
 
-from ._ML_inference import DragonInferenceHandler
-from ._keys import MLTaskKeys, PyTorchInferenceKeys
-from ._logger import get_logger
-from ._script_info import _script_info
+from ..keys._keys import MLTaskKeys, PyTorchInferenceKeys
+from .._core import get_logger
 
+from ._dragon_inference import DragonInferenceHandler
 
-_LOGGER = get_logger("Chain Inference")
+
+_LOGGER = get_logger("DragonChainInference")
 
 
 __all__ = [
@@ -25,7 +25,7 @@ class DragonChainInference:
     'Classifier Chains' where subsequent models depend on the predictions 
     of previous models.
     """
-    def __init__(self, handlers: List[DragonInferenceHandler]):
+    def __init__(self, handlers: list[DragonInferenceHandler]):
         """
         Args:
             handlers (List[DragonInferenceHandler]): An ordered list of inference handlers. 
@@ -59,11 +59,11 @@ class DragonChainInference:
                 seen_targets.add(tid)
 
     @property
-    def target_ids(self) -> List[str]:
+    def target_ids(self) -> list[str]:
         """Returns a unified list of all target_ids in the chain order."""
         return self._all_target_ids
 
-    def predict_batch(self, features: Union[np.ndarray, torch.Tensor]) -> Dict[str, torch.Tensor]:
+    def predict_batch(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, torch.Tensor]:
         """
         Runs the inference chain on a batch of features.
 
@@ -71,7 +71,7 @@ class DragonChainInference:
             features (np.ndarray | torch.Tensor): The initial input features (2D).
 
         Returns:
-            Dict[str, torch.Tensor]: A dictionary mapping every target_id in the chain 
+            dict[str, torch.Tensor]: A dictionary mapping every target_id in the chain 
             to its predicted tensor.
         """
         # We perform operations on CPU or let the handlers manage device transfer internally.
@@ -86,7 +86,7 @@ class DragonChainInference:
             features = features.unsqueeze(0)
 
         current_features = features
-        results: Dict[str, torch.Tensor] = {}
+        results: dict[str, torch.Tensor] = {}
 
         for i, handler in enumerate(self.handlers):
             # 1. Predict
@@ -131,7 +131,7 @@ class DragonChainInference:
 
         return results
     
-    def predict(self, features: Union[np.ndarray, torch.Tensor]) -> Dict[str, torch.Tensor]:
+    def predict(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, torch.Tensor]:
         """
         Runs the chain on a single sample, returning PyTorch Tensors.
         
@@ -156,7 +156,7 @@ class DragonChainInference:
         single_results = {k: v[0] for k, v in batch_results.items()}
         return single_results
 
-    def predict_batch_numpy(self, features: Union[np.ndarray, torch.Tensor]) -> Dict[str, np.ndarray]:
+    def predict_batch_numpy(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, np.ndarray]:
         """
         Convenience wrapper that returns NumPy arrays instead of Tensors.
         Useful for final consumption of the chain results.
@@ -164,7 +164,7 @@ class DragonChainInference:
         tensor_results = self.predict_batch(features)
         return {k: v.cpu().numpy() for k, v in tensor_results.items()}
 
-    def predict_numpy(self, features: Union[np.ndarray, torch.Tensor]) -> Dict[str, Any]:
+    def predict_numpy(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, Any]:
         """
         Runs the chain on a single sample, returning Python scalars or NumPy arrays.
         
@@ -187,6 +187,3 @@ class DragonChainInference:
                 
         return numpy_results
 
-
-def info():
-    _script_info(__all__)

ml_tools/ML_inference/_dragon_inference.py

@@ -0,0 +1,332 @@
+import torch
+from torch import nn
+import numpy as np
+from pathlib import Path
+from typing import Union, Literal, Any, Optional
+
+from .._core import get_logger
+from ..keys._keys import PyTorchInferenceKeys, PyTorchCheckpointKeys, MLTaskKeys
+
+from ._base_inference import _BaseInferenceHandler
+
+
+_LOGGER = get_logger("DragonInference")
+
+
+__all__ = [
+    "DragonInferenceHandler",
+]
+
+
+class DragonInferenceHandler(_BaseInferenceHandler):
+    """
+    Handles loading a PyTorch model's state dictionary and performing inference for tabular data.
+    """
+    def __init__(self,
+                 model: nn.Module,
+                 state_dict: Union[str, Path],
+                 task: Optional[Literal["regression", 
+                               "binary classification", 
+                               "multiclass classification", 
+                               "multitarget regression", 
+                               "multilabel binary classification"]] = None,
+                 device: str = 'cpu',
+                 scaler: Optional[Union[str, Path]] = None):
+        """
+        Initializes the handler for single-target tasks.
+
+        Args:
+            model (nn.Module): An instantiated PyTorch model architecture.
+            state_dict (str | Path): Path to the saved .pth model state_dict file.
+            task (str, optional): The type of task. If None, it will be detected from file.
+            device (str): The device to run inference on ('cpu', 'cuda', 'mps').
+            scaler (str | Path | None): A path to a saved DragonScaler state.
+            
+        Note: class_map (Dict[int, str]) will be loaded from the model file, to set or override it use `.set_class_map()`.
+        """
+        # Call the parent constructor to handle model loading, device, and scaler
+        # The parent constructor resolves 'task'
+        super().__init__(model=model, 
+                         state_dict=state_dict, 
+                         device=device, 
+                         scaler=scaler, 
+                         task=task)
+        
+        # --- Validation of resolved task ---
+        valid_tasks = [
+            MLTaskKeys.REGRESSION,
+            MLTaskKeys.BINARY_CLASSIFICATION, 
+            MLTaskKeys.MULTICLASS_CLASSIFICATION,
+            MLTaskKeys.MULTITARGET_REGRESSION,
+            MLTaskKeys.MULTILABEL_BINARY_CLASSIFICATION
+        ]
+        
+        if self.task not in valid_tasks:
+            _LOGGER.error(f"'task' recognized as '{self.task}', but this inference handler only supports: {valid_tasks}.")
+            raise ValueError()
+
+        self.target_ids: Optional[list[str]] = None
+        self._target_ids_set: bool = False
+        
+        # --- Attempt to load target names from FinalizedFileHandler ---
+        if self._file_handler.target_names is not None:
+            self.set_target_ids(self._file_handler.target_names)
+        elif self._file_handler.target_name is not None:
+            self.set_target_ids([self._file_handler.target_name])
+        else:
+            _LOGGER.warning("No target names found in file metadata.")
+
+    def _preprocess_input(self, features: Union[np.ndarray, torch.Tensor]) -> torch.Tensor:
+        """
+        Converts input to a torch.Tensor, applies FEATURE scaling if a scaler is
+        present, and moves it to the correct device.
+        """
+        if isinstance(features, np.ndarray):
+            features_tensor = torch.from_numpy(features).float()
+        else:
+            features_tensor = features.float()
+
+        if self.feature_scaler:
+            features_tensor = self.feature_scaler.transform(features_tensor)
+
+        return features_tensor.to(self.device)
+    
+    def set_target_ids(self, target_names: list[str], force_overwrite: bool=False):
+        """
+        Assigns the provided list of strings as the target variable names.
+        
+        If target IDs have already been set, this method will log a warning.
+
+        Args:
+            target_names (list[str]): A list of target names.
+            force_overwrite (bool): If True, allows the method to overwrite previously set target IDs.
+        """
+        if self._target_ids_set:
+            warning_message = "Target IDs was previously set."
+            if not force_overwrite:
+                warning_message += " Use `force_overwrite=True` to overwrite."
+                _LOGGER.warning(warning_message)
+                return
+            else:
+                warning_message += " Overwriting..."
+                _LOGGER.warning(warning_message)
+
+        self.target_ids = target_names
+        self._target_ids_set = True
+        _LOGGER.info("Target IDs set.")
+
+    def predict_batch(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, torch.Tensor]:
+        """
+        Core batch prediction method.
+
+        Args:
+            features (np.ndarray | torch.Tensor): A 2D array/tensor of input features.
+
+        Returns:
+            Dict: A dictionary containing the raw output tensors from the model.
+        """
+        if features.ndim != 2:
+            _LOGGER.error("Input for batch prediction must be a 2D array or tensor.")
+            raise ValueError()
+
+        input_tensor = self._preprocess_input(features)
+
+        with torch.no_grad():
+            output = self.model(input_tensor)
+
+            # --- Target Scaling Logic (Inverse Transform) ---
+            # Only for regression tasks and if a target scaler exists
+            if self.target_scaler:
+                if self.task not in [MLTaskKeys.REGRESSION, MLTaskKeys.MULTITARGET_REGRESSION]:
+                    # raise error
+                    _LOGGER.error("Target scaler is only applicable for regression tasks. A target scaler was provided for a non-regression task.")
+                    raise ValueError()
+                
+                # Ensure output is 2D (N, Targets) for the scaler
+                original_shape = output.shape
+                if output.ndim == 1:
+                    output = output.reshape(-1, 1)
+                
+                # Apply inverse transform (de-scale)
+                output = self.target_scaler.inverse_transform(output)
+                
+                # Restore original shape if necessary (though usually we want 2D or 1D flat)
+                if len(original_shape) == 1:
+                    output = output.flatten()
+
+            # --- Task Specific Formatting ---
+            if self.task == MLTaskKeys.MULTICLASS_CLASSIFICATION:
+                probs = torch.softmax(output, dim=1)
+                labels = torch.argmax(probs, dim=1)
+                return {
+                    PyTorchInferenceKeys.LABELS: labels,
+                    PyTorchInferenceKeys.PROBABILITIES: probs
+                }
+                
+            elif self.task == MLTaskKeys.BINARY_CLASSIFICATION:
+                if output.ndim == 2 and output.shape[1] == 1:
+                    output = output.squeeze(1)
+                    
+                probs = torch.sigmoid(output) 
+                labels = (probs >= self._classification_threshold).int()
+                return {
+                    PyTorchInferenceKeys.LABELS: labels,
+                    PyTorchInferenceKeys.PROBABILITIES: probs
+                }
+                
+            elif self.task == MLTaskKeys.REGRESSION:
+                # For single-target regression, ensure output is flattened
+                return {PyTorchInferenceKeys.PREDICTIONS: output.flatten()}
+            
+            elif self.task == MLTaskKeys.MULTILABEL_BINARY_CLASSIFICATION:
+                probs = torch.sigmoid(output)
+                labels = (probs >= self._classification_threshold).int()
+                return {
+                    PyTorchInferenceKeys.LABELS: labels,
+                    PyTorchInferenceKeys.PROBABILITIES: probs
+                }
+            
+            elif self.task == MLTaskKeys.MULTITARGET_REGRESSION:
+                return {PyTorchInferenceKeys.PREDICTIONS: output}
+            
+            else:
+                _LOGGER.error(f"Unrecognized task '{self.task}'.")
+                raise ValueError()
+
+    def predict(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, torch.Tensor]:
+        """
+        Core single-sample prediction method for single-target models.
+
+        Args:
+            features (np.ndarray | torch.Tensor): A 1D array/tensor of input features.
+
+        Returns:
+            Dict: A dictionary containing the raw output tensors for a single sample.
+        """
+        if features.ndim == 1:
+            features = features.reshape(1, -1) # Reshape to a batch of one
+
+        if features.shape[0] != 1:
+            _LOGGER.error("The 'predict()' method is for a single sample. Use 'predict_batch()' for multiple samples.")
+            raise ValueError()
+
+        batch_results = self.predict_batch(features)
+
+        # Extract the first (and only) result from the batch output
+        single_results = {key: value[0] for key, value in batch_results.items()}
+        return single_results
+    
+    # --- NumPy Convenience Wrappers (on CPU) ---
+
+    def predict_batch_numpy(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, np.ndarray]:
+        """
+        Convenience wrapper for predict_batch that returns NumPy arrays
+        and adds string labels for classification tasks if a class_map is set.
+        """
+        tensor_results = self.predict_batch(features)
+        numpy_results = {key: value.cpu().numpy() for key, value in tensor_results.items()}
+        
+        # Add string names for classification if map exists
+        is_classification = self.task in [
+            MLTaskKeys.BINARY_CLASSIFICATION, 
+            MLTaskKeys.MULTICLASS_CLASSIFICATION
+        ]
+        
+        if is_classification and self._idx_to_class and PyTorchInferenceKeys.LABELS in numpy_results:
+            int_labels = numpy_results[PyTorchInferenceKeys.LABELS] # This is a (B,) array
+            numpy_results[PyTorchInferenceKeys.LABEL_NAMES] = [ # type: ignore
+                self._idx_to_class.get(label_id, "Unknown")
+                for label_id in int_labels
+            ]
+        
+        return numpy_results
+
+    def predict_numpy(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, Any]:
+        """
+        Convenience wrapper for predict that returns NumPy arrays or scalars
+        and adds string labels for classification tasks if a class_map is set.
+        """
+        tensor_results = self.predict(features)
+
+        if self.task == MLTaskKeys.REGRESSION:
+            # .item() implicitly moves to CPU and returns a Python scalar
+            return {PyTorchInferenceKeys.PREDICTIONS: tensor_results[PyTorchInferenceKeys.PREDICTIONS].item()}
+        
+        elif self.task in [MLTaskKeys.BINARY_CLASSIFICATION, MLTaskKeys.MULTICLASS_CLASSIFICATION]:
+            int_label = tensor_results[PyTorchInferenceKeys.LABELS].item()
+            label_name = "Unknown"
+            if self._idx_to_class:
+                label_name = self._idx_to_class.get(int_label, "Unknown") # type: ignore
+
+            return {
+                PyTorchInferenceKeys.LABELS: int_label,
+                PyTorchInferenceKeys.LABEL_NAMES: label_name,
+                PyTorchInferenceKeys.PROBABILITIES: tensor_results[PyTorchInferenceKeys.PROBABILITIES].cpu().numpy()
+            }
+            
+        elif self.task in [MLTaskKeys.MULTILABEL_BINARY_CLASSIFICATION, MLTaskKeys.MULTITARGET_REGRESSION]:
+            # For multi-target models, the output is always an array.
+            numpy_results = {key: value.cpu().numpy() for key, value in tensor_results.items()}
+            return numpy_results
+        else:
+            # should never happen
+            _LOGGER.error(f"Unrecognized task '{self.task}'.")
+            raise ValueError()
+    
+    def quick_predict(self, features: Union[np.ndarray, torch.Tensor]) -> dict[str, Any]:
+        """
+        Convenience wrapper to get the mapping {target_name: prediction} or {target_name: label}
+        
+        `target_ids` must be implemented.
+        """
+        if self.target_ids is None:
+            _LOGGER.error(f"'target_ids' has not been implemented.")
+            raise AttributeError()
+        
+        if self.task == MLTaskKeys.REGRESSION:
+            result = self.predict_numpy(features)[PyTorchInferenceKeys.PREDICTIONS]
+            return {self.target_ids[0]: result}
+        
+        elif self.task in [MLTaskKeys.BINARY_CLASSIFICATION, MLTaskKeys.MULTICLASS_CLASSIFICATION]:
+            result = self.predict_numpy(features)[PyTorchInferenceKeys.LABELS]
+            return {self.target_ids[0]: result}
+        
+        elif self.task == MLTaskKeys.MULTITARGET_REGRESSION:
+            result = self.predict_numpy(features)[PyTorchInferenceKeys.PREDICTIONS].flatten().tolist()
+            return {key: value for key, value in zip(self.target_ids, result)}
+        
+        elif self.task == MLTaskKeys.MULTILABEL_BINARY_CLASSIFICATION:
+            result = self.predict_numpy(features)[PyTorchInferenceKeys.LABELS].flatten().tolist()
+            return {key: value for key, value in zip(self.target_ids, result)}
+        
+        else:
+            # should never happen
+            _LOGGER.error(f"Unrecognized task '{self.task}'.")
+            raise ValueError()
+        
+    def set_classification_threshold(self, threshold: float, force_overwrite: bool=False):
+        """
+        Sets the classification threshold for the current inference instance.
+        
+        If a threshold was previously loaded from a model configuration, this
+        method will log a warning and refuse to update the value. This
+        prevents accidentally overriding a setting from a loaded checkpoint.
+        
+        To bypass this safety check set `force_overwrite` to `True`.
+
+        Args:
+            threshold (float): The new classification threshold value to set.
+            force_overwrite (bool): If True, allows overwriting a threshold that was loaded from a configuration file. 
+        """
+        if self._loaded_threshold:
+            warning_message = f"The current '{PyTorchCheckpointKeys.CLASSIFICATION_THRESHOLD}={self._classification_threshold}' was loaded and set from a model configuration file."
+            if not force_overwrite:
+                warning_message += " Use 'force_overwrite' if you are sure you want to modify it. This will not affect the value from the file."
+                _LOGGER.warning(warning_message)
+                return
+            else:
+                warning_message += f" Overwriting it to {threshold}."
+                _LOGGER.warning(warning_message)
+ 
+        self._classification_threshold = threshold
+

ml_tools/ML_inference/_imprimir.py

@@ -0,0 +1,11 @@
+from .._core import _imprimir_disponibles
+
+_GRUPOS = [
+    "DragonInferenceHandler",
+    "DragonChainInference",
+    "multi_inference_regression",
+    "multi_inference_classification"
+]
+
+def info():
+    _imprimir_disponibles(_GRUPOS)