def test_str(self): """ Tests whether stringify works. """ params = {"x": 1, "name": "B"} cand1 = Candidate(params) cand1.cost = 2 str(cand1)
def test_to_csv_entry(self): """ Tests the correctness of the csv entry generation """ params = {"x": 1, "name": "B"} cand1 = Candidate(params) entry = cand1.to_csv_entry() assert_equal(entry, "B,1,None,None")
def test_init(self): """ Tests the initialization. - Raising ValueError when no dict is given - Parameter correctness - worker_information correctness """ params = {"x": 1, "name": "B"} worker_info = "test_worker_info." cand1 = Candidate(params, worker_information=worker_info) assert_dict_equal(cand1.params, params) assert_equal(cand1.worker_information, worker_info) with assert_raises(ValueError): Candidate(False)
def test_add(self): name = "test_experiment" param_def = { "x": MinMaxNumericParamDef(0, 1), "name": NominalParamDef(["A", "B", "C"]) } minimization = True exp = Experiment(name, param_def, minimization) cand = Candidate({"x": 1, "name": "A"}) cand_invalid = Candidate({"x": 1}) cand_invalid2 = Candidate({"x": 2, "name": "A"}) with assert_raises(ValueError): exp.add_pending(cand_invalid) with assert_raises(ValueError): exp.add_pending(cand_invalid2) exp.add_pending(cand) assert cand in exp.candidates_pending with assert_raises(ValueError): exp.add_pending(False) exp.add_finished(cand) assert cand in exp.candidates_finished with assert_raises(ValueError): exp.add_finished(False) cand2 = Candidate({"x": 0, "name": "B"}) exp.add_working(cand2) assert cand2 in exp.candidates_working with assert_raises(ValueError): exp.add_working(False) exp.add_pausing(cand2) assert cand2 in exp.candidates_pending with assert_raises(ValueError): exp.add_pausing(False) exp.add_working(cand2) assert cand2 in exp.candidates_working with assert_raises(ValueError): exp.add_working(False) exp.add_finished(cand2) assert cand2 in exp.candidates_finished with assert_raises(ValueError): exp.add_finished(False)
def get_next_candidates(self, num_candidates=1): self._logger.debug("Returning next %s candidates", num_candidates) if len(self._experiment.candidates_finished ) < self.initial_random_runs: # we do a random search. random_candidates = self.random_searcher.get_next_candidates( num_candidates) self._logger.debug("Still in the random run phase. Returning %s", random_candidates) return random_candidates candidates = [] if self.gp is None: self._logger.debug("No gp available. Updating with %s", self._experiment) self.update(self._experiment) new_candidate_points = self.acquisition_function.compute_proposals( self.gp, self._experiment, number_proposals=num_candidates, return_max=self.return_max) self._logger.debug("Generated new candidate points. Are %s", new_candidate_points) self.return_max = False for point_and_value in new_candidate_points: # get the the candidate point which is the first entry in the tuple. point_candidate = Candidate( self._experiment.warp_pt_out(point_and_value[0])) candidates.append(point_candidate) self._logger.debug("Candidates extracted. Returning %s", candidates) return candidates
def test_dict(self): """ Tests the to-dict and from-dict methods. :return: """ params = {"x": 1, "name": "B"} cand1 = Candidate(params) entry = cand1.to_dict() d = {} d["params"] = params d["result"] = None d["cost"] = None d["worker_information"] = None assert_dict_equal(entry, d) cand2 = from_dict(entry) assert_equal(cand1, cand2)
def test_better_cand(self): name = "test_experiment" param_def = { "x": MinMaxNumericParamDef(0, 1), "name": NominalParamDef(["A", "B", "C"]) } minimization = True exp = Experiment(name, param_def, minimization) cand = Candidate({"x": 1, "name": "B"}) cand2 = Candidate({"x": 0, "name": "A"}) cand_none = Candidate({"x": 0.5, "name": "C"}) cand.result = 1 cand2.result = 0 assert_true(exp.better_cand(cand2, cand)) assert_true(exp.better_cand(cand2, cand_none)) exp.minimization_problem = False assert_true(exp.better_cand(cand, cand2)) assert_false(exp.better_cand(cand2, cand))
def test_add(self): cand = Candidate({"x": 1, "name": "A"}) cand_invalid = Candidate({"x": 1}) cand_invalid2 = Candidate({"x": 2, "name": "A"}) with assert_raises(ValueError): self.exp.add_pending(cand_invalid) with assert_raises(ValueError): self.exp.add_pending(cand_invalid2) self.exp.add_pending(cand) assert cand in self.exp.candidates_pending with assert_raises(ValueError): self.exp.add_pending(False) self.exp.add_finished(cand) assert cand in self.exp.candidates_finished with assert_raises(ValueError): self.exp.add_finished(False) cand2 = Candidate({"x": 0, "name": "B"}) self.exp.add_working(cand2) assert cand2 in self.exp.candidates_working with assert_raises(ValueError): self.exp.add_working(False) self.exp.add_pausing(cand2) assert cand2 in self.exp.candidates_pending with assert_raises(ValueError): self.exp.add_pausing(False) self.exp.add_working(cand2) assert cand2 in self.exp.candidates_working with assert_raises(ValueError): self.exp.add_working(False) self.exp.add_finished(cand2) assert cand2 in self.exp.candidates_finished with assert_raises(ValueError): self.exp.add_finished(False)
def test_warp(self): name = "test_experiment" param_def = { "x": MinMaxNumericParamDef(0, 1), "name": NominalParamDef(["A", "B", "C"]) } minimization = True exp = Experiment(name, param_def, minimization) cand = Candidate({"x": 1}) cand_out = exp.warp_pt_out(exp.warp_pt_in(cand.params)) assert_dict_equal(cand.params, cand_out)
def test_dict(self): """ Tests the to-dict and from-dict methods. """ params = {"x": 1, "name": "B"} cand1 = Candidate(params) entry = cand1.to_dict() d = { "params": params, "result": None, "cost": None, "last_update_time": cand1.last_update_time, "worker_information": None, "failed": False, "generated_time": cand1.generated_time, "cand_id": cand1.cand_id } assert_dict_equal(entry, d) cand2 = from_dict(entry) assert_equal(cand1, cand2)
def test_better_cand(self): cand = Candidate({"x": 1, "name": "B"}) cand2 = Candidate({"x": 0, "name": "A"}) cand_none = Candidate({"x": 0.5, "name": "C"}) cand_invalid = Candidate({"x": 0.5, "name": "D"}) cand.result = 1 cand2.result = 0 assert_true(self.exp.better_cand(cand2, cand)) assert_true(self.exp.better_cand(cand2, cand_none)) self.exp.minimization_problem = False assert_true(self.exp.better_cand(cand, cand2)) assert_false(self.exp.better_cand(cand2, cand)) assert_true(self.exp.better_cand(cand, None)) assert_false(self.exp.better_cand(None, cand)) assert_false(self.exp.better_cand(None, None)) with assert_raises(ValueError): self.exp.better_cand(cand, cand_invalid) with assert_raises(ValueError): self.exp.better_cand(cand_invalid, cand) with assert_raises(ValueError): self.exp.better_cand("fails", cand) with assert_raises(ValueError): self.exp.better_cand(cand, "fails")
def test_csv(self): name = "test_experiment" param_def = { "x": MinMaxNumericParamDef(0, 1), "name": NominalParamDef(["A", "B", "C"]) } minimization = True exp = Experiment(name, param_def, minimization) cand = Candidate({"x": 1, "name": "A"}) exp.add_finished(cand) string, steps_incl = exp.to_csv_results() assert_equal(steps_incl, 1) assert_equal( string, "step,name,x,cost,result,best_result\n1,A,1,None,None,None\n")
def get_next_candidates(self, experiment, num_candidates=None): if num_candidates is None: num_candidates = self.num_precomputed #check whether a random search is necessary. if len(experiment.candidates_finished) < self.initial_random_runs: return self.random_searcher.get_next_candidates( experiment, num_candidates) self._refit(experiment) #TODO refitted must be set, too. candidates = [] new_candidate_points = self.acquisition_function.compute_proposals( self.gp, experiment, number_proposals=num_candidates) for point_and_value in new_candidate_points: #get the the candidate point which is the first entry in the tuple. point_candidate = Candidate( experiment.warp_pt_out(point_and_value[0])) candidates.append(point_candidate) return candidates
def _gen_one_candidate(self): """ Generates a single candidate. This is done by generating parameter values for each of the available parameters. Returns ------- candidate : Candidate The generated candidate """ self._logger.debug("Generating single candidate.") self.random_state = check_random_state(self.random_state) value_dict = {} for key, param_def in self._experiment.parameter_definitions.iteritems( ): value_dict[key] = self._gen_param_val(param_def) generated_candidate = Candidate(value_dict) self._logger.debug("Generated candidate: %s", generated_candidate) return generated_candidate
def test_eq(self): """ Tests the equiality. - Equal works - Equal with a non-Candidate works """ params = {"x": 1, "name": "B"} params2 = {"x": 2, "name": "B"} cand1 = Candidate(params) cand2 = Candidate(params) assert_equal(cand1, cand2) cand3 = Candidate(params2) assert_false(cand1.__eq__(cand3)) assert_false(cand1.__eq__(False))
def _get_one_candidate(self, experiment): self.random_state = check_random_state(self.random_state) value_dict = {} for key, param_def in experiment.parameter_definitions.iteritems(): value_dict[key] = self._gen_param_val(param_def) return Candidate(value_dict)
def test_warp(self): cand = Candidate({"x": 1}) cand_out = self.exp.warp_pt_out(self.exp.warp_pt_in(cand.params)) assert_dict_equal(cand.params, cand_out)
def test_to_dict(self): cand = Candidate({"x": 1, "name": "A"}) self.exp.add_finished(cand) self.exp.to_dict()