add support for continuous dimensions

Author: SimonBlanke

src/hyperactive/opt/_adapters/_adapter_utils.py

@@ -29,8 +29,11 @@ def adapt_search_space(experiment, search_config, capabilities):
     """Adapt search space and experiment for backend capabilities.
 
     If the backend doesn't support certain search space features
-    (e.g., categorical values), this function encodes the search space
-    and wraps the experiment to handle encoding/decoding transparently.
+    (e.g., categorical values, continuous ranges), this function:
+    - Validates the search space format
+    - Encodes categorical dimensions (strings to integers)
+    - Discretizes continuous dimensions (tuples to lists)
+    - Wraps the experiment to decode parameters during scoring
 
     Parameters
     ----------
@@ -46,9 +49,14 @@ def adapt_search_space(experiment, search_config, capabilities):
     experiment : BaseExperiment
         The experiment, possibly wrapped for decoding.
     search_config : dict
-        The search config, possibly with encoded search space.
+        The search config, possibly with encoded/discretized search space.
     adapter : SearchSpaceAdapter or None
-        The adapter if encoding was applied, None otherwise.
+        The adapter if adaptation was applied, None otherwise.
+
+    Raises
+    ------
+    ValueError, TypeError
+        If the search space format is invalid.
     """
     search_space_key = detect_search_space_key(search_config)
 
@@ -59,11 +67,14 @@ def adapt_search_space(experiment, search_config, capabilities):
     # Create adapter with backend capabilities
     adapter = SearchSpaceAdapter(search_config[search_space_key], capabilities)
 
+    # Validate search space format
+    adapter.validate()
+
     # Backend supports all features - pass through unchanged
-    if not adapter.needs_encoding:
+    if not adapter.needs_adaptation:
         return experiment, search_config, None
 
-    # Encoding needed - transform search space and wrap experiment
+    # Adaptation needed - transform search space and wrap experiment
     encoded_config = search_config.copy()
     encoded_config[search_space_key] = adapter.encode()
     wrapped_experiment = adapter.wrap_experiment(experiment)

src/hyperactive/opt/_adapters/_base_optuna_adapter.py

@@ -117,20 +117,66 @@ def _suggest_params(self, trial, param_space):
         for key, space in param_space.items():
             if hasattr(space, "suggest"):  # optuna distribution object
                 params[key] = trial._suggest(space, key)
-            elif isinstance(space, tuple) and len(space) == 2:
-                # Tuples are treated as ranges (low, high)
-                low, high = space
-                if isinstance(low, int) and isinstance(high, int):
-                    params[key] = trial.suggest_int(key, low, high)
-                else:
-                    params[key] = trial.suggest_float(key, low, high, log=False)
+            elif isinstance(space, tuple):
+                # Tuples are continuous ranges in unified format
+                params[key] = self._suggest_continuous(trial, key, space)
             elif isinstance(space, list):
                 # Lists are treated as categorical choices
                 params[key] = trial.suggest_categorical(key, space)
             else:
                 raise ValueError(f"Invalid parameter space for key '{key}': {space}")
         return params
 
+    def _suggest_continuous(self, trial, key, space):
+        """Suggest a continuous parameter from a tuple specification.
+
+        Handles unified tuple formats:
+        - (low, high) - linear scale
+        - (low, high, "log") - log scale
+        - (low, high, n_points) - linear scale (n_points ignored for Optuna)
+        - (low, high, n_points, "log") - log scale (n_points ignored for Optuna)
+
+        Parameters
+        ----------
+        trial : optuna.Trial
+            The Optuna trial object
+        key : str
+            The parameter name
+        space : tuple
+            The continuous range specification
+
+        Returns
+        -------
+        float or int
+            The suggested value
+        """
+        if len(space) < 2:
+            raise ValueError(
+                f"Parameter '{key}': continuous range needs at least 2 values "
+                f"(low, high), got {len(space)}."
+            )
+
+        low, high = space[0], space[1]
+        log_scale = False
+
+        # Parse optional arguments
+        if len(space) == 3:
+            third = space[2]
+            if isinstance(third, str) and third.lower() == "log":
+                log_scale = True
+            # If third is int/float, it's n_points - ignore for Optuna
+        elif len(space) == 4:
+            # (low, high, n_points, "log")
+            fourth = space[3]
+            if isinstance(fourth, str) and fourth.lower() == "log":
+                log_scale = True
+
+        # Suggest based on type
+        if isinstance(low, int) and isinstance(high, int):
+            return trial.suggest_int(key, low, high, log=log_scale)
+        else:
+            return trial.suggest_float(key, low, high, log=log_scale)
+
     def _objective(self, trial):
         """Objective function for Optuna optimization.
 

src/hyperactive/opt/_adapters/_gfo.py

@@ -25,7 +25,7 @@ class _BaseGFOadapter(BaseOptimizer):
         "python_dependencies": ["gradient-free-optimizers>=1.5.0"],
         # Search space capabilities
         "capability:discrete": True,
-        "capability:continuous": True,
+        "capability:continuous": False,  # GFO needs lists, not (low, high) tuples
         "capability:categorical": False,  # GFO only supports numeric values
         "capability:constraints": True,
     }
@@ -78,7 +78,9 @@ def get_search_config(self):
 
         search_config = self._handle_gfo_defaults(search_config)
 
-        search_config["search_space"] = self._to_dict_np(search_config["search_space"])
+        # Note: _to_dict_np is called in _solve(), after SearchSpaceAdapter processes
+        # continuous tuples. If we convert here, tuples like (1e-4, 1e-1, "log")
+        # would become numpy arrays with strings before the adapter can discretize them.
 
         return search_config
 
@@ -151,6 +153,10 @@ def _solve(self, experiment, **search_config):
         n_iter = search_config.pop("n_iter", 100)
         max_time = search_config.pop("max_time", None)
 
+        # Convert search_space lists to numpy arrays (GFO requirement)
+        # This must happen after SearchSpaceAdapter has processed continuous tuples
+        search_config["search_space"] = self._to_dict_np(search_config["search_space"])
+
         gfo_cls = self._get_gfo_class()
         gfopt = gfo_cls(**search_config)