Squashed all the changes related to densities. _pdf works with the (#241)

shrunk unit hypercube range for the Beta hyperparameter case, and tests
have been rewritten to accomodate.

Author: hvarfner

ConfigSpace/configuration_space.pyx

@@ -1344,6 +1344,31 @@ class ConfigurationSpace(collections.abc.Mapping):
         """
         self.random = np.random.RandomState(seed)
 
+    def remove_hyperparameter_priors(self) -> 'ConfigurationSpace':
+        """
+        Produces a new ConfigurationSpace where all priors on parameters are removed.
+        Non-uniform hyperpararmeters are replaced with uniform ones, and 
+        CategoricalHyperparameters with weights have their weights removed. 
+        
+        Returns
+        -------
+        :class:`~ConfigSpace.configuration_space.ConfigurationSpace`
+            The resulting configuration space, without priors on the hyperparameters
+        """
+        uniform_config_space = ConfigurationSpace()
+        for parameter in self.get_hyperparameters():
+            if hasattr(parameter, 'to_uniform'):
+                uniform_config_space.add_hyperparameter(parameter.to_uniform())
+            else:
+                uniform_config_space.add_hyperparameter(copy.copy(parameter))
+        
+        new_conditions = self.substitute_hyperparameters_in_conditions(self.get_conditions(), uniform_config_space)
+        new_forbiddens = self.substitute_hyperparameters_in_forbiddens(self.get_forbiddens(), uniform_config_space)
+        uniform_config_space.add_conditions(new_conditions)
+        uniform_config_space.add_forbidden_clauses(new_forbiddens)
+        
+        return uniform_config_space
+
     def estimate_size(self) -> Union[float, int]:
         """
         Estimate the size of the current configuration space (i.e. unique configurations).
@@ -1370,6 +1395,102 @@ class ConfigurationSpace(collections.abc.Mapping):
                 size = size * sizes[i]
             return size
 
+    @staticmethod
+    def substitute_hyperparameters_in_conditions(conditions, new_configspace) -> List['ConditionComponent']:
+        """
+        Takes a set of conditions and generates a new set of conditions with the same structure, where 
+        each hyperparameter is replaced with its namesake in new_configspace. As such, the set of conditions
+        remain unchanged, but the included hyperparameters are changed to match those types that exist in
+        new_configspace.
+
+        Parameters
+        ----------
+        new_configspace: ConfigurationSpace 
+            A ConfigurationSpace containing hyperparameters with the same names as those in the conditions.
+
+        Returns
+        -------
+        List[ConditionComponent]: 
+            The list of conditions, adjusted to fit the new ConfigurationSpace
+        """    
+        new_conditions = []
+        for condition in conditions:
+            if isinstance(condition, AbstractConjunction):
+                conjunction_type = type(condition)
+                children = condition.get_descendant_literal_conditions()
+                substituted_children = ConfigurationSpace.substitute_hyperparameters_in_conditions(children, new_configspace)
+                substituted_conjunction = conjunction_type(*substituted_children)
+                new_conditions.append(substituted_conjunction)
+            
+            elif isinstance(condition, AbstractCondition):
+                condition_type = type(condition)
+                child_name = getattr(condition.get_children()[0], 'name')
+                parent_name = getattr(condition.get_parents()[0], 'name')
+                new_child = new_configspace[child_name]
+                new_parent = new_configspace[parent_name]
+                
+                if hasattr(condition, 'value'):
+                    condition_arg = getattr(condition, 'value')
+                    substituted_condition = condition_type(child=new_child, parent=new_parent, value=condition_arg)
+                elif hasattr(condition, 'values'):
+                    condition_arg = getattr(condition, 'values')
+                    substituted_condition = condition_type(child=new_child, parent=new_parent, values=condition_arg)
+                else:
+                    raise AttributeError(f'Did not find the expected attribute in condition {type(condition)}.')
+                
+                new_conditions.append(substituted_condition)
+            else:
+                raise TypeError(f'Did not expect the supplied condition type {type(condition)}.')
+                
+        return new_conditions
+
+    @staticmethod
+    def substitute_hyperparameters_in_forbiddens(forbiddens, new_configspace) -> List['ConditionComponent']:
+        """
+        Takes a set of forbidden clauses and generates a new set of forbidden clauses with the same structure, 
+        where each hyperparameter is replaced with its namesake in new_configspace. As such, the set of forbidden 
+        clauses remain unchanged, but the included hyperparameters are changed to match those types that exist in
+        new_configspace.
+
+        Parameters
+        ----------
+        new_configspace: ConfigurationSpace 
+            A ConfigurationSpace containing hyperparameters with the same names as those in the forbidden clauses.
+
+        Returns
+        -------
+        List[AbstractForbiddenComponent]: 
+            The list of forbidden clauses, adjusted to fit the new ConfigurationSpace
+        """    
+        new_forbiddens = []
+        for forbidden in forbiddens:
+            if isinstance(forbidden, AbstractForbiddenConjunction):
+                conjunction_type = type(forbidden)
+                children = forbidden.get_descendant_literal_clauses()
+                substituted_children = ConfigurationSpace.substitute_hyperparameters_in_forbiddens(children, new_configspace)
+                substituted_conjunction = conjunction_type(*substituted_children)
+                new_forbiddens.append(substituted_conjunction)
+            
+            elif isinstance(forbidden, AbstractForbiddenClause):
+                forbidden_type = type(forbidden)
+                hyperparameter_name = getattr(forbidden.hyperparameter, 'name')
+                new_hyperparameter = new_configspace[hyperparameter_name]
+                
+                if hasattr(forbidden, 'value'):
+                    forbidden_arg = getattr(forbidden, 'value')
+                    substituted_forbidden = forbidden_type(hyperparameter=new_hyperparameter, value=forbidden_arg)
+                elif hasattr(forbidden, 'values'):
+                    forbidden_arg = getattr(forbidden, 'values')
+                    substituted_forbidden = forbidden_type(hyperparameter=new_hyperparameter, values=forbidden_arg)
+                else:
+                    raise AttributeError(f'Did not find the expected attribute in forbidden {type(forbidden)}.')
+                
+                new_forbiddens.append(substituted_forbidden)
+            else:
+                raise TypeError(f'Did not expect the supplied forbidden type {type(forbidden)}.')
+        
+        return new_forbiddens
+
 
 class Configuration(collections.abc.Mapping):
     def __init__(self, configuration_space: ConfigurationSpace,

ConfigSpace/forbidden.pyx

@@ -12,7 +12,7 @@
 #       notice, this list of conditions and the following disclaimer in the
 #       documentation and/or other materials provided with the distribution.
 #     * Neither the name of the <organization> nor the
-#       names of its contributors may be used to endorse or promote products
+#       names of itConfigurationSpaces contributors may be used to endorse or promote products
 #       derived from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND