Add get_size() (#208)

* Add get_size()

* Improve documentation

* Fix unit test name

Author: mfeurer

ConfigSpace/configuration_space.pyx

@@ -1341,6 +1341,32 @@ class ConfigurationSpace(collections.abc.Mapping):
         """
         self.random = np.random.RandomState(seed)
 
+    def estimate_size(self) -> Union[float, int]:
+        """
+        Estimate the size of the current configuration space (i.e. unique configurations).
+
+        This is ``np.inf`` in case if there is a single hyperparameter of size ``np.inf`` (i.e. a
+        :class:`~ConfigSpace.hyperparameters.UniformFloatHyperparameter`), otherwise
+        it is the product of the size of all hyperparameters. The function correctly guesses the
+        number of unique configurations if there are no condition and forbidden statements in the
+        configuration spaces. Otherwise, this is an upper bound. Use
+        :func:`~ConfigSpace.util.generate_grid` to generate all valid configurations if required.
+
+        Returns
+        -------
+        Union[float, int]
+        """
+        sizes = []
+        for hp in self._hyperparameters.values():
+            sizes.append(hp.get_size())
+        if len(sizes) == 0:
+            return 0.0
+        else:
+            size = sizes[0]
+            for i in range(1, len(sizes)):
+                size = size * sizes[i]
+            return size
+
 
 class Configuration(collections.abc.Mapping):
     def __init__(self, configuration_space: ConfigurationSpace,

ConfigSpace/hyperparameters.pyx

@@ -151,6 +151,9 @@ cdef class Hyperparameter(object):
     cpdef int compare_vector(self, DTYPE_t value, DTYPE_t value2):
         raise NotImplementedError()
 
+    def get_size(self) -> float:
+        raise NotImplementedError()
+
 
 cdef class Constant(Hyperparameter):
     cdef public value
@@ -255,6 +258,8 @@ cdef class Constant(Hyperparameter):
                       transform: bool = False) -> List:
         return []
 
+    def get_size(self) -> float:
+        return 1.0
 
 cdef class UnParametrizedHyperparameter(Constant):
     pass
@@ -603,6 +608,12 @@ cdef class UniformFloatHyperparameter(FloatHyperparameter):
                 neighbors.append(neighbor)
         return neighbors
 
+    def get_size(self) -> float:
+        if self.q is None:
+            return np.inf
+        else:
+            return np.rint((self.upper - self.lower) / self.q) + 1
+
 
 cdef class NormalFloatHyperparameter(FloatHyperparameter):
     cdef public mu
@@ -857,6 +868,14 @@ cdef class NormalFloatHyperparameter(FloatHyperparameter):
             neighbors.append(new_value)
         return neighbors
 
+    def get_size(self) -> float:
+        if self.q is None:
+            return np.inf
+        elif self.lower is None:
+            return np.inf
+        else:
+            return np.rint((self.upper - self.lower) / self.q) + 1
+
 
 cdef class UniformIntegerHyperparameter(IntegerHyperparameter):
     def __init__(self, name: str, lower: int, upper: int, default_value: Union[int, None] = None,
@@ -1108,6 +1127,13 @@ cdef class UniformIntegerHyperparameter(IntegerHyperparameter):
 
         return neighbors
 
+    def get_size(self) -> float:
+        if self.q is None:
+            q = 1
+        else:
+            q = self.q
+        return np.rint((self.upper - self.lower) / q) + 1
+
 
 cdef class NormalIntegerHyperparameter(IntegerHyperparameter):
     cdef public mu
@@ -1358,6 +1384,16 @@ cdef class NormalIntegerHyperparameter(IntegerHyperparameter):
                 neighbors.append(new_value)
         return neighbors
 
+    def get_size(self) -> float:
+        if self.lower is None:
+            return np.inf
+        else:
+            if self.q is None:
+                q = 1
+            else:
+                q = self.q
+            return np.rint((self.upper - self.lower) / self.q) + 1
+
 
 cdef class CategoricalHyperparameter(Hyperparameter):
     cdef public tuple choices
@@ -1623,6 +1659,9 @@ cdef class CategoricalHyperparameter(Hyperparameter):
                          "OrdinalHyperparameter, but is "
                          "<cdef class 'ConfigSpace.hyperparameters.CategoricalHyperparameter'>")
 
+    def get_size(self) -> float:
+        return len(self.choices)
+
 
 cdef class OrdinalHyperparameter(Hyperparameter):
     cdef public tuple sequence
@@ -1908,3 +1947,6 @@ cdef class OrdinalHyperparameter(Hyperparameter):
 
     def allow_greater_less_comparison(self) -> bool:
         return True
+
+    def get_size(self) -> float:
+        return len(self.sequence)

test/test_configuration_space.py

@@ -803,6 +803,18 @@ def test_acts_as_mapping(self):
         assert list(d.items()) == list(zip(names, hyperparameters))
         assert len(d) == 5
 
+    def test_estimate_size(self):
+        cs = ConfigurationSpace()
+        self.assertEqual(cs.estimate_size(), 0)
+        cs.add_hyperparameter(Constant('constant', 0))
+        self.assertEqual(cs.estimate_size(), 1)
+        cs.add_hyperparameter(UniformIntegerHyperparameter('integer', 0, 5))
+        self.assertEqual(cs.estimate_size(), 6)
+        cs.add_hyperparameter(CategoricalHyperparameter('cat', [0, 1, 2]))
+        self.assertEqual(cs.estimate_size(), 18)
+        cs.add_hyperparameter(UniformFloatHyperparameter('float', 0, 1))
+        self.assertTrue(np.isinf(cs.estimate_size()))
+
 
 class ConfigurationTest(unittest.TestCase):
     def setUp(self):

test/test_hyperparameters.py

@@ -83,6 +83,10 @@ def test_constant(self):
         c1_meta = Constant("value", 1, dict(self.meta_data))
         self.assertEqual(c1_meta.meta, self.meta_data)
 
+        # Test getting the size
+        for constant in (c1, c2, c3, c4, c5, c1_meta):
+            self.assertEqual(constant.get_size(), 1)
+
     def test_uniformfloat(self):
         # TODO test non-equality
         # TODO test sampling from a log-distribution which has a negative
@@ -143,6 +147,12 @@ def test_uniformfloat(self):
                                             default_value=1.0, meta=dict(self.meta_data))
         self.assertEqual(f_meta.meta, self.meta_data)
 
+        # Test get_size
+        for float_hp in (f1, f3, f4):
+            self.assertTrue(np.isinf(float_hp.get_size()))
+        self.assertEqual(f2.get_size(), 101)
+        self.assertEqual(f5.get_size(), 100)
+
     def test_uniformfloat_to_integer(self):
         f1 = UniformFloatHyperparameter("param", 1, 10, q=0.1, log=True)
         with pytest.warns(UserWarning, match="Setting quantization < 1 for Integer "
@@ -281,6 +291,11 @@ def test_normalfloat(self):
                                            default_value=1.0, meta=dict(self.meta_data))
         self.assertEqual(f_meta.meta, self.meta_data)
 
+        # Test get_size
+        for float_hp in (f1, f2, f3, f4, f5):
+            self.assertTrue(np.isinf(float_hp.get_size()))
+        self.assertEqual(f6.get_size(), 100)
+
     def test_normalfloat_to_uniformfloat(self):
         f1 = NormalFloatHyperparameter("param", 0, 10, q=0.1)
         f1_expected = UniformFloatHyperparameter("param", -30, 30, q=0.1)
@@ -343,12 +358,12 @@ def test_uniforminteger(self):
             "param, Type: UniformInteger, Range: [0, 10], Default: 5",
             str(f2))
 
-        # f2_large_q = UniformIntegerHyperparameter("param", 0, 10, q=2)
-        # f2_large_q_ = UniformIntegerHyperparameter("param", 0, 10, q=2)
-        # self.assertEqual(f2_large_q, f2_large_q_)
-        # self.assertEqual(
-        #    "param, Type: UniformInteger, Range: [0, 10], Default: 5, Q: 2",
-        #    str(f2_large_q))
+        f2_large_q = UniformIntegerHyperparameter("param", 0, 10, q=2)
+        f2_large_q_ = UniformIntegerHyperparameter("param", 0, 10, q=2)
+        self.assertEqual(f2_large_q, f2_large_q_)
+        self.assertEqual(
+           "param, Type: UniformInteger, Range: [0, 10], Default: 5, Q: 2",
+           str(f2_large_q))
 
         f3 = UniformIntegerHyperparameter("param", 1, 10, log=True)
         f3_ = UniformIntegerHyperparameter("param", 1, 10, log=True)
@@ -382,6 +397,13 @@ def test_uniforminteger(self):
                                                   default_value=1, meta=dict(self.meta_data))
         self.assertEqual(f_meta.meta, self.meta_data)
 
+        self.assertEqual(f1.get_size(), 6)
+        self.assertEqual(f2.get_size(), 11)
+        self.assertEqual(f2_large_q.get_size(), 6)
+        self.assertEqual(f3.get_size(), 10)
+        self.assertEqual(f4.get_size(), 10)
+        self.assertEqual(f5.get_size(), 10)
+
     def test_uniformint_legal_float_values(self):
         n_iter = UniformIntegerHyperparameter("n_iter", 5., 1000., default_value=20.0)
 
@@ -475,6 +497,10 @@ def test_normalint(self):
                                              meta=dict(self.meta_data))
         self.assertEqual(f_meta.meta, self.meta_data)
 
+        # Test get_size
+        for int_hp in (f1, f2, f3, f4, f5):
+            self.assertTrue(np.isinf(int_hp.get_size()))
+
     def test_normalint_legal_float_values(self):
         n_iter = NormalIntegerHyperparameter("n_iter", 0, 1., default_value=2.0)
         self.assertIsInstance(n_iter.default_value, int)
@@ -556,6 +582,13 @@ def test_categorical(self):
                                            meta=dict(self.meta_data))
         self.assertEqual(f_meta.meta, self.meta_data)
 
+        self.assertEqual(f1.get_size(), 2)
+        self.assertEqual(f2.get_size(), 1000)
+        self.assertEqual(f3.get_size(), 999)
+        self.assertEqual(f4.get_size(), 1000)
+        self.assertEqual(f5.get_size(), 1000)
+        self.assertEqual(f6.get_size(), 2)
+
     def test_categorical_strings(self):
         f1 = CategoricalHyperparameter("param", ["a", "b"])
         f1_ = CategoricalHyperparameter("param", ["a", "b"])
@@ -1155,6 +1188,10 @@ def test_get_num_neighbors(self):
         self.assertEqual(f1.get_num_neighbors("hot"), 1)
         self.assertEqual(f1.get_num_neighbors("cold"), 2)
 
+    def test_ordinal_get_size(self):
+        f1 = OrdinalHyperparameter("temp", ["freezing", "cold", "warm", "hot"])
+        self.assertEqual(f1.get_size(), 4)
+
     def test_rvs(self):
         f1 = UniformFloatHyperparameter("param", 0, 10)