configspace.update for hyperparameter settings

docs/reference/hyperparameters.md

@@ -214,6 +214,10 @@ What makes a hyperparameter the hyperparameter it is then:
     if they share the same underlying vectorized space.
 
 
+!!! tip "Updating Hyperparameter properties"
+
+    Creating your own hyperparameter class, it is important to note that its properties may be updated after creation via the `Hyperparameter.__setattr__' method. This method blocks any changes after initialisation to any attribute directly or the creation of new attributes. Attribute values can only be changed through the class constructor parameters (the arguments of `__init__` function), and is only possible when they share **the same name**. Take this into consideration when subclassing the `Hyperparameter` class.
+
 !!! example "CategoricalHyperparameter"
 
     Inside of the `__init__` method of a `CategoricalHyperparameter`, you will find something along the lines
@@ -497,7 +501,7 @@ class BetaIntegerHyperparamter(IntegerHyperparameter):
         try:
             scaler = UnitScaler(i64(self.lower), i64(self.upper), log=log, dtype=i64)
         except ValueError as e:
-            raise ValueError(f"Hyperparameter '{name}' has illegal settings") from e
+            raise ValueError(f"Illegal value(s) for Hyperparameter '{name}'") from e
 
 
         if default_value is None:

pyproject.toml

@@ -69,7 +69,7 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = ["ConfigSpace[test, tooling, docs]"]
-test = ["pytest>=7", "pytest-cov", "pytest_cases"]
+test = ["pytest>=7,<9.1", "pytest-cov", "pytest_cases"]
 tooling = ["mypy", "pre-commit", "ruff", "types-pyyaml"]
 docs = [
   "mkdocs",

src/ConfigSpace/configuration_space.py

@@ -817,6 +817,43 @@ def substitute_hyperparameters_in_forbiddens(
 
         return new_forbiddens
 
+    def update(self, object: [Hyperparameter, ConditionLike, ForbiddenLike],
+               value: Any, attribute: str = None) -> None:
+        """Update the configuration space by changing a hyperparameter, condition or
+        forbidden clause.
+
+        Args:
+            object: Hyperparameter, condition or forbidden clause to update
+            value: The value to update it by
+            attribute: The attribute to update (optional)
+        """
+        if isinstance(object, Hyperparameter) and attribute is not None:
+            # 1. Update hyperparameter attribute
+            previous_vector = object._vector_dist
+            self[object.name].__setattr__(attribute, value)
+
+            def _update_clause_vector(clause: [ConditionLike, ForbiddenLike]):
+                if isinstance(clause, (Conjunction, ForbiddenConjunction)):
+                    for dlc in clause.dlcs:
+                        _update_clause_vector(dlc)
+                else:
+                    if (isinstance(clause, Condition) and clause.parent.name == object.name) or (isinstance(clause, ForbiddenClause) and clause.hyperparameter.name == object.name):
+                        if hasattr(clause, "vector_values"):  # Vectorised condition
+                            clause.vector_values = [object.to_vector(value) for value in clause.values]
+                        elif hasattr(clause, "vector_value"):  # Single value
+                            clause.vector_value = object.to_vector(clause.value)
+
+            if previous_vector != object._vector_dist:  # Vector has changed, hence vectorised values must be updated
+                # 2. Update the conditions vector values
+                for condition in self.conditions:
+                    _update_clause_vector(condition)
+                # 3. Update the forbiddens vector values
+                for forbidden in self.forbidden_clauses:
+                    _update_clause_vector(forbidden)
+        else:
+            raise NotImplementedError("ConfigSpace.update is currently only available for Hyperparameter attributes.")
+
+
     def __eq__(self, other: Any) -> bool:
         """Override the default Equals behavior."""
         if isinstance(other, self.__class__):

src/ConfigSpace/hyperparameters/beta_float.py

@@ -117,7 +117,7 @@ def __init__(
         try:
             scaler = UnitScaler(f64(self.lower), f64(self.upper), log=log, dtype=f64)
         except ValueError as e:
-            raise ValueError(f"Hyperparameter '{name}' has illegal settings") from e
+            raise ValueError(f"Illegal value(s) for Hyperparameter '{name}'") from e
 
         if (self.alpha > 1) or (self.beta > 1):
             normalized_mode = (self.alpha - 1) / (self.alpha + self.beta - 2)

src/ConfigSpace/hyperparameters/beta_integer.py

@@ -118,7 +118,7 @@ def __init__(
         try:
             scaler = UnitScaler(i64(self.lower), i64(self.upper), log=log, dtype=i64)
         except ValueError as e:
-            raise ValueError(f"Hyperparameter '{name}' has illegal settings") from e
+            raise ValueError(f"Illegal value(s) for Hyperparameter '{name}'") from e
 
         if default_value is None:
             if (self.alpha > 1) or (self.beta > 1):

src/ConfigSpace/hyperparameters/hyperparameter.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Hashable, Mapping, Sequence
@@ -132,11 +133,47 @@ def __init__(
         if not self.legal_value(self.default_value):
             raise ValueError(
                 f"Illegal default value {self.default_value} for"
-                f" hyperparamter '{self.name}'.",
+                f" hyperparameter '{self.name}'.",
             )
 
         self._normalized_default_value = self.to_vector(self.default_value)
 
+    def __setattr__(self, name: str, value: Any):
+        """Check if attribute can be set on HP, and reinitialises the class if so."""
+        # NOTE: Here we first verify if the object is being initialised by checking the call stack if the parent function is called "__init__"
+        # This is currently the best way to check as checking the caller class etc is too complex
+        # Alternatively, we could compare the __code__ objects/properties of the caller for self.__init__.__code__ but this would be more computationally expensive
+        stack = inspect.stack()  # NOTE: Calling stack is notoriously expensive, which could bottleneck the update function
+        from ConfigSpace.configuration_space import ConfigurationSpace
+        configuration_space_file = inspect.getfile(ConfigurationSpace)
+
+        if stack[1][3] == '__init__':  # Init, normal __setattr__ control flow
+            super().__setattr__(name, value)
+        # We are updating an existing attribute
+        elif stack[1].filename == configuration_space_file:  # Called from ConfigSpace, hence legal
+            # NOTE: We could make the above check more protective -- using stack[2].frame.f_locals['space'] --- but this is a very convoluted check
+            # Extract all editable attributes
+            init_params: tuple[str] = self.__init__.__code__.co_varnames[:self.__init__.__code__.co_argcount]
+
+            if name not in init_params or not hasattr(self, name):
+                raise ValueError(f"Can only set parameters passed to self.__init__. '{name}' is not one of: {init_params}")
+
+            try:
+                init_params = {key: self.__dict__[key] for key in init_params if hasattr(self, key)}  # This will break if the parameter is not saved under its passed name
+            except KeyError as e:
+                raise KeyError(f"You are seeing this message because the class {self.__class__.__name__} does not define an instance attribute with the same name as the class constructor parameter. To update Hyperparameter attributes after initialization, either modify the __init__ function of the class to define the attribute with the same name or call hp_instance.__init__(**new_init_parameters) to reset the parameters") from e
+            init_params[name] = value  # Place the update value
+
+            previous_state = self.__dict__.copy()
+            try:
+                self.__init__(**init_params)  # Reinitialise
+            except Exception as ex:
+                self.__dict__.clear()
+                self.__dict__.update(previous_state)
+                raise ex
+        else:
+            raise RuntimeError(f"Can only update Hyperparameter attributes after initialization via Configspace.update. (Attempted to set: {self.name}.{name} = {value})")
+
     @property
     def lower_vectorized(self) -> f64:
         """Lower bound of the hyperparameter in vector space."""

src/ConfigSpace/hyperparameters/normal_float.py

@@ -98,7 +98,7 @@ def __init__(
         """
         if mu <= 0 and log:
             raise ValueError(
-                f"Hyperparameter '{name}' has illegal settings: "
+                f"Illegal value for Hyperparameter '{name}': "
                 f"mu={mu} must be positive for log-scale.",
             )
 
@@ -111,7 +111,7 @@ def __init__(
         try:
             scaler = UnitScaler(f64(self.lower), f64(self.upper), log=log, dtype=f64)
         except ValueError as e:
-            raise ValueError(f"Hyperparameter '{name}' has illegal settings") from e
+            raise ValueError(f"Illegal value(s) for Hyperparameter '{name}'") from e
 
         if default_value is None:
             _default_value = np.clip(self.mu, self.lower, self.upper)

src/ConfigSpace/hyperparameters/normal_integer.py

@@ -101,7 +101,7 @@ def __init__(
         """
         if mu <= 0 and log:
             raise ValueError(
-                f"Hyperparameter '{name}' has illegal settings: "
+                f"Illegal value for Hyperparameter '{name}': "
                 f"mu={mu} must be positive for log-scale.",
             )
 
@@ -119,7 +119,7 @@ def __init__(
                 dtype=i64,
             )
         except ValueError as e:
-            raise ValueError(f"Hyperparameter '{name}' has illegal settings") from e
+            raise ValueError(f"Illegal value(s) for Hyperparameter '{name}'") from e
 
         if default_value is None:
             _default_value = int(np.rint(np.clip(self.mu, self.lower, self.upper)))

src/ConfigSpace/hyperparameters/uniform_float.py

@@ -97,7 +97,7 @@ def __init__(
         try:
             scaler = UnitScaler(f64(self.lower), f64(self.upper), log=log, dtype=f64)
         except ValueError as e:
-            raise ValueError(f"Hyperparameter '{name}' has illegal settings") from e
+            raise ValueError(f"Illegal value(s) for Hyperparameter '{name}'") from e
 
         vect_dist = UnitUniformContinuousDistribution(
             pdf_max_density=1 / float(self.upper - self.lower),

src/ConfigSpace/hyperparameters/uniform_integer.py

@@ -110,7 +110,7 @@ def __init__(
         try:
             scaler = UnitScaler(i64(self.lower), i64(self.upper), log=log, dtype=i64)
         except ValueError as e:
-            raise ValueError(f"Hyperparameter '{name}' has illegal settings") from e
+            raise ValueError(f"Illegal value(s) for Hyperparameter '{name}'") from e
 
         size = self.upper - self.lower + 1
         if not self.log: