0.23.4

convert_keys() updated

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

@@ -7827,26 +7827,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Seed set to 123\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Experiment saved to test_get_spot_attributes_as_df_exp.pkl\n",
-      "Result file test_get_spot_attributes_as_df_res.pkl exists. Loading the result.\n",
-      "Loaded experiment from test_get_spot_attributes_as_df_res.pkl\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import pytest\n",
     "import numpy as np\n",
@@ -7942,6 +7925,56 @@
     "assert not lower_row.empty and lower_row['Attribute Value'].values[0] == [-1]"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## iterate_dic_values()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from spotpython.hyperparameters.values import iterate_dict_values\n",
+    "var_dict = {'a': np.array([1, 3, 5]), 'b': np.array([2, 4, 6])}\n",
+    "print(var_dict)\n",
+    "list(iterate_dict_values(var_dict))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## convert_keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'a': 1, 'b': 2.1, 'c': 3}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from spotpython.hyperparameters.values import convert_keys\n",
+    "d = {'a': 1, 'b': 2.1, 'c': 3}\n",
+    "var_type = [\"int\", \"num\", \"int\"]\n",
+    "convert_keys(d, var_type)\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.23.3"
+version = "0.23.4"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

src/spotpython/hyperparameters/values.py

@@ -65,6 +65,135 @@ def assign_values(X: np.array, var_list: list) -> dict:
     return result
 
 
