0.14.41

New function set_hyperparameters()

Author: bartzbeielstein

pyproject.toml

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

src/spotPython/data/lightdatamodule.py

@@ -150,13 +150,15 @@ def setup(self, stage: Optional[str] = None) -> None:
             if self.scaler is not None:
                 # Fit the scaler on training data and transform both train and val data
                 scaler_train_data = torch.stack([self.data_train[i][0] for i in range(len(self.data_train))]).squeeze(1)
-                #train_val_data = self.data_train[:,0]
+                # train_val_data = self.data_train[:,0]
                 print(scaler_train_data.shape)
                 self.scaler.fit(scaler_train_data)
                 self.data_train = [(self.scaler.transform(data), target) for data, target in self.data_train]
                 data_tensors_train = [data.clone().detach() for data, target in self.data_train]
                 target_tensors_train = [target.clone().detach() for data, target in self.data_train]
-                self.data_train = TensorDataset(torch.stack(data_tensors_train).squeeze(1), torch.stack(target_tensors_train))
+                self.data_train = TensorDataset(
+                    torch.stack(data_tensors_train).squeeze(1), torch.stack(target_tensors_train)
+                )
                 # print(self.data_train)
                 self.data_val = [(self.scaler.transform(data), target) for data, target in self.data_val]
                 data_tensors_val = [data.clone().detach() for data, target in self.data_val]
@@ -173,7 +175,9 @@ def setup(self, stage: Optional[str] = None) -> None:
                 self.data_test = [(self.scaler.transform(data), target) for data, target in self.data_test]
                 data_tensors_test = [data.clone().detach() for data, target in self.data_test]
                 target_tensors_test = [target.clone().detach() for data, target in self.data_test]
-                self.data_test = TensorDataset(torch.stack(data_tensors_test).squeeze(1), torch.stack(target_tensors_test))
+                self.data_test = TensorDataset(
+                    torch.stack(data_tensors_test).squeeze(1), torch.stack(target_tensors_test)
+                )
 
         # if stage == "predict" or stage is None:
         #     print(f"test_size, full_train_size: {test_size}, {full_train_size}")
@@ -194,9 +198,7 @@ def setup(self, stage: Optional[str] = None) -> None:
             )
             if self.scaler is not None:
                 self.data_predict = [(self.scaler.transform(data), target) for data, target in self.data_predict]
