dragon-ml-toolbox 14.7.0__py3-none-any.whl → 16.2.1__py3-none-any.whl

ml_tools/ML_vision_transformers.py

@@ -2,10 +2,11 @@ from typing import Union, Dict, Type, Callable, Optional, Any, List, Literal
 from PIL import ImageOps, Image
 from torchvision import transforms
 from pathlib import Path
+import json
 
 from ._logger import _LOGGER
 from ._script_info import _script_info
-from .keys import VisionTransformRecipeKeys
+from ._keys import VisionTransformRecipeKeys
 from .path_manager import make_fullpath
 
 
@@ -52,49 +53,12 @@ class ResizeAspectFill:
         return ImageOps.expand(image, padding, fill=self.pad_color)
 
 
+#############################################################
 #NOTE: Add custom transforms.
 TRANSFORM_REGISTRY: Dict[str, Type[Callable]] = {
     "ResizeAspectFill": ResizeAspectFill,
 }
-
-
-def _build_transform_from_recipe(recipe: Dict[str, Any]) -> transforms.Compose:
-    """Internal helper to build a transform pipeline from a recipe dict."""
-    pipeline_steps: List[Callable] = []
-    
-    if VisionTransformRecipeKeys.PIPELINE not in recipe:
-        _LOGGER.error("Recipe dict is invalid: missing 'pipeline' key.")
-        raise ValueError("Invalid recipe format.")
-
-    for step in recipe[VisionTransformRecipeKeys.PIPELINE]:
-        t_name = step.get(VisionTransformRecipeKeys.NAME)
-        t_kwargs = step.get(VisionTransformRecipeKeys.KWARGS, {})
-        
-        if not t_name:
-            _LOGGER.error(f"Invalid transform step, missing 'name': {step}")
-            continue
-        
-        transform_class: Any = None
-
-        # 1. Check standard torchvision transforms
-        if hasattr(transforms, t_name):
-            transform_class = getattr(transforms, t_name)
-        # 2. Check custom transforms
-        elif t_name in TRANSFORM_REGISTRY:
-            transform_class = TRANSFORM_REGISTRY[t_name]
-        # 3. Not found
-        else:
-            _LOGGER.error(f"Unknown transform '{t_name}' in recipe. Not found in torchvision.transforms or TRANSFORM_REGISTRY.")
-            raise ValueError(f"Unknown transform name: {t_name}")
-            
-        # Instantiate the transform
-        try:
-            pipeline_steps.append(transform_class(**t_kwargs))
-        except Exception as e:
-            _LOGGER.error(f"Failed to instantiate transform '{t_name}' with kwargs {t_kwargs}: {e}")
-            raise
-            
-    return transforms.Compose(pipeline_steps)
+#############################################################
 
 
 def create_offline_augmentations(
@@ -199,5 +163,122 @@ def create_offline_augmentations(
     _LOGGER.info(f"Offline augmentation complete. Saved {total_saved} new images.")
 
 
+def _build_transform_from_recipe(recipe: Dict[str, Any]) -> transforms.Compose:
+    """Internal helper to build a transform pipeline from a recipe dict."""
+    pipeline_steps: List[Callable] = []
+    
+    if VisionTransformRecipeKeys.PIPELINE not in recipe:
+        _LOGGER.error("Recipe dict is invalid: missing 'pipeline' key.")
+        raise ValueError("Invalid recipe format.")
+
+    for step in recipe[VisionTransformRecipeKeys.PIPELINE]:
+        t_name = step.get(VisionTransformRecipeKeys.NAME)
+        t_kwargs = step.get(VisionTransformRecipeKeys.KWARGS, {})
+        
+        if not t_name:
+            _LOGGER.error(f"Invalid transform step, missing 'name': {step}")
+            continue
+        
+        transform_class: Any = None
+
+        # 1. Check standard torchvision transforms
+        if hasattr(transforms, t_name):
+            transform_class = getattr(transforms, t_name)
+        # 2. Check custom transforms
+        elif t_name in TRANSFORM_REGISTRY:
+            transform_class = TRANSFORM_REGISTRY[t_name]
+        # 3. Not found
+        else:
+            _LOGGER.error(f"Unknown transform '{t_name}' in recipe. Not found in torchvision.transforms or TRANSFORM_REGISTRY.")
+            raise ValueError(f"Unknown transform name: {t_name}")
+            
+        # Instantiate the transform
+        try:
+            pipeline_steps.append(transform_class(**t_kwargs))
+        except Exception as e:
+            _LOGGER.error(f"Failed to instantiate transform '{t_name}' with kwargs {t_kwargs}: {e}")
+            raise
+            
+    return transforms.Compose(pipeline_steps)
+
+
+def _save_recipe(recipe: Dict[str, Any], filepath: Path) -> None:
+    """
+    Saves a transform recipe dictionary to a JSON file.
+
+    Args:
+        recipe (Dict[str, Any]): The recipe dictionary to save.
+        filepath (str): The path to the output .json file.
+    """
+    final_filepath = filepath.with_suffix(".json")
+    
+    try:
+        with open(final_filepath, 'w') as f:
+            json.dump(recipe, f, indent=4)
+        _LOGGER.info(f"Transform recipe saved as '{final_filepath.name}'.")
+    except Exception as e:
+        _LOGGER.error(f"Failed to save recipe to '{final_filepath}': {e}")
+        raise
+
+
+def _load_recipe_and_build_transform(filepath: Union[str,Path]) -> transforms.Compose:
+    """
+    Loads a transform recipe from a .json file and reconstructs the
+    torchvision.transforms.Compose pipeline.
+
+    Args:
+        filepath (str): Path to the saved transform recipe .json file.
+
+    Returns:
+        transforms.Compose: The reconstructed transformation pipeline.
+        
+    Raises:
+        ValueError: If a transform name in the recipe is not found in
+                    torchvision.transforms or the custom TRANSFORM_REGISTRY.
+    """
+    # validate filepath
+    final_filepath = make_fullpath(filepath, enforce="file")
+    
+    try:
+        with open(final_filepath, 'r') as f:
+            recipe = json.load(f)
+    except Exception as e:
+        _LOGGER.error(f"Failed to load recipe from '{final_filepath}': {e}")
+        raise
+        
+    pipeline_steps: List[Callable] = []
+    
+    if VisionTransformRecipeKeys.PIPELINE not in recipe:
+        _LOGGER.error("Recipe file is invalid: missing 'pipeline' key.")
+        raise ValueError("Invalid recipe format.")
+
+    for step in recipe[VisionTransformRecipeKeys.PIPELINE]:
+        t_name = step[VisionTransformRecipeKeys.NAME]
+        t_kwargs = step[VisionTransformRecipeKeys.KWARGS]
+        
+        transform_class: Any = None
+
+        # 1. Check standard torchvision transforms
+        if hasattr(transforms, t_name):
+            transform_class = getattr(transforms, t_name)
+        # 2. Check custom transforms
+        elif t_name in TRANSFORM_REGISTRY:
+            transform_class = TRANSFORM_REGISTRY[t_name]
+        # 3. Not found
+        else:
+            _LOGGER.error(f"Unknown transform '{t_name}' in recipe. Not found in torchvision.transforms or TRANSFORM_REGISTRY.")
+            raise ValueError(f"Unknown transform name: {t_name}")
+            
+        # Instantiate the transform
+        try:
+            pipeline_steps.append(transform_class(**t_kwargs))
+        except Exception as e:
+            _LOGGER.error(f"Failed to instantiate transform '{t_name}' with kwargs {t_kwargs}: {e}")
+            raise
+            
+    _LOGGER.info(f"Successfully loaded and built transform pipeline from '{final_filepath.name}'.")
+    return transforms.Compose(pipeline_steps)
+
+
 def info():
     _script_info(__all__)

ml_tools/PSO_optimization.py

@@ -12,9 +12,9 @@ from .serde import deserialize_object
 from .math_utilities import threshold_binary_values, threshold_binary_values_batch
 from .path_manager import sanitize_filename, make_fullpath, list_files_by_extension
 from ._logger import _LOGGER
-from .keys import EnsembleKeys
+from ._keys import EnsembleKeys
 from ._script_info import _script_info
-from .SQL import DatabaseManager
+from .SQL import DragonSQL
 from .optimization_tools import _save_result
 
 """
@@ -191,7 +191,7 @@ def _set_feature_names(size: int, names: Union[list[str], None]):
         return names
 
 
-def _run_single_pso(objective_function: ObjectiveFunction, pso_args: dict, feature_names: list[str], target_name: str, random_state: int, save_format: Literal['csv', 'sqlite', 'both'], csv_path: Path, db_manager: Optional[DatabaseManager], db_table_name: str):
+def _run_single_pso(objective_function: ObjectiveFunction, pso_args: dict, feature_names: list[str], target_name: str, random_state: int, save_format: Literal['csv', 'sqlite', 'both'], csv_path: Path, db_manager: Optional[DragonSQL], db_table_name: str):
     """Helper for a single PSO run that also handles saving."""
     pso_args.update({"seed": random_state})
     
@@ -213,7 +213,7 @@ def _run_single_pso(objective_function: ObjectiveFunction, pso_args: dict, featu
     return best_features_named, best_target_named
 
 
-def _run_post_hoc_pso(objective_function: ObjectiveFunction, pso_args: dict, feature_names: list[str], target_name: str, repetitions: int, save_format: Literal['csv', 'sqlite', 'both'], csv_path: Path, db_manager: Optional[DatabaseManager], db_table_name: str):
+def _run_post_hoc_pso(objective_function: ObjectiveFunction, pso_args: dict, feature_names: list[str], target_name: str, repetitions: int, save_format: Literal['csv', 'sqlite', 'both'], csv_path: Path, db_manager: Optional[DragonSQL], db_table_name: str):
     """Helper for post-hoc analysis that saves results incrementally."""
     progress = trange(repetitions, desc="Post-Hoc PSO", unit="run")
     for _ in progress:
@@ -342,7 +342,7 @@ def run_pso(lower_boundaries: list[float],
         schema = {"result_id": "INTEGER PRIMARY KEY AUTOINCREMENT", **schema}
         
         # Create table
-        with DatabaseManager(db_path) as db:
+        with DragonSQL(db_path) as db:
             db.create_table(db_table_name, schema)
         
     pso_arguments = {
@@ -357,7 +357,7 @@ def run_pso(lower_boundaries: list[float],
     
     # --- Dispatcher ---
     # Use a real or dummy context manager to handle the DB connection cleanly
-    db_context = DatabaseManager(db_path) if save_format in ['sqlite', 'both'] else nullcontext()
+    db_context = DragonSQL(db_path) if save_format in ['sqlite', 'both'] else nullcontext()
 
     with db_context as db_manager:
         if post_hoc_analysis is None or post_hoc_analysis <= 1:

ml_tools/SQL.py

@@ -9,11 +9,11 @@ from .path_manager import make_fullpath, sanitize_filename
 
 
 __all__ = [
-    "DatabaseManager",
+    "DragonSQL",
 ]
 
 
-class DatabaseManager:
+class DragonSQL:
     """
     A user-friendly context manager for handling SQLite database operations.
 
@@ -35,7 +35,7 @@ class DatabaseManager:
     ...     "feature_a": "REAL",
     ...     "score": "REAL"
     ... }
-    >>> with DatabaseManager("my_results.db") as db:
+    >>> with DragonSQL("my_results.db") as db:
     ...     db.create_table("experiments", schema)
     ...     data = {"run_name": "first_run", "feature_a": 0.123, "score": 95.5}
     ...     db.insert_row("experiments", data)
@@ -43,7 +43,7 @@ class DatabaseManager:
     ...     print(df)
     """
     def __init__(self, db_path: Union[str, Path]):
-        """Initializes the DatabaseManager with the path to the database file."""
+        """Initializes the DragonSQL with the path to the database file."""
         if isinstance(db_path, str):
             if not db_path.endswith(".db"):
                 db_path = db_path + ".db"

ml_tools/{keys.py → _keys.py}

@@ -1,3 +1,10 @@
+class MagicWords:
+    """General purpose keys"""
+    LATEST = "latest"
+    CURRENT = "current"
+    RENAME = "rename"
+
+
 class PyTorchLogKeys:
     """
     Used internally for ML scripts module.
@@ -7,6 +14,7 @@ class PyTorchLogKeys:
     # --- Epoch Level ---
     TRAIN_LOSS = 'train_loss'
     VAL_LOSS = 'val_loss'
+    LEARNING_RATE = 'lr'
 
     # --- Batch Level ---
     BATCH_LOSS = 'loss'
@@ -79,6 +87,15 @@ class PyTorchCheckpointKeys:
     SCHEDULER_STATE = "scheduler_state_dict"
     EPOCH = "epoch"
     BEST_SCORE = "best_score"
+    HISTORY = "history"
+    CHECKPOINT_NAME = "PyModelCheckpoint"
+    # Finalized config
+    CLASSIFICATION_THRESHOLD = "classification_threshold"
+    CLASS_MAP = "class_map"
+    SEQUENCE_LENGTH = "sequence_length"
+    INITIAL_SEQUENCE = "initial_sequence"
+    TARGET_NAME = "target_name"
+    TARGET_NAMES = "target_names"
 
 
 class UtilityKeys:
@@ -119,6 +136,34 @@ class ObjectDetectionKeys:
     LABELS = "labels"
 
 
+class MLTaskKeys:
+    """Used by the Trainer and InferenceHandlers"""
+    REGRESSION = "regression"
+    MULTITARGET_REGRESSION = "multitarget regression"
+    
+    BINARY_CLASSIFICATION = "binary classification"
+    MULTICLASS_CLASSIFICATION = "multiclass classification"
+    MULTILABEL_BINARY_CLASSIFICATION = "multilabel binary classification"
+    
+    BINARY_IMAGE_CLASSIFICATION = "binary image classification"
+    MULTICLASS_IMAGE_CLASSIFICATION = "multiclass image classification"
+    
+    BINARY_SEGMENTATION = "binary segmentation"
+    MULTICLASS_SEGMENTATION = "multiclass segmentation"
+    
+    OBJECT_DETECTION = "object detection"
+    
+    SEQUENCE_SEQUENCE = "sequence-to-sequence"
+    SEQUENCE_VALUE = "sequence-to-value"
+    
+    ALL_BINARY_TASKS = [BINARY_CLASSIFICATION, MULTILABEL_BINARY_CLASSIFICATION, BINARY_IMAGE_CLASSIFICATION, BINARY_SEGMENTATION]
+
+
+class DragonTrainerKeys:
+    VALIDATION_METRICS_DIR = "Validation_Metrics"
+    TEST_METRICS_DIR = "Test_Metrics"
+
+
 class _OneHotOtherPlaceholder:
     """Used internally by GUI_tools."""
     OTHER_GUI = "OTHER"

ml_tools/_schema.py

@@ -2,7 +2,7 @@ from typing import NamedTuple, Tuple, Optional, Dict, Union
 from pathlib import Path
 
 from .custom_logger import save_list_strings
-from .keys import DatasetKeys
+from ._keys import DatasetKeys
 from ._logger import _LOGGER
 
 

ml_tools/ensemble_evaluation.py

@@ -25,7 +25,7 @@ from typing import Union, Optional, Literal
 from .path_manager import sanitize_filename, make_fullpath
 from ._script_info import _script_info
 from ._logger import _LOGGER
-from .keys import SHAPKeys
+from ._keys import SHAPKeys
 
 
 __all__ = [

ml_tools/ensemble_inference.py

@@ -1,7 +1,6 @@
 from typing import Union, Literal, Dict, Any, Optional, List
 from pathlib import Path
 import json
-import joblib
 import numpy as np
 # Inference models
 import xgboost
@@ -10,16 +9,17 @@ import lightgbm
 from ._script_info import _script_info
 from ._logger import _LOGGER
 from .path_manager import make_fullpath, list_files_by_extension
-from .keys import EnsembleKeys
+from ._keys import EnsembleKeys
+from .serde import deserialize_object
 
 
 __all__ = [
-    "InferenceHandler",
+    "DragonEnsembleInferenceHandler",
     "model_report"
 ]
 
 
-class InferenceHandler:
+class DragonEnsembleInferenceHandler:
     """
     Handles loading ensemble models and performing inference for either regression or classification tasks.
     """
@@ -44,9 +44,9 @@ class InferenceHandler:
         for fname, fpath in model_files.items():
             try:
                 full_object: dict
-                full_object = _deserialize_object(filepath=fpath, 
+                full_object = deserialize_object(filepath=fpath, 
                                                  verbose=self.verbose, 
-                                                 raise_on_error=True) # type: ignore
+                                                 expected_type=dict)
                 
                 model: Any = full_object[EnsembleKeys.MODEL]
                 target_name: str = full_object[EnsembleKeys.TARGET]
@@ -170,7 +170,7 @@ def model_report(
 
     # --- 2. Deserialize and Extract Info ---
     try:
-        full_object: dict = _deserialize_object(model_p) # type: ignore
+        full_object: dict = deserialize_object(model_p, expected_type=dict, verbose=verbose) # type: ignore
         model = full_object[EnsembleKeys.MODEL]
         target = full_object[EnsembleKeys.TARGET]
         features = full_object[EnsembleKeys.FEATURES]
@@ -218,31 +218,5 @@ def model_report(
     return report_data
 
 
-# Local implementation to avoid calling utilities dependencies
-def _deserialize_object(filepath: Union[str,Path], verbose: bool=True, raise_on_error: bool=True) -> Optional[Any]:
-    """
-    Loads a serialized object from a .joblib file.
-
-    Parameters:
-        filepath (str | Path): Full path to the serialized .joblib file.
-
-    Returns:
-        (Any | None): The deserialized Python object, or None if loading fails.
-    """
-    true_filepath = make_fullpath(filepath)
-    
-    try:
-        obj = joblib.load(true_filepath)
-    except (IOError, OSError, EOFError, TypeError, ValueError) as e:
-        _LOGGER.error(f"Failed to deserialize object from '{true_filepath}'.")
-        if raise_on_error:
-            raise e
-        return None
-    else:
-        if verbose:
-            _LOGGER.info(f"Loaded object of type '{type(obj)}'")
-        return obj
-
-
 def info():
     _script_info(__all__)

ml_tools/ensemble_learning.py

@@ -17,7 +17,7 @@ from .utilities import yield_dataframes_from_dir, train_dataset_yielder
 from .serde import serialize_object_filename
 from .path_manager import sanitize_filename, make_fullpath
 from ._script_info import _script_info
-from .keys import EnsembleKeys
+from ._keys import EnsembleKeys
 from ._logger import _LOGGER
 from .ensemble_evaluation import (evaluate_model_classification,
                                   plot_roc_curve,

ml_tools/optimization_tools.py

@@ -8,7 +8,7 @@ from .path_manager import make_fullpath, list_csv_paths, sanitize_filename
 from .utilities import yield_dataframes_from_dir
 from ._logger import _LOGGER
 from ._script_info import _script_info
-from .SQL import DatabaseManager
+from .SQL import DragonSQL
 from ._schema import FeatureSchema
 
 
@@ -262,7 +262,7 @@ def _save_result(
         result_dict: dict,
         save_format: Literal['csv', 'sqlite', 'both'],
         csv_path: Path,
-        db_manager: Optional[DatabaseManager] = None,
+        db_manager: Optional[DragonSQL] = None,
         db_table_name: Optional[str] = None,
         categorical_mappings: Optional[Dict[str, Dict[str, int]]] = None
     ):

ml_tools/path_manager.py

@@ -9,7 +9,7 @@ from ._logger import _LOGGER
 
 
 __all__ = [
-    "PathManager",
+    "DragonPathManager",
     "make_fullpath",
     "sanitize_filename",
     "list_csv_paths",
@@ -18,7 +18,7 @@ __all__ = [
 ]
 
 
-class PathManager:
+class DragonPathManager:
     """
     Manages and stores a project's file paths, acting as a centralized
     "path database". It supports both development mode and applications
@@ -43,7 +43,7 @@ class PathManager:
 
         Args:
             anchor_file (str): The path to a file within your package, typically
-                            the `__file__` of the script where PathManager
+                            the `__file__` of the script where DragonPathManager
                             is instantiated. This is used to locate the
                             package root directory.
             base_directories (List[str] | None): An optional list of strings,
@@ -149,7 +149,7 @@ class PathManager:
                 if key in self._paths:
                     path_items.append((key, self._paths[key]))
                 elif verbose:
-                    _LOGGER.warning(f"Key '{key}' not found in PathManager, skipping.")
+                    _LOGGER.warning(f"Key '{key}' not found in DragonPathManager, skipping.")
         else:
             path_items = self._paths.items()
 
@@ -194,7 +194,7 @@ class PathManager:
     def __repr__(self) -> str:
         """Provides a string representation of the stored paths."""
         path_list = "\n".join(f"  '{k}': '{v}'" for k, v in self._paths.items())
-        return f"PathManager(\n{path_list}\n)"
+        return f"DragonPathManager(\n{path_list}\n)"
     
     # --- Dictionary-Style Methods ---
     def __getitem__(self, key: str) -> Path:

ml_tools/utilities.py

@@ -10,7 +10,6 @@ from ._logger import _LOGGER
 from ._schema import FeatureSchema
 
 
-# Keep track of available tools
 __all__ = [
     "load_dataframe",
     "load_dataframe_greedy",
@@ -361,7 +360,7 @@ def save_dataframe_filename(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Uni
     elif isinstance(df, pl.DataFrame):
         # Transform empty strings to Null
         df_to_save = df.with_columns(
-            pl.when(pl.col(pl.Utf8).str.strip() == "")
+            pl.when(pl.col(pl.Utf8).str.strip() == "") # type: ignore
             .then(None)
             .otherwise(pl.col(pl.Utf8))
         )

dragon_ml_toolbox-14.7.0.dist-info/RECORD

@@ -1,49 +0,0 @@
-dragon_ml_toolbox-14.7.0.dist-info/licenses/LICENSE,sha256=L35WDmmLZNTlJvxF6Vy7Uy4SYNi6rCfWUqlTHpoRMoU,1081
-dragon_ml_toolbox-14.7.0.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=gkOdNDbKYpIJezwSo2CEnISkLeYfYHv9t8b5K2-P69A,2687
-ml_tools/ETL_cleaning.py,sha256=2VBRllV8F-ZiPylPp8Az2gwn5ztgazN0BH5OKnRUhV0,20402
-ml_tools/ETL_engineering.py,sha256=KfYqgsxupAx6e_TxwO1LZXeu5mFkIhVXJrNjP3CzIZc,54927
-ml_tools/GUI_tools.py,sha256=Va6ig-dHULPVRwQYYtH3fvY5XPIoqRcJpRW8oXC55Hw,45413
-ml_tools/MICE_imputation.py,sha256=KLJXGQLKJ6AuWWttAG-LCCaxpS-ygM4dXPiguHDaL6Y,20815
-ml_tools/ML_callbacks.py,sha256=elD2Yr030sv_6gX_m9GVd6HTyrbmt34nFS8lrgS4HtM,15808
-ml_tools/ML_configuration.py,sha256=DaYmm7Yklcu1emLyo-pRQG74SK4YEkCYFRT6_aV3rqA,4417
-ml_tools/ML_datasetmaster.py,sha256=Zi5jBnBI_U6tD8mpCVL5bQcsqsGEMAzMsCVI_wFD2QU,30175
-ml_tools/ML_evaluation.py,sha256=EvlgFeMQeZ1RSEMtNd-nv7W0d0SVcR4n6cwW5UG16DU,25358
-ml_tools/ML_evaluation_multi.py,sha256=bQZ2gJY-dBzKQxvtd-B6wVaGBdFpQGVBr7tQZFokp5E,17166
-ml_tools/ML_inference.py,sha256=YJ953bhNWsdlPRtJQh3h2ACfMIgp8dQ9KtL9Azar-5s,23489
-ml_tools/ML_models.py,sha256=PqOcNlws7vCJMbiVCKqlPuktxvskZVUHG3VfU-Yshf8,31415
-ml_tools/ML_models_advanced.py,sha256=vk3PZBSu3DVso2S1rKTxxdS43XG8Q5FnasIL3-rMajc,12410
-ml_tools/ML_optimization.py,sha256=P0zkhKAwTpkorIBtR0AOIDcyexo5ngmvFUzo3DfNO-E,22692
-ml_tools/ML_scaler.py,sha256=tw6onj9o8_kk3FQYb930HUzvv1zsFZe2YZJdF3LtHkU,7538
-ml_tools/ML_trainer.py,sha256=salZxfv3RWRCiinp5S9xeUsHysMbMQ52EecR8GyEbaM,51461
-ml_tools/ML_utilities.py,sha256=eYe2N-65FTzaOHF5gmiJl-HmicyzhqcdvlDiIivr5_g,22993
-ml_tools/ML_vision_datasetmaster.py,sha256=bmHDC6SsBUxDSFjqQGuyzGfKuf1Imi1Ng6O2-dYF7I4,62607
-ml_tools/ML_vision_evaluation.py,sha256=t12R7i1RkOCt9zu1_lxSBr8OH6A6Get0k8ftDLctn6I,10486
-ml_tools/ML_vision_inference.py,sha256=He3KV3VJAm8PwO-fOq4b9VO8UXFr-GmpuCnoHXf4VZI,20588
-ml_tools/ML_vision_models.py,sha256=WqiRN9JAjv--BcwkDrooXAs4Qo26JHPCHh3JSPm4kMI,26226
-ml_tools/ML_vision_transformers.py,sha256=h332O9BjDMgxrBc0I-bJwJODWlcp7nJHbX1QS2etwBk,7738
-ml_tools/PSO_optimization.py,sha256=T-HWHMRJUnPvPwixdU5jif3_rnnI36TzcL8u3oSCwuA,22960
-ml_tools/RNN_forecast.py,sha256=Qa2KoZfdAvSjZ4yE78N4BFXtr3tTr0Gx7tQJZPotsh0,1967
-ml_tools/SQL.py,sha256=vXLPGfVVg8bfkbBE3HVfyEclVbdJy0TBhuQONtMwSCQ,11234
-ml_tools/VIF_factor.py,sha256=at5IVqPvicja2-DNSTSIIy3SkzDWCmLzo3qTG_qr5n8,10422
-ml_tools/_ML_vision_recipe.py,sha256=zrgxFUvTJqQVuwR7jWlbIC2FD29u6eNFPkTRoJ7yEZI,3178
-ml_tools/__init__.py,sha256=kJiankjz9_qXu7gU92mYqYg_anLvt-B6RtW0mMH8uGo,76
-ml_tools/_logger.py,sha256=dlp5cGbzooK9YSNSZYB4yjZrOaQUGW8PTrM411AOvL8,4717
-ml_tools/_schema.py,sha256=yu6aWmn_2Z4_AxAtJGDDCIa96y6JcUp-vgnCS013Qmw,3908
-ml_tools/_script_info.py,sha256=21r83LV3RubsNZ_RTEUON6RbDf7Mh4_udweNcvdF_Fk,212
-ml_tools/constants.py,sha256=3br5Rk9cL2IUo638eJuMOGdbGQaWssaUecYEvSeRBLM,3322
-ml_tools/custom_logger.py,sha256=TGc0Ww2Xlqj2XE3q4bP43hV7T3qnb5ci9f0pYHXF5TY,11226
-ml_tools/data_exploration.py,sha256=bwHzFJ-IAo5GN3T53F-1J_pXUg8VHS91sG_90utAsfg,69911
-ml_tools/ensemble_evaluation.py,sha256=2sJ3jD6yBNPRNwSokyaLKqKHi0QhF13ChoFe5yd4zwg,28368
-ml_tools/ensemble_inference.py,sha256=0yLmLNj45RVVoSCLH1ZYJG9IoAhTkWUqEZmLOQTFGTY,9348
-ml_tools/ensemble_learning.py,sha256=vsIED7nlheYI4w2SBzP6SC1AnNeMfn-2A1Gqw5EfxsM,21964
-ml_tools/handle_excel.py,sha256=pfdAPb9ywegFkM9T54bRssDOsX-K7rSeV0RaMz7lEAo,14006
-ml_tools/keys.py,sha256=-OiL9G0RIOKQk6BwETKIP3LWz2s5-x6lZW2YitJa4mY,3330
-ml_tools/math_utilities.py,sha256=xeKq1quR_3DYLgowcp4Uam_4s3JltUyOnqMOGuAiYWU,8802
-ml_tools/optimization_tools.py,sha256=TYFQ2nSnp7xxs-VyoZISWgnGJghFbsWasHjruegyJRs,12763
-ml_tools/path_manager.py,sha256=CyDU16pOKmC82jPubqJPT6EBt-u-3rGVbxyPIZCvDDY,18432
-ml_tools/serde.py,sha256=c8uDYjYry_VrLvoG4ixqDj5pij88lVn6Tu4NHcPkwDU,6943
-ml_tools/utilities.py,sha256=aWqvYzmxlD74PD5Yqu1VuTekDJeYLQrmPIU_VeVyRp0,22526
-dragon_ml_toolbox-14.7.0.dist-info/METADATA,sha256=NTifVXiC2zr5RhzCUTuUMEcU-wfswXxoYOO6N3UXFmM,6492
-dragon_ml_toolbox-14.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dragon_ml_toolbox-14.7.0.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
-dragon_ml_toolbox-14.7.0.dist-info/RECORD,,

ml_tools/RNN_forecast.py

@@ -1,56 +0,0 @@
-import torch
-from torch import nn
-import numpy as np
-
-from ._script_info import _script_info
-
-
-__all__ = [
-    "rnn_forecast"
-]
-
-def rnn_forecast(model: nn.Module, start_sequence: torch.Tensor, steps: int, device: str = 'cpu'):
-    """
-    Runs a sequential forecast for a trained RNN-based model.
-
-    This function iteratively predicts future time steps, where each new prediction
-    is generated by feeding the previous prediction back into the model.
-
-    Args:
-        model (nn.Module): The trained PyTorch RNN model (e.g., LSTM, GRU).
-        start_sequence (torch.Tensor): The initial sequence to start the forecast from.
-                                       Shape should be (sequence_length, num_features).
-        steps (int): The number of future time steps to predict.
-        device (str, optional): The device to run the forecast on ('cpu', 'cuda', 'mps'). 
-                                Defaults to 'cpu'.
-
-    Returns:
-        np.ndarray: A numpy array containing the forecasted values.
-    """
-    model.eval()
-    model.to(device)
-    
-    predictions = []
-    current_sequence = start_sequence.to(device)
-
-    with torch.no_grad():
-        for _ in range(steps):
-            # Get the model's prediction for the current sequence
-            output = model(current_sequence.unsqueeze(0)) # Add batch dimension
-            
-            # The prediction is the last element of the output sequence
-            next_pred = output[0, -1, :].view(1, -1)
-            
-            # Store the prediction
-            predictions.append(next_pred.cpu().numpy())
-            
-            # Update the sequence for the next iteration:
-            # Drop the first element and append the new prediction
-            current_sequence = torch.cat([current_sequence[1:], next_pred], dim=0)
-            
-    # Concatenate all predictions and flatten the array for easy use
-    return np.concatenate(predictions).flatten()
-
-
-def info():
-    _script_info(__all__)