def test_local_search_2(
self,
_get_initial_points_patch,
):
pcs_file = os.path.join(self.test_files_dir, "test_local_search.pcs")
seed = np.random.randint(1, 100000)
runhistory = unittest.mock.Mock()
runhistory.data = [None] * 1000
with open(pcs_file) as fh:
config_space = pcs.read(fh.readlines())
config_space.seed(seed)
def acquisition_function(points):
return np.array([[np.count_nonzero(point.get_array())]
for point in points])
start_point = config_space.get_default_configuration()
_get_initial_points_patch.return_value = [start_point]
ls = LocalSearch(acquisition_function, config_space, max_steps=100000)
# To have some data in a mock runhistory
ls.runhistory = [None] * 1000
acq_val_incumbent, incumbent = ls._maximize(runhistory, None, 1)[0]
np.testing.assert_allclose(
incumbent.get_array(),
np.ones(len(config_space.get_hyperparameters())))
def test_local_search_2(
self,
_calculate_num_points_patch,
_get_initial_points_patch,
):
pcs_file = os.path.join(self.test_files_dir, "test_local_search.pcs")
seed = np.random.randint(1, 100000)
with open(pcs_file) as fh:
config_space = pcs.read(fh.readlines())
config_space.seed(seed)
def acquisition_function(point):
return np.array([np.count_nonzero(point[0].get_array())])
start_point = config_space.get_default_configuration()
_calculate_num_points_patch.return_value = 1
_get_initial_points_patch.return_value = [start_point]
l = LocalSearch(acquisition_function,
config_space,
epsilon=0.01,
max_iterations=100000)
acq_val_incumbent, incumbent = l._maximize(None, None, 10)[0]
np.testing.assert_allclose(
incumbent.get_array(),
np.ones(len(config_space.get_hyperparameters())))
def read_pcs_file(fn: str, logger=None):
"""Encapsulates generating configuration space object from file.
Automatically detects whether the cs is saved in json, pcs or pcs_new.
Parameters
----------
fn: string
File name of pcs file
Returns
-------
ConfigSpace: ConfigSpace
"""
# Three possible formats: json, pcs and pcs_new. We prefer json.
with open(fn) as fp:
if fn.endswith('.json'):
cs = pcs_json.read(fp.read())
if logger:
logger.debug("Loading pcs as json from: %s", fn)
else:
pcs_str = fp.readlines()
try:
cs = pcs.read(pcs_str)
except NotImplementedError:
if logger:
logger.debug(
"Could not parse pcs file with old format; trying new format ..."
)
cs = pcs_new.read(pcs_str)
return cs
def read_pcs_file(self, fn: str):
"""Encapsulates generating configuration space object
Parameters
----------
fn: string
File name of pcs file
Returns
-------
ConfigSpace: ConfigSpace
"""
space = pcs.read(fn)
return space
def __call__(self, parser: ArgumentParser, namespace: Namespace, values: list, option_string: str=None):
fn = values
if fn:
if os.path.isfile(fn):
with open(fn) as fp:
pcs_str = fp.readlines()
try:
parsed_scen_args["cs"] = pcs.read(pcs_str)
except:
logger.debug("Could not parse pcs file with old format; trying new format ...")
parsed_scen_args["cs"] = pcs_new.read(pcs_str)
parsed_scen_args["cs"].seed(42)
else:
parser.exit(1, "Could not find pcs file: {}".format(fn))
setattr(namespace, self.dest, values)
def __call__(self, parser: ArgumentParser, namespace: Namespace, values: list, option_string: str=None):
fn = values
if fn:
if os.path.isfile(fn):
# Three possible formats: json, pcs and pcs_new. We prefer json.
with open(fn) as fp:
if fn.endswith('.json'):
parsed_scen_args['cs'] = pcs_json.read(fp.read())
logger.debug("Loading pcs as json from: %s", fn)
else:
pcs_str = fp.readlines()
try:
parsed_scen_args["cs"] = pcs.read(pcs_str)
except:
logger.debug("Could not parse pcs file with old format; trying new format ...")
parsed_scen_args["cs"] = pcs_new.read(pcs_str)
parsed_scen_args["cs"].seed(42)
else:
parser.exit(1, "Could not find pcs file: {}".format(fn))
setattr(namespace, self.dest, values)
def test_local_search_2(self):
pcs_file = os.path.join(self.test_files_dir, "test_local_search.pcs")
seed = np.random.randint(1, 100000)
with open(pcs_file) as fh:
config_space = pcs.read(fh.readlines())
config_space.seed(seed)
def acquisition_function(point):
return np.count_nonzero(np.array(point))
start_point = config_space.get_default_configuration()
l = LocalSearch(acquisition_function,
config_space,
epsilon=0.01,
max_iterations=100000)
incumbent, acq_val_incumbent = l.maximize(start_point)
self.assertEqual(acq_val_incumbent, len(start_point.get_array()))
self.assertTrue(
np.all(incumbent.get_array() == np.ones([acq_val_incumbent])))
def _transform_arguments(self):
"""TODO"""
self.n_features = len(self.feature_dict)
self.feature_array = None
if self.overall_obj[:3] in ["PAR", "par"]:
par_str = self.overall_obj[3:]
elif self.overall_obj[:4] in ["mean", "MEAN"]:
par_str = self.overall_obj[4:]
# Check for par-value as in "par10"/ "mean5"
if len(par_str) > 0:
self.par_factor = int(par_str)
else:
self.logger.debug("No par-factor detected. Using 1 by default.")
self.par_factor = 1
# read instance files
if self.train_inst_fn:
if os.path.isfile(self.train_inst_fn):
self.train_insts = self.in_reader.read_instance_file(
self.train_inst_fn)
else:
self.logger.error("Have not found instance file: %s" %
(self.train_inst_fn))
sys.exit(1)
if self.test_inst_fn:
if os.path.isfile(self.test_inst_fn):
self.test_insts = self.in_reader.read_instance_file(
self.test_inst_fn)
else:
self.logger.error("Have not found test instance file: %s" %
(self.test_inst_fn))
sys.exit(1)
self.instance_specific = {}
def extract_instance_specific(instance_list):
insts = []
for inst in instance_list:
if len(inst) > 1:
self.instance_specific[inst[0]] = " ".join(inst[1:])
insts.append(inst[0])
return insts
self.train_insts = extract_instance_specific(self.train_insts)
if self.test_insts:
self.test_insts = extract_instance_specific(self.test_insts)
self.train_insts = self._to_str_and_warn(l=self.train_insts)
self.test_insts = self._to_str_and_warn(l=self.test_insts)
# read feature file
if self.feature_fn:
if os.path.isfile(self.feature_fn):
self.feature_dict = self.in_reader.read_instance_features_file(
self.feature_fn)[1]
if self.feature_dict:
self.feature_array = []
for inst_ in self.train_insts:
self.feature_array.append(self.feature_dict[inst_])
self.feature_array = numpy.array(self.feature_array)
self.n_features = self.feature_array.shape[1]
# read pcs file
if self.pcs_fn and os.path.isfile(self.pcs_fn):
with open(self.pcs_fn) as fp:
pcs_str = fp.readlines()
try:
self.cs = pcs.read(pcs_str)
except:
self.logger.debug(
"Could not parse pcs file with old format; trying new format next"
)
self.cs = pcs_new.read(pcs_str)
self.cs.seed(42)
elif self.pcs_fn:
self.logger.error("Have not found pcs file: %s" % (self.pcs_fn))
sys.exit(1)
# you cannot set output dir to None directly
# because None is replaced by default always
if self.output_dir == "":
self.output_dir = None
self.logger.debug("Deactivate output directory.")
else:
self.logger.info("Output to %s" % (self.output_dir))
if self.shared_model and self.input_psmac_dirs is None:
# per default, we assume that
# all psmac runs write to the same directory
self.input_psmac_dirs = [self.output_dir]
def _transform_arguments(self):
self.n_features = len(self.feature_dict)
self.feature_array = None
if self.overall_obj[:3] in ["PAR", "par"]:
self.par_factor = int(self.overall_obj[3:])
elif self.overall_obj[:4] in ["mean", "MEAN"]:
self.par_factor = int(self.overall_obj[4:])
else:
self.par_factor = 1
# read instance files
if self.train_inst_fn:
if os.path.isfile(self.train_inst_fn):
self.train_insts = self.in_reader.read_instance_file(
self.train_inst_fn)
else:
self.logger.error("Have not found instance file: %s" %
(self.train_inst_fn))
sys.exit(1)
if self.test_inst_fn:
if os.path.isfile(self.test_inst_fn):
self.test_insts = self.in_reader.read_instance_file(
self.test_inst_fn)
else:
self.logger.error("Have not found test instance file: %s" %
(self.test_inst_fn))
sys.exit(1)
self.instance_specific = {}
def extract_instance_specific(instance_list):
insts = []
for inst in instance_list:
if len(inst) > 1:
self.instance_specific[inst[0]] = " ".join(inst[1:])
insts.append(inst[0])
return insts
self.train_insts = extract_instance_specific(self.train_insts)
if self.test_insts:
self.test_insts = extract_instance_specific(self.test_insts)
# read feature file
if self.feature_fn:
if os.path.isfile(self.feature_fn):
self.feature_dict = self.in_reader.read_instance_features_file(
self.feature_fn)[1]
if self.feature_dict:
self.n_features = len(self.feature_dict[list(
self.feature_dict.keys())[0]])
self.feature_array = []
for inst_ in self.train_insts:
self.feature_array.append(self.feature_dict[inst_])
self.feature_array = numpy.array(self.feature_array)
# read pcs file
if self.pcs_fn and os.path.isfile(self.pcs_fn):
with open(self.pcs_fn) as fp:
pcs_str = fp.readlines()
self.cs = pcs.read(pcs_str)
self.cs.seed(42)
elif self.pcs_fn:
self.logger.error("Have not found pcs file: %s" % (self.pcs_fn))
sys.exit(1)
self.logger.info("Output to %s" % (self.output_dir))