+def iterate_dict_values(var_dict: Dict[str, np.ndarray]) -> Generator[Dict[str, Union[int, float]], None, None]:
+    """Iterate over the values of a dictionary of variables.
+    This function takes a dictionary of variables as input arguments and returns a generator that
+    yields dictionaries with the values from the arrays in the input dictionary.
+
+    Args:
+        var_dict (dict): A dictionary where keys are variable names and values are numpy arrays.
+
+    Returns:
+        Generator[dict]:
+            A generator that yields dictionaries with the values from the arrays in the input dictionary.
+
+    Raises:
+        ValueError: If the arrays in the dictionary do not have the same length.
+
+    Examples:
+        >>> import numpy as np
+        >>> from spotpython.hyperparameters.values import iterate_dict_values
+        >>> var_dict = {'a': np.array([1, 3, 5]), 'b': np.array([2, 4, 6])}
+        >>> print(var_dict)
+                {'a': array([1, 3, 5]), 'b': array([2, 4, 6])}
+        >>> list(iterate_dict_values(var_dict))
+                [{'a': np.int64(1), 'b': np.int64(2)},
+                {'a': np.int64(3), 'b': np.int64(4)},
+                {'a': np.int64(5), 'b': np.int64(6)}]
+    """
+    # Check if the dictionary is empty
+    if not var_dict:
+        return
+
+    # Get the length of the first array
+    first_length = None
+    for value in var_dict.values():
+        if first_length is None:
+            first_length = len(value)
+        elif len(value) != first_length:
+            raise ValueError("All arrays must have the same length.")
+
+    # Generate the output dictionaries
+    for i in range(first_length):
+        yield {key: value[i] for key, value in var_dict.items()}
+
+
+def convert_keys(d: Dict[str, Union[int, float, str]], var_type: List[str]) -> Dict[str, Union[int, float]]:
+    """Convert values in a dictionary to integers or floats based on a list of variable types.
+    This function processes a dictionary 'd' based on the list of variable types 'var_type'.
+    It handles the conversion of strings or other compatible types to 'int' or 'float' as specified.
+    Specifically:
+        1. If `var_type[i]` is anything other than `"num"` or `"float"`, the value should be converted to `int()`.
+            If the conversion fails (i.e., if the value is not an integer value or representation), an error is raised.
+        2. If `var_type[i]` is `"float"`, the value should be converted to `float()`.
+        3. If `var_type[i]` is `"num"`, the function should decide whether to convert the value to `int()` or `float()`
+            based on whether it represents an integer or a float.
+
+    Args:
+        d (dict): The input dictionary with values to convert.
+        var_type (list): A list of variable types where:
+            - Not "num" or "float": the value is converted to int(). If conversion to int() fails, an error is raised.
+            - "float": convert the value to a float.
+            - "num": the value is converted to int() if it represents an integer, otherwise to float().
+
+    Returns:
+        dict: A modified dictionary with values converted based on 'var_type' settings.
+
+    Raises:
+        ValueError: If the conversion to an integer is not possible when required.
+
+    Examples:
+            >>> from spotpython.hyperparameters.values import convert_keys
+                d = {'a': 1, 'b': 2.1, 'c': 3}
+                var_type = ["int", "num", "int"]
+                convert_keys(d, var_type)
+                    {'a': 1, 'b': 2.1, 'c': 3}
+    """
+    keys = list(d.keys())
+
+    for i in range(len(keys)):
+        try:
+            if var_type[i] not in ["num", "float"]:
+                value = float(d[keys[i]])
+                if value.is_integer():
+                    d[keys[i]] = int(value)
+                else:
+                    raise ValueError(f"Invalid value for conversion at {keys[i]}: {d[keys[i]]} (not an integer)")
+            elif var_type[i] == "float":
+                d[keys[i]] = float(d[keys[i]])
+            elif var_type[i] == "num":
+                value = float(d[keys[i]])
+                d[keys[i]] = int(value) if value.is_integer() else value
+        except (ValueError, TypeError) as e:
+            raise ValueError(f"Invalid value for conversion at {keys[i]}: {d[keys[i]]}")
+
+    return d
+
+
+def get_one_config_from_X(X, fun_control=None):
+    """Get one config from X.
+
+    Args:
+        X (np.array):
+            The array with the hyper parameter values.
+        fun_control (dict):
+            The function control dictionary.
+
+    Returns:
+        (dict):
+            The config dictionary.
+
+    Examples:
+        >>> from river.tree import HoeffdingAdaptiveTreeRegressor
+            from spotriver.data.river_hyper_dict import RiverHyperDict
+            fun_control = {}
+            add_core_model_to_fun_control(core_model=HoeffdingAdaptiveTreeRegressor,
+                fun_control=func_control,
+                hyper_dict=RiverHyperDict,
+                filename=None)
+            X = np.array([0, 0, 0, 0, 0])
+            get_one_config_from_X(X, fun_control)
+            {'leaf_prediction': 'mean',
+            'leaf_model': 'NBAdaptive',
+            'splitter': 'HoeffdingAdaptiveTreeSplitter',
+            'binary_split': 'info_gain',
+            'stop_mem_management': False}
+    """
+    var_dict = assign_values(X, fun_control["var_name"])
+    config = return_conf_list_from_var_dict(var_dict, fun_control)[0]
+    return config
+
+
 def get_tuned_architecture(spot_tuner, force_minX=False) -> dict:
     """
     Returns the tuned architecture. If the spot tuner has noise,
@@ -163,60 +292,6 @@ def return_conf_list_from_var_dict(
     return conf_list
 
 
-def iterate_dict_values(var_dict: Dict[str, np.ndarray]) -> Generator[Dict[str, Union[int, float]], None, None]:
-    """Iterate over the values of a dictionary of variables.
-    This function takes a dictionary of variables as input arguments and returns a generator that
-    yields dictionaries with the values from the arrays in the input dictionary.
-
-    Args:
-        var_dict (dict): A dictionary where keys are variable names and values are numpy arrays.
-
-    Returns:
-        Generator[dict]:
-            A generator that yields dictionaries with the values from the arrays in the input dictionary.
-
-    Examples:
-        >>> import numpy as np
-        >>> from spotpython.hyperparameters.values import iterate_dict_values
-        >>> var_dict = {'a': np.array([1, 3, 5]), 'b': np.array([2, 4, 6])}
-        >>> list(iterate_dict_values(var_dict))
-        [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a': 5, 'b': 6}]
-    """
-    n = len(next(iter(var_dict.values())))
-    for i in range(n):
-        yield {key: value[i] for key, value in var_dict.items()}
-
-
-def convert_keys(d: Dict[str, Union[int, float, str]], var_type: List[str]) -> Dict[str, Union[int, float]]:
-    """Convert values in a dictionary to integers based on a list of variable types.
-    This function takes a dictionary `d` and a list of variable types `var_type` as arguments.
-    For each key in the dictionary,
-    if the corresponding entry in `var_type` is not equal to `"num"`,
-    the value associated with that key is converted to an integer.
-
-    Args:
-        d (dict): The input dictionary.
-        var_type (list):
-            A list of variable types. If the entry is not `"num"` the corresponding
-            value will be converted to the type `"int"`.
-
-    Returns:
-        dict: The modified dictionary with values converted to integers based on `var_type`.
-
-    Examples:
-        >>> from spotpython.hyperparameters.values import convert_keys
-        >>> d = {'a': '1.1', 'b': '2', 'c': '3.1'}
-        >>> var_type = ["int", "num", "int"]
-        >>> convert_keys(d, var_type)
-        {'a': 1, 'b': '2', 'c': 3}
-    """
-    keys = list(d.keys())
-    for i in range(len(keys)):
-        if var_type[i] not in ["num", "float"]:
-            d[keys[i]] = int(d[keys[i]])
-    return d
-
-
 def get_dict_with_levels_and_types(fun_control: Dict[str, Any], v: Dict[str, Any], default=False) -> Dict[str, Any]:
     """Get dictionary with levels and types.
     The function maps the numerical output of the hyperparameter optimization to the corresponding levels
@@ -877,40 +952,6 @@ def get_one_core_model_from_X(
     return core_model
 
 
-def get_one_config_from_X(X, fun_control=None):
-    """Get one config from X.
-
-    Args:
-        X (np.array):
-            The array with the hyper parameter values.
-        fun_control (dict):
-            The function control dictionary.
-
-    Returns:
-        (dict):
-            The config dictionary.
-
-    Examples:
-        >>> from river.tree import HoeffdingAdaptiveTreeRegressor
-            from spotriver.data.river_hyper_dict import RiverHyperDict
-            fun_control = {}
-            add_core_model_to_fun_control(core_model=HoeffdingAdaptiveTreeRegressor,
-                fun_control=func_control,
-                hyper_dict=RiverHyperDict,
-                filename=None)
-            X = np.array([0, 0, 0, 0, 0])
-            get_one_config_from_X(X, fun_control)
-            {'leaf_prediction': 'mean',
-            'leaf_model': 'NBAdaptive',
-            'splitter': 'HoeffdingAdaptiveTreeSplitter',
-            'binary_split': 'info_gain',
-            'stop_mem_management': False}
-    """
-    var_dict = assign_values(X, fun_control["var_name"])
-    config = return_conf_list_from_var_dict(var_dict, fun_control)[0]
-    return config
-
-
 def get_one_sklearn_model_from_X(X, fun_control=None):
     """Get one sklearn model from X.
 

test/test_convert_keys.py

@@ -0,0 +1,39 @@
+import pytest
+from spotpython.hyperparameters.values import convert_keys
+
+def test_convert_keys():
+    # Test case 1: Basic conversion to int and float should succeed
+    d = {'a': '1', 'b': '2.0', 'c': '3.5'}
+    var_type = ["int", "num", "float"]
+    result = convert_keys(d, var_type)
+    expected = {'a': 1, 'b': 2, 'c': 3.5}
+    assert result == expected
+    
+    # Test case 2: Conversion to int should raise an error for non-integer strings
+    d = {'a': '1.5', 'b': '2', 'c': '3'}
+    var_type = ["int", "int", "int"]
+    with pytest.raises(ValueError, match="Invalid value for conversion at a: 1.5"):
+        convert_keys(d, var_type)
+
+    # Test case 3: Conversion with all "num" type should succeed
+    d = {'a': '1', 'b': '2.2', 'c': '3'}
+    var_type = ["num", "num", "num"]
+    result = convert_keys(d, var_type)
+    expected = {'a': 1, 'b': 2.2, 'c': 3}
+    assert result == expected
+
+    # Test case 4: Check for correct float conversion with "float" type
+    d = {'a': '1.0', 'b': '2.5', 'c': '3.1'}
+    var_type = ["float", "float", "float"]
+    result = convert_keys(d, var_type)
+    expected = {'a': 1.0, 'b': 2.5, 'c': 3.1}
+    assert result == expected
+
+    # Test case 5: Handling strings that cannot be converted to numbers
+    d = {'a': 'hello', 'b': '2', 'c': '3'}
+    var_type = ["int", "float", "num"]
+    with pytest.raises(ValueError, match="Invalid value for conversion at a: hello"):
+        convert_keys(d, var_type)
+
+if __name__ == "__main__":
+    pytest.main()