dragon-ml-toolbox 20.4.0__tar.gz → 20.5.0__tar.gz

{dragon_ml_toolbox-20.4.0/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-20.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 20.4.0
+Version: 20.5.0
 Summary: Complete pipelines and helper tools for data science and machine learning projects.
 Author-email: Karl Luigi Loza Vidaurre <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-20.4.0 → dragon_ml_toolbox-20.5.0/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 20.4.0
+Version: 20.5.0
 Summary: Complete pipelines and helper tools for data science and machine learning projects.
 Author-email: Karl Luigi Loza Vidaurre <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-20.4.0 → dragon_ml_toolbox-20.5.0}/ml_tools/ML_optimization/_multi_dragon.py

@@ -170,9 +170,13 @@ class DragonParetoOptimizer:
             re_evaluate=False # model is deterministic
         )
 
-    def run(self) -> pd.DataFrame:
+    def run(self,
+            plots_and_log: bool=True) -> pd.DataFrame:
         """
         Execute the optimization with progress tracking and periodic logging.
+        
+        Args:
+            plots_and_log (bool): If True, generates plots and logs during optimization. Disable for multi-run scenarios.
 
         Returns:
             pd.DataFrame: A DataFrame containing the non-dominated solutions (Pareto Front).
@@ -189,9 +193,10 @@ class DragonParetoOptimizer:
         _LOGGER.info(f"🧬 Starting NSGA-II (GeneticAlgorithm) for {generations} generations...")
         
         # Initialize log file
-        with open(log_file, "w") as f:
-            f.write(f"Pareto Optimization Log - {generations} Generations\n")
-            f.write("=" * 60 + "\n")
+        if plots_and_log:
+            with open(log_file, "w") as f:
+                f.write(f"Pareto Optimization Log - {generations} Generations\n")
+                f.write("=" * 60 + "\n")
             
         # History tracking for visualization
         history_records = []
@@ -201,43 +206,44 @@ class DragonParetoOptimizer:
             for gen in range(1, generations + 1):
                 self.algorithm.step()
                 
-                # Capture stats for history (every generation for smooth plots)
-                current_evals = self.algorithm.population.evals.clone() # type: ignore
-                
-                gen_stats = {}
-                for i, target_name in enumerate(self.ordered_target_names):
-                    vals = current_evals[:, i]
-                    v_mean = float(vals.mean())
-                    v_min = float(vals.min())
-                    v_max = float(vals.max())
-                    
-                    # Store for plotting
-                    history_records.append({
-                        "Generation": gen,
-                        "Target": target_name,
-                        "Mean": v_mean,
-                        "Min": v_min,
-                        "Max": v_max
-                    })
-                    
-                    gen_stats[target_name] = (v_mean, v_min, v_max)
-                
-                # Periodic Logging of Population Stats to FILE
-                if gen % log_interval == 0 or gen == generations:
-                    stats_msg = [f"Gen {gen}:"]
-                    for t_name, (v_mean, v_min, v_max) in gen_stats.items():
-                        stats_msg.append(f"{t_name}: {v_mean:.3f} (Range: {v_min:.3f}-{v_max:.3f})")
+                if plots_and_log:
+                    # Capture stats for history (every generation for smooth plots)
+                    current_evals = self.algorithm.population.evals.clone() # type: ignore
                     
-                    log_line = " | ".join(stats_msg)
+                    gen_stats = {}
+                    for i, target_name in enumerate(self.ordered_target_names):
+                        vals = current_evals[:, i]
+                        v_mean = float(vals.mean())
+                        v_min = float(vals.min())
+                        v_max = float(vals.max())
+                        
+                        # Store for plotting
+                        history_records.append({
+                            "Generation": gen,
+                            "Target": target_name,
+                            "Mean": v_mean,
+                            "Min": v_min,
+                            "Max": v_max
+                        })
+                        
+                        gen_stats[target_name] = (v_mean, v_min, v_max)
                     
-                    # Write to file
-                    with open(log_file, "a") as f:
-                        f.write(log_line + "\n")
+                    # Periodic Logging of Population Stats to FILE
+                    if gen % log_interval == 0 or gen == generations:
+                        stats_msg = [f"Gen {gen}:"]
+                        for t_name, (v_mean, v_min, v_max) in gen_stats.items():
+                            stats_msg.append(f"{t_name}: {v_mean:.3f} (Range: {v_min:.3f}-{v_max:.3f})")
+                        
+                        log_line = " | ".join(stats_msg)
+                        
+                        # Write to file
+                        with open(log_file, "a") as f:
+                            f.write(log_line + "\n")
                 
                 pbar.update(1)
         
         # --- Post-Optimization Visualization ---
-        if history_records:
+        if plots_and_log and history_records:
             _LOGGER.debug("Generating optimization history plots...")
             history_df = pd.DataFrame(history_records)
             self._plot_optimization_history(history_df, save_path)
@@ -308,7 +314,8 @@ class DragonParetoOptimizer:
         _LOGGER.info(f"Optimization complete. Found {len(pareto_df)} non-dominated solutions.")
 
         # --- Plotting ---
-        self._generate_plots(pareto_df, save_path)
+        if plots_and_log:
+            self._generate_plots(pareto_df, save_path)
 
         return pareto_df
     

{dragon_ml_toolbox-20.4.0 → dragon_ml_toolbox-20.5.0}/ml_tools/data_exploration/__init__.py

@@ -36,6 +36,7 @@ from ._features import (
 from ._schema_ops import (
     finalize_feature_schema,
     apply_feature_schema,
+    reconstruct_from_schema
 )
 
 from .._core import _imprimir_disponibles
@@ -62,6 +63,7 @@ __all__ = [
     "encode_categorical_features",
     "finalize_feature_schema",
     "apply_feature_schema",
+    "reconstruct_from_schema",
     "match_and_filter_columns_by_regex",
     "standardize_percentages",
     "reconstruct_one_hot",

{dragon_ml_toolbox-20.4.0 → dragon_ml_toolbox-20.5.0}/ml_tools/data_exploration/_schema_ops.py

@@ -9,6 +9,13 @@ from .._core import get_logger
 _LOGGER = get_logger("Data Exploration: Schema Ops")
 
 
+__all__ = [
+    "finalize_feature_schema",
+    "apply_feature_schema",
+    "reconstruct_from_schema",
+]
+
+
 def finalize_feature_schema(
     df_features: pd.DataFrame,
     categorical_mappings: Optional[dict[str, dict[str, int]]]
@@ -86,7 +93,7 @@ def apply_feature_schema(
     schema: FeatureSchema,
     targets: Optional[list[str]] = None,
     unknown_value: int = 99999,
-    verbose: bool = True
+    verbose: int = 3
 ) -> pd.DataFrame:
     """
     Aligns the input DataFrame with the provided FeatureSchema.
