dragon-ml-toolbox 13.3.0__py3-none-any.whl → 16.2.0__py3-none-any.whl

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__ = [
@@ -112,7 +112,7 @@ def evaluate_model_classification(
         report_df = pd.DataFrame(report_dict).iloc[:-1, :].T
         plt.figure(figsize=figsize)
         sns.heatmap(report_df, annot=True, cmap=heatmap_cmap, fmt='.2f', 
-                    annot_kws={"size": base_fontsize - 4})
+                    annot_kws={"size": base_fontsize - 4}, vmin=0.0, vmax=1.0)
         plt.title(f"{model_name} - {target_name}", fontsize=base_fontsize)
         plt.xticks(fontsize=base_fontsize - 2)
         plt.yticks(fontsize=base_fontsize - 2)
@@ -133,6 +133,7 @@ def evaluate_model_classification(
         normalize="true",
         ax=ax
     )
+    disp.im_.set_clim(vmin=0.0, vmax=1.0)
 
     ax.set_title(f"{model_name} - {target_name}", fontsize=base_fontsize)
     ax.tick_params(axis='both', labelsize=base_fontsize)
@@ -327,7 +328,8 @@ def plot_calibration_curve(
     target_name: str,
     figure_size: tuple = (10, 10),
     base_fontsize: int = 24,
-    n_bins: int = 15
+    n_bins: int = 15,
+    line_color: str = 'darkorange'
 ) -> plt.Figure: # type: ignore
     """
     Plots the calibration curve (reliability diagram) for a classifier.
@@ -348,22 +350,63 @@ def plot_calibration_curve(
     """
     fig, ax = plt.subplots(figsize=figure_size)
     
-    disp = CalibrationDisplay.from_estimator(
-        model,
-        x_test,
-        y_test,
-        n_bins=n_bins,
-        ax=ax
+    # --- Step 1: Get probabilities from the estimator ---
+    # We do this manually so we can pass them to from_predictions
+    try:
+        y_prob = model.predict_proba(x_test)
+        # Use probabilities for the positive class (assuming binary)
+        y_score = y_prob[:, 1]
+    except Exception as e:
+        _LOGGER.error(f"Could not get probabilities from model: {e}")
+        plt.close(fig)
+        return fig # Return empty figure
+
+    # --- Step 2: Get binned data *without* plotting ---
+    with plt.ioff(): 
+        fig_temp, ax_temp = plt.subplots()
+        cal_display_temp = CalibrationDisplay.from_predictions(
+            y_test, 
+            y_score, 
+            n_bins=n_bins, 
+            ax=ax_temp,
+            name="temp"
+        )
+        line_x, line_y = cal_display_temp.line_.get_data() # type: ignore
+        plt.close(fig_temp)
+
+    # --- Step 3: Build the plot from scratch on ax ---
+
+    # 3a. Plot the ideal diagonal line
+    ax.plot([0, 1], [0, 1], 'k--', label='Perfectly calibrated')
+
+    # 3b. Use regplot for the regression line and its CI
+    sns.regplot(
+        x=line_x, 
+        y=line_y,
+        ax=ax,
+        scatter=False,  # No scatter dots
+        label=f"Calibration Curve ({n_bins} bins)",
+        line_kws={
+            'color': line_color,
+            'linestyle': '--', 
+            'linewidth': 2
+        }
     )
 
+    # --- Step 4: Apply original formatting ---
     ax.set_title(f"{model_name} - Reliability Curve for {target_name}", fontsize=base_fontsize)
     ax.tick_params(axis='both', labelsize=base_fontsize - 2)
     ax.set_xlabel("Mean Predicted Probability", fontsize=base_fontsize)
     ax.set_ylabel("Fraction of Positives", fontsize=base_fontsize)
-    ax.legend(fontsize=base_fontsize - 4)
+    
+    # Set limits
+    ax.set_ylim(0.0, 1.0)
+    ax.set_xlim(0.0, 1.0)
+    
+    ax.legend(fontsize=base_fontsize - 4, loc='lower right')
     fig.tight_layout()
 
-    # Save figure
+    # --- Step 5: Save figure (using original logic) ---
     save_path = make_fullpath(save_dir, make=True)
     sanitized_target_name = sanitize_filename(target_name)
     full_save_path = save_path / f"Calibration_Plot_{sanitized_target_name}.svg"

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/math_utilities.py

@@ -219,7 +219,7 @@ def discretize_categorical_values(
         _LOGGER.error(f"'categorical_info' is not a dictionary, or is empty.")
         raise ValueError()
 
-    _, total_features = input_array.shape
+    _, total_features = working_array.shape
     for col_idx, cardinality in categorical_info.items():
         if not isinstance(col_idx, int):
              _LOGGER.error(f"Column index key {col_idx} is not an integer.")

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/serde.py

@@ -85,7 +85,7 @@ def serialize_object(obj: Any, file_path: Path, verbose: bool = True, raise_on_e
         return None
     else:
         if verbose:
-            if isinstance(obj, _SIMPLE_TYPES):
+            if type(obj) in _SIMPLE_TYPES:
                 _LOGGER.info(f"Object of type '{type(obj)}' saved to '{file_path}'")
             else:
                 _LOGGER.info(f"Object '{obj}' saved to '{file_path}'")
@@ -140,7 +140,7 @@ def deserialize_object(
         
         if verbose:
             # log special objects
-            if isinstance(obj, _SIMPLE_TYPES):
+            if type(obj) in _SIMPLE_TYPES:
                 _LOGGER.info(f"Loaded object of type '{type(obj)}' from '{true_filepath}'.")
             else:
                 _LOGGER.info(f"Loaded object '{obj}' from '{true_filepath}'.")

ml_tools/utilities.py

@@ -7,16 +7,18 @@ from typing import Literal, Union, Optional, Any, Iterator, Tuple, overload
 from .path_manager import sanitize_filename, make_fullpath, list_csv_paths
 from ._script_info import _script_info
 from ._logger import _LOGGER
+from ._schema import FeatureSchema
 
 
-# Keep track of available tools
 __all__ = [
     "load_dataframe",
     "load_dataframe_greedy",
+    "load_dataframe_with_schema",
     "yield_dataframes_from_dir",
     "merge_dataframes",
     "save_dataframe_filename",
     "save_dataframe",
+    "save_dataframe_with_schema",
     "distribute_dataset_by_target",
     "train_dataset_orchestrator",
     "train_dataset_yielder"
@@ -96,6 +98,7 @@ def load_dataframe(
         elif kind == "polars":
             pl_kwargs: dict[str,Any]
             pl_kwargs = {}
+            pl_kwargs['null_values'] = ["", " "]
             if use_columns:
                 pl_kwargs['columns'] = use_columns
                 
@@ -173,6 +176,68 @@ def load_dataframe_greedy(directory: Union[str, Path],
     return df
 
 
+def load_dataframe_with_schema(
+    df_path: Union[str, Path], 
+    schema: "FeatureSchema",
+    all_strings: bool = False,
+) -> Tuple[pd.DataFrame, str]:
+    """
+    Loads a CSV file into a Pandas DataFrame, strictly validating its
+    feature columns against a FeatureSchema.
+
+    This function wraps `load_dataframe`. After loading, it validates
+    that the first N columns of the DataFrame (where N =
+    len(schema.feature_names)) contain *exactly* the set of features
+    specified in the schema.
+
+    - If the columns are present but out of order, they are reordered.
+    - If any required feature is missing from the first N columns, it fails.
+    - If any extra column is found within the first N columns, it fails.
+
+    Columns *after* the first N are considered target columns and are
+    logged for verification.
+
+    Args:
+        df_path (str, Path): 
+            The path to the CSV file.
+        schema (FeatureSchema): 
+            The schema object to validate against.
+        all_strings (bool): 
+            If True, loads all columns as string data types.
+
+    Returns:
+        (Tuple[pd.DataFrame, str]):
+            A tuple containing the loaded, validated (and possibly
+            reordered) pandas DataFrame and the base name of the file.
+            
+    Raises:
+        ValueError: 
+            - If the DataFrame is missing columns required by the schema
+              within its first N columns.
+            - If the DataFrame's first N columns contain unexpected
+              columns that are not in the schema.
+        FileNotFoundError: 
+            If the file does not exist at the given path.
+    """
+    # Step 1: Load the dataframe using the original function
+    try:
+        df, df_name = load_dataframe(
+            df_path=df_path, 
+            use_columns=None,  # Load all columns for validation
+            kind="pandas", 
+            all_strings=all_strings,
+            verbose=True
+        )
+    except Exception as e:
+        _LOGGER.error(f"Failed during initial load for schema validation: {e}")
+        raise e
+    
+    # Step 2: Call the helper to validate and reorder
+    df_validated = _validate_and_reorder_schema(df=df, schema=schema)
+
+    return df_validated, df_name
+
+
 def yield_dataframes_from_dir(datasets_dir: Union[str,Path], verbose: bool=True):
     """
     Iterates over all CSV files in a given directory, loading each into a Pandas DataFrame.
@@ -288,15 +353,25 @@ def save_dataframe_filename(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Uni
         
     # --- Type-specific saving logic ---
     if isinstance(df, pd.DataFrame):
-        df.to_csv(output_path, index=False, encoding='utf-8')
+        # Transform "" to np.nan before saving
+        df_to_save = df.replace(r'^\s*$', np.nan, regex=True)
+        # Save
+        df_to_save.to_csv(output_path, index=False, encoding='utf-8')
     elif isinstance(df, pl.DataFrame):
-        df.write_csv(output_path) # Polars defaults to utf8 and no index
+        # Transform empty strings to Null
+        df_to_save = df.with_columns(
+            pl.when(pl.col(pl.Utf8).str.strip() == "") # type: ignore
+            .then(None)
+            .otherwise(pl.col(pl.Utf8))
+        )
+        # Save
+        df_to_save.write_csv(output_path)
     else:
         # This error handles cases where an unsupported type is passed
         _LOGGER.error(f"Unsupported DataFrame type: {type(df)}. Must be pandas or polars.")
         raise TypeError()
     
-    _LOGGER.info(f"Saved dataset: '{filename}' with shape: {df.shape}")
+    _LOGGER.info(f"Saved dataset: '{filename}' with shape: {df_to_save.shape}")
 
 
 def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], full_path: Path):
@@ -319,6 +394,52 @@ def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], full_path: Path):
                             filename=full_path.name)
 
 
+def save_dataframe_with_schema(
+    df: pd.DataFrame, 
+    full_path: Path,
+    schema: "FeatureSchema"
+) -> None:
+    """
+    Saves a pandas DataFrame to a CSV, strictly enforcing that the
+    first N columns match the FeatureSchema.
+
+    This function validates that the first N columns of the DataFrame
+    (where N = len(schema.feature_names)) contain *exactly* the set
+    of features specified in the schema.
+    
+    - If the columns are present but out of order, they are reordered.
+    - If any required feature is missing from the first N columns, it fails.
+    - If any extra column is found within the first N columns, it fails.
+
+    Columns *after* the first N are considered target columns and are
+    logged for verification.
+
+    Args:
+        df (pd.DataFrame): 
+            The DataFrame to save.
+        full_path (Path): 
+            The complete file path where the DataFrame will be saved.
+        schema (FeatureSchema): 
+            The schema object to validate against.
+
+    Raises:
+        ValueError: 
+            - If the DataFrame is missing columns required by the schema
+              within its first N columns.
+            - If the DataFrame's first N columns contain unexpected
+              columns that are not in the schema.
+    """
+    if not isinstance(full_path, Path) or not full_path.suffix.endswith(".csv"):
+        _LOGGER.error('A path object pointing to a .csv file must be provided.')
+        raise ValueError()
+    
+    # Call the helper to validate and reorder
+    df_to_save = _validate_and_reorder_schema(df=df, schema=schema)
+    
+    # Call the original save function
+    save_dataframe(df=df_to_save, full_path=full_path)
+
+
 def distribute_dataset_by_target(
     df_or_path: Union[pd.DataFrame, str, Path],
     target_columns: list[str],
@@ -431,5 +552,72 @@ def train_dataset_yielder(
         yield (df_features, df_target, feature_names, target_col)
 
 
+def _validate_and_reorder_schema(
+    df: pd.DataFrame, 
+    schema: "FeatureSchema"
+) -> pd.DataFrame:
+    """
+    Internal helper to validate and reorder a DataFrame against a schema.
+
+    Checks for missing, extra, and out-of-order feature columns
+    (the first N columns). Returns a reordered DataFrame if necessary.
+    Logs all actions.
+
+    Raises:
+        ValueError: If validation fails.
+    """
+    # Get schema and DataFrame column info
+    expected_features = list(schema.feature_names)
+    expected_set = set(expected_features)
+    n_features = len(expected_features)
+    
+    all_df_columns = df.columns.to_list()
+
+    # --- Strict Validation ---
+
+    # 0. Check if DataFrame is long enough
+    if len(all_df_columns) < n_features:
+        _LOGGER.error(f"DataFrame has only {len(all_df_columns)} columns, but schema requires {n_features} features.")
+        raise ValueError()
+    
+    df_feature_cols = all_df_columns[:n_features]
+    df_feature_set = set(df_feature_cols)
+    df_target_cols = all_df_columns[n_features:]
+
+    # 1. Check for missing features
+    missing_from_df = expected_set - df_feature_set
+    if missing_from_df:
+        _LOGGER.error(f"DataFrame's first {n_features} columns are missing required schema features: {missing_from_df}")
+        raise ValueError()
+
+    # 2. Check for extra (unexpected) features
+    extra_in_df = df_feature_set - expected_set
+    if extra_in_df:
+        _LOGGER.error(f"DataFrame's first {n_features} columns contain unexpected columns: {extra_in_df}")
+        raise ValueError()
+
+    # --- Reordering ---
+    
+    df_to_process = df
+
+    # If we pass validation, the sets are equal. Now check order.
+    if df_feature_cols == expected_features:
+        _LOGGER.info("DataFrame feature columns already match schema order.")
+    else:
+        _LOGGER.warning("DataFrame feature columns do not match schema order. Reordering...")
+        
+        # Rebuild the DataFrame with the correct feature order + target columns
+        new_order = expected_features + df_target_cols
+        df_to_process = df[new_order]
+
+    # Log the presumed target columns for user verification
+    if not df_target_cols:
+        _LOGGER.warning(f"No target columns were found after index {n_features-1}.")
+    else:
+        _LOGGER.info(f"Presumed Target Columns: {df_target_cols}")
+    
+    return df_to_process # type: ignore
+
+
 def info():
     _script_info(__all__)

dragon_ml_toolbox-13.3.0.dist-info/RECORD

@@ -1,41 +0,0 @@
-dragon_ml_toolbox-13.3.0.dist-info/licenses/LICENSE,sha256=L35WDmmLZNTlJvxF6Vy7Uy4SYNi6rCfWUqlTHpoRMoU,1081
-dragon_ml_toolbox-13.3.0.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=iy2r_R7wjzsCbz_Q_jMsp_jfZ6oP8XW9QhwzRBH0mGY,1904
-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=X273Qlgoqqg7KTmoKd75YDyAPB0UIbTzGP3xsCmRh3E,11717
-ml_tools/ML_callbacks.py,sha256=elD2Yr030sv_6gX_m9GVd6HTyrbmt34nFS8lrgS4HtM,15808
-ml_tools/ML_datasetmaster.py,sha256=7QJnOM6GWFklKt2fiukITM3DK49i3ThK8wazb5szwpE,34396
-ml_tools/ML_evaluation.py,sha256=3u5dOhS77gn3kAshKr2GwSa5xZBF0YM77ZkFevqNPvA,18528
-ml_tools/ML_evaluation_multi.py,sha256=L6Ub_uObXsI7ToVCF6DtmAFekHRcga5wWMOnRYRR-BY,16121
-ml_tools/ML_inference.py,sha256=yq2gdN6s_OUYC5ZLQrIJC5BA5H33q8UKODXwb-_0M2c,23549
-ml_tools/ML_models.py,sha256=4Kb23pSusPMRH8h-R9ztK6JoH1lMuckxq7ihorll-H8,29965
-ml_tools/ML_optimization.py,sha256=P0zkhKAwTpkorIBtR0AOIDcyexo5ngmvFUzo3DfNO-E,22692
-ml_tools/ML_scaler.py,sha256=tw6onj9o8_kk3FQYb930HUzvv1zsFZe2YZJdF3LtHkU,7538
-ml_tools/ML_trainer.py,sha256=9BP6JFClqGfe7GL-FGG3n5e-no9ssjEOLol7P6baGrI,29019
-ml_tools/ML_utilities.py,sha256=EnKpPTnJ2qjZmz7kvows4Uu5CfSA7ByRmI1v2-KarKw,9337
-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/__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=7tSAgRL7e-Ekm7rS1FLDocaPLCnaoKc7VSrtfwCtCEg,10067
-ml_tools/data_exploration.py,sha256=-BbWO7BBFapPi_7ZuWo65VqguJXaBfgFSptrXyoWrDk,51902
-ml_tools/ensemble_evaluation.py,sha256=FGHSe8LBI8_w8LjNeJWOcYQ1UK_mc6fVah8gmSvNVGg,26853
-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=oykUVLB4Wos3AZomowjtI8AFFC5xnMUH-icNHydRpOk,2275
-ml_tools/math_utilities.py,sha256=PxoOrnuj6Ntp7_TJqyDWi0JX03WpAO5iaFNK2Oeq5I4,8800
-ml_tools/optimization_tools.py,sha256=TYFQ2nSnp7xxs-VyoZISWgnGJghFbsWasHjruegyJRs,12763
-ml_tools/path_manager.py,sha256=CyDU16pOKmC82jPubqJPT6EBt-u-3rGVbxyPIZCvDDY,18432
-ml_tools/serde.py,sha256=CmdJmQCPdrm2RQA1hWLsGxU_B3aClQoQ9B4vcQtIrEs,6951
-ml_tools/utilities.py,sha256=OcAyV1tEcYAfOWlGjRgopsjDLxU3DcI5EynzvWV4q3A,15754
-dragon_ml_toolbox-13.3.0.dist-info/METADATA,sha256=m2RVQa8YeN6e4hnsg6TwAMjymhTrburFXbmw-yB8JeQ,6166
-dragon_ml_toolbox-13.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dragon_ml_toolbox-13.3.0.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
-dragon_ml_toolbox-13.3.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__)