dragon-ml-toolbox 13.5.0__tar.gz → 13.7.0__tar.gz

{dragon_ml_toolbox-13.5.0/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-13.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 13.5.0
+Version: 13.7.0
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: "Karl L. Loza Vidaurre" <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-13.5.0 → dragon_ml_toolbox-13.7.0/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 13.5.0
+Version: 13.7.0
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: "Karl L. Loza Vidaurre" <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-13.5.0 → dragon_ml_toolbox-13.7.0}/ml_tools/MICE_imputation.py

@@ -7,19 +7,20 @@ from plotnine import ggplot, labs, theme, element_blank # type: ignore
 from typing import Optional, Union
 
 from .utilities import load_dataframe, merge_dataframes, save_dataframe_filename
-from .math_utilities import threshold_binary_values
+from .math_utilities import threshold_binary_values, discretize_categorical_values
 from .path_manager import sanitize_filename, make_fullpath, list_csv_paths
 from ._logger import _LOGGER
 from ._script_info import _script_info
+from ._schema import FeatureSchema
 
 
 __all__ = [
+    "MiceImputer",
     "apply_mice",
     "save_imputed_datasets",
-    "get_na_column_names",
     "get_convergence_diagnostic",
     "get_imputed_distributions",
-    "run_mice_pipeline"
+    "run_mice_pipeline",
 ]
 
 
