def get_tuning_driver(self):
from ctree.opentuner.driver import OpenTunerDriver
from opentuner.search.manipulator import ConfigurationManipulator
from opentuner.search.manipulator import FloatParameter
from opentuner.search.objective import MinimizeTime
manip = ConfigurationManipulator()
manip.add_parameter(FloatParameter("x", -100.0, 100.0))
manip.add_parameter(FloatParameter("y", -100.0, 100.0))
return OpenTunerDriver(manipulator=manip, objective=MinimizeTime())
def manipulator(self):
manipulator = ConfigurationManipulator()
for d in xrange(self.args.dimensions):
manipulator.add_parameter(FloatParameter(d,
-self.args.domain,
self.args.domain))
return manipulator
def solve(self, job):
logging.debug('Starting opentuner')
failed_jobs_threshold = self.jobs_limit * _FAILED_JOBS_COEF
manipulator = ConfigurationManipulator()
for var in job.optimization_job.task_variables:
if var.HasField('continuous_variable'):
cont_var = var.continuous_variable
param = FloatParameter(var.name, cont_var.l, cont_var.r)
else:
int_var = var.integer_variable
param = IntegerParameter(var.name, int_var.l, int_var.r)
manipulator.add_parameter(param)
parser = argparse.ArgumentParser(parents=opentuner.argparsers())
args = parser.parse_args([])
args.parallelism = 4
args.no_dups = True
interface = DefaultMeasurementInterface(args=args,
manipulator=manipulator,
project_name=job.job_id)
api = TuningRunManager(interface, args)
jobs = []
current_value = None
failed_jobs = 0
while failed_jobs < failed_jobs_threshold and not self._check_for_termination(
job):
remaining_jobs = []
for job_id, desired_result in jobs:
res = self._get_evaluation_job_result(job_id)
if res is not None:
if current_value is None or current_value > res + _THRESHOLD_EPS:
failed_jobs = 0
else:
failed_jobs += 1
result = Result(time=res)
api.report_result(desired_result, result)
else:
remaining_jobs.append((job_id, desired_result))
jobs = remaining_jobs
while len(jobs) < self.jobs_limit:
desired_result = api.get_next_desired_result()
if desired_result is None:
break
job_id = self._start_evaluation_job(
job, desired_result.configuration.data)
if job_id is None:
api.report_result(desired_result, Result(time=math.inf))
else:
jobs.append((job_id, desired_result))
if not jobs:
break
r = api.get_best_result()
if r is not None:
current_value = r.time
logging.debug('Opentuner current state: %s %s', r.time,
api.get_best_configuration())
time.sleep(5)
res = api.get_best_result().time
vars = api.get_best_configuration()
api.finish()
return res, vars
def build_manipulator(api_config):
"""Build a ConfigurationManipulator object to be used by opentuner.
Parameters
----------
api_config : dict-like of dict-like
Configuration of the optimization variables. See API description.
Returns
-------
manipulator : ConfigurationManipulator
Some over complexified class required by opentuner to run.
"""
manipulator = ConfigurationManipulator()
for pname in api_config:
ptype = api_config[pname]["type"]
pspace = api_config[pname].get("space", None)
pmin, pmax = api_config[pname].get("range", (None, None))
if ptype == "real":
if pspace in ("linear", "logit"):
ot_param = FloatParameter(pname, pmin, pmax)
elif pspace in ("log", "bilog"):
LogFloatParameter_ = ClippedParam(LogFloatParameter)
ot_param = LogFloatParameter_(pname, pmin, pmax)
else:
assert False, "unsupported param space = %s" % pspace
elif ptype == "int":
if pspace in ("linear", "logit"):
ot_param = IntegerParameter(pname, pmin, pmax)
elif pspace in ("log", "bilog"):
ot_param = LogIntegerParameter(pname, pmin, pmax)
else:
assert False, "unsupported param space = %s" % pspace
elif ptype == "bool":
# The actual bool parameter seems not to work in Py3 :(
ot_param = IntegerParameter(pname, 0, 1)
elif ptype in ("cat", "ordinal"):
# Treat ordinal and categorical variables the same for now.
assert "values" in api_config[pname]
pvalues = api_config[pname]["values"]
ot_param = EnumParameter(pname, pvalues)
else:
assert False, "type=%s/space=%s not handled in opentuner yet" % (
ptype, pspace)
manipulator.add_parameter(ot_param)
return manipulator
def manipulator(self):
'''
Define the search space by creating a ConfigurationManipulator
'''
manipulator = ConfigurationManipulator()
if self.args.window is None:
manipulator.add_parameter(IntegerParameter('window', 1000, 5000))
if self.args.interval is None:
manipulator.add_parameter(IntegerParameter('interval', 2000, 10000))
if self.args.sketch_size is None:
manipulator.add_parameter(IntegerParameter('sketch-size', 1000, 5000))
if self.args.k_hops is None:
manipulator.add_parameter(IntegerParameter('k-hops', 1, 5))
if self.args.chunk_size is None:
manipulator.add_parameter(IntegerParameter('chunk-size', 5, 20))
if self.args.lambda_param is None:
manipulator.add_parameter(FloatParameter('lambda-param', 0.0, 1.0))
# manipulator.add_parameter(EnumParameter('threshold-metric', ['mean', 'max']))
# manipulator.add_parameter(FloatParameter('num-stds', 3.5, 6.0))
return manipulator
def float(self, name, min_value, max_value):
if self.first(name):
self.manipulator.add_parameter(
FloatParameter(name, min_value, max_value))
return min_value