dragon-ml-toolbox 19.7.0__py3-none-any.whl → 19.8.0__py3-none-any.whl

{dragon_ml_toolbox-19.7.0.dist-info → dragon_ml_toolbox-19.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 19.7.0
+Version: 19.8.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-19.7.0.dist-info → dragon_ml_toolbox-19.8.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-dragon_ml_toolbox-19.7.0.dist-info/licenses/LICENSE,sha256=L35WDmmLZNTlJvxF6Vy7Uy4SYNi6rCfWUqlTHpoRMoU,1081
-dragon_ml_toolbox-19.7.0.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=XBLtvGjvBf-q93a5iylHj94Lm78UzInC-3Cii01jc6I,3127
+dragon_ml_toolbox-19.8.0.dist-info/licenses/LICENSE,sha256=L35WDmmLZNTlJvxF6Vy7Uy4SYNi6rCfWUqlTHpoRMoU,1081
+dragon_ml_toolbox-19.8.0.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=XBLtvGjvBf-q93a5iylHj94Lm78UzInC-3Cii01jc6I,3127
 ml_tools/ETL_cleaning.py,sha256=cKXyRFaaFs_beAGDnQM54xnML671kq-yJEGjHafW-20,351
 ml_tools/ETL_engineering.py,sha256=cwh1FhtNdUHllUDvho-x3SIVj4KwG_rFQR6VYzWUg0U,898
 ml_tools/GUI_tools.py,sha256=O89rG8WQv6GY1DiphQjIsPzXFCQID6te7q_Sgt1iTkQ,294
@@ -8,7 +8,7 @@ ml_tools/MICE_imputation.py,sha256=tpLM-rdq4sKbc2GHfj7UrkS3DmBZ3B_DlbrklWbI7gI,3
 ml_tools/ML_callbacks.py,sha256=hrfsIpGkQ1G4Ucfio8JDO1TWjiluuLHCmE7r0ScqxNs,218
 ml_tools/ML_chaining_inference.py,sha256=-JD-LbPtFQkEEWyLUuszWvsqE6nbgkKaQBjrwmBPer0,124
 ml_tools/ML_chaining_utilities.py,sha256=TmiVea_66qfB2l3UEVua4Wb5Sg1D75bSz_-Js3DudfA,360
-ml_tools/ML_configuration.py,sha256=pKSrmCgOEbv2F3VZg52AmpuicKPdmAMgRxyHTT4WGfI,2681
+ml_tools/ML_configuration.py,sha256=R8ca9q6W_Lm8lQ48qmxWfdMeHJ5o9hmcHhVdekrY_UQ,2730
 ml_tools/ML_configuration_pytab.py,sha256=6BdyL8sdAp6SDCM1DQrKZKo3yXnEgPX8mWXOaYVMhp0,257
 ml_tools/ML_datasetmaster.py,sha256=bbT29BOGjUThcYctd2eA9K4Y6wKU6sewFMZ7tjVgpqo,154
 ml_tools/ML_evaluation.py,sha256=My7W2IDPca7cMgmJoGyqqVzFL36ssaXA5f4MqKtvWBA,319
@@ -58,7 +58,7 @@ ml_tools/_core/_MICE_imputation.py,sha256=_juIymUnNDRWjSLepL8Ee_PncoShbxjR7YtqTt
 ml_tools/_core/_ML_callbacks.py,sha256=qtCrVFHTq-nk4NIsAdwIkfkKwFXX6I-6PoCgqZELp70,16734
 ml_tools/_core/_ML_chaining_inference.py,sha256=vXUPZzuQ2yKU71kkvUsE0xPo0hN-Yu6gfnL0JbXoRjI,7783
 ml_tools/_core/_ML_chaining_utilities.py,sha256=nsYowgRbkIYuzRiHlqsM3tnC3c-8O73CY8DHUF14XL0,19248
-ml_tools/_core/_ML_configuration.py,sha256=t_6p_slOPhmy04wJcQj6D_bJyZRaXlsIeWIiULaJnXc,48716
+ml_tools/_core/_ML_configuration.py,sha256=6lKod_NuXSj0ElYmkkwnRxZEiZctMlX1x4b0ByRKKhg,52281
 ml_tools/_core/_ML_configuration_pytab.py,sha256=C3e4iScqdRePVDoqnic6xXMOW7DNYqpgTCeaFDyMdL4,3286
 ml_tools/_core/_ML_datasetmaster.py,sha256=yU1BMtzz6XumMWCetVACrRLk7WJQwmYhaQ-VAWu9Ots,32043
 ml_tools/_core/_ML_evaluation.py,sha256=bu8qlYzhWSC1B7wNfCC5TSF-oed-uP8EF7TV45VTiBM,37325
@@ -70,7 +70,7 @@ ml_tools/_core/_ML_models.py,sha256=8FUx4-TVghlBF9srh1_5UxovrWPU7YEZ6XXLqwJei88,
 ml_tools/_core/_ML_models_advanced.py,sha256=oU6M5FEBMQ9yPp32cziWh3bz8SXRho07vFMC8ZDVcuU,45002
 ml_tools/_core/_ML_models_pytab.py,sha256=EHHnDG02ghcJORy2gipm3NcrlzL0qygD44o7QGmT1Zs,26297
 ml_tools/_core/_ML_optimization.py,sha256=b1qfHiGyvVoj-ENqDbHTf1jNx55niUWE9KEZJv3vg80,28253
-ml_tools/_core/_ML_optimization_pareto.py,sha256=7jjV7i-A_J8vizDKg2ZIWNMVRu5oJokRmDbIkhofdlk,34831
+ml_tools/_core/_ML_optimization_pareto.py,sha256=fad4UjW5TDbCgIsVFk1qmkq8DnU5sahFFuC2DgKAQ3I,36889
 ml_tools/_core/_ML_scaler.py,sha256=Nhu6qli_QezHQi5NKhRb8Z51bBJgzk2nEp_yW4B9H4U,8134
 ml_tools/_core/_ML_sequence_datasetmaster.py,sha256=0YVOPf-y4ZNdgUxropXUWrmInNyGYaUYprYvXf31n9U,17811
 ml_tools/_core/_ML_sequence_evaluation.py,sha256=AiPHtZ9DRpE6zL9n3Tp5eGGD9vrYRkLbZ0Nc274mL7I,8069
@@ -92,7 +92,7 @@ ml_tools/_core/_ensemble_evaluation.py,sha256=17lWl4bWLT1BAMv_fhGf2D3wy-F4jx0Hgn
 ml_tools/_core/_ensemble_inference.py,sha256=PfZG-r65Vw3IAmBJZg9W0zYGEe-QbhfUh_rd2ho-rr8,8610
 ml_tools/_core/_ensemble_learning.py,sha256=X8ghbjDOLMENCWdISXLhDlHQtR3C6SW1tkTBAcfRRPY,22016
 ml_tools/_core/_excel_handler.py,sha256=gV4rSIsiowb0xllpEJxzUKaYDDVpmP_lxs9wZA76-cc,14050
-ml_tools/_core/_keys.py,sha256=4RE-ZuCJkUmqefz-dc3qrVbftqVAWkunZFrP2yJjpCU,6740
+ml_tools/_core/_keys.py,sha256=UpTLHMG1j4FB7hCItcqnfAAuSVMK3Rf-i7jcu6Wkf-Y,6836
 ml_tools/_core/_logger.py,sha256=86Ge0sDE_WgwsZBglQRYPyFYX3lcsIo0NzszNPzlxuk,5254
 ml_tools/_core/_math_utilities.py,sha256=IlXAiZgTcLtus03jJOBOyF9ZCQDf8qLGjrCHu9Mrgak,9091
 ml_tools/_core/_models_advanced_base.py,sha256=ceW0V_CcfOnSFqHlxUhVU8-5mtQq4tFyo8TX-xVexrY,4982
@@ -104,7 +104,7 @@ ml_tools/_core/_schema.py,sha256=TM5WVVMoKOvr_Bc2z34sU_gzKlM465PRKTgdZaEOkGY,140
 ml_tools/_core/_script_info.py,sha256=21r83LV3RubsNZ_RTEUON6RbDf7Mh4_udweNcvdF_Fk,212
 ml_tools/_core/_serde.py,sha256=tsI4EO2Y7jrBMmbQ1pinDsPOrOg-SaPuB-Dt40q0taE,5609
 ml_tools/_core/_utilities.py,sha256=iA8fLWdhsIx4ut2Dp8M_OyU0Y3PPLgGdIklyl17x6xk,22560
-dragon_ml_toolbox-19.7.0.dist-info/METADATA,sha256=64wv9eyG4FCm-QRo-9S0wSwARsYo6I-ULnRli6t6UxU,8764
-dragon_ml_toolbox-19.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dragon_ml_toolbox-19.7.0.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
-dragon_ml_toolbox-19.7.0.dist-info/RECORD,,
+dragon_ml_toolbox-19.8.0.dist-info/METADATA,sha256=ywnJLv63NUVz3LMgHTSbOsRZl95rW02_Sozqwq2u-p0,8764
+dragon_ml_toolbox-19.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dragon_ml_toolbox-19.8.0.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
+dragon_ml_toolbox-19.8.0.dist-info/RECORD,,

ml_tools/ML_configuration.py

@@ -37,7 +37,8 @@ from ._core._ML_configuration import (
     DragonAutoIntParams,
     
     # --- Training Config ---  
-    DragonTrainingConfig,  
+    DragonTrainingConfig,
+    DragonParetoConfig,
     info
 )
 
@@ -80,5 +81,6 @@ __all__ = [
     "DragonAutoIntParams",
     
     # --- Training Config ---
-    "DragonTrainingConfig"
+    "DragonTrainingConfig",
+    "DragonParetoConfig",
 ]

ml_tools/_core/_ML_configuration.py

@@ -1,4 +1,5 @@
-from typing import Union, Optional, List, Any, Dict, Literal
+from typing import Union, Optional, List, Any, Dict, Literal, Tuple
+from pathlib import Path
 from collections.abc import Mapping
 import numpy as np
 
@@ -51,7 +52,8 @@ __all__ = [
     "DragonAutoIntParams",
     
     # --- Training Config ---
-    "DragonTrainingConfig"
+    "DragonTrainingConfig",
+    "DragonParetoConfig"
 ]
 
 
@@ -445,6 +447,9 @@ class _BaseModelParams(Mapping):
             if isinstance(v, FeatureSchema):
                 # Force the repr() string, otherwise json.dump treats it as a list
                 clean_dict[k] = repr(v)
+            elif isinstance(v, Path):
+                # JSON cannot serialize Path objects, convert to string
+                clean_dict[k] = str(v)
             else:
                 clean_dict[k] = v
         return clean_dict
@@ -646,6 +651,8 @@ class DragonTrainingConfig(_BaseModelParams):
     Configuration object for the training process.
     
     Can be unpacked as a dictionary for logging or accessed as an object.
+    
+    Accepts arbitrary keyword arguments which are set as instance attributes.
     """
     def __init__(self,
                  validation_size: float,
@@ -656,7 +663,7 @@ class DragonTrainingConfig(_BaseModelParams):
                  early_stop_patience: Optional[int] = None,
                  scheduler_patience: Optional[int] = None,
                  scheduler_lr_factor: Optional[float] = None,
-                 scheduler_threshold: Optional[float] = None) -> None:
+                 **kwargs: Any) -> None:
         self.validation_size = validation_size
         self.test_size = test_size
         self.initial_learning_rate = initial_learning_rate
@@ -665,7 +672,75 @@ class DragonTrainingConfig(_BaseModelParams):
         self.early_stop_patience = early_stop_patience
         self.scheduler_patience = scheduler_patience
         self.scheduler_lr_factor = scheduler_lr_factor
-        self.scheduler_threshold = scheduler_threshold
+        
+        # Process kwargs with validation
+        for key, value in kwargs.items():
+            # Python guarantees 'key' is a string for **kwargs
+            
+            # Allow None in value
+            if value is None:
+                setattr(self, key, value)
+                continue
+            
+            if isinstance(value, dict):
+                _LOGGER.error("Nested dictionaries are not supported, unpack them first.")
+                raise TypeError()
+            
+            # Check if value is a number or a string or a JSON supported type, except dict
+            if not isinstance(value, (str, int, float, bool, list, tuple)):
+                _LOGGER.error(f"Invalid type for configuration '{key}': {type(value).__name__}")
+                raise TypeError()
+            
+            setattr(self, key, value)
+
+
+class DragonParetoConfig(_BaseModelParams):
+    """
+    Configuration object for the Pareto Optimization process.
+    """
+    def __init__(self,
+                 save_directory: Union[str, Path],
+                 target_objectives: Dict[str, Literal["min", "max"]],
+                 continuous_bounds_map: Union[Dict[str, Tuple[float, float]], Dict[str, List[float]]],
+                 columns_to_round: Optional[List[str]] = None,
+                 population_size: int = 400,
+                 generations: int = 1000,
+                 solutions_filename: str = "ParetoSolutions",
+                 float_precision: int = 4,
+                 log_interval: int = 10,
+                 plot_size: Tuple[int, int] = (10, 7),
+                 plot_font_size: int = 16,
+                 discretize_start_at_zero: bool = True):
+        """  
+        Configure the Pareto Optimizer.
+
+        Args:
+            save_directory (str | Path): Directory to save artifacts.
+            target_objectives (Dict[str, "min"|"max"]): Dictionary mapping target names to optimization direction.
+                Example: {"price": "max", "error": "min"}
+            continuous_bounds_map (Dict): Bounds for continuous features {name: (min, max)}.
+            columns_to_round (List[str] | None): List of continuous column names that should be rounded to the nearest integer.
+            population_size (int): Size of the genetic population.
+            generations (int): Number of generations to run.
+            solutions_filename (str): Filename for saving Pareto solutions.
+            float_precision (int): Number of decimal places to round standard float columns.
+            log_interval (int): Interval for logging progress.
+            plot_size (Tuple[int, int]): Size of the 2D plots.
+            plot_font_size (int): Font size for plot text.
+            discretize_start_at_zero (bool): Categorical encoding start index. True=0, False=1.
+        """
+        self.save_directory = save_directory
+        self.target_objectives = target_objectives
+        self.continuous_bounds_map = continuous_bounds_map
+        self.columns_to_round = columns_to_round
+        self.population_size = population_size
+        self.generations = generations
+        self.solutions_filename = solutions_filename
+        self.float_precision = float_precision
+        self.log_interval = log_interval
+        self.plot_size = plot_size
+        self.plot_font_size = plot_font_size
+        self.discretize_start_at_zero = discretize_start_at_zero
 
 
 # ----------------------------

ml_tools/_core/_ML_optimization_pareto.py

@@ -20,6 +20,7 @@ from evotorch.operators import functional as func_ops
 from ._SQL import DragonSQL
 from ._ML_inference import DragonInferenceHandler
 from ._ML_chaining_inference import DragonChainInference
+from ._ML_configuration import DragonParetoConfig
 from ._optimization_tools import create_optimization_bounds, plot_optimal_feature_distributions_from_dataframe
 from ._math_utilities import discretize_categorical_values
 from ._utilities import save_dataframe_filename
@@ -57,26 +58,21 @@ class DragonParetoOptimizer:
     def __init__(self,
                  inference_handler: Union[DragonInferenceHandler, DragonChainInference],
                  schema: FeatureSchema,
-                 target_objectives: Dict[str, Literal["min", "max"]],
-                 continuous_bounds_map: Union[Dict[str, Tuple[float, float]], Dict[str, List[float]]],
-                 population_size: int = 400,
-                 discretize_start_at_zero: bool = True):
+                 config: DragonParetoConfig):
         """
         Initialize the Pareto Optimizer.
 
         Args:
             inference_handler (DragonInferenceHandler | DragonChainInference): Validated model handler.
             schema (FeatureSchema): Feature schema for bounds and types.
-            target_objectives (Dict[str, "min"|"max"]): Dictionary mapping target names to optimization direction.
-                Example: {"price": "max", "error": "min"}
-            continuous_bounds_map (Dict): Bounds for continuous features {name: (min, max)}.
-            population_size (int): Size of the genetic population.
-            discretize_start_at_zero (bool): Categorical encoding start index.
+            config (DragonParetoConfig): Configuration for the Pareto optimizer.
         """
         self.inference_handler = inference_handler
         self.schema = schema
-        self.target_objectives = target_objectives
-        self.discretize_start_at_zero = discretize_start_at_zero
+        self.config = config
+        
+        self.target_objectives = config.target_objectives
+        self.discretize_start_at_zero = config.discretize_start_at_zero
         
         # Initialize state for results
         self.pareto_front: Optional[pd.DataFrame] = None
@@ -106,7 +102,7 @@ class DragonParetoOptimizer:
         
         available_targets = self.inference_handler.target_ids
 
-        for name, direction in target_objectives.items():
+        for name, direction in self.target_objectives.items():
             if name not in available_targets:
                 _LOGGER.error(f"Target '{name}' not found in model targets: {available_targets}")
                 raise ValueError()
@@ -124,8 +120,8 @@ class DragonParetoOptimizer:
         # Uses the external tool which reads the schema to set correct bounds for both continuous and categorical
         bounds = create_optimization_bounds(
             schema=schema,
-            continuous_bounds_map=continuous_bounds_map,
-            start_at_zero=discretize_start_at_zero
+            continuous_bounds_map=config.continuous_bounds_map,
+            start_at_zero=self.discretize_start_at_zero
         )
         self.lower_bounds = list(bounds[0])
         self.upper_bounds = list(bounds[1])
@@ -136,7 +132,7 @@ class DragonParetoOptimizer:
             target_indices=self.target_indices, # Used by Standard Handler
             target_names=self.ordered_target_names, # Used by Chain Handler
             categorical_index_map=schema.categorical_index_map,
-            discretize_start_at_zero=discretize_start_at_zero,
+            discretize_start_at_zero=self.discretize_start_at_zero,
             is_chain=self.is_chain
         )
 
@@ -155,7 +151,7 @@ class DragonParetoOptimizer:
         # GeneticAlgorithm. It automatically applies NSGA-II logic (Pareto sorting) when problem is multi-objective.
         self.algorithm = GeneticAlgorithm(
             self.problem,
-            popsize=population_size,
+            popsize=config.population_size,
             operators=[
                 SimulatedBinaryCrossOver(self.problem, tournament_size=3, eta=20.0, cross_over_rate=1.0),
                 GaussianMutation(self.problem, stdev=0.1)
@@ -163,21 +159,17 @@ class DragonParetoOptimizer:
             re_evaluate=False # model is deterministic
         )
 
-    def run(self, 
-            generations: int, 
-            save_dir: Union[str, Path],
-            log_interval: int = 10) -> pd.DataFrame:
+    def run(self) -> pd.DataFrame:
         """
         Execute the optimization with progress tracking and periodic logging.
 
-        Args:
-            generations (int): Number of generations to evolve.
-            save_dir (str|Path): Directory to save results and plots.
-            log_interval (int): How often (in generations) to log population statistics.
-
         Returns:
             pd.DataFrame: A DataFrame containing the non-dominated solutions (Pareto Front).
         """
+        generations = self.config.generations
+        save_dir = self.config.save_directory
+        log_interval = self.config.log_interval
+        
         save_path = make_fullpath(save_dir, make=True, enforce="directory")
         log_file = save_path / "optimization_log.txt"
         
@@ -189,26 +181,41 @@ class DragonParetoOptimizer:
         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 = []
 
         # --- Optimization Loop with Progress Bar ---
         with tqdm(total=generations, desc="Evolving Pareto Front", unit="gen") as pbar:
             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}:"]
-                    
-                    # Get current population values
-                    current_evals = self.algorithm.population.evals
-                    
-                    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())
-                        
-                        stats_msg.append(f"{target_name}: {v_mean:.3f} (Range: {v_min:.3f}-{v_max:.3f})")
+                    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)
                     
@@ -217,6 +224,12 @@ class DragonParetoOptimizer:
                         f.write(log_line + "\n")
                 
                 pbar.update(1)
+        
+        # --- Post-Optimization Visualization ---
+        if history_records:
+            _LOGGER.debug("Generating optimization history plots...")
+            history_df = pd.DataFrame(history_records)
+            self._plot_optimization_history(history_df, save_path)
 
         # --- Extract Pareto Front ---
         # Manually identify the Pareto front from the final population using domination counts
@@ -289,10 +302,6 @@ class DragonParetoOptimizer:
         return pareto_df
     
     def save_solutions(self, 
-                       filename: str = "Pareto_Solutions", 
-                       save_dir: Optional[Union[str, Path]] = None, 
-                       columns_to_round: Optional[List[str]] = None,
-                       float_precision: int = 4,
                        save_to_sql: bool = False,
                        sql_table_name: Optional[str] = None,
                        sql_if_exists: Literal['fail', 'replace', 'append'] = 'replace') -> None:
@@ -301,12 +310,8 @@ class DragonParetoOptimizer:
         for specific continuous columns. Optionally saves to a SQL database.
 
         Args:
-            save_dir (str | Path | None): Directory to save the CSV. If None, uses the optimization directory.
-            filename (str): Name of the file (without .csv extension).
-            columns_to_round (List[str], optional): List of continuous column names that should be rounded to the nearest integer.
-            float_precision (int): Number of decimal places to round standard float columns.
             save_to_sql (bool): If True, also writes the results to a SQLite database in the save_dir.
-            sql_table_name (str, optional): Specific table name for SQL. If None, uses 'filename'.
+            sql_table_name (str, optional): Specific table name for SQL. If None, uses the solutions filename.
             sql_if_exists (str): Behavior if SQL table exists ('fail', 'replace', 'append').
         """
         if self.pareto_front is None:
@@ -314,11 +319,15 @@ class DragonParetoOptimizer:
             raise ValueError()
         
         # handle directory
-        if save_dir is None:
-            if self._metrics_dir is None:
-                _LOGGER.error("No save directory specified and no optimization directory found.")
-                raise ValueError()
-            save_dir = self._metrics_dir
+        save_path = self._metrics_dir
+        if save_path is None:
+            _LOGGER.error("No save directory found. Cannot save solutions.")
+            raise ValueError()
+        
+        # unpack values from config
+        filename = self.config.solutions_filename
+        columns_to_round = self.config.columns_to_round
+        float_precision = self.config.float_precision
 
         # Create a copy to avoid modifying the internal state
         df_to_save = self.pareto_front.copy()
@@ -354,8 +363,6 @@ class DragonParetoOptimizer:
             df_to_save[float_cols] = df_to_save[float_cols].round(float_precision)
 
         # Save CSV
-        save_path = make_fullpath(save_dir, make=True, enforce="directory")
-        
         # sanitize filename and add extension if missing
         sanitized_filename = sanitize_filename(filename)
         csv_filename = sanitized_filename if sanitized_filename.lower().endswith(".csv") else f"{sanitized_filename}.csv"
@@ -577,7 +584,7 @@ class DragonParetoOptimizer:
         """Standard 2D scatter plot."""
         x_name, y_name = self.ordered_target_names[0], self.ordered_target_names[1]
         
-        plt.figure(figsize=(10, 8))
+        plt.figure(figsize=self.config.plot_size, dpi=ParetoOptimizationKeys.DPI)
         
         # Use a color gradient based on the Y-axis to make "better" values visually distinct
         sns.scatterplot(
@@ -592,7 +599,7 @@ class DragonParetoOptimizer:
             legend=False
         )
         
-        plt.title(f"Pareto Front: {x_name} vs {y_name}", fontsize=14)
+        plt.title(f"Pareto Front: {x_name} vs {y_name}", fontsize=self.config.plot_font_size + 2, pad=ParetoOptimizationKeys.FONT_PAD)
         plt.grid(True, linestyle='--', alpha=0.6)
         
         # Add simple annotation for the 'corners' (extremes)
@@ -616,8 +623,7 @@ class DragonParetoOptimizer:
                        x_target: Union[int, str],
                        y_target: Union[int, str],
                        z_target: Union[int, str],
-                       hue_target: Optional[Union[int, str]] = None,
-                       save_dir: Optional[Union[str, Path]] = None,):
+                       hue_target: Optional[Union[int, str]] = None):
         """
         Public API to generate 3D visualizations for specific targets.
         
@@ -626,15 +632,11 @@ class DragonParetoOptimizer:
             y_target (int|str): Index or name of the target for the Y axis.
             z_target (int|str): Index or name of the target for the Z axis.
             hue_target (int|str, optional): Index or name of the target for coloring. Defaults to z_target if None.
-            save_dir (str|Path, optional): Directory to save plots. Defaults to the directory used during optimization.
         """
