def run_context(self):
run = RunContext(
mock.Mock(), mock.Mock(assignments={
"fixed1": 0,
"fixed2": "test"
}))
run.to_json = mock.Mock(return_value={"run": {}})
run._end = mock.Mock()
run._log_source_code = mock.Mock()
return run
def make_run_context(self):
run_context = RunContext(
connection=mock.Mock(),
run=mock.Mock(assignments={
"fixed1": 0,
"fixed2": "test"
}),
)
run_context._update_run = mock.Mock()
return run_context
def create_run_state(sigopt_settings, pod, k8s_settings):
run_id = pod.metadata.labels["run"]
sigopt_conn = sigopt_settings.conn
run = sigopt_conn.training_runs(run_id).fetch()
run_context = RunContext(sigopt_conn, run)
return RunState(run_context, sigopt_settings, k8s_settings,
pod.metadata.name)
def create_from_pod(cls, sigopt_settings, k8s_settings, pod):
run_id = pod.metadata.labels["run"]
sigopt_conn = sigopt_settings.conn
run = sigopt_conn.training_runs(run_id).fetch()
run_context = RunContext(sigopt_conn, run)
return cls(run_context, sigopt_settings, k8s_settings,
pod.metadata.name)
def test_run_options_run_and_name_keys(self):
run_options = {
'name': 'test-run',
'run': Mock(),
}
with pytest.raises(ValueError):
parse_run_options(run_options)
run_options = {
'name': None,
'run': None,
}
assert parse_run_options(run_options)
run_options = {
'name': "",
'run': None,
}
assert parse_run_options(run_options)
run_options = {
'name': "",
'run': RunContext(Mock(), Mock(assignments={'a': 1})),
}
assert parse_run_options(run_options)
def test_run_options_run_context_object(self):
run_options = {'run': TrainingRun(Mock())}
with pytest.raises(TypeError):
parse_run_options(run_options)
run_options = {
'run': RunContext(Mock(), Mock(assignments={'a': 1})),
}
assert parse_run_options(run_options)
def start(self):
sigterm_event = threading.Event()
set_events_on_sigterm([sigterm_event, self.stop_event])
try:
pod = self.k8s_settings.api.read_namespaced_pod(
self.run_name, self.k8s_settings.namespace)
self.logger.info("found existing pod %s", self.run_name)
run_state = create_run_state(self.sigopt_settings, pod,
self.k8s_settings)
except KubernetesApiException as kae:
if kae.status != HTTPStatus.NOT_FOUND:
raise
sigopt_conn = self.sigopt_settings.conn
run = sigopt_conn.training_runs(self.run_id).fetch()
run_context = RunContext(sigopt_conn, run)
run_state = RunState(run_context, self.sigopt_settings,
self.k8s_settings, self.run_name)
pod = create_run_pod(
k8s_settings=self.k8s_settings,
run_context=run_context,
)
self.logger.info("created pod %s", pod.metadata.name)
self.run_states.update({self.run_name: run_state})
self.watcher_thread.start()
try:
while not self.stop_event.is_set() and not run_state.is_finished():
try:
self.stop_event.wait(timeout=1)
except TimeoutError:
pass
except KeyboardInterrupt:
pass
self.stop_event.set()
self.watcher_thread.join()
if self.watcher_thread.exception_occurred.is_set():
raise Exception("An exception occurred in the watcher thread")
if sigterm_event.is_set():
raise Exception("Sigterm received")
import numpy as np
import sys
def rand_str(n, chars=string.ascii_letters + string.digits):
chars = np.array(list(chars))
idx = np.random.choice(len(chars), n)
return ''.join(chars[idx])
def generate_feature_importances(num_feature=50, max_feature_len=100, score_type='exp'):
lens = np.random.choice(np.arange(1, max_feature_len + 1), num_feature)
features = [rand_str(n) for n in lens]
scores = np.random.uniform(size=num_feature)
if score_type == 'exp':
scores = np.exp((scores - 0.5) * 10)
return {
'type': 'weight',
'scores': dict(zip(features, scores))
}
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--run', default=19, help='run id')
parser.add_argument('--score_type', default='exp', help='score type')
parser.add_argument('--num_feature', default=50, help='number of defauts')
parser.add_argument('--max_feature_length', default=100, help='max feature name length')
args = parser.parse_args()
fp = generate_feature_importances(args.num_feature, args.max_feature_length, args.score_type)
context = RunContext(connection=get_connection(), run=sigopt.get_run(args.run))
context.log_sys_metadata('feature_importances', fp)