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

ml_tools/ensemble_evaluation.py

@@ -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/keys.py

@@ -36,6 +36,7 @@ class PyTorchInferenceKeys:
     # For classification tasks
     LABELS = "labels"
     PROBABILITIES = "probabilities"
+    LABEL_NAMES = "label_names"
 
 
 class PytorchModelArchitectureKeys:
@@ -80,6 +81,44 @@ class PyTorchCheckpointKeys:
     BEST_SCORE = "best_score"
 
 
+class UtilityKeys:
+    """Keys used for utility modules"""
+    MODEL_PARAMS_FILE = "model_parameters"
+    TOTAL_PARAMS = "Total Parameters"
+    TRAINABLE_PARAMS = "Trainable Parameters"
+    PTH_FILE = "pth report "
+    MODEL_ARCHITECTURE_FILE = "model_architecture_summary"
+
+
+class VisionKeys:
+    """For vision ML metrics"""
+    SEGMENTATION_REPORT = "segmentation_report"
+    SEGMENTATION_HEATMAP = "segmentation_metrics_heatmap"
+    SEGMENTATION_CONFUSION_MATRIX = "segmentation_confusion_matrix"
+    # Object detection
+    OBJECT_DETECTION_REPORT = "object_detection_report"
+
+
+class VisionTransformRecipeKeys:
+    """Defines the key names for the transform recipe JSON file."""
+    TASK = "task"
+    PIPELINE = "pipeline"
+    NAME = "name"
+    KWARGS = "kwargs"
+    PRE_TRANSFORMS = "pre_transforms"
+    
+    RESIZE_SIZE = "resize_size"
+    CROP_SIZE = "crop_size"
+    MEAN = "mean"
+    STD = "std"
+
+
+class ObjectDetectionKeys:
+    """Used by the object detection dataset"""
+    BOXES = "boxes"
+    LABELS = "labels"
+
+
 class _OneHotOtherPlaceholder:
     """Used internally by GUI_tools."""
     OTHER_GUI = "OTHER"

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/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,19 @@ 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 +99,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 +177,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 +354,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() == "")
+            .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 +395,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 +553,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,,