dragon-ml-toolbox 3.10.0__tar.gz → 3.10.2__tar.gz

{dragon_ml_toolbox-3.10.0/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-3.10.2}/PKG-INFO

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

{dragon_ml_toolbox-3.10.0 → dragon_ml_toolbox-3.10.2/dragon_ml_toolbox.egg-info}/PKG-INFO

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

{dragon_ml_toolbox-3.10.0 → dragon_ml_toolbox-3.10.2}/ml_tools/GUI_tools.py

@@ -389,23 +389,73 @@ class BaseFeatureHandler(ABC):
 
         Should return a dictionary mapping each GUI input name to its type ('continuous' or 'categorical').
         
+        _Example:_
         ```python
-        #Example: 
-        {'temperature': 'continuous', 'material_type': 'categorical'}
+        {
+            'Temperature': 'continuous', 
+            'Material Type': 'categorical'
+        }
+        ```
+        """
+        pass
+    
+    @property
+    @abstractmethod
+    def map_gui_to_real(self) -> Dict[str,str]:
+        """
+        Must be implemented by the subclass.
+
+        Should return a dictionary mapping each GUI continuous feature name to its expected model feature name.
+        
+        _Example:_
+        ```python
+        {
+            'Temperature (K)': 'temperature_k', 
+            'Pressure (Pa)': 'pressure_pa'
+        }
         ```
         """
         pass
 
     @abstractmethod
-    def process_categorical(self, feature_name: str, chosen_value: Any) -> Dict[str, float]:
+    def process_categorical(self, gui_feature_name: str, chosen_value: Any) -> Dict[str, float]:
         """
         Must be implemented by the subclass.
 
-        Should take a GUI categorical feature name and its chosen value, and return a dictionary mapping the one-hot-encoded feature names to their
+        Should take a GUI categorical feature name and its chosen value, and return a dictionary mapping the one-hot-encoded/binary real feature names to their
         float values (as expected by the inference model).
+        
+        _Example:_
+        ```python        
+        # GUI input: "Material Type"
+        # GUI values: "Steel", "Aluminum", "Titanium"
+        {
+            "is_steel": 0, 
+            "is_aluminum": 1,
+            "is_titanium": 0,
+        }
+        ```
         """
         pass
-
+    
+    def _process_continuous(self, gui_feature_name: str, chosen_value: Any) -> Tuple[str, float]:
+        """
+        Maps GUI names to model expected names and casts the value to float.
+        
+        Should not be overridden by subclasses.
+        """
+        try:
+            real_name = self.map_gui_to_real[gui_feature_name]
+            float_value = float(chosen_value)
+        except KeyError as e:
+            _LOGGER.error(f"No matching name for '{gui_feature_name}'. Check the 'map_gui_to_real' implementation.")
+            raise e
+        except (ValueError, TypeError) as e2:
+            _LOGGER.error(f"Invalid number conversion for '{chosen_value}' of '{gui_feature_name}'.")
+            raise e2
+        else:
+            return real_name, float_value
+    
     def __call__(self, window_values: Dict[str, Any]) -> np.ndarray:
         """
         Performs the full vector preparation, returning a 1D numpy array.
@@ -416,16 +466,17 @@ class BaseFeatureHandler(ABC):
         processed_features: Dict[str, float] = {}
         for gui_name, feature_type in self.gui_input_map.items():
             chosen_value = window_values.get(gui_name)
-
+            
+            # value validation
             if chosen_value is None or str(chosen_value) == '':
                 raise ValueError(f"GUI input '{gui_name}' is missing a value.")
 
+            # process continuous
             if feature_type == 'continuous':
-                try:
-                    processed_features[gui_name] = float(chosen_value)
-                except (ValueError, TypeError):
-                    raise ValueError(f"Invalid number '{chosen_value}' for '{gui_name}'.")
-
+                mapped_name, float_value = self._process_continuous(gui_name, chosen_value)
+                processed_features[mapped_name] = float_value
+            
+            # process categorical
             elif feature_type == 'categorical':
                 feature_dict = self.process_categorical(gui_name, chosen_value)
                 processed_features.update(feature_dict)
@@ -446,18 +497,34 @@ class BaseFeatureHandler(ABC):
         return np.array(final_vector, dtype=np.float32)
 
 
-def update_target_fields(window: sg.Window, results_dict: Dict[str, Any]):
+def update_target_fields(window: sg.Window, results_dict: Dict[str, Any], map_model_to_gui: Optional[Dict[str,str]]):
     """
     Updates the GUI's target fields with inference results.
 
     Args:
         window (sg.Window): The application's window object.
-        results_dict (dict): A dictionary where keys are target element-keys and values are the predicted results to update.
+        results_dict (dict): A dictionary where keys are target names (as expected by the GUI) and values are the predicted results to update.
+        map_model_to_gui (dict | None): Map `results_dict.keys()` from model target names to GUI target names, if gui names were customized.
     """
-    for target_name, result in results_dict.items():
+    if map_model_to_gui is not None:
+        # Validation
+        if len(map_model_to_gui) != len(results_dict):
+            _LOGGER.error(f"Expected a mapping for {len(results_dict)} targets, but received {len(map_model_to_gui)} target map names.")
+            raise ValueError
+        
+        # new dictionary with GUI keys and corresponding result values
+        display_dict = {
+            gui_key: results_dict[model_key]
+            for model_key, gui_key in map_model_to_gui.items()
+        }
+    else:
+        # If no map is provided, use given result keys
+        display_dict = results_dict
+
+    for key, result in display_dict.items():
         # Format numbers to 2 decimal places, leave other types as-is
         display_value = f"{result:.2f}" if isinstance(result, (int, float)) else result
-        window[target_name].update(display_value) # type: ignore
+        window[key].update(display_value) # type: ignore
 
 
 def info():

{dragon_ml_toolbox-3.10.0 → dragon_ml_toolbox-3.10.2}/ml_tools/ensemble_learning.py

@@ -973,9 +973,9 @@ class InferenceHandler:
                                                  verbose=self.verbose, 
                                                  raise_on_error=True) # type: ignore
                 
-                model: Any = full_object["model"]
-                target_name: str = full_object["target_name"]
-                feature_names_list: List[str] = full_object["feature_names"]
+                model: Any = full_object[ModelSaveKeys.MODEL]
+                target_name: str = full_object[ModelSaveKeys.TARGET]
+                feature_names_list: List[str] = full_object[ModelSaveKeys.FEATURES]
                 
                 # Check that feature names match
                 if self._feature_names is None:

{dragon_ml_toolbox-3.10.0 → dragon_ml_toolbox-3.10.2}/pyproject.toml

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