Add configspace conversion

setup.py

@@ -32,6 +32,7 @@
     "dask": ["dask[complete]"],
     "track": ["track @ git+https://github.com/Delaunay/track"],
     "profet": ["emukit", "GPy", "torch", "pybnn"],
+    "configspace": ["ConfigSpace"]
 }
 extras_require["all"] = list(set(sum(extras_require.values(), [])))
 

src/orion/algo/space.py → src/orion/algo/space/__init__.py

@@ -31,6 +31,7 @@
 import copy
 import logging
 import numbers
+from typing import Generic, TypeVar
 
 import numpy
 from scipy.stats import distributions
@@ -67,6 +68,47 @@ def __repr__(self):
         return "..."
 
 
+def _to_snake_case(name: str) -> str:
+    """Transform a class name ``MyClassName`` to snakecase ``my_class_name``"""
+    frags = []
+
+    frag = []
+    for c in name:
+        if c.isupper() and frag:
+            frags.append("".join(frag).lower())
+            frag = []
+
+        frag.append(c)
+
+    if frag:
+        frags.append("".join(frag).lower())
+
+    return "_".join(frags)
+
+
+T = TypeVar("T")
+
+
+class Visitor(Generic[T]):
+    def visit(self, dim: "Dimension") -> T:
+        return dim.visit(self)
+
+    def dimension(self, dim: "Dimension") -> T:
+        pass
+
+    def real(self, dim: "Dimension") -> T:
+        pass
+
+    def integer(self, dim: "Dimension") -> T:
+        pass
+
+    def categorical(self, dim: "Dimension") -> T:
+        pass
+
+    def fidelity(self, dim: "Dimension") -> T:
+        pass
+
+
 class Dimension:
     """Base class for search space dimensions.
 
@@ -337,6 +379,10 @@ def cardinality(self):
         """
         return numpy.inf
 
+    def visit(self, visitor: Visitor[T]) -> T:
+        """Execute a visitor on the given dimension"""
+        return getattr(visitor, _to_snake_case(self.__class__.__name__))(self)
+
 
 def _is_numeric_array(point):
     """Test whether a point is numerical object or an array containing only numerical objects"""

src/orion/algo/space/configspace.py

