def rung_4(space1: Space):
"""Create duplicated fake points and objectives for rung 4."""
points = np.linspace(1, 4, 4)
keys = list(space1.keys())
types = [dim.type for dim in space1.values()]
results: dict[str, tuple[float, Trial]] = {}
for point in points:
trial = create_trial(
(1, point // 2, point // 2),
names=keys,
results={"objective": point},
types=types,
)
trial_hash = trial.compute_trial_hash(
trial,
ignore_fidelity=True,
ignore_experiment=True,
)
assert trial.objective is not None
results[trial_hash] = (trial.objective.value, trial)
return RungDict(
n_trials=4,
resources=1,
results=results,
)
def generate_trials(olh_samples: np.array, roi_space: Space) -> list[dict]:
"""
Generates trials from the given normalized orthogonal Latin hypercube samples
Parameters
----------
olh_samples: `numpy.array`
Samples from the orthogonal Latin hypercube
roi_space: orion.algo.space.Space
Parameter space region-of-interest
Returns
-------
A list of trials as `dict` objects, each a list of parameter values in the
original search space
"""
trials = []
for sample in olh_samples:
trial_dict = {}
for j, param_name in enumerate(roi_space.keys()):
interval_min, interval_max = roi_space[param_name].interval()
# TODO: deal with categoricals
trial_dict[param_name] = (sample[j] *
(interval_max - interval_min) +
interval_min)
trials.append(trial_dict)
return trials
def test_order(self):
"""Test that the same space built twice will have the same ordering."""
space1 = Space()
space1.register(Integer('yolo1', 'uniform', -3, 6, shape=(2, )))
space1.register(Integer('yolo2', 'uniform', -3, 6, shape=(2, )))
space1.register(Real('yolo3', 'norm', 0.9))
space1.register(Categorical('yolo4', ('asdfa', 2)))
space2 = Space()
space2.register(Integer('yolo1', 'uniform', -3, 6, shape=(2, )))
space2.register(Real('yolo3', 'norm', 0.9))
space2.register(Categorical('yolo4', ('asdfa', 2)))
space2.register(Integer('yolo2', 'uniform', -3, 6, shape=(2, )))
assert list(space1) == list(space1.keys())
assert list(space2) == list(space2.keys())
assert list(space1.values()) == list(space2.values())
assert list(space1.items()) == list(space2.items())
assert list(space1.keys()) == list(space2.keys())
assert list(space1.values()) == list(space2.values())
assert list(space1.items()) == list(space2.items())
def test_order(self):
"""Test that the same space built twice will have the same ordering."""
space1 = Space()
space1.register(Integer("yolo1", "uniform", -3, 6, shape=(2,)))
space1.register(Integer("yolo2", "uniform", -3, 6, shape=(2,)))
space1.register(Real("yolo3", "norm", 0.9))
space1.register(Categorical("yolo4", ("asdfa", 2)))
space2 = Space()
space2.register(Integer("yolo1", "uniform", -3, 6, shape=(2,)))
space2.register(Real("yolo3", "norm", 0.9))
space2.register(Categorical("yolo4", ("asdfa", 2)))
space2.register(Integer("yolo2", "uniform", -3, 6, shape=(2,)))
assert list(space1) == list(space1.keys())
assert list(space2) == list(space2.keys())
assert list(space1.values()) == list(space2.values())
assert list(space1.items()) == list(space2.items())
assert list(space1.keys()) == list(space2.keys())
assert list(space1.values()) == list(space2.values())
assert list(space1.items()) == list(space2.items())
def get_factorial_performance_analysis(oa_table: pd.DataFrame, space: Space,
n_levels: int) -> pd.DataFrame:
"""Compute the factorial perfomance analysis"""
levels = list(range(1, n_levels + 1))
factorial_performance_analysis = [[level] for level in levels]
for key in space.keys():
marginal_means = (oa_table[[key, "objective"
]].groupby([key]).mean().reset_index())
dim_levels = set(levels)
for _, row in marginal_means.iterrows():
dim_level = int(row[key])
factorial_performance_analysis[dim_level - 1].append(
row["objective"])
dim_levels.remove(dim_level)
for remaining_level in dim_levels:
factorial_performance_analysis[remaining_level - 1].append(
float("inf"))
return pd.DataFrame(factorial_performance_analysis,
columns=["level"] + list(space.keys()))
