def set_bounds(self):
bounds = []
for key in sorted(self.config.matrix.keys()):
value = self.config.matrix[key]
self._features.append(key)
# one hot encoding for categorical type
if value.is_categorical:
values = to_numpy(value)
num_feasible = len(values)
for _ in range(num_feasible):
bounds.append((0, 1))
self._categorical_features[key] = {
"values": values,
"number": num_feasible,
}
self._dim += num_feasible
elif value.is_discrete:
self._dim = self._dim + 1
discrete_values = to_numpy(value)
bounds.append((get_min(value), get_max(value)))
self._discrete_features[key] = {"values": discrete_values}
elif value.is_uniform:
self._dim = self._dim + 1
bounds.append((float(get_min(value)), float(get_max(value))))
self._bounds = np.asarray(bounds)
def test_matrix_values_option(self):
config_dict = {"kind": "choice", "value": [1, 2, 3]}
config = MatrixChoiceConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
assert to_numpy(config) == config_dict["value"]
assert sample(config) in [1, 2, 3]
assert get_length(config) == 3
assert config.is_categorical is False
assert config.is_distribution is False
assert config.is_range is False
assert config.is_uniform is False
assert config.is_discrete is True
assert config.is_continuous is False
assert get_min(config) == 1
assert get_max(config) == 3
config_dict["value"] = ["ok", "nook"]
config = MatrixChoiceConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
assert to_numpy(config) == config_dict["value"]
assert sample(config) in ["ok", "nook"]
assert get_length(config) == 2
assert config.is_categorical is True
assert config.is_distribution is False
assert config.is_range is False
assert config.is_uniform is False
assert config.is_discrete is True
assert config.is_continuous is False
assert get_min(config) is None
assert get_max(config) is None
config_dict["value"] = [[1, 2], [2, 4]]
config = MatrixChoiceConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
assert to_numpy(config) == config_dict["value"]
assert sample(config) in [[1, 2], [2, 4]]
assert get_length(config) == 2
assert config.is_categorical is True
assert config.is_distribution is False
assert config.is_range is False
assert config.is_uniform is False
assert config.is_discrete is True
assert config.is_continuous is False
assert get_min(config) is None
assert get_max(config) is None
def assert_equal(config, v1, v2, q, v3=None):
result = {"loc": v1, "scale": v2, "q": q}
if v3:
result["size"] = v3
assert config.to_dict()["value"] == result
with self.assertRaises(ValidationError):
to_numpy(config)
with self.assertRaises(ValidationError):
get_length(config)
assert isinstance(sample(config), float)
assert config.is_categorical is False
assert config.is_distribution is True
assert config.is_range is False
assert config.is_uniform is False
assert config.is_discrete is False
assert config.is_continuous is True
assert get_min(config) is None
assert get_max(config) is None
def get_suggestions(self):
suggestions = []
keys = list(self.config.matrix.keys())
values = [to_numpy(v) for v in self.config.matrix.values()]
for v in itertools.product(*values):
suggestions.append(dict(zip(keys, v)))
if self.config.n_runs:
return suggestions[:self.config.n_runs]
return suggestions
def assert_equal(config, v1, v2, v3=None):
result = {"low": v1, "high": v2}
if v3:
result["size"] = v3
assert config.to_dict()["value"] == result
with self.assertRaises(ValidationError):
to_numpy(config)
with self.assertRaises(ValidationError):
to_numpy(config)
with self.assertRaises(ValidationError):
get_length(config)
assert v1 <= sample(config) <= v2
assert config.is_categorical is False
assert config.is_distribution is True
assert config.is_range is False
assert config.is_uniform is True
assert config.is_discrete is False
assert config.is_continuous is True
assert get_min(config) == v1
assert get_max(config) == v2
def _set_search_space(self):
for k, v in self.config.matrix.items():
self._search_space[k] = to_hyperopt(k, v)
if v.IDENTIFIER in {
MatrixChoiceConfig.IDENTIFIER,
MatrixRangeConfig.IDENTIFIER,
MatrixLinSpaceConfig.IDENTIFIER,
MatrixLogSpaceConfig.IDENTIFIER,
MatrixGeomSpaceConfig.IDENTIFIER,
}:
# Get the categorical/discrete values mapping
self._param_to_value[k] = to_numpy(v)
def test_matrix_pchoice_option(self):
config_dict = {
"kind": "pchoice",
"value": [(1, 0.1), (2, 0.3), (3, 6)]
}
with self.assertRaises(ValidationError):
MatrixPChoiceConfig.from_dict(config_dict)
config_dict["value"] = [(1, 0.1), (2, 0.3), (3, 0.8)]
with self.assertRaises(ValidationError):
MatrixPChoiceConfig.from_dict(config_dict)
config_dict["value"] = [(1, 0.1), (2, 0.3), (3, -0.6)]
with self.assertRaises(ValidationError):
MatrixPChoiceConfig.from_dict(config_dict)
config_dict["value"] = ["ok", "nook"]
with self.assertRaises(ValidationError):
MatrixPChoiceConfig.from_dict(config_dict)
# Pass for correct config
config_dict["value"] = [(1, 0.1), (2, 0.1), (3, 0.8)]
config = MatrixPChoiceConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
with self.assertRaises(ValidationError):
to_numpy(config)
assert sample(config) in [1, 2, 3]
assert get_length(config) == 3
assert config.is_categorical is False
assert config.is_distribution is True
assert config.is_range is False
assert config.is_uniform is False
assert config.is_discrete is True
assert config.is_continuous is False
assert get_min(config) is None
assert get_max(config) is None
def assert_equal(config, v1, v2, v3):
result = {"start": v1, "stop": v2, "num": v3}
assert config.to_dict()["value"] == result
np.testing.assert_array_equal(to_numpy(config),
np.geomspace(**result))
assert get_length(config) == len(np.geomspace(**result))
assert sample(config) in np.geomspace(**result)
assert config.is_categorical is False
assert config.is_distribution is False
assert config.is_range is True
assert config.is_uniform is False
assert config.is_discrete is True
assert config.is_continuous is False
assert get_min(config) == v1
assert get_max(config) == v2
def to_hyperopt(name, matrix):
if matrix.IDENTIFIER in {
MatrixChoiceConfig.IDENTIFIER,
MatrixRangeConfig.IDENTIFIER,
MatrixLinSpaceConfig.IDENTIFIER,
MatrixLogSpaceConfig.IDENTIFIER,
MatrixGeomSpaceConfig.IDENTIFIER,
}:
return hyperopt.hp.choice(name, to_numpy(matrix))
if matrix.IDENTIFIER == MatrixPChoiceConfig.IDENTIFIER:
raise ValidationError(
"{} is not supported by Hyperopt.".format(matrix.IDENTIFIER)
)
if matrix.IDENTIFIER == MatrixUniformConfig.IDENTIFIER:
return hyperopt.hp.uniform(
name, matrix.value.get("low"), matrix.value.get("high")
)
if matrix.IDENTIFIER == MatrixQUniformConfig.IDENTIFIER:
return hyperopt.hp.quniform(
name,
matrix.value.get("low"),
matrix.value.get("high"),
matrix.value.get("q"),
)
if matrix.IDENTIFIER == MatrixLogUniformConfig.IDENTIFIER:
return hyperopt.hp.loguniform(
name, matrix.value.get("low"), matrix.value.get("high")
)
if matrix.IDENTIFIER == MatrixQLogUniformConfig.IDENTIFIER:
return hyperopt.hp.qloguniform(
name,
matrix.value.get("low"),
matrix.value.get("high"),
matrix.value.get("q"),
)
if matrix.IDENTIFIER == MatrixNormalConfig.IDENTIFIER:
return hyperopt.hp.normal(
name, matrix.value.get("loc"), matrix.value.get("scale")
)
if matrix.IDENTIFIER == MatrixQNormalConfig.IDENTIFIER:
return hyperopt.hp.qnormal(
name,
matrix.value.get("loc"),
matrix.value.get("scale"),
matrix.value.get("q"),
)
if matrix.IDENTIFIER == MatrixLogNormalConfig.IDENTIFIER:
return hyperopt.hp.lognormal(
name, matrix.value.get("loc"), matrix.value.get("scale")
)
if matrix.IDENTIFIER == MatrixQLogNormalConfig.IDENTIFIER:
return hyperopt.hp.qlognormal(
name,
matrix.value.get("loc"),
matrix.value.get("scale"),
matrix.value.get("q"),
)