@@ -79,7 +80,7 @@ def save_imputed_datasets(save_dir: Union[str, Path], imputed_datasets: list, df
 
 
 #Get names of features that had missing values before imputation
-def get_na_column_names(df: pd.DataFrame):
+def _get_na_column_names(df: pd.DataFrame):
     return [col for col in df.columns if df[col].isna().any()]
 
 
@@ -264,7 +265,7 @@ def run_mice_pipeline(df_path_or_dir: Union[str,Path], target_columns: list[str]
         
         save_imputed_datasets(save_dir=save_datasets_path, imputed_datasets=imputed_datasets, df_targets=df_targets, imputed_dataset_names=imputed_dataset_names)
         
-        imputed_column_names = get_na_column_names(df=df)
+        imputed_column_names = _get_na_column_names(df=df)
         
         get_convergence_diagnostic(kernel=kernel, imputed_dataset_names=imputed_dataset_names, column_names=imputed_column_names, root_dir=save_metrics_path)
         
@@ -278,5 +279,206 @@ def _skip_targets(df: pd.DataFrame, target_cols: list[str]):
     return df_feats, df_targets
 
 
+# modern implementation
+class MiceImputer:
+    """
+    A modern MICE imputation pipeline that uses a FeatureSchema
+    to correctly discretize categorical features after imputation.
+    """
+    def __init__(self, 
+                 schema: FeatureSchema,
+                 iterations: int=20,
+                 resulting_datasets: int = 1,
+                 random_state: int = 101):
+        
+        self.schema = schema
+        self.random_state = random_state
+        self.iterations = iterations
+        self.resulting_datasets = resulting_datasets
+        
+        # --- Store schema info ---
+        
+        # 1. Categorical info
+        if not self.schema.categorical_index_map:
+            _LOGGER.warning("FeatureSchema has no 'categorical_index_map'. No discretization will be applied.")
+            self.cat_info = {}
+        else:
+            self.cat_info = self.schema.categorical_index_map
+            
+        # 2. Ordered feature names (critical for index mapping)
+        self.ordered_features = list(self.schema.feature_names)
+        
+        # 3. Names of categorical features
+        self.categorical_features = list(self.schema.categorical_feature_names)
+
+        _LOGGER.info(f"MiceImputer initialized. Found {len(self.cat_info)} categorical features to discretize.")
+        
+    def _post_process(self, imputed_df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Applies schema-based discretization to a completed dataframe.
+        
+        This method works around the behavior of `discretize_categorical_values`
+        (which returns a full int32 array) by:
+        1. Calling it on the full, ordered feature array.
+        2. Extracting *only* the valid discretized categorical columns.
+        3. Updating the original float dataframe with these integer values.
+        """
+        # If no categorical features are defined, return the df as-is.
+        if not self.cat_info:
+            return imputed_df
+
+        try:
+            # 1. Ensure DataFrame columns match the schema order
+            # This is critical for the index-based categorical_info
+            df_ordered: pd.DataFrame = imputed_df[self.ordered_features] # type: ignore
+            
+            # 2. Convert to NumPy array
+            array_ordered = df_ordered.to_numpy()
+
+            # 3. Apply discretization utility (which returns a full int32 array)
+            # This array has *correct* categorical values but *truncated* continuous values.
+            discretized_array_int32 = discretize_categorical_values(
+                array_ordered,
+                self.cat_info,
+                start_at_zero=True  # Assuming 0-based indexing
+            )
+
+            # 4. Create a new DF from the int32 array, keeping the categorical columns.
+            df_discretized_cats = pd.DataFrame(
+                discretized_array_int32,
+                columns=self.ordered_features,
+                index=df_ordered.index  # <-- Critical: align index
+            )[self.categorical_features] # <-- Select only cat features
+
+            # 5. "Rejoin": Start with a fresh copy of the *original* imputed DF (which has correct continuous floats).
+            final_df = df_ordered.copy()
+            
+            # 6. Use .update() to "paste" the integer categorical values
+            # over the old float categorical values. Continuous floats are unaffected.
+            final_df.update(df_discretized_cats)
+            
+            return final_df
+
+        except Exception as e:
+            _LOGGER.error(f"Failed during post-processing discretization:\n\tInput DF shape: {imputed_df.shape}\n\tSchema features: {len(self.ordered_features)}\n\tCategorical info keys: {list(self.cat_info.keys())}\n{e}")
+            raise
+        
+    def _run_mice(self, 
+                  df: pd.DataFrame, 
+                  df_name: str) -> tuple[mf.ImputationKernel, list[pd.DataFrame], list[str]]:
+        """
+        Runs the MICE kernel and applies schema-based post-processing.
+        
+        Parameters:
+            df (pd.DataFrame): The input dataframe *with NaNs*. Should only contain feature columns.
+            df_name (str): The base name for the dataset.
+
+        Returns:
+            tuple[mf.ImputationKernel, list[pd.DataFrame], list[str]]:
+                - The trained MICE kernel
+                - A list of imputed and processed DataFrames
+                - A list of names for the new DataFrames
+        """
+        # Ensure input df only contains features from the schema and is in the correct order.
+        try:
+            df_feats = df[self.ordered_features]
+        except KeyError as e:
+            _LOGGER.error(f"Input DataFrame is missing required schema columns: {e}")
+            raise
+        
+        # 1. Initialize kernel
+        kernel = mf.ImputationKernel(
+            data=df_feats,
+            num_datasets=self.resulting_datasets,
+            random_state=self.random_state
+        )
+        
+        _LOGGER.info("➡️ Schema-based MICE imputation running...")
+        
+        # 2. Perform MICE
+        kernel.mice(self.iterations)
+        
+        # 3. Retrieve, process, and collect datasets
+        imputed_datasets = []
+        for i in range(self.resulting_datasets):
+            # complete_data returns a pd.DataFrame
+            completed_df = kernel.complete_data(dataset=i)
+            
+            # Apply our new discretization and ordering
+            processed_df = self._post_process(completed_df)
+            imputed_datasets.append(processed_df)
+
+        if not imputed_datasets:
+            _LOGGER.error("No imputed datasets were generated.")
+            raise ValueError()
+
+        # 4. Generate names
+        if self.resulting_datasets == 1:
+            imputed_dataset_names = [f"{df_name}_MICE"]
+        else:
+            imputed_dataset_names = [f"{df_name}_MICE_{i+1}" for i in range(self.resulting_datasets)]
+        
+        # 5. Validate indexes 
+        for imputed_df, subname in zip(imputed_datasets, imputed_dataset_names):
+            assert imputed_df.shape[0] == df.shape[0], f"❌ Row count mismatch in dataset {subname}"
+            assert all(imputed_df.index == df.index), f"❌ Index mismatch in dataset {subname}"
+        
+        _LOGGER.info("Schema-based MICE imputation complete.")
+        
+        return kernel, imputed_datasets, imputed_dataset_names
+        
+    def run_pipeline(self, 
+                     df_path_or_dir: Union[str,Path],
+                     save_datasets_dir: Union[str,Path], 
+                     save_metrics_dir: Union[str,Path],
+                     ):
+        """
+        Runs the complete MICE imputation pipeline.
+
+        This method automates the entire workflow:
+            1. Loads data from a CSV file path or a directory with CSV files.
+            2. Separates features and targets based on the `FeatureSchema`.
+            3. Runs the MICE algorithm on the feature set.
+            4. Applies schema-based post-processing to discretize categorical features.
+            5. Saves the final, processed, and imputed dataset(s) (re-joined with targets) to `save_datasets_dir`.
+            6. Generates and saves convergence and distribution plots for all imputed columns to `save_metrics_dir`.
+
+        Parameters
+        ----------
+        df_path_or_dir :[str,Path]
+            Path to a single CSV file or a directory containing multiple CSV files to impute.
+        save_datasets_dir : [str,Path]
+            Directory where the final imputed and processed dataset(s) will be saved as CSVs.
+        save_metrics_dir : [str,Path]
+            Directory where convergence and distribution plots will be saved.
+        """
+        # Check paths
+        save_datasets_path = make_fullpath(save_datasets_dir, make=True)
+        save_metrics_path = make_fullpath(save_metrics_dir, make=True)
+        
+        input_path = make_fullpath(df_path_or_dir)
+        if input_path.is_file():
+            all_file_paths = [input_path]
+        else:
+            all_file_paths = list(list_csv_paths(input_path).values())
+        
+        for df_path in all_file_paths:
+            
+            df, df_name = load_dataframe(df_path=df_path, kind="pandas")
+            
+            df_features: pd.DataFrame = df[self.schema.feature_names] # type: ignore
+            df_targets = df.drop(columns=self.schema.feature_names)
+            
+            imputed_column_names = _get_na_column_names(df=df_features)
+            
+            kernel, imputed_datasets, imputed_dataset_names = self._run_mice(df=df_features, df_name=df_name)
+            
+            save_imputed_datasets(save_dir=save_datasets_path, imputed_datasets=imputed_datasets, df_targets=df_targets, imputed_dataset_names=imputed_dataset_names)
+            
+            get_convergence_diagnostic(kernel=kernel, imputed_dataset_names=imputed_dataset_names, column_names=imputed_column_names, root_dir=save_metrics_path)
+            
+            get_imputed_distributions(kernel=kernel, df_name=df_name, root_dir=save_metrics_path, column_names=imputed_column_names)
+
+
 def info():
     _script_info(__all__)

{dragon_ml_toolbox-13.5.0 → dragon_ml_toolbox-13.7.0}/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.5.0 → dragon_ml_toolbox-13.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dragon-ml-toolbox"
-version = "13.5.0"
+version = "13.7.0"
 description = "A collection of tools for data science and machine learning projects."
 authors = [
     { name = "Karl L. Loza Vidaurre", email = "luigiloza@gmail.com" }