@@ -100,7 +107,7 @@ def apply_feature_schema(
         targets (list[str] | None): Optional list of target column names.
         unknown_value (int): Integer value to assign to unknown categorical levels.
                              Defaults to 99999 to avoid collision with existing categories.
-        verbose (bool): If True, logs info about dropped extra columns.
+        verbose (int): Verbosity level for logging. Higher values produce more detailed logs.
 
     Returns:
         pd.DataFrame: A new DataFrame with the exact column order and encoding defined by the schema.
@@ -147,7 +154,8 @@ def apply_feature_schema(
             # Handle Unknown Categories
             if df_processed[col_name].isnull().any():
                 n_missing = df_processed[col_name].isnull().sum()
-                _LOGGER.warning(f"Feature '{col_name}': Found {n_missing} unknown categories. Mapping to {unknown_value}.")
+                if verbose >= 1:
+                    _LOGGER.warning(f"Feature '{col_name}': Found {n_missing} unknown categories. Mapping to {unknown_value}.")
                 
                 # Fill unknowns with the specified integer
                 df_processed[col_name] = df_processed[col_name].fillna(unknown_value)
@@ -159,14 +167,13 @@ def apply_feature_schema(
     
     extra_cols = set(df_processed.columns) - set(final_column_order)
     if extra_cols:
-        _LOGGER.info(f"Dropping {len(extra_cols)} extra columns not present in schema.")
-        if verbose:
-            for extra_column in extra_cols:
-                print(f"  - Dropping column: '{extra_column}'")
+        if verbose >= 1:
+            _LOGGER.warning(f"Dropping {len(extra_cols)} extra columns not present in schema: {extra_cols}")
 
     df_final = df_processed[final_column_order]
     
-    _LOGGER.info(f"Schema applied successfully. Final shape: {df_final.shape}")
+    if verbose >= 2:
+        _LOGGER.info(f"Schema applied successfully. Final shape: {df_final.shape}")
     
     # df_final should be a dataframe
     if isinstance(df_final, pd.Series):
@@ -174,3 +181,95 @@ def apply_feature_schema(
 
     return df_final
 
+
+def reconstruct_from_schema(
+    df: pd.DataFrame,
+    schema: FeatureSchema,
+    targets: Optional[list[str]] = None,
+    verbose: int = 3
+) -> pd.DataFrame:
+    """
+    Reverses the schema application to make data human-readable.
+
+    This function decodes categorical features back to their string representations
+    using the schema's mappings. It strictly enforces the schema structure,
+    ignoring extra columns (unless they are specified as targets).
+
+    Args:
+        df (pd.DataFrame): The input DataFrame containing encoded features.
+        schema (FeatureSchema): The schema defining feature names and reverse mappings.
+        targets (list[str] | None): Optional list of target column names to preserve. These are not decoded and kept in the order specified here.
+        verbose (int): Verbosity level for logging info about the process.
+
+    Returns:
+        pd.DataFrame: A new DataFrame with the exact column order (features + targets),
+                      with categorical features decoded to strings.
+
+    Raises:
+        ValueError: If any required feature or target column is missing.
+    """
+    # 1. Setup
+    df_decoded = df.copy()
+    targets = targets if targets is not None else []
+
+    # 2. Validation: Strict Column Presence
+    # Check Features
+    missing_features = [col for col in schema.feature_names if col not in df_decoded.columns]
+    if missing_features:
+        _LOGGER.error(f"Schema Reconstruction Mismatch: Missing required features: {missing_features}")
+        raise ValueError()
+    
+    # Check Targets
+    if targets:
+        missing_targets = [col for col in targets if col not in df_decoded.columns]
+        if missing_targets:
+            _LOGGER.error(f"Schema Reconstruction Mismatch: Missing required targets: {missing_targets}")
+            raise ValueError()
+
+    # 3. Reorder and Filter (Drop extra columns early)
+    # The valid columns are Features + Targets
+    valid_columns = list(schema.feature_names) + targets
+    
+    extra_cols = set(df_decoded.columns) - set(valid_columns)
+    if extra_cols:
+        if verbose >= 1:
+            _LOGGER.warning(f"Dropping extra columns not present in schema or targets: {extra_cols}")
+
+    # Enforce order: Features first, then Targets
+    df_decoded = df_decoded[valid_columns]
+
+    # 4. Reverse Categorical Encoding
+    if schema.categorical_feature_names and schema.categorical_mappings:
+        for col_name in schema.categorical_feature_names:
+            if col_name not in schema.categorical_mappings:
+                continue
+
+            forward_mapping = schema.categorical_mappings[col_name]
+            # Create reverse map: {int: str}
+            reverse_mapping = {v: k for k, v in forward_mapping.items()}
+            
+            # --- SAFE TYPE CASTING ---
+            # Ensure values are Integers before mapping (handle 5.0 vs 5).
+            try:
+                if pd.api.types.is_numeric_dtype(df_decoded[col_name]):
+                    df_decoded[col_name] = df_decoded[col_name].astype("Int64")
+            except (TypeError, ValueError):
+                # casted to NaN later during mapping
+                pass
+            # -------------------------
+
+            # Check for unknown codes before mapping
+            if verbose >= 1:
+                unique_codes = df_decoded[col_name].dropna().unique()
+                unknown_codes = [code for code in unique_codes if code not in reverse_mapping]
+                if unknown_codes:
+                    _LOGGER.warning(f"Feature '{col_name}': Found unknown encoded values {unknown_codes}. These will be mapped to NaN.")
+
+            # Apply reverse mapping
+            df_decoded[col_name] = df_decoded[col_name].map(reverse_mapping)
+            
+    if verbose >= 2:
+        _LOGGER.info(f"Schema reconstruction successful. Final shape: {df_decoded.shape}")
+    
+    return df_decoded
+

{dragon_ml_toolbox-20.4.0 → dragon_ml_toolbox-20.5.0}/ml_tools/schema/_feature_schema.py

@@ -202,13 +202,39 @@ class FeatureSchema(NamedTuple):
                           filename=DatasetKeys.CATEGORICAL_NAMES,
                           verbose=verbose)
         
-    def save_artifacts(self, directory: Union[str,Path]):
+    def save_description(self, directory: Union[str, Path], verbose: bool = False) -> None:
+        """
+        Saves the schema's description to a .txt file.
+        
+        Args:
+            directory: The directory where the file will be saved.
+            verbose: If True, prints a confirmation message upon saving.
+        """
+        dir_path = make_fullpath(directory, make=True, enforce="directory")
+        filename = "FeatureSchema-description.txt"
+        file_path = dir_path / filename
+
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(str(self))
+            
+            if verbose:
+                _LOGGER.info(f"Schema description saved to '{dir_path.name}/{filename}'")
+        except IOError as e:
+            _LOGGER.error(f"Failed to save schema description: {e}")
+            raise e
+        
+    def save_artifacts(self, directory: Union[str,Path], verbose: bool=True):
         """
         Saves feature names, categorical feature names, continuous feature names to separate text files.
         """
-        self.save_all_features(directory=directory, verbose=True)
-        self.save_continuous_features(directory=directory, verbose=True)
-        self.save_categorical_features(directory=directory, verbose=True)
+        self.save_all_features(directory=directory, verbose=False)
+        self.save_continuous_features(directory=directory, verbose=False)
+        self.save_categorical_features(directory=directory, verbose=False)
+        self.save_description(directory=directory, verbose=False)
+        
+        if verbose:
+            _LOGGER.info(f"All FeatureSchema artifacts saved to directory: '{directory}'")
         
     def __repr__(self) -> str:
         """Returns a concise representation of the schema's contents."""

{dragon_ml_toolbox-20.4.0 → dragon_ml_toolbox-20.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dragon-ml-toolbox"
-version = "20.4.0"
+version = "20.5.0"
 description = "Complete pipelines and helper tools for data science and machine learning projects."
 authors = [
     { name = "Karl Luigi Loza Vidaurre", email = "luigiloza@gmail.com" }