def setUp(self):
self.param1 = ChoiceParameter(
name="x", parameter_type=ParameterType.STRING, values=["foo", "bar", "baz"]
)
self.param1_repr = (
"ChoiceParameter(name='x', parameter_type=STRING, "
"values=['foo', 'bar', 'baz'])"
)
self.param2 = ChoiceParameter(
name="x",
parameter_type=ParameterType.STRING,
values=["foo", "bar", "baz"],
is_ordered=True,
is_task=True,
)
self.param3 = ChoiceParameter(
name="x",
parameter_type=ParameterType.STRING,
values=["foo", "bar"],
is_fidelity=True,
target_value="bar",
)
self.param3_repr = (
"ChoiceParameter(name='x', parameter_type=STRING, "
"values=['foo', 'bar'], fidelity=True, target_value='bar')"
)
def get_factorial_search_space() -> SearchSpace:
return SearchSpace(
# Expected `List[ax.core.parameter.Parameter]` for 2nd parameter
# `parameters` to call `ax.core.search_space.SearchSpace.__init__` but
# got `List[ChoiceParameter]`.
parameters=[
ChoiceParameter(
name="factor1",
parameter_type=ParameterType.STRING,
# Expected `List[typing.Optional[typing.Union[bool, float, str]]]` for
# 4th parameter `values` to call
# `ax.core.parameter.ChoiceParameter.__init__` but got
# `List[str]`.
values=["level11", "level12", "level13"],
),
ChoiceParameter(
name="factor2",
parameter_type=ParameterType.STRING,
# Expected `List[typing.Optional[typing.Union[bool, float, str]]]` for
# 4th parameter `values` to call
# `ax.core.parameter.ChoiceParameter.__init__` but got
# `List[str]`.
values=["level21", "level22"],
),
ChoiceParameter(
name="factor3",
parameter_type=ParameterType.STRING,
# Expected `List[typing.Optional[typing.Union[bool, float, str]]]` for
# 4th parameter `values` to call
# `ax.core.parameter.ChoiceParameter.__init__` but got
# `List[str]`.
values=["level31", "level32", "level33", "level34"],
),
])
def setUp(self):
self.a = RangeParameter(
name="a", parameter_type=ParameterType.FLOAT, lower=0.5, upper=5.5
)
self.b = RangeParameter(
name="b", parameter_type=ParameterType.INT, lower=2, upper=10
)
self.c = ChoiceParameter(
name="c", parameter_type=ParameterType.STRING, values=["foo", "bar", "baz"]
)
self.d = FixedParameter(name="d", parameter_type=ParameterType.BOOL, value=True)
self.e = ChoiceParameter(
name="e", parameter_type=ParameterType.FLOAT, values=[0.0, 0.1, 0.2, 0.5]
)
self.f = RangeParameter(
name="f",
parameter_type=ParameterType.INT,
lower=2,
upper=10,
log_scale=True,
)
self.g = RangeParameter(
name="g", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0
)
self.parameters = [self.a, self.b, self.c, self.d, self.e, self.f]
self.ss1 = SearchSpace(parameters=self.parameters)
self.ss2 = SearchSpace(
parameters=self.parameters,
parameter_constraints=[
OrderConstraint(lower_parameter=self.a, upper_parameter=self.b)
],
)
self.ss1_repr = (
"SearchSpace("
"parameters=["
"RangeParameter(name='a', parameter_type=FLOAT, range=[0.5, 5.5]), "
"RangeParameter(name='b', parameter_type=INT, range=[2, 10]), "
"ChoiceParameter(name='c', parameter_type=STRING, "
"values=['foo', 'bar', 'baz']), "
"FixedParameter(name='d', parameter_type=BOOL, value=True), "
"ChoiceParameter(name='e', parameter_type=FLOAT, "
"values=[0.0, 0.1, 0.2, 0.5]), "
"RangeParameter(name='f', parameter_type=INT, range=[2, 10], "
"log_scale=True)], "
"parameter_constraints=[])"
)
self.ss2_repr = (
"SearchSpace("
"parameters=["
"RangeParameter(name='a', parameter_type=FLOAT, range=[0.5, 5.5]), "
"RangeParameter(name='b', parameter_type=INT, range=[2, 10]), "
"ChoiceParameter(name='c', parameter_type=STRING, "
"values=['foo', 'bar', 'baz']), "
"FixedParameter(name='d', parameter_type=BOOL, value=True), "
"ChoiceParameter(name='e', parameter_type=FLOAT, "
"values=[0.0, 0.1, 0.2, 0.5]), "
"RangeParameter(name='f', parameter_type=INT, range=[2, 10], "
"log_scale=True)], "
"parameter_constraints=[OrderConstraint(a <= b)])"
)
def setUp(self):
self.search_space = SearchSpace(
parameters=[
RangeParameter(
"x", lower=1, upper=3, parameter_type=ParameterType.FLOAT
),
RangeParameter("a", lower=1, upper=2, parameter_type=ParameterType.INT),
ChoiceParameter(
"b",
parameter_type=ParameterType.FLOAT,
values=[1.0, 10.0, 100.0],
is_ordered=True,
),
ChoiceParameter(
"c",
parameter_type=ParameterType.FLOAT,
values=[10.0, 100.0, 1000.0],
is_ordered=True,
),
ChoiceParameter(
"d", parameter_type=ParameterType.STRING, values=["r", "q", "z"]
),
],
parameter_constraints=[
ParameterConstraint(constraint_dict={"x": -0.5, "a": 1}, bound=0.5)
],
)
self.t = OrderedChoiceEncode(
search_space=self.search_space,
observation_features=None,
observation_data=None,
)
def setUp(self):
self.search_space = SearchSpace(
parameters=[
RangeParameter("x",
lower=1,
upper=3,
parameter_type=ParameterType.FLOAT),
RangeParameter("a",
lower=1,
upper=2,
parameter_type=ParameterType.INT),
ChoiceParameter(
"b",
parameter_type=ParameterType.FLOAT,
values=[1.0, 10.0, 100.0],
is_ordered=True,
),
ChoiceParameter(
"c",
parameter_type=ParameterType.FLOAT,
values=[10.0, 100.0, 1000.0],
is_ordered=True,
),
ChoiceParameter("d",
parameter_type=ParameterType.STRING,
values=["r", "q", "z"]),
],
parameter_constraints=[
ParameterConstraint(constraint_dict={
"x": -0.5,
"a": 1
},
bound=0.5)
],
)
self.t = ChoiceEncode(
search_space=self.search_space,
observation_features=None,
observation_data=None,
)
self.observation_features = [
ObservationFeatures(parameters={
"x": 2.2,
"a": 2,
"b": 10.0,
"c": 10.0,
"d": "r"
})
]
# expected parameters after transform
self.expected_transformed_params = {
"x": 2.2,
"a": 2,
# ordered float choice originally; transformed normalized value
"b": normalize_values([1.0, 10.0, 100.0])[1],
# ordered float choice originally; transformed normalized value
"c": normalize_values([10.0, 100.0, 1000.0])[0],
# string choice originally; transformed to int index.
"d": 0,
}
def testProperties(self):
self.assertEqual(self.param1.name, "x")
self.assertEqual(self.param1.parameter_type, ParameterType.STRING)
self.assertEqual(len(self.param1.values), 3)
self.assertFalse(self.param1.is_numeric)
self.assertFalse(self.param1.is_ordered)
self.assertFalse(self.param1.is_task)
self.assertTrue(self.param2.is_ordered)
self.assertTrue(self.param2.is_task)
# check is_ordered defaults
bool_param = ChoiceParameter(
name="x", parameter_type=ParameterType.BOOL, values=[True, False]
)
self.assertTrue(bool_param.is_ordered)
int_param = ChoiceParameter(
name="x", parameter_type=ParameterType.INT, values=[2, 1, 3]
)
self.assertTrue(int_param.is_ordered)
self.assertListEqual(int_param.values, sorted(int_param.values))
float_param = ChoiceParameter(
name="x", parameter_type=ParameterType.FLOAT, values=[1.5, 2.5, 3.5]
)
self.assertTrue(float_param.is_ordered)
string_param = ChoiceParameter(
name="x", parameter_type=ParameterType.STRING, values=["foo", "bar", "baz"]
)
self.assertFalse(string_param.is_ordered)
def setUp(self):
self.search_space = SearchSpace(
parameters=[
RangeParameter(
"x", lower=1, upper=3, parameter_type=ParameterType.FLOAT
),
ChoiceParameter(
"b",
parameter_type=ParameterType.FLOAT,
values=[1.0, 10.0, 100.0],
is_ordered=True,
),
ChoiceParameter(
"c",
parameter_type=ParameterType.STRING,
values=["online", "offline"],
is_task=True,
),
]
)
self.t = TaskEncode(
search_space=self.search_space,
observation_features=None,
observation_data=None,
)
def setUp(self):
self.parameters = [
ChoiceParameter("x", ParameterType.FLOAT, values=[0, 1]),
ChoiceParameter("y", ParameterType.STRING, values=["foo", "bar"]),
FixedParameter("z", ParameterType.BOOL, value=True),
]
parameter_constraints = []
self.search_space = SearchSpace(self.parameters, parameter_constraints)
self.observation_features = [
ObservationFeatures(parameters={
"x": 0,
"y": "foo",
"z": True
}),
ObservationFeatures(parameters={
"x": 1,
"y": "foo",
"z": True
}),
ObservationFeatures(parameters={
"x": 1,
"y": "bar",
"z": True
}),
]
self.observation_data = [
ObservationData(
metric_names=["a", "b"],
means=np.array([1.0, -1.0]),
covariance=np.array([[1.0, 4.0], [4.0, 6.0]]),
),
ObservationData(
metric_names=["a", "b"],
means=np.array([2.0, -2.0]),
covariance=np.array([[2.0, 5.0], [5.0, 7.0]]),
),
ObservationData(metric_names=["a"],
means=np.array([3.0]),
covariance=np.array([[3.0]])),
]
self.observations = [
Observation(
features=self.observation_features[i],
data=self.observation_data[i],
arm_name=str(i),
) for i in range(3)
]
self.pending_observations = {
"b":
[ObservationFeatures(parameters={
"x": 0,
"y": "foo",
"z": True
})]
}
self.model_gen_options = {"option": "yes"}
def setUp(self):
self.search_space = SearchSpace(
parameters=[
RangeParameter(
"x",
lower=1,
upper=3,
parameter_type=ParameterType.FLOAT,
),
RangeParameter("a", lower=1, upper=2, parameter_type=ParameterType.INT),
ChoiceParameter(
"b", parameter_type=ParameterType.STRING, values=["a", "b", "c"]
),
ChoiceParameter(
"c",
parameter_type=ParameterType.BOOL,
values=[True, False],
is_ordered=False,
),
ChoiceParameter(
"d",
parameter_type=ParameterType.FLOAT,
values=[1.0, 10.0, 100.0],
is_ordered=True,
),
],
parameter_constraints=[
ParameterConstraint(constraint_dict={"x": -0.5, "a": 1}, bound=0.5)
],
)
self.t = OneHot(
search_space=self.search_space,
observation_features=None,
observation_data=None,
)
self.t2 = OneHot(
search_space=self.search_space,
observation_features=None,
observation_data=None,
config={"rounding": "randomized"},
)
self.transformed_features = ObservationFeatures(
parameters={
"x": 2.2,
"a": 2,
"b" + OH_PARAM_INFIX + "_0": 0,
"b" + OH_PARAM_INFIX + "_1": 1,
"b" + OH_PARAM_INFIX + "_2": 0,
# Only two choices => one parameter.
"c" + OH_PARAM_INFIX: 0,
"d": 10.0,
}
)
self.observation_features = ObservationFeatures(
parameters={"x": 2.2, "a": 2, "b": "b", "c": False, "d": 10.0}
)
def testEq(self):
param4 = ChoiceParameter(name="x",
parameter_type=ParameterType.STRING,
values=["foo", "bar", "baz"])
self.assertEqual(self.param1, param4)
self.assertNotEqual(self.param1, self.param2)
param5 = ChoiceParameter(name="x",
parameter_type=ParameterType.STRING,
values=["foo", "foobar"])
self.assertNotEqual(self.param1, param5)
def get_large_factorial_search_space() -> SearchSpace:
return SearchSpace(
parameters=[
ChoiceParameter(
name="factor1",
parameter_type=ParameterType.STRING,
values=[f"level1{i}" for i in range(7)],
),
ChoiceParameter(
name="factor2",
parameter_type=ParameterType.STRING,
values=[f"level2{i}" for i in range(10)],
),
]
)
def setUp(self):
self.search_space = SearchSpace(
parameters=[
RangeParameter(
"x", lower=1, upper=3, parameter_type=ParameterType.FLOAT
),
RangeParameter(
"y", lower=1, upper=2, parameter_type=ParameterType.FLOAT
),
RangeParameter(
"z",
lower=1,
upper=2,
parameter_type=ParameterType.FLOAT,
log_scale=True,
),
RangeParameter("a", lower=1, upper=2, parameter_type=ParameterType.INT),
ChoiceParameter(
"b", parameter_type=ParameterType.STRING, values=["a", "b", "c"]
),
],
parameter_constraints=[],
)
self.t = CenteredUnitX(
search_space=self.search_space,
observation_features=None,
observation_data=None,
)
def transform_search_space(self, search_space: SearchSpace) -> SearchSpace:
transformed_parameters: List[Parameter] = []
for p in search_space.parameters.values():
if p.name in self.transform_parameters:
# pyre: p_cast is declared to have type `RangeParameter` but
# pyre-fixme[9]: is used as type `Parameter`.
p_cast: RangeParameter = p
transformed_parameters.append(
ChoiceParameter(
name=p_cast.name,
parameter_type=p_cast.parameter_type,
# Expected `List[Optional[typing.Union[bool, float, str]]]` for
# 4th parameter `values` to call
# `ax.core.parameter.ChoiceParameter.__init__` but got
# `List[int]`.
# pyre-fixme[6]:
values=list(range(p_cast.lower, p_cast.upper + 1)),
))
else:
transformed_parameters.append(p)
return SearchSpace(
parameters=transformed_parameters,
parameter_constraints=[
pc.clone() for pc in search_space.parameter_constraints
],
)
def testTransformSearchSpace(self):
ss2 = deepcopy(self.search_space)
ss2 = self.t.transform_search_space(ss2)
for p in ("x", "a", "b", "c", "d"):
self.assertIsInstance(ss2.parameters[p], RangeParameter)
self.assertEqual(ss2.parameters["x"].parameter_type, ParameterType.FLOAT)
for p in ("a", "b", "c", "d"):
self.assertEqual(ss2.parameters[p].parameter_type, ParameterType.INT)
self.assertEqual(ss2.parameters["b"].lower, 0)
self.assertEqual(ss2.parameters["b"].upper, 2)
self.assertEqual(ss2.parameters["c"].lower, 0)
self.assertEqual(ss2.parameters["c"].upper, 2)
self.assertEqual(ss2.parameters["d"].lower, 0)
self.assertEqual(ss2.parameters["d"].upper, 2)
# Ensure we error if we try to transform a fidelity parameter
ss3 = SearchSpace(
parameters=[
ChoiceParameter(
"b",
parameter_type=ParameterType.FLOAT,
values=[1.0, 10.0, 100.0],
is_ordered=True,
is_fidelity=True,
target_value=100.0,
)
]
)
t = OrderedChoiceEncode(
search_space=ss3, observation_features=None, observation_data=None
)
with self.assertRaises(ValueError):
t.transform_search_space(ss3)
def setUp(self):
self.obsd1 = ObservationData(
metric_names=["m1", "m2", "m2"],
means=np.array([1.0, 2.0, 8.0]),
covariance=np.array([[1.0, 0.2, 0.4], [0.2, 2.0, 0.8],
[0.4, 0.8, 3.0]]),
)
self.obsd2 = ObservationData(
metric_names=["m1", "m1", "m2", "m2"],
means=np.array([1.0, 5.0, 2.0, 1.0]),
covariance=np.array([
[1.0, 0.0, 0.0, 0.0],
[0.0, 1.0, 0.2, 0.4],
[0.0, 0.2, 2.0, 0.8],
[0.0, 0.4, 0.8, 3.0],
]),
)
self.search_space = SearchSpace(parameters=[
RangeParameter(name="x",
parameter_type=ParameterType.FLOAT,
lower=0,
upper=10),
ChoiceParameter(name="z",
parameter_type=ParameterType.STRING,
values=["a", "b"]),
])
self.obsf1 = ObservationFeatures({"x": 2, "z": "a"})
self.obsf2 = ObservationFeatures({"x": 5, "z": "b"})
self.t = StratifiedStandardizeY(
search_space=self.search_space,
observation_features=[self.obsf1, self.obsf2],
observation_data=[self.obsd1, self.obsd2],
config={"parameter_name": "z"},
)
def transform_search_space(self, search_space: SearchSpace) -> SearchSpace:
transformed_parameters: Dict[str, Parameter] = {}
for p_name, p in search_space.parameters.items():
if p_name in self.encoded_parameters and isinstance(
p, ChoiceParameter):
if p.is_fidelity:
raise ValueError(
f"Cannot choice-encode fidelity parameter {p_name}")
tvals, ptype = transform_choice_values(p)
transformed_parameters[p_name] = ChoiceParameter(
name=p_name,
parameter_type=ptype,
values=tvals.tolist(),
is_ordered=p.is_ordered,
)
else:
transformed_parameters[p.name] = p
return SearchSpace(
parameters=list(transformed_parameters.values()),
parameter_constraints=[
pc.clone_with_transformed_parameters(
transformed_parameters=transformed_parameters)
for pc in search_space.parameter_constraints
],
)
def transform_search_space(self, search_space: SearchSpace) -> SearchSpace:
transformed_parameters: Dict[str, Parameter] = {}
for p_name, p in search_space.parameters.items():
if p_name in self.encoded_parameters and isinstance(
p, ChoiceParameter):
if p.is_fidelity:
raise ValueError(
f"Cannot choice-encode fidelity parameter {p_name}.")
# Choice(|K|) => Choice(0, K-1, is_task=True)
transformed_parameters[p_name] = ChoiceParameter(
name=p_name,
parameter_type=ParameterType.INT,
values=list(range(len(p.values))), # pyre-ignore [6]
is_ordered=p.is_ordered,
is_task=True,
sort_values=True,
)
else:
transformed_parameters[p.name] = p
return SearchSpace(
parameters=list(transformed_parameters.values()),
parameter_constraints=[
pc.clone_with_transformed_parameters(
transformed_parameters=transformed_parameters)
for pc in search_space.parameter_constraints
],
)
def setUp(self):
self.search_space = SearchSpace(parameters=[
RangeParameter(
"x",
lower=1,
upper=3,
parameter_type=ParameterType.FLOAT,
log_scale=True,
),
RangeParameter(
"a", lower=1, upper=2, parameter_type=ParameterType.INT),
ChoiceParameter("b",
parameter_type=ParameterType.STRING,
values=["a", "b", "c"]),
])
self.t = Log(
search_space=self.search_space,
observation_features=None,
observation_data=None,
)
self.search_space_with_target = SearchSpace(parameters=[
RangeParameter(
"x",
lower=1,
upper=3,
parameter_type=ParameterType.FLOAT,
log_scale=True,
is_fidelity=True,
target_value=3,
)
])
def transform_search_space(self, search_space: SearchSpace) -> SearchSpace:
transformed_parameters: Dict[str, Parameter] = {}
for p_name, p in search_space.parameters.items():
if p_name in self.transform_parameters and isinstance(p, RangeParameter):
# pyre-fixme[6]: Expected `int` for 1st param but got `float`.
values = list(range(p.lower, p.upper + 1))
target_value = (
None
if p.target_value is None
else next(i for i, v in enumerate(values) if v == p.target_value)
)
transformed_parameters[p_name] = ChoiceParameter(
name=p_name,
parameter_type=p.parameter_type,
# Expected `List[Optional[typing.Union[bool, float, str]]]` for
# 4th parameter `values` to call
# `ax.core.parameter.ChoiceParameter.__init__` but got
# `List[int]`.
# pyre-fixme[6]:
values=values,
is_ordered=True,
is_fidelity=p.is_fidelity,
target_value=target_value,
)
else:
transformed_parameters[p.name] = p
return SearchSpace(
parameters=list(transformed_parameters.values()),
parameter_constraints=[
pc.clone_with_transformed_parameters(
transformed_parameters=transformed_parameters
)
for pc in search_space.parameter_constraints
],
)
def get_branin_search_space(
with_fidelity_parameter: bool = False, with_choice_parameter: bool = False
) -> SearchSpace:
parameters = [
RangeParameter(
name="x1", parameter_type=ParameterType.FLOAT, lower=-5, upper=10
),
ChoiceParameter(
name="x2",
parameter_type=ParameterType.FLOAT,
values=[float(x) for x in range(0, 16)],
)
if with_choice_parameter
else RangeParameter(
name="x2", parameter_type=ParameterType.FLOAT, lower=0, upper=15
),
]
if with_fidelity_parameter:
parameters.append(
RangeParameter(
name="fidelity",
parameter_type=ParameterType.FLOAT,
lower=0.0,
upper=1.0,
is_fidelity=True,
target_value=1.0,
)
)
return SearchSpace(parameters=cast(List[Parameter], parameters))
def testTransformSearchSpace(self):
ss2 = deepcopy(self.search_space)
ss2 = self.t.transform_search_space(ss2)
# Parameter type fixed.
self.assertEqual(ss2.parameters["x"].parameter_type,
ParameterType.FLOAT)
self.assertEqual(ss2.parameters["b"].parameter_type,
ParameterType.FLOAT)
self.assertEqual(ss2.parameters["c"].parameter_type, ParameterType.INT)
self.assertEqual(ss2.parameters["c"].lower, 0)
self.assertEqual(ss2.parameters["c"].upper, 1)
# Test error if there are fidelities
ss3 = SearchSpace(parameters=[
ChoiceParameter(
"c",
parameter_type=ParameterType.STRING,
values=["online", "offline"],
is_task=True,
is_fidelity=True,
target_value="online",
)
])
with self.assertRaises(ValueError):
TaskEncode(search_space=ss3,
observation_features=None,
observation_data=None)
def testExtractSearchSpaceDigest(self):
search_space_digest = extract_search_space_digest(
self.search_space, ["x", "y", "z"])
self.assertEqual(search_space_digest.bounds, [(0.0, 1.0), (1.0, 2.0),
(0.0, 5.0)])
self.assertEqual(search_space_digest.task_features, [])
self.assertEqual(search_space_digest.target_fidelities, {1: 2.0})
search_space_digest = extract_search_space_digest(
self.search_space, ["x", "z"])
self.assertEqual(search_space_digest.target_fidelities, {})
# Test that Int param is treated as task feature
search_space = SearchSpace(self.parameters)
search_space._parameters["x"] = RangeParameter("x",
ParameterType.INT,
lower=1,
upper=4)
search_space_digest = extract_search_space_digest(
search_space, ["x", "y", "z"])
self.assertEqual(search_space_digest.task_features, [0])
# Test validation
search_space._parameters["x"] = ChoiceParameter(
"x", ParameterType.FLOAT, [0.1, 0.4])
with self.assertRaises(ValueError):
extract_search_space_digest(search_space, ["x", "y", "z"])
search_space._parameters["x"] = RangeParameter("x",
ParameterType.FLOAT,
lower=1.0,
upper=4.0,
log_scale=True)
with self.assertRaises(ValueError):
extract_search_space_digest(search_space, ["x", "y", "z"])
def testTransformSearchSpace(self):
ss2 = self.search_space.clone()
ss2 = self.t.transform_search_space(ss2)
self.assertEqual(len(ss2.parameters), 1)
expected_parameter = ChoiceParameter(
name="arms",
parameter_type=ParameterType.STRING,
values=list(self.t.signature_to_parameterization.keys()),
)
self.assertEqual(ss2.parameters.get("arms"), expected_parameter)
# Test error if there are fidelities
ss3 = SearchSpace(parameters=[
RangeParameter(
"a",
lower=1,
upper=3,
parameter_type=ParameterType.FLOAT,
is_fidelity=True,
target_value=3,
)
])
with self.assertRaises(ValueError):
SearchSpaceToChoice(
search_space=ss3,
observation_features=self.observation_features,
observation_data=None,
)
def testGetBoundsAndTask(self):
bounds, task_features, target_fidelities = get_bounds_and_task(
self.search_space, ["x", "y", "z"])
self.assertEqual(bounds, [(0.0, 1.0), (1.0, 2.0), (0.0, 5.0)])
self.assertEqual(task_features, [])
self.assertEqual(target_fidelities, {1: 2.0})
bounds, task_features, target_fidelities = get_bounds_and_task(
self.search_space, ["x", "z"])
self.assertEqual(target_fidelities, {})
# Test that Int param is treated as task feature
search_space = SearchSpace(self.parameters)
search_space._parameters["x"] = RangeParameter("x",
ParameterType.INT,
lower=1,
upper=4)
bounds, task_features, target_fidelities = get_bounds_and_task(
search_space, ["x", "y", "z"])
self.assertEqual(task_features, [0])
# Test validation
search_space._parameters["x"] = ChoiceParameter(
"x", ParameterType.FLOAT, [0.1, 0.4])
with self.assertRaises(ValueError):
get_bounds_and_task(search_space, ["x", "y", "z"])
search_space._parameters["x"] = RangeParameter("x",
ParameterType.FLOAT,
lower=1.0,
upper=4.0,
log_scale=True)
with self.assertRaises(ValueError):
get_bounds_and_task(search_space, ["x", "y", "z"])
def setUp(self):
self.fixed_parameter = FixedParameter(
name="x", parameter_type=ParameterType.BOOL, value=True)
self.choice_parameter = ChoiceParameter(
name="x",
parameter_type=ParameterType.STRING,
values=["foo", "bar", "baz"])
def testSingleValue(self):
with self.assertRaises(UserInputError):
ChoiceParameter(name="x",
parameter_type=ParameterType.STRING,
values=["foo"])
with self.assertRaises(UserInputError):
self.param1.set_values(["foo"])
def test_validation(self):
# Case where dependent parameter is not in the search space.
with self.assertRaisesRegex(ValueError,
".* 'l2_reg_weight' is not part"):
HierarchicalSearchSpace(parameters=[
ChoiceParameter(
name="model",
parameter_type=ParameterType.STRING,
values=["Linear", "XGBoost"],
dependents={
"Linear": ["learning_rate", "l2_reg_weight"],
"XGBoost": ["num_boost_rounds"],
},
),
self.lr_parameter,
self.num_boost_rounds_parameter,
])
# Case where there are two root-parameter candidates.
with self.assertRaisesRegex(NotImplementedError,
"Could not find the root"):
HierarchicalSearchSpace(parameters=[
self.model_parameter,
self.model_2_parameter,
self.lr_parameter,
self.l2_reg_weight_parameter,
self.num_boost_rounds_parameter,
])
# TODO: Test case where subtrees are not independent.
with self.assertRaisesRegex(UserInputError,
".* contain the same parameters"):
HierarchicalSearchSpace(parameters=[
ChoiceParameter(
name="root",
parameter_type=ParameterType.BOOL,
values=[True, False],
dependents={
True: ["model", "model_2"],
},
),
self.model_parameter,
self.model_2_parameter,
self.lr_parameter,
self.l2_reg_weight_parameter,
self.num_boost_rounds_parameter,
])
def setUp(self):
self.search_space = SearchSpace(parameters=[
RangeParameter(
"a", lower=1, upper=3, parameter_type=ParameterType.FLOAT),
ChoiceParameter("b",
parameter_type=ParameterType.STRING,
values=["a", "b", "c"]),
])
self.observation_features = [
ObservationFeatures(parameters={
"a": 2,
"b": "a"
}),
ObservationFeatures(parameters={
"a": 3,
"b": "b"
}),
ObservationFeatures(parameters={
"a": 3,
"b": "c"
}),
]
self.signature_to_parameterization = {
Arm(parameters=obsf.parameters).signature: obsf.parameters
for obsf in self.observation_features
}
self.transformed_features = [
ObservationFeatures(
parameters={
"arms": Arm(parameters={
"a": 2,
"b": "a"
}).signature
}),
ObservationFeatures(
parameters={
"arms": Arm(parameters={
"a": 3,
"b": "b"
}).signature
}),
ObservationFeatures(
parameters={
"arms": Arm(parameters={
"a": 3,
"b": "c"
}).signature
}),
]
self.t = SearchSpaceToChoice(
search_space=self.search_space,
observation_features=self.observation_features,
observation_data=None,
)
self.t2 = SearchSpaceToChoice(
search_space=self.search_space,
observation_features=[self.observation_features[0]],
observation_data=None,
)
def get_discrete_search_space() -> SearchSpace:
return SearchSpace(
[
RangeParameter("x", ParameterType.INT, 0, 3),
RangeParameter("y", ParameterType.INT, 5, 7),
ChoiceParameter("z", ParameterType.STRING, ["red", "panda"]),
]
)
def get_large_factorial_search_space() -> SearchSpace:
return SearchSpace(parameters=[
ChoiceParameter(
name=f"factor{j}",
parameter_type=ParameterType.STRING,
values=[f"level1{i}" for i in range(10)],
) for j in range(6)
])