-        if save_dir is None:
-            if self._metrics_dir is None:
-                _LOGGER.error("No save directory specified and no previous optimization directory found.")
-                raise ValueError()
-            save_dir = self._metrics_dir
-        
-        save_path_root = make_fullpath(save_dir, make=True, enforce="directory")
+        if self._metrics_dir is None:
+            _LOGGER.error("No save directory specified and no previous optimization directory found.")
+            raise ValueError()
+        save_path_root = self._metrics_dir
         
         save_path = make_fullpath(save_path_root / ParetoOptimizationKeys.PARETO_PLOTS_DIR, make=True, enforce="directory")
         
@@ -716,6 +718,58 @@ class DragonParetoOptimizer:
         html_path = sub_dir_path / f"Pareto_3D_Interactive.html"
         fig_html.write_html(str(html_path))
 
+    def _plot_optimization_history(self, history_df: pd.DataFrame, save_dir: Path):
+        """
+        Generates convergence plots (Mean/Min/Max) for each objective over generations.
+        
+        Args:
+            history_df: DataFrame with cols [Generation, Target, Mean, Min, Max]
+            save_dir: Base directory to save plots
+        """
+        # Create subdirectory for history plots
+        plot_dir = make_fullpath(save_dir / ParetoOptimizationKeys.HISTORY_PLOTS_DIR, make=True, enforce="directory")
+        
+        unique_targets = history_df["Target"].unique()
+        
+        for target in unique_targets:
+            subset = history_df[history_df["Target"] == target]
+            
+            # Determine direction (just for annotation/context if needed, but plotting stats is neutral)
+            direction = self.target_objectives.get(target, "unknown")
+            
+            plt.figure(figsize=self.config.plot_size, dpi=ParetoOptimizationKeys.DPI)
+            
+            # Plot Mean
+            plt.plot(subset["Generation"], subset["Mean"], label="Population Mean", color="#4c72b0", linewidth=2)
+            
+            # Plot Min/Max Range
+            plt.fill_between(
+                subset["Generation"], 
+                subset["Min"], 
+                subset["Max"], 
+                color="#4c72b0", 
+                alpha=0.15, 
+                label="Min-Max Range"
+            )
+            
+            # Plot extremes as dashed lines
+            plt.plot(subset["Generation"], subset["Min"], linestyle="--", color="#55a868", alpha=0.6, linewidth=1, label="Min")
+            plt.plot(subset["Generation"], subset["Max"], linestyle="--", color="#c44e52", alpha=0.6, linewidth=1, label="Max")
+
+            plt.title(f"Convergence History: {target} ({direction.upper()})", fontsize=self.config.plot_font_size + 2, pad=ParetoOptimizationKeys.FONT_PAD)
+            plt.xlabel("Generation", labelpad=ParetoOptimizationKeys.FONT_PAD, fontsize=self.config.plot_font_size)
+            plt.ylabel("Target Value", labelpad=ParetoOptimizationKeys.FONT_PAD, fontsize=self.config.plot_font_size)
+            plt.legend(loc='best', fontsize=self.config.plot_font_size)
+            plt.grid(True, linestyle="--", alpha=0.5)
+            plt.xticks(fontsize=self.config.plot_font_size - 4)
+            plt.yticks(fontsize=self.config.plot_font_size - 4)
+            
+            plt.tight_layout()
+            
+            fname = f"Convergence_{sanitize_filename(target)}.svg"
+            plt.savefig(plot_dir / fname, bbox_inches='tight')
+            plt.close()
+
 class _ParetoFitnessEvaluator:
     """
     Evaluates fitness for Multi-Objective optimization.

ml_tools/_core/_keys.py

@@ -196,6 +196,11 @@ class ParetoOptimizationKeys:
     """Used by the ML optimization pareto module."""
     PARETO_PLOTS_DIR = "Pareto_Plots"
     SQL_DATABASE_FILENAME = "OptimizationResults.db"
+    HISTORY_PLOTS_DIR = "History"
+    
+    # Plot Config values
+    FONT_PAD = 10
+    DPI = 400
 
 
 class OptimizationToolsKeys: