def get_grid_search_parameter_grids(
op: "PlannedOperator",
num_samples: Optional[int] = None,
num_grids: Optional[float] = None,
pgo: Optional[PGO] = None,
data_schema: Dict[str, Any] = {},
) -> List[Dict[str, List[Any]]]:
"""Top level function: given a lale operator, returns a list of parameter grids
suitable for passing to GridSearchCV.
Note that you will need to wrap the lale operator for sklearn compatibility to call GridSearchCV
directly. The lale GridSearchCV wrapper takes care of that for you
"""
hp_grids = get_search_space_grids(op,
num_grids=num_grids,
pgo=pgo,
data_schema=data_schema)
grids = SearchSpaceGridstoGSGrids(hp_grids, num_samples=num_samples)
if should_print_search_space("true", "all", "backend", "gridsearchcv"):
name = op.name()
if not name:
name = "an operator"
print(
f"GridSearchCV grids for {name}:\n{gridsearchcv_grids_to_string(grids)}"
)
return grids
def get_search_space_grids( op:'PlannedOperator',
num_grids:Optional[float]=None,
pgo:Optional[PGO]=None)->List[SearchSpaceGrid]:
""" Top level function: given a lale operator, returns a list of hp grids.
Parameters
----------
op : The lale PlannedOperator
num_grids: integer or float, optional
if set to an integer => 1, it will determine how many parameter grids will be returned (at most)
if set to an float between 0 and 1, it will determine what fraction should be returned
note that setting it to 1 is treated as in integer. To return all results, use None
"""
all_parameters = op_to_search_space_grids(op, pgo=pgo)
if should_print_search_space("true", "all", "search_space_grids", "grids"):
name = op.name()
if not name:
name = "an operator"
print(f"search space grids for {name}:\n{search_space_grids_to_string(all_parameters)}")
if num_grids is None:
return all_parameters
else:
if num_grids <= 0:
warnings.warn(f"get_search_space_grids(num_grids={num_grids}) called with a non-positive value for lale_num_grids")
return []
if num_grids >= 1:
samples = math.ceil(num_grids)
if samples >= len(all_parameters):
return all_parameters
else:
warnings.warn(f"get_search_space_grids(num_grids={num_grids}) sampling {math.ceil(num_grids)}/{len(all_parameters)}")
return random.sample(all_parameters, math.ceil(num_grids))
else:
samples = round(len(all_parameters)*num_grids)
warnings.warn(f"get_search_space_grids(num_grids={num_grids}) sampling {samples}/{len(all_parameters)}")
return random.sample(all_parameters, samples)
def get_smac_space(
op: "Ops.PlannedOperator",
lale_num_grids: Optional[float] = None,
lale_pgo: Optional[PGO] = None,
data_schema: Dict[str, Any] = {},
) -> ConfigurationSpace:
"""Top level function: given a lale operator, returns a ConfigurationSpace for use with SMAC.
Parameters
----------
op : The lale PlannedOperator
lale_num_grids: integer or float, optional
if set to an integer => 1, it will determine how many parameter grids will be returned (at most)
if set to an float between 0 and 1, it will determine what fraction should be returned
note that setting it to 1 is treated as in integer. To return all results, use None
"""
hp_grids = get_search_space_grids(
op, num_grids=lale_num_grids, pgo=lale_pgo, data_schema=data_schema
)
cs = hp_grids_to_smac_cs(hp_grids)
if should_print_search_space("true", "all", "backend", "smac"):
name = op.name()
if not name:
name = "an operator"
print(f"SMAC configuration for {name}:\n{str(cs)}")
return cs
def op_to_search_space(
op: PlannedOperator, pgo: Optional[PGO] = None, data_schema={}
) -> SearchSpace:
""" Given an operator, this method compiles its schemas into a SearchSpace
"""
search_space = SearchSpaceOperatorVisitor.run(op, pgo=pgo, data_schema=data_schema)
if should_print_search_space("true", "all", "search_space"):
name = op.name()
if not name:
name = "an operator"
print(f"search space for {name}:\n {str(search_space)}")
return search_space
def hyperopt_search_space(op: "PlannedOperator",
schema=None,
pgo: Optional[PGO] = None,
data_schema={}):
search_space = op_to_search_space(op, pgo=pgo, data_schema=data_schema)
if search_space:
name = op.name()
if should_print_search_space("true", "all", "backend", "hyperopt"):
print(
f"hyperopt search space for {name}: {search_space_to_hp_str(search_space, name)}"
)
return search_space_to_hp_expr(search_space, name)
else:
return None