-                data_tensors_predict = [
-                    data.clone().detach() for data, target in self.data_predict
-                ]
+                data_tensors_predict = [data.clone().detach() for data, target in self.data_predict]
                 target_tensors_predict = [target.clone().detach() for data, target in self.data_predict]
                 self.data_predict = TensorDataset(
                     torch.stack(data_tensors_predict).squeeze(1), torch.stack(target_tensors_predict)

src/spotPython/hyperparameters/values.py

@@ -1744,3 +1744,75 @@ def get_metric_sklearn(metric_name) -> object:
     """
     metric_sklearn = getattr(sklearn.metrics, metric_name)
     return metric_sklearn
+
+
+def set_hyperparameter(fun_control, key, values):
+    """
+    Set hyperparameter values in the fun_control dictionary based on the type of the values argument.
+
+    Args:
+        fun_control (dict):
+            The fun_control dictionary.
+        key (str):
+            The key of the hyperparameter.
+        values (Union[int, float, bool, list]):
+            The values of the hyperparameter. This can be:
+                - For int and float: a list containing lower and upper bounds.
+                - For bool: a list containing two boolean values.
+                - For factor: a list of strings representing levels.
+
+    Examples:
+        >>> from spotPython.hyperparameters.values import set_hyperparameter
+        >>> fun_control = {
+                "core_model_hyper_dict": {
+                    "n_estimators": {"type": "int", "default": 10, "lower": 2, "upper": 1000},
+                    "step": {"type": "float", "default": 1.0, "lower": 0.1, "upper": 10.0},
+                    "use_aggregation": {"type": "factor", "default": 1, "lower": 0, "upper": 1, "levels": [0, 1]},
+                    "leaf_model": {"type": "factor", "default": "LinearRegression", "upper": 2}
+                }
+            }
+        >>> set_hyperparameter(fun_control, "n_estimators", [2, 5])
+        >>> set_hyperparameter(fun_control, "step", [0.2, 5.0])
+        >>> set_hyperparameter(fun_control, "use_aggregation", [False, True])
+        >>> set_hyperparameter(fun_control, "leaf_model", ["LinearRegression", "Perceptron"])
+    """
+    if isinstance(values, list):
+        if all(isinstance(v, int) for v in values):
+            _set_int_hyperparameter_values(fun_control, key, values[0], values[1])
+        elif all(isinstance(v, float) for v in values):
+            _set_float_hyperparameter_values(fun_control, key, values[0], values[1])
+        elif all(isinstance(v, bool) for v in values):
+            _set_boolean_hyperparameter_values(fun_control, key, values[0], values[1])
+        elif all(isinstance(v, str) for v in values):
+            _set_factor_hyperparameter_values(fun_control, key, values)
+        else:
+            raise ValueError("Invalid type in values list.")
+    else:
+        raise TypeError("values should be a list.")
+
+
+def _set_int_hyperparameter_values(fun_control, key, lower, upper) -> None:
+    # Set integer hyperparameter values in fun_control dictionary
+    fun_control["core_model_hyper_dict"][key].update({"lower": lower, "upper": upper})
+
+
+def _set_float_hyperparameter_values(fun_control, key, lower, upper) -> None:
+    # Set float hyperparameter values in fun_control dictionary
+    fun_control["core_model_hyper_dict"][key].update({"lower": lower, "upper": upper})
+
+
+def _set_boolean_hyperparameter_values(fun_control, key, lower, upper):
+    # Set boolean hyperparameter values in fun_control dictionary
+    fun_control["core_model_hyper_dict"][key].update({"lower": lower, "upper": upper})
+
+
+def _set_factor_hyperparameter_values(fun_control, key, levels):
+    # Set factor hyperparameter values in fun_control dictionary
+    if "core_model_hyper_dict" not in fun_control.keys():
+        return
+    if not isinstance(levels, list):
+        levels = [levels]
+    if not all(isinstance(level, str) for level in levels):
+        print("!!! Warning: levels should be a list of strings.")
+        return
+    fun_control["core_model_hyper_dict"][key].update({"levels": levels, "upper": len(levels) - 1})

test/test_set_hyperparameter.py

@@ -0,0 +1,48 @@
+import pytest
+from spotPython.hyperparameters.values import set_hyperparameter
+
+
+def test_set_hyperparameter_int():
+    fun_control = {"core_model_hyper_dict": {"n_estimators": {"type": "int", "default": 10, "lower": 2, "upper": 1000}}}
+    set_hyperparameter(fun_control, "n_estimators", [2, 5])
+    assert fun_control["core_model_hyper_dict"]["n_estimators"]["lower"] == 2
+    assert fun_control["core_model_hyper_dict"]["n_estimators"]["upper"] == 5
+
+
+def test_set_hyperparameter_float():
+    fun_control = {"core_model_hyper_dict": {"step": {"type": "float", "default": 1.0, "lower": 0.1, "upper": 10.0}}}
+    set_hyperparameter(fun_control, "step", [0.2, 5.0])
+    assert fun_control["core_model_hyper_dict"]["step"]["lower"] == 0.2
+    assert fun_control["core_model_hyper_dict"]["step"]["upper"] == 5.0
+
+
+def test_set_hyperparameter_boolean():
+    fun_control = {
+        "core_model_hyper_dict": {
+            "use_aggregation": {"type": "boolean", "default": 1, "lower": 0, "upper": 1, "levels": [0, 1]}
+        }
+    }
+    set_hyperparameter(fun_control, "use_aggregation", [False, True])
+    assert fun_control["core_model_hyper_dict"]["use_aggregation"]["lower"] is False
+    assert fun_control["core_model_hyper_dict"]["use_aggregation"]["upper"] is True
+
+
+def test_set_hyperparameter_factor():
+    fun_control = {
+        "core_model_hyper_dict": {"leaf_model": {"type": "factor", "default": "LinearRegression", "upper": 1}}
+    }
+    set_hyperparameter(fun_control, "leaf_model", ["LinearRegression", "Perceptron"])
+    assert fun_control["core_model_hyper_dict"]["leaf_model"]["levels"] == ["LinearRegression", "Perceptron"]
+    assert fun_control["core_model_hyper_dict"]["leaf_model"]["upper"] == 1
+
+
+def test_set_hyperparameter_invalid_type():
+    fun_control = {"core_model_hyper_dict": {"n_estimators": {"type": "int", "default": 10, "lower": 2, "upper": 1000}}}
+    with pytest.raises(ValueError):
+        set_hyperparameter(fun_control, "n_estimators", [2, "five"])
+
+
+def test_set_hyperparameter_invalid_values_type():
+    fun_control = {"core_model_hyper_dict": {"n_estimators": {"type": "int", "default": 10, "lower": 2, "upper": 1000}}}
+    with pytest.raises(TypeError):
+        set_hyperparameter(fun_control, "n_estimators", "2, 5")