def testExperimentTagTruncation(self):
ray.init(num_cpus=2)
def train(config, reporter):
reporter(timesteps_total=1)
trial_executor = RayTrialExecutor()
register_trainable("f1", train)
experiments = {
"foo": {
"run": "f1",
"config": {
"a" * 50: tune.sample_from(lambda spec: 5.0 / 7),
"b" * 50: tune.sample_from(lambda spec: "long" * 40),
},
}
}
for name, spec in experiments.items():
trial_generator = BasicVariantGenerator()
trial_generator.add_configurations({name: spec})
while not trial_generator.is_finished():
trial = trial_generator.next_trial()
if not trial:
break
trial_executor.start_trial(trial)
self.assertLessEqual(len(os.path.basename(trial.logdir)), 200)
trial_executor.stop_trial(trial)
def generate_trials(spec, name):
suggester = BasicVariantGenerator()
suggester.add_configurations({name: spec})
trials = []
while not suggester.is_finished():
trial = suggester.next_trial()
if trial:
trials.append(trial)
else:
break
return trials
def _add_trials(self, name, spec):
"""Add trial by invoking TrialRunner."""
resource = {}
resource["trials"] = []
trial_generator = BasicVariantGenerator()
trial_generator.add_configurations({name: spec})
while not trial_generator.is_finished():
trial = trial_generator.next_trial()
if not trial:
break
runner.add_trial(trial)
resource["trials"].append(self._trial_info(trial))
return resource
def testBasicVariantLimiter(self):
search_alg = BasicVariantGenerator(max_concurrent=2)
experiment_spec = {
"run": "__fake",
"num_samples": 5,
"stop": {
"training_iteration": 1
},
}
search_alg.add_configurations({"test": experiment_spec})
trial1 = search_alg.next_trial()
self.assertTrue(trial1)
trial2 = search_alg.next_trial()
self.assertTrue(trial2)
# Returns None because of limiting
trial3 = search_alg.next_trial()
self.assertFalse(trial3)
# Finish trial, now trial 3 should be created
search_alg.on_trial_complete(trial1.trial_id, None, False)
trial3 = search_alg.next_trial()
self.assertTrue(trial3)
trial4 = search_alg.next_trial()
self.assertFalse(trial4)
search_alg.on_trial_complete(trial2.trial_id, None, False)
search_alg.on_trial_complete(trial3.trial_id, None, False)
trial4 = search_alg.next_trial()
self.assertTrue(trial4)
trial5 = search_alg.next_trial()
self.assertTrue(trial5)
search_alg.on_trial_complete(trial4.trial_id, None, False)
# Should also be None because search is finished
trial6 = search_alg.next_trial()
self.assertFalse(trial6)
def testQueueFilling(self):
os.environ["TUNE_MAX_PENDING_TRIALS_PG"] = "1"
ray.init(num_cpus=4)
def f1(config):
for i in range(10):
yield i
tune.register_trainable("f1", f1)
search_alg = BasicVariantGenerator()
search_alg.add_configurations(
{
"foo": {
"run": "f1",
"num_samples": 100,
"config": {
"a": tune.sample_from(lambda spec: 5.0 / 7),
"b": tune.sample_from(lambda spec: "long" * 40),
},
"resources_per_trial": {"cpu": 2},
}
}
)
runner = TrialRunner(search_alg=search_alg)
runner.step()
runner.step()
runner.step()
self.assertEqual(len(runner._trials), 3)
runner.step()
self.assertEqual(len(runner._trials), 3)
self.assertEqual(runner._trials[0].status, Trial.RUNNING)
self.assertEqual(runner._trials[1].status, Trial.RUNNING)
self.assertEqual(runner._trials[2].status, Trial.PENDING)