@@ -0,0 +1,212 @@
+from math import log10
+from typing import Optional
+
+from orion.algo.space import Categorical, Dimension, Integer, Real, Space, Visitor
+
+try:
+    from ConfigSpace import ConfigurationSpace
+    from ConfigSpace.hyperparameters import (
+        CategoricalHyperparameter,
+        FloatHyperparameter,
+        Hyperparameter,
+        IntegerHyperparameter,
+        NormalFloatHyperparameter,
+        NormalIntegerHyperparameter,
+        UniformFloatHyperparameter,
+        UniformIntegerHyperparameter,
+    )
+
+    IMPORT_ERROR = None
+
+except ImportError as err:
+    IMPORT_ERROR = err
+
+    IntegerHyperparameter = object()
+    FloatHyperparameter = object()
+    ConfigurationSpace = object()
+    Hyperparameter = object()
+    UniformFloatHyperparameter = object()
+    NormalFloatHyperparameter = object()
+    UniformIntegerHyperparameter = object()
+    NormalIntegerHyperparameter = object()
+    CategoricalHyperparamete = object()
+
+
+def _qantization(dim: Dimension) -> float:
+    """Convert precision to the quantization factor"""
+    if dim.precision:
+        return 10 ** (-dim.precision)
+    return None
+
+
+class ToConfigSpace(Visitor[Optional[Hyperparameter]]):
+    """Convert an Orion space into a configspace"""
+
+    def __init__(self) -> None:
+        if IMPORT_ERROR is not None:
+            raise IMPORT_ERROR
+
+    def dimension(self, dim: Dimension) -> None:
+        """Raise an error if the visitor is called on an abstract class"""
+        raise NotImplementedError()
+
+    def real(self, dim: Dimension) -> Optional[FloatHyperparameter]:
+        """Convert a real dimension into a configspace equivalent"""
+        if dim.prior_name in ("reciprocal", "uniform"):
+            a, b = dim._args
+
+            return UniformFloatHyperparameter(
+                name=dim.name,
+                lower=a,
+                upper=b,
+                default_value=dim.default_value,
+                q=_qantization(dim),
+                log=dim.prior_name == "reciprocal",
+            )
+
+        if dim.prior_name in ("normal", "norm"):
+            a, b = dim._args
+
+            return NormalFloatHyperparameter(
+                name=dim.name,
+                mu=a,
+                sigma=b,
+                default_value=dim.default_value,
+                q=_qantization(dim),
+                log=False,
+                lower=dim.low if hasattr(dim, "low") else None,
+                upper=dim.high if hasattr(dim, "high") else None,
+            )
+
+        return
+
+    def integer(self, dim: Dimension) -> Optional[IntegerHyperparameter]:
+        """Convert a integer dimension into a configspace equivalent"""
+        if dim.prior_name in ("int_uniform", "int_reciprocal"):
+            a, b = dim._args
+
+            return UniformIntegerHyperparameter(
+                name=dim.name,
+                lower=a,
+                upper=b,
+                default_value=dim.default_value,
+                q=_qantization(dim),
+                log=dim.prior_name == "int_reciprocal",
+            )
+
+        if dim.prior_name in ("norm", "normal"):
+            a, b = dim._args
+
+            return NormalIntegerHyperparameter(
+                name=dim.name,
+                mu=a,
+                sigma=b,
+                default_value=dim.default_value,
+                q=_qantization(dim),
+                log=False,
+                lower=dim.low if hasattr(dim, "low") else None,
+                upper=dim.high if hasattr(dim, "high") else None,
+            )
+
+        return None
+
+    def categorical(self, dim: Dimension) -> Optional[CategoricalHyperparameter]:
+        """Convert a categorical dimension into a configspace equivalent"""
+        return CategoricalHyperparameter(
+            name=dim.name,
+            choices=dim.categories,
+            weights=dim._probs,
+        )
+
+    def fidelity(self, dim: Dimension) -> None:
+        """Ignores fidelity dimension as configspace does not have an equivalent"""
+        return None
+
+    def space(self, space: Space) -> ConfigurationSpace:
+        """Convert orion space to configspace"""
+        cspace = ConfigurationSpace()
+        dims = []
+
+        for _, dim in space.items():
+            cdim = self.visit(dim)
+
+            if cdim:
+                dims.append(cdim)
+
+        cspace.add_hyperparameters(dims)
+        return cspace
+
+
+def toconfigspace(space: Space) -> ConfigurationSpace:
+    """Convert orion space to configspace
+
+    Notes
+    -----
+    ``ConfigurationSpace`` will set its own default values
+    if not set inside ``Space``
+
+    """
+    conversion = ToConfigSpace()
+    return conversion.space(space)
+
+
+def tooriondim(dim: Hyperparameter) -> Dimension:
+    """Convert a config space hyperparameter to an orion dimension"""
+
+    if isinstance(dim, CategoricalHyperparameter):
+        choices = {k: w for k, w in zip(dim.choices, dim.probabilities)}
+        return Categorical(dim.name, choices)
+
+    klass = Integer
+    args = []
+    kwargs = dict(
+        # NOTE: Config space always has a config value
+        # so orion-space would get it as well
+        default_value=dim.default_value
+    )
+
+    if isinstance(dim, (UniformFloatHyperparameter, UniformIntegerHyperparameter)):
+        if isinstance(dim, UniformFloatHyperparameter):
+            klass = Real
+        else:
+            kwargs["precision"] = int(-log10(dim.q)) if dim.q else 4
+
+        dist = "uniform"
+        args.append(dim.lower)
+        args.append(dim.upper)
+
+        if dim.log:
+            dist = "reciprocal"
+
+    if isinstance(dim, (NormalFloatHyperparameter, NormalIntegerHyperparameter)):
+        if isinstance(dim, NormalFloatHyperparameter):
+            klass = Real
+        else:
+            kwargs["precision"] = int(-log10(dim.q)) if dim.q else 4
+
+        dist = "norm"
+        args.append(dim.mu)
+        args.append(dim.sigma)
+
+        if dim.lower:
+            kwargs["low"] = dim.lower
+            kwargs["high"] = dim.upper
+
+    return klass(dim.name, dist, *args, **kwargs)
+
+
+def toorionspace(cspace: ConfigurationSpace) -> Space:
+    """Convert from orion space to configspace
+
+    Notes
+    -----
+    ``ConfigurationSpace`` will set default values for each dimensions of ``Space``
+
+    """
+    space = Space()
+
+    for _, cdim in cspace.get_hyperparameters_dict().items():
+        odim = tooriondim(cdim)
+        space.register(odim)
+
+    return space

tests/unittests/algo/test_configspace.py

@@ -0,0 +1,45 @@
+import pytest
+
+from orion.algo.space import Categorical, Fidelity, Integer, Real, Space
+from orion.algo.space.configspace import IMPORT_ERROR, toconfigspace, toorionspace
+
+
+@pytest.mark.skipif(IMPORT_ERROR, reason="Running without ConfigSpace")
+def test_orion_configspace():
+    space = Space()
+
+    space.register(Integer("r1i", "reciprocal", 1, 6))
+    space.register(Integer("u1i", "uniform", -3, 6))
+    space.register(Integer("u2i", "uniform", -3, 6))
+    space.register(Integer("u3i", "uniform", -3, 6, default_value=2))
+
+    space.register(Real("r1f", "reciprocal", 1, 6))
+    space.register(Real("u1f", "uniform", -3, 6))
+    space.register(Real("u2f", "uniform", -3, 6))
+
+    space.register(Categorical("c1", ("asdfa", 2)))
+    space.register(Categorical("c2", dict(a=0.2, b=0.8)))
+    space.register(Fidelity("f1", 1, 9, 3))
+
+    space.register(Real("n1", "norm", 0.9, 0.1, precision=6))
+    space.register(Real("n2", "norm", 0.9, 0.1, precision=None))
+    space.register(Real("n3", "norm", 0.9, 0.1))
+
+    newspace = toconfigspace(space)
+
+    roundtrip = toorionspace(newspace)
+
+    for k, original in space.items():
+        # ConfigSpace does not have a fidelity dimension
+        if k == "f1":
+            continue
+
+        converted = roundtrip[k]
+
+        # Orion space did not have default values
+        # but ConfigSpace always set them
+        if not original.default_value:
+            converted._default_value = None
+
+        assert type(original) == type(converted)
+        assert original == converted