def test_get_parsing_results(self): self.initialise_segment_table("abnese_lengthening_segment_table.txt") configurations["MORPHEME_BOUNDARY_FLAG"] = True configurations["LENGTHENING_FLAG"] = True configurations["HMM_ENCODING_LENGTH_MULTIPLIER"] = 100 configurations["DATA_ENCODING_LENGTH_MULTIPLIER"] = 20 hmm = HMM({ 'q0': ['q1'], 'q1': (['qf'], ['aabb', 'abb', 'bbaabb', 'aba', 'aaba', 'bbaa']) }) rule1 = Rule([], [{ "long": "+" }], [], [{}, { "bound": "+" }], obligatory=True) rule2 = Rule([], [{ "syll": "+" }], [{ "cons": "+" }], [{ "cons": "+" }], obligatory=True) rule_set = RuleSet([rule1, rule2]) grammar = Grammar(hmm, rule_set) data = [ u'baba:a', u'babaab:ab', u'ab:a', u'aab:a', u'aab:ab', u'ab:ab' ] hypothesis = Hypothesis(grammar, data) simulated_annealing = SimulatedAnnealing(hypothesis, 0) print(simulated_annealing._get_parsing_results())
class TestSimulatedAnnealing(unittest.TestCase): def setUp(self): self.flow = [ [0, 1, 2], [4, 0, 5], [7, 2, 0]] self.distance = [ [0, 5, 2], [1, 0, 1], [6, 2, 0]] self.i = Instance(None, self.distance, self.flow) self.sa = SimulatedAnnealing() self.startpoint = Solution((0, 1, 2)) def test_solve_with_startpoint(self): expected = (2, 1, 0) actual = self.sa.solve(self.i, self.startpoint).sequence self.assertEqual(expected, actual) def test_guess_temperature(self): expected = 255.0 actual = self.sa._guess_temp(None, prob=0.98, df=1000) self.assertAlmostEqual(expected, actual, -1) def test_guess_temperature_for_given_instance(self): expected = 3.5 actual = self.sa._guess_temp(self.i, prob=0.95) self.assertAlmostEqual(expected, actual, 0)
def main(): try: n = int(sys.argv[1]) # Run Single File except ValueError: g = GraphInterface.fromFile(sys.argv[1]) a = SimulatedAnnealing(g) start = datetime.now() paths, costs = a.run(max_iterations=100) cost = costs[-1] end = datetime.now() print(f"File: {sys.argv[1]}.\nTime (s): {(end - start).total_seconds()}. \nCost: {int_just(cost,5)} \nSolution: {paths}.") else: # Run all files for all problems <= argv[1] if len(sys.argv) >= 3 and sys.argv[2] == "all": results = [] for i in range(1, n + 1): a, b = run_problem_size(i, print_individual=False) results.append((a, b)) for t, i in zip(results, range(1, n + 1)): print( f"Cities: {int_just(i, 3)}Average time: {int_just(t[0], 6)} Average Cost (s): {int_just( t[1], 12)}") # Run all files for problems of size argv[1] else: a, b = run_problem_size(n) print( f"\nFor {n} cities. \nAverage Time: {a} \nAverage Cost: {b}.")
def test_simulate_annealing(self): sa_parameter = { "cycles": 100, "trails": 10, "P_start": 0.7, "P_end": 0.001 } parameter = json.dumps(sa_parameter) self.simulated_annealing = SimulatedAnnealing( self.dataset, self.combinations_df, self.normal_profile_selection, parameter) self.simulated_annealing.start() best_costs = self.simulated_annealing.best_results_list best_scrap_list = [] for profile_dict in best_costs: scrap_sum = 0 for uuid, raw_profile in profile_dict.items(): scrap_sum += raw_profile.scrap best_scrap_list.append(scrap_sum) plt.plot(best_scrap_list) plt.show()
def load_modules_and_run(feature_table_file_path, corpus_file_path, constraint_set_file_path, configuration_files_dir_path): #TODO finish the loading from file #file, path, desc = imp.find_module("bb", [configuration_files_dir_path]) # #module = imp.load_module("bb", file, path, desc) #print(type(module)) #print(dir(module)) #module.print_() #importing in here because it is after OtmlConfigurationManager initialization from grammar.lexicon import Lexicon from grammar.feature_table import FeatureTable from grammar.constraint_set import ConstraintSet from grammar.grammar import Grammar from traversable_grammar_hypothesis import TraversableGrammarHypothesis from corpus import Corpus from simulated_annealing import SimulatedAnnealing feature_table = FeatureTable.load(feature_table_file_path) corpus = Corpus.load(corpus_file_path) constraint_set = ConstraintSet.load(constraint_set_file_path, feature_table) lexicon = Lexicon(corpus.get_words(), feature_table) grammar = Grammar(feature_table, constraint_set, lexicon) data = corpus.get_words() traversable_hypothesis = TraversableGrammarHypothesis(grammar, data) simulated_annealing = SimulatedAnnealing(traversable_hypothesis) simulated_annealing.run()
def findRoutes(): start_time = time() body = None body = request.get_json(force=True) temp = request.args.get('use_heuristic') flag = False if temp != "false": flag = True print(body) lista = list(body) if len(lista) < 2: return [] destinations = None destinations = RouteController() for i in lista: destinations.add_cord(Coordinate(i['lat'], i['lng'], 'A')) #TODO sa = None sa = SimulatedAnnealing(destinations, initial_temperature=1000, cooling_rate=0.0015, use_heuristic=flag) sa.run() response = [] for i in sa.best: response.append({'lat': i.lat, 'lng': i.long}) elapsed_time = time() - start_time print("Elapsed time: %0.10f seconds." % elapsed_time) return jsonify(response)
def run(self, path, DEBUG=False): painter = Painter(path, DEBUG=DEBUG) simulated_annealing = SimulatedAnnealing(self.coordinates, max_interations=5000000, alpha=0.9995, min_temperature=0.00000001) solution, costs = simulated_annealing.execute() painter.plot_path(solution, self.coordinates) painter.plot_costs(costs) print("Best solution: {}".format(solution)) print("Costs: {}".format(costs))
def run_simulation(configurations_tuples, simulation_number, log_file_template, feature_table_file_name, corpus_file_name, constraint_set_file_name, sample_target_lexicon=None, sample_target_outputs=None, target_lexicon_indicator_function=None, target_constraint_set_file_name=None, target_lexicon_file_name=None, convert_corpus_word_to_target_word_function=None, initial_lexicon_file_name=None): for configurations_tuple in configurations_tuples: configurations[configurations_tuple[0]] = configurations_tuple[1] log_file_name = log_file_template.format(platform.node(), simulation_number) dirname, filename = split(abspath(__file__)) log_file_path = join(dirname, "../logging/", log_file_name) # if os.path.exists(log_file_path): # raise ValueError("log name already exits") logger = logging.getLogger() logger.setLevel(logging.INFO) file_log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s %(message)s', "%Y-%m-%d %H:%M:%S") file_log_handler = logging.FileHandler(log_file_path, mode='w') file_log_handler.setFormatter(file_log_formatter) logger.addHandler(file_log_handler) feature_table = FeatureTable.load(get_feature_table_fixture(feature_table_file_name)) corpus = Corpus.load(get_corpus_fixture(corpus_file_name)) constraint_set = ConstraintSet.load(get_constraint_set_fixture(constraint_set_file_name), feature_table) if initial_lexicon_file_name: corpus_for_lexicon = Corpus.load(get_corpus_fixture(initial_lexicon_file_name)) lexicon = Lexicon(corpus_for_lexicon.get_words(), feature_table) else: lexicon = Lexicon(corpus.get_words(), feature_table) grammar = Grammar(feature_table, constraint_set, lexicon) data = corpus.get_words() traversable_hypothesis = TraversableGrammarHypothesis(grammar, data) keyargs_dict = {} if sample_target_lexicon and sample_target_outputs and target_lexicon_indicator_function: keyargs_dict["sample_target_lexicon"] = sample_target_lexicon keyargs_dict["sample_target_outputs"] = sample_target_outputs keyargs_dict["target_lexicon_indicator_function"] = target_lexicon_indicator_function if target_constraint_set_file_name and (target_lexicon_file_name or convert_corpus_word_to_target_word_function): target_energy = get_target_hypothesis_energy(feature_table, target_constraint_set_file_name, corpus, target_lexicon_file_name, convert_corpus_word_to_target_word_function) keyargs_dict["target_energy"] = target_energy simulated_annealing = SimulatedAnnealing(traversable_hypothesis, **keyargs_dict) simulated_annealing.run()
def main(): parser = argparse.ArgumentParser( description='Input TSP file and hyperparameters') parser.add_argument('--tsp_file', '-f', help='TSP file path') args = parser.parse_args() tsp_file = args.tsp_file processor = TSPProcessor(tsp_file) nodes = processor.euc2d_process() '''set the simulated annealing algorithm params''' temp = 10000 stopping_temp = 0.00000001 alpha = 0.999995 stopping_iter = 10000000 '''set the dimensions of the grid''' size_width = 200 size_height = 200 '''set the number of nodes''' population_size = 70 '''generate random list of nodes''' # nodes = NodeGenerator(size_width, size_height, population_size).generate() '''run simulated annealing algorithm with 2-opt''' sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter) sa.anneal() '''animate''' save_path = os.path.join( os.path.join(os.path.dirname(tsp_file), 'result_gif'), os.path.basename(tsp_file) + '.gif') sa.animateSolutions(save_path) '''show the improvement over time''' sa.plotLearning()
def main(): '''define some global variables''' results = [] '''set the simulated annealing algorithm parameter grid''' temp = 50000 stopping_temp = 0.000000001 alpha = .999 stopping_iter = 10000000 '''generate random list of nodes''' nodes = np.array([[20, 20], [60, 20], [100, 40], [120, 80], [160, 20], [200, 40], [180, 60], [180, 100], [140, 140], [200, 160], [180, 200], [140, 180], [100, 160], [80, 180], [60, 200], [20, 160], [40, 120], [100, 120], [60, 80], [20, 40]]) nodes = np.random.permutation(nodes) '''run simulated annealing algorithm with 2-opt''' sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter) start_time = time.time() sa.anneal() execution_time = time.time() - start_time '''general plots''' print('Min weight: ', sa.min_weight) print('Iterations: ', sa.iteration) print('Execution time: ', execution_time) '''animate''' sa.animateSolutions() '''show the improvement over time''' sa.plotLearning()
def main(): '''set the simulated annealing algorithm params''' temp = 1000 stopping_temp = 0.00000001 alpha = 0.9995 stopping_iter = 10000000 '''set the dimensions of the grid''' size_width = 200 size_height = 200 '''set the number of nodes''' population_size = 70 '''generate random list of nodes''' nodes = NodeGenerator(size_width, size_height, population_size).generate() '''run simulated annealing algorithm with 2-opt''' sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter) sa.anneal() '''animate''' sa.animateSolutions() '''show the improvement over time''' sa.plotLearning()
def main(): '''set the simulated annealing algorithm params''' temp = 1000 stopping_temp = 0.00000001 alpha = 0.9995 stopping_iter = 10000000 '''set the dimensions of the grid''' size_width = 50 size_height = 50 '''set the number of nodes''' population_size = 100 '''generate random list of nodes''' '''nodes = NodeGenerator(size_width, size_height, population_size).generate()''' f = open('data.txt') xs = [] ys = [] for data in f.readlines(): data = data.strip('\n') nums = data.split(" ") while '' in nums: nums.remove('') xs.append(int(nums[0])) ys.append(int(nums[1])) nodes = np.column_stack((xs, ys)) f.close() '''run simulated annealing algorithm with 2-opt''' sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter) sa.anneal() '''animate''' sa.animateSolutions() '''show the improvement over time''' sa.plotLearning()
def run_annealing(problem_path: str, temperature: float, iterations: int) -> List[ float]: """ Args: problem_path: temperature Returns: A list detailing the costs at each iteration. """ g = GraphInterface.fromFile(problem_path) a = SimulatedAnnealing(g, temperature=temperature) path, costs = a.run(max_iterations=iterations) return costs
def test_random_solution_generation(self): sa_parameter = { "cycles": 100, "trails": 50, "P_start": 0.7, "P_end": 0.001 } parameter = json.dumps(sa_parameter) self.simulated_annealing = SimulatedAnnealing(self.dataset, self.combinations_df, parameter) dict = self.simulated_annealing.get_random_solution( self.dataset, self.combinations_df, self.normal_profile_selection)
def __init__(self, all_cities_and_distances, chosen_scheduler=params.beta_scheduler, cooling_rate=params.cooling_rate, initial_temperature=params.initial_temperature, max_steps=params.max_steps, min_temp=params.min_temp): SimulatedAnnealing.__init__(self, chosen_scheduler=chosen_scheduler, cooling_rate=cooling_rate, initial_temperature=initial_temperature, max_steps=max_steps, min_temp=min_temp) self.init_state(all_cities_and_distances) self.distances = init_distance_matrix(all_cities_and_distances)
def run_simulated_annealing(initial_temperature, cooling_coefficient, minimal_temperature): print('Running Simulated Annealing...') print() sa = SimulatedAnnealing(states, initial_temperature, cooling_coefficient, minimal_temperature, inc_support, dec_support) sa.run() print('Found optimal route with value of ' + str(sa.best_solution.value) + '.') print( str(sa.best_solution.calculate_real_value()) + ' electoral votes were collected.') sa.best_solution.print() print()
def run_large_problem(temperature: float, iterations: int) -> None: """ Runs the simulated annealing on a 36 city problem. Args: temperature: An annealing constant to use in the model. iterations: The number of iterations to run through. """ g = GraphInterface.fromFile("problems/problem36") a = SimulatedAnnealing(g, temperature=temperature) start = datetime.now() path, costs = a.run(max_iterations=iterations) print(f"total seconds: {(datetime.now()-start).total_seconds()}") with open("big_problem_costs.csv", "w") as f: f.write(",".join([str(c) for c in costs])) print(f"Max cost was {max(costs)}| Min cost was {min(costs)}.")
def main(): cities = City.load_cities('./data/data50.txt') graph = Graph(cities) init_sol = graph.nearestNeighbourSolution() history = SimulatedAnnealing(graph, init_sol, 0.9998, 10, 0.0000001, 1000000).anneal() DynamicPlot().show(cities, history, graph)
def setUp(self): configurations["CONSTRAINT_SET_MUTATION_WEIGHTS"] = { "insert_constraint": 1, "remove_constraint": 1, "demote_constraint": 1, "insert_feature_bundle_phonotactic_constraint": 1, "remove_feature_bundle_phonotactic_constraint": 1, "augment_feature_bundle": 0} configurations["CONSTRAINT_INSERTION_WEIGHTS"] = { "Dep": 1, "Max": 1, "Ident": 0, "Phonotactic": 1} configurations["LEXICON_MUTATION_WEIGHTS"] = { "insert_segment": 1, "delete_segment": 1, "change_segment": 0} configurations["RANDOM_SEED"] = True #configurations["SEED"] = 84 configurations["INITIAL_TEMPERATURE"] = 100 configurations["COOLING_PARAMETER"] = 0.999985 configurations["INITIAL_NUMBER_OF_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 1 configurations["MIN_FEATURE_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 1 configurations["DATA_ENCODING_LENGTH_MULTIPLIER"] = 100 configurations["RESTRICTION_ON_ALPHABET"] = True configurations["MAX_FEATURE_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = float("INF") configurations["MAX_NUMBER_OF_CONSTRAINTS_IN_CONSTRAINT_SET"] = float("INF") configurations["DEBUG_LOGGING_INTERVAL"] = 50 configurations["LOG_FILE_NAME"] = "{}_d_lengthening_INF_INF_{}.txt".format(platform.node(), simulation_number) self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 1 self.feature_table = FeatureTable.load(get_feature_table_fixture("d_lengthening_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("d_lengthening_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def desired_lexicon_indicator_function(words): number_of_long_vowels = sum([word.count(":") for word in words]) return "number of long vowels: {}".format(number_of_long_vowels) def convert_corpus_word_to_target_word(word): return word.replace(':', '') target_energy = self.get_target_hypothesis_energy(self.feature_table, "d_lengthening_target_constraint_set.json", corpus, convert_corpus_word_to_target_word_function=convert_corpus_word_to_target_word) #391689 self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=desired_lexicon_indicator_function, sample_target_lexicon=["id", "ad"], sample_target_outputs=["i:d", "a:d"], target_energy=target_energy)
def compute_route(self): util = JobConfig() max_step = self.max_step max_util = self.num_mappers * self.num_reducers * self.bandwidth if self.build_paths(): # Executing simulated annealing for map-reduce routing simulated_annealing = SimulatedAnnealing(max_util, \ max_step, \ self.routing_init_state, \ self.routing_generate_neighbor, \ self.routing_compute_util) util = simulated_annealing.run() # print "util: ", util.get_util() return util
def simulatedAnnealingSolver(inputs, T=100, n_iter=10000, temp_update=.9): if inputs["rides"] < 100: n_iter = 300 temp_update = .9 elif inputs["rides"] < 1000: n_iter = 1000 temp_update = .95 else: n_iter = 5000 temp_update = .99 model = SimulatedAnnealing(inputs, T=T, n_iter=n_iter, temp_update=temp_update) model.fit() print("score ", model.cur_score) return model.solution
class TestOtmlWithAspirationAndLengtheningDemoteOnly(unittest.TestCase): def setUp(self): self.feature_table = FeatureTable.load(get_feature_table_fixture("aspiration_and_lengthening_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("aspiration_and_lengthening_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("aspiration_and_lengthening_demote_only_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def function(words): number_of_long_vowels = sum([word.count(":") for word in words]) number_of_aspirated_consonants = sum([word.count("h") for word in words]) combined_number = number_of_long_vowels + number_of_aspirated_consonants return "number of long vowels and aspirated consonants in lexicon: {} (long vowels = {}, " \ "aspirated consonants = {})".format(combined_number, number_of_long_vowels, number_of_aspirated_consonants) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=function, sample_target_lexicon= ["ad", "id", "ta", "ti"], sample_target_outputs= ["a:d", "i:d", "tha", "thi"]) run_test = True @unittest.skipUnless(run_test, "long running test skipped") def test_run(self): random.seed(1) configurations["CONSTRAINT_SET_MUTATION_WEIGHTS"] = { "insert_constraint": 0, "remove_constraint": 0, "demote_constraint": 1, "insert_feature_bundle_phonotactic_constraint": 0, "remove_feature_bundle_phonotactic_constraint": 0, "augment_feature_bundle": 0} configurations["CONSTRAINT_INSERTION_WEIGHTS"] = { "Dep": 1, "Max": 1, "Ident": 0, "Phonotactic": 1} configurations["LEXICON_MUTATION_WEIGHTS"] = { "insert_segment": 1, "delete_segment": 1, "change_segment": 0} configurations["COOLING_PARAMETER"] = 0.9995 configurations["INITIAL_NUMBER_OF_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 2 configurations["MAX_FEATURE_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 2 configurations["DATA_ENCODING_LENGTH_MULTIPLIER"] = 100 configurations["MAX_NUMBER_OF_CONSTRAINTS_IN_CONSTRAINT_SET"] = 12 configurations["RESTRICTION_ON_ALPHABET"] = True configurations["DEBUG_LOGGING_INTERVAL"] = 50 number_of_steps_performed, hypothesis = self.simulated_annealing.run()
class TestOtmlWithFrenchDeletion(unittest.TestCase): def setUp(self): self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 25 self.feature_table = FeatureTable.load(get_feature_table_fixture("french_deletion_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("french_deletion_corpus_for_with_restrictions.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("french_deletion_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(get_corpus_fixture("french_deletion_corpus_for_with_restrictions.txt"), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis) run_test = True @unittest.skipUnless(run_test, "long running test skipped") def test_run(self): configurations["CONSTRAINT_SET_MUTATION_WEIGHTS"] = { "insert_constraint": 0, "remove_constraint": 0, "demote_constraint": 1, "insert_feature_bundle_phonotactic_constraint": 0, "remove_feature_bundle_phonotactic_constraint": 0, "augment_feature_bundle": 0} configurations["LEXICON_MUTATION_WEIGHTS"]= { "insert_segment": 1, "delete_segment": 1, "change_segment": 0} configurations["DATA_ENCODING_LENGTH_MULTIPLIER"] = 1 configurations["INITIAL_TEMPERATURE"] = 100 configurations["COOLING_PARAMETER"] = 0.9999 configurations["RESTRICTION_ON_ALPHABET"] = True configurations["DEBUG_LOGGING_INTERVAL"] = 50 number_of_steps_performed, hypothesis = self.simulated_annealing.run() def _set_up_logging(self): unit_tests_log_file_name = log_file_name.format(platform.node(), simulation_number) #if os.path.exists(unit_tests_log_file_name): # raise ValueError("log name already exits") logger = logging.getLogger() logger.setLevel(logging.INFO) file_log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s %(message)s', "%Y-%m-%d %H:%M:%S") dirname, filename = split(abspath(__file__)) unit_tests_log_path = normpath(join(dirname, unit_tests_log_file_name)) file_log_handler = logging.FileHandler(unit_tests_log_path, mode='w') file_log_handler.setFormatter(file_log_formatter) logger.addHandler(file_log_handler)
def setUp(self): self.feature_table = FeatureTable.load(get_feature_table_fixture("a_b_and_cons_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("bb_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis)
def compute_route(self): util = JobConfig() if self.build_paths(): max_step = self.max_step max_util = self.cur_demand.get_net() # Executing simulated annealing for map-reduce routing simulated_annealing = SimulatedAnnealing(max_util, \ max_step, \ self.routing_init_state, \ self.routing_generate_neighbor, \ self.routing_compute_util, \ self.check_constraint) util = simulated_annealing.run() # print "util: ", util.get_util() return util
def execute_job(self, job): available_hosts = [h for h in self.graph.get_hosts() if h.is_free()] util = JobConfig() # There are enough nodes to run the job if len(available_hosts) > (self.num_mappers + self.num_reducers): max_util = self.num_mappers * self.num_reducers * self.bandwidth max_step = self.max_step # Executing simulated annealing for map-reduce placement simulated_annealing = SimulatedAnnealing(max_util, \ max_step, \ self.placement_init_state, \ self.placement_generate_neighbor, \ self.placement_compute_util) util = simulated_annealing.run() return util
def run_problem_size(n: int, print_individual: bool = True) -> List[ Tuple[float, float]]: """ Runs all problems for a single problem size. Args: n: The size of problems to consider """ times = [] nodes = [] for f in os.listdir(f"problems/{n}/"): g = GraphInterface.fromFile(f"problems/{n}/{f}") a = SimulatedAnnealing(g) start = datetime.now() path, costs = a.run(max_iterations=10000) cost = costs[-1] end = datetime.now() times.append((end - start).total_seconds()) nodes.append(cost) return ((sum(times)/ len(times)), (sum(nodes) / len(nodes)))
def setUp(self): self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 25 self.feature_table = FeatureTable.load(get_feature_table_fixture("french_deletion_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("french_deletion_corpus_for_with_restrictions.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("french_deletion_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(get_corpus_fixture("french_deletion_corpus_for_with_restrictions.txt"), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis)
def setUp(self): self.flow = [ [0, 1, 2], [4, 0, 5], [7, 2, 0]] self.distance = [ [0, 5, 2], [1, 0, 1], [6, 2, 0]] self.i = Instance(None, self.distance, self.flow) self.sa = SimulatedAnnealing() self.startpoint = Solution((0, 1, 2))
def test_simulated_annealing_runtime(self): import simulations.turkish_vowel_harmony as current_simulation configurations.load_configurations_from_dict( current_simulation.configurations_dict) self.initialise_segment_table('turkish_segment_table.txt') initial_hmm = None initial_rule_set = None initial_hypothesis = Hypothesis.create_initial_hypothesis( current_simulation.data, initial_hmm, initial_rule_set) target_tuple = current_simulation.target_tuple data = current_simulation.data target_rule_set = RuleSet.load_form_flat_list(target_tuple[1]) target_hypothesis = Hypothesis.create_hypothesis( HMM(target_tuple[0]), target_rule_set, data) target_energy = target_hypothesis.get_energy() simulated_annealing = SimulatedAnnealing(initial_hypothesis, target_energy) simulated_annealing.before_loop() # mutate hypothesis for some time before measuring steps for i in range(500): simulated_annealing.make_step() @timeit_best_of_N def make_step_profiled(): simulated_annealing.make_step() make_step_profiled()
def solve(files, variables, temperature, cooling, inner_loop, ratio): instances = 50 duration_sum = 0 weight_usage_ratio_sum = 0 satisfied_ratio_sum = 0 for file in files: sa = SimulatedAnnealing(temperature, cooling, inner_loop, ratio, File(file)) start_time = time.time() result = sa.evaluate() duration = time.time() - start_time print(result.value, result.satisfied_ratio, result.weight_usage_ratio, result.bit_array) duration_sum += duration weight_usage_ratio_sum += result.weight_usage_ratio satisfied_ratio_sum += result.satisfied_ratio # break # from seconds to milliseconds duration_avg = (duration_sum / instances) * 1000 weight_usage_ratio_avg = (weight_usage_ratio_sum / instances) satisfied_ratio_avg = (satisfied_ratio_sum / instances) return duration_avg, weight_usage_ratio_avg, satisfied_ratio_avg
def breakCipher(self,enc,dictionary): ngrams = NGram() uniEnc = ngrams.unigrams(enc) biEnc = ngrams.bigrams(enc) triEnc = ngrams.trigrams(enc) uniDictionary = ngrams.unigrams(dictionary) biDictionary = ngrams.bigrams(dictionary) triDictionary = ngrams.trigrams(dictionary) sort_tg_enc = sorted(uniEnc,key=uniEnc.get,reverse=True) sort_tg_dic = sorted(uniDictionary,key=uniDictionary.get,reverse=True) key = {} for index,x in enumerate(sort_tg_enc): key[x] = sort_tg_dic[index] # text = "" # for x in enc: # if x == " " or x == "\n": # text += x # else: # text += key[x] h = SimulatedAnnealing() h.breakOpen(enc,key,uniDictionary,triDictionary)
def setUp(self): self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 1 self.feature_table = FeatureTable.load(get_feature_table_fixture(feature_table_file_name)) corpus = Corpus.load(get_corpus_fixture(corpus_file_name)) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture(constraint_set_file_name), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=indicator_function, sample_target_lexicon=sample_desired_lexicon, sample_target_outputs=sample_desired_outputs)
def setUp(self): self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 1 self.feature_table = FeatureTable.load(get_feature_table_fixture("tk_aspiration_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("tk_aspiration_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def function(words): number_of_aspirated_consonants = sum([word.count("h") for word in words]) return "number of aspirated consonants = {})".format(number_of_aspirated_consonants) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=function, sample_target_lexicon=["ti", "ta", "ki", "ka"], sample_target_outputs=["thi", "tha", "khi", "kha"])
def setUp(self): self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 1 self.feature_table = FeatureTable.load(get_feature_table_fixture("a_b_and_cons_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("bb_for_paper_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def function(words): return "number of bab's: {}".format(sum([word.count("bab") for word in words])) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=function, sample_target_lexicon=["bb", "abb"], sample_target_outputs=["bab", "abab"])
def executar(self): self.listaDadosIniciais = Configuracao.gerarDadosIniciais( self.configuracao) resultado = Resultado(self.configuracao.problema) for a in range(4): algoritmo = None if (a == 0): algoritmo = Algoritmo(Configuracao.algoritmos[a], HillClimbing(self.configuracao)) elif (a == 1): algoritmo = Algoritmo(Configuracao.algoritmos[a], HillClimbingRestart(self.configuracao)) elif (a == 2): algoritmo = Algoritmo(Configuracao.algoritmos[a], SimulatedAnnealing(self.configuracao)) else: algoritmo = Algoritmo(Configuracao.algoritmos[a], GeneticAlgorithm(self.configuracao)) for iteracao in range(10): algoritmo.executar(self.listaDadosIniciais[iteracao], iteracao) algoritmo.gerarEstatisticas() Graficos.gerarGraficoFuncaoObjetivo(algoritmo, self.configuracao) resultado.adicionar(algoritmo) inicioComparativo = time.perf_counter() self.finalizar(resultado) terminoComparativo = time.perf_counter() print( f"Geração da tabela/gráfico de comparativo de performance em {terminoComparativo - inicioComparativo:0.4f} segundos" )
def setUp(self): configurations["CORPUS_DUPLICATION_FACTOR"] = 2 self.feature_table = FeatureTable.load(get_feature_table_fixture("aspiration_and_lengthening_extended_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("aspiration_and_lengthening_extended_260_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def function(words): number_of_long_vowels = sum([word.count(":") for word in words]) number_of_aspirated_consonants = sum([word.count("h") for word in words]) combined_number = number_of_long_vowels + number_of_aspirated_consonants return "number of long vowels and aspirated consonants in lexicon: {} (long vowels = {}, " \ "aspirated consonants = {})".format(combined_number, number_of_long_vowels, number_of_aspirated_consonants) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=function)
class TestOtmlWithFaith(unittest.TestCase): def setUp(self): self.feature_table = FeatureTable.load(get_feature_table_fixture("a_b_and_cons_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("bb_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis) run_test = True @unittest.skipUnless(run_test, "long running test skipped") def test_run(self): configurations["CONSTRAINT_SET_MUTATION_WEIGHTS"] = { "insert_constraint": 1, "remove_constraint": 1, "demote_constraint": 1, "insert_feature_bundle_phonotactic_constraint": 0, "remove_feature_bundle_phonotactic_constraint": 0, "augment_feature_bundle": 0} configurations["CONSTRAINT_INSERTION_WEIGHTS"] = { "Dep": 1, "Max": 1, "Ident": 0, "Phonotactic": 1} configurations["LEXICON_MUTATION_WEIGHTS"] = { "insert_segment": 1, "delete_segment": 1, "change_segment": 0} configurations["DEBUG_LOGGING_INTERVAL"] = 50 configurations["COOLING_PARAMETER"] = 0.999985 configurations["INITIAL_NUMBER_OF_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 2 number_of_steps_performed, hypothesis = self.simulated_annealing.run()
def setUp(self): self.feature_table = FeatureTable.load(get_feature_table_fixture("aspiration_and_lengthening_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("aspiration_and_lengthening_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("aspiration_and_lengthening_demote_only_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def function(words): number_of_long_vowels = sum([word.count(":") for word in words]) number_of_aspirated_consonants = sum([word.count("h") for word in words]) combined_number = number_of_long_vowels + number_of_aspirated_consonants return "number of long vowels and aspirated consonants in lexicon: {} (long vowels = {}, " \ "aspirated consonants = {})".format(combined_number, number_of_long_vowels, number_of_aspirated_consonants) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=function, sample_target_lexicon= ["ad", "id", "ta", "ti"], sample_target_outputs= ["a:d", "i:d", "tha", "thi"])
def setUp(self): self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 1 self.feature_table = FeatureTable.load(get_feature_table_fixture("td_kg_ai_aspiration_and_lengthening_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("td_kg_ai_aspiration_and_lengthening_400_enhanced_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def desired_lexicon_indicator_function(words): number_of_long_vowels = sum([word.count(":") for word in words]) number_of_aspirated_consonants = sum([word.count("h") for word in words]) combined_number = number_of_long_vowels + number_of_aspirated_consonants return "number of long vowels and aspirated consonants in lexicon: {} (long vowels = {}, " \ "aspirated consonants = {})".format(combined_number, number_of_long_vowels, number_of_aspirated_consonants) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=desired_lexicon_indicator_function, sample_target_lexicon=["ti", "ta", "ki", "ka", "id", "ad", "ig", "ag"], sample_target_outputs=["thi", "tha", "khi", "kha", "i:d", "a:d", "i:g", "a:g"], target_energy=3333)
#dists1 = gen_dists([(0,0), (-4,0), (1,4), (3,4), (3,2), (8,-6), (-2,-3), (-4,-3)]) dists1 = gen_dists(gen_random(128)) #print(dists1) # example usage of greedy algorithm sovle greedy = Greedy(dists1) g_sol = greedy.solve() print("GREEDY SOLUTION:\t\t\t"+str(g_sol)+" ---> " + str(greedy.cost)) # example usage of SimpleTabooSearch find solution at once sts = SimpleTabooSearch(dists1) sts_sol = sts.solve() print("SIMPLE TABOO SEARCH SOLUTION:\t\t"+ str(sts_sol)+ " ---> "+ str(sts.cost)) san = SimulatedAnnealing(dists1,g_sol) san_sol = san.solve() print("GREEDY - SIMULATED ANNEALING SOLUTION:\t\t"+ str(san_sol)+ " ---> "+ str(san.cost)) san2 = SimulatedAnnealing(dists1,sts_sol) san_sol2 = san2.solve() print("SIMPLE TABOO - SIMULATED ANNEALING SOLUTION:\t\t"+ str(san_sol2)+ " ---> "+ str(san2.cost)) aco = AntColony(dists1,g_sol) aco_sol = aco.solve() print("ANT COLONY SOLUTION:\t\t"+ str(aco_sol)+ " ---> "+ str(aco.cost)) # example usage of SimpleTabooSearch step by step with access to intermediate values #sts1 = SimpleTabooSearch(dists1) #while sts1.step(): # #print(str(sts1.i)+" step --best-->\t"+str(sts1.best)) # print(str(sts1.i)+" step --current-->\t"+str(sts1.current))
file_log_handler.setFormatter(file_log_formatter) logger.addHandler(file_log_handler) feature_tables_dir_path = join(dir_name, "tests/fixtures/feature_tables") constraint_sets_dir_path = join(dir_name, "tests/fixtures/constraint_sets") feature_table_file_path = join(feature_tables_dir_path, current_simulation.feature_table_file_name) feature_table = FeatureTable.load(feature_table_file_path) constraint_set_file_path = join( constraint_sets_dir_path, current_simulation.constraint_set_file_name) constraint_set = ConstraintSet.load(constraint_set_file_path) corpus = Corpus(current_simulation.corpus) data = corpus.get_words() max_word_length_in_data = max([len(word) for word in data]) lexicon = Lexicon(data, max_word_length_in_data) grammar = Grammar(constraint_set, lexicon) hypothesis = Hypothesis(grammar, data) if hasattr(current_simulation, "target_energy"): target_energy = current_simulation.target_energy else: target_energy = None simulated_annealing = SimulatedAnnealing(hypothesis, target_energy) simulated_annealing.run()
Argmax(Map(Function(Sum(HoleNode())), VarList('actions'))), Argmax( Map(Function(Sum(Map(Function(HoleNode()), NoneNode()))), VarList('actions'))), Argmax( Map( Function( Sum( Map( Function( Minus(Times(HoleNode(), HoleNode()), HoleNode())), NoneNode()))), VarList('actions'))), ] chosen = int(sys.argv[1]) n_SA_iterations = 3000 max_game_rounds = 500 n_games = 1000 init_temp = 1 d = 1 algo_name = 'HOLESA_' + str(chosen) start_SA = time.time() SA = SimulatedAnnealing(n_SA_iterations, max_game_rounds, n_games, init_temp, d, algo_name) best_program, _ = SA.run(incomplete[chosen]) end_SA = time.time() - start_SA print('Best program after SA - Time elapsed = ', end_SA) print(best_program.to_string())
for q_cities in num_cities: for i in xrange(q_cities): city = City() cities_list.append(city) if args.numtests == 1: show_window = True print '----------- SIMULATED ANNEALING WITH %d CITIES -----------' % q_cities simulated_annealing_s = [] for i in xrange(args.numtests): print 'Test ', i + 1 if show_window: simulated_window = ManageGraph() else: simulated_window = None simulated_annealing_s.append(SimulatedAnnealing(simulated_window, cities_list, show_window=show_window)) min_simulated.append(min(i.get_best_distance() for i in simulated_annealing_s)) simulated_avg.append(sum(sa_best.get_best_distance() for sa_best in simulated_annealing_s) / float(len(simulated_annealing_s))) max_simulated.append(max(i.get_best_distance() for i in simulated_annealing_s)) print '----------- GENETIC ALGORITHM WITH %d CITIES -----------' % q_cities genetic_algorithm_s = [] for i in xrange(args.numtests): print 'Test ', i + 1 if show_window: genetic_window = ManageGraph() else: genetic_window = None genetic_algorithm_s.append(GeneticAlgorithm(genetic_window, cities_list, show_window=show_window))
from board import Board from simulated_annealing import SimulatedAnnealing import time if __name__ == '__main__': startTime = time.time() for i in range(0, 5): print("i: {}".format(i)) board = Board() print("Rainhas:") print(board) SimulatedAnnealing(board).run() endTime = time.time() elapsedTime = (endTime - startTime) average = elapsedTime / 10 print("Tempo total: {} ".format(elapsedTime)) print("Tempo médio: {}".format(average))
def setUp(self): configurations["CONSTRAINT_SET_MUTATION_WEIGHTS"] = { "insert_constraint": 1, "remove_constraint": 1, "demote_constraint": 1, "insert_feature_bundle_phonotactic_constraint": 1, "remove_feature_bundle_phonotactic_constraint": 1, "augment_feature_bundle": 0} configurations["CONSTRAINT_INSERTION_WEIGHTS"] = { "Dep": 1, "Max": 1, "Ident": 0, "Phonotactic": 1} configurations["LEXICON_MUTATION_WEIGHTS"] = { "insert_segment": 1, "delete_segment": 1, "change_segment": 0} configurations["INITIAL_TEMPERATURE"] = 100 configurations["COOLING_PARAMETER"] = 0.999985 configurations["INITIAL_NUMBER_OF_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 1 configurations["MIN_FEATURE_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 1 configurations["MAX_FEATURE_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = float("INF") configurations["DATA_ENCODING_LENGTH_MULTIPLIER"] = 100 configurations["MAX_NUMBER_OF_CONSTRAINTS_IN_CONSTRAINT_SET"] = float("INF") configurations["RESTRICTION_ON_ALPHABET"] = True configurations["DEBUG_LOGGING_INTERVAL"] = 50 self.unit_tests_log_file_name = "../../logging/{}_td_kg_aiueo_aspiration_and_lengthening_400_INF_INF_{}.txt".format(platform.node(), simulation_number) self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 1 self.feature_table = FeatureTable.load(get_feature_table_fixture("td_kg_aiueo_aspiration_and_lengthening_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("td_kg_aiueo_aspiration_and_lengthening_400_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def desired_lexicon_indicator_function(words): number_of_long_vowels = sum([word.count(":") for word in words]) number_of_aspirated_consonants = sum([word.count("h") for word in words]) combined_number = number_of_long_vowels + number_of_aspirated_consonants return "number of long vowels and aspirated consonants in lexicon: {} (long vowels = {}, " \ "aspirated consonants = {})".format(combined_number, number_of_long_vowels, number_of_aspirated_consonants) def convert_corpus_word_to_target_word(word): return word.replace('h', '').replace(':', '') target_energy = self.get_target_hypothesis_energy(self.feature_table, "td_kg_ai_aspiration_and_lengthening_target_constraint_set.json", corpus, convert_corpus_word_to_target_word_function=convert_corpus_word_to_target_word) #391689 self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=desired_lexicon_indicator_function, sample_target_lexicon=["ti", "ta", "ki", "ka", "id", "ad", "ig", "ag", "tu", "te"], sample_target_outputs=["thi", "tha", "khi", "kha", "i:d", "a:d", "i:g", "a:g", "thu", "the"], target_energy=target_energy)
# k and n_states are paired together in order to make a fair comparison # between algorithms. This is because IW if k is low will have a low number # of states returned. k_options = [3, 4, 5] k = k_options[int(sys.argv[4])] n_states_options = [94, 201, 622] # k=3 94, k=4 201, k=5 622, k=6 1244 n_states = n_states_options[int(sys.argv[4])] n_games = 100 init_temp = 1 d = 1 max_game_rounds = 500 max_nodes = 100 n_MC_simulations = 1000 inner_SA = SimulatedAnnealing(n_SA_iterations, max_game_rounds, n_games, init_temp, d, False) outer_SA = SimulatedAnnealing(1000, max_game_rounds, n_games, init_temp, d, True) dsl = DSL() if search_type == 0: # IW tree = ParseTree(dsl=dsl, max_nodes=max_nodes, k=k, is_IW=True) search_algo = IteratedWidth(tree, n_states, k) suffix = 'IW' + '_LS' + str(LS_type) + '_SA' + str(n_SA_iterations) + '_ST' + str(n_states) + '_k' + str(k) + '_GA' + str(n_games) elif search_type == 1: # BFS tree = ParseTree(dsl=dsl, max_nodes=max_nodes, k=k, is_IW=False) search_algo = BFS(tree, n_states) suffix = 'BFS' + '_LS' + str(LS_type) + '_SA' + str(n_SA_iterations) + '_ST' + str(n_states) + '_k' + str(k) + '_GA' + str(n_games)
class TestOtmlWithTAspiration(unittest.TestCase): def setUp(self): self._set_up_logging() configurations["CORPUS_DUPLICATION_FACTOR"] = 1 self.feature_table = FeatureTable.load(get_feature_table_fixture("tk_aspiration_feature_table.json")) corpus = Corpus.load(get_corpus_fixture("tk_aspiration_corpus.txt")) self.constraint_set = ConstraintSet.load(get_constraint_set_fixture("faith_constraint_set.json"), self.feature_table) self.lexicon = Lexicon(corpus.get_words(), self.feature_table) self.grammar = Grammar(self.feature_table, self.constraint_set, self.lexicon) self.data = corpus.get_words() self.traversable_hypothesis = TraversableGrammarHypothesis(self.grammar, self.data) def function(words): number_of_aspirated_consonants = sum([word.count("h") for word in words]) return "number of aspirated consonants = {})".format(number_of_aspirated_consonants) self.simulated_annealing = SimulatedAnnealing(self.traversable_hypothesis, target_lexicon_indicator_function=function, sample_target_lexicon=["ti", "ta", "ki", "ka"], sample_target_outputs=["thi", "tha", "khi", "kha"]) run_test = True @unittest.skipUnless(run_test, "long running test skipped") def test_run(self): configurations["CONSTRAINT_SET_MUTATION_WEIGHTS"] = { "insert_constraint": 1, "remove_constraint": 1, "demote_constraint": 1, "insert_feature_bundle_phonotactic_constraint": 1, "remove_feature_bundle_phonotactic_constraint": 1, "augment_feature_bundle": 0} configurations["CONSTRAINT_INSERTION_WEIGHTS"] = { "Dep": 1, "Max": 1, "Ident": 0, "Phonotactic": 1} configurations["LEXICON_MUTATION_WEIGHTS"] = { "insert_segment": 1, "delete_segment": 1, "change_segment": 0} configurations["INITIAL_TEMPERATURE"] = 100 configurations["COOLING_PARAMETER"] = 0.999985 configurations["INITIAL_NUMBER_OF_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 1 configurations["MIN_FEATURE_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = 1 configurations["MAX_FEATURE_BUNDLES_IN_PHONOTACTIC_CONSTRAINT"] = float("INF") configurations["DATA_ENCODING_LENGTH_MULTIPLIER"] = 100 configurations["MAX_NUMBER_OF_CONSTRAINTS_IN_CONSTRAINT_SET"] = float("INF") configurations["RESTRICTION_ON_ALPHABET"] = True configurations["DEBUG_LOGGING_INTERVAL"] = 50 number_of_steps_performed, hypothesis = self.simulated_annealing.run() def _set_up_logging(self): unit_tests_log_file_name = "../../logging/{}_tk_aspiration_INF_INF_{}.txt".format(platform.node(), simulation_number) if os.path.exists(unit_tests_log_file_name): raise ValueError("log name already exits") logger = logging.getLogger() logger.setLevel(logging.INFO) file_log_formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s %(message)s', "%Y-%m-%d %H:%M:%S") dirname, filename = split(abspath(__file__)) unit_tests_log_path = normpath(join(dirname, unit_tests_log_file_name)) file_log_handler = logging.FileHandler(unit_tests_log_path, mode='w') file_log_handler.setFormatter(file_log_formatter) logger.addHandler(file_log_handler)
def benchmark(): REPEATS = 10 SECONDS = [5, 10, 30, 60, 300, 1200] for seconds in SECONDS: v = 0 time_s = datetime.now() for k in range(REPEATS): rs = RandomSearch(states, seconds, inc_support, dec_support) rs.run() v += rs.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Random Search', str(seconds), str(v / REPEATS), str(tt / REPEATS)) for seconds in SECONDS: v = 0 time_s = datetime.now() for k in range(REPEATS): ls = LocalSearch(states, seconds, inc_support, dec_support) ls.run() v += ls.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Local Search', str(seconds), str(v / REPEATS), str(tt / REPEATS)) for seconds in SECONDS: for initial_cadence in [10, 25, 50]: for critical_event in [10, 25, 50]: v = 0 time_s = datetime.now() for k in range(REPEATS): ts = TabuSearch(states, seconds, initial_cadence, critical_event, inc_support, dec_support) ts.run() v += ts.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Tabu Search', str(seconds), str(initial_cadence), str(critical_event), str(v / REPEATS), str(tt / REPEATS)) for crossover in ['pmx', 'ox']: for mutate in ['transposition', 'insertion', 'inversion']: for seconds in SECONDS: for population_size in [10, 25, 50]: v = 0 time_s = datetime.now() for k in range(REPEATS): ga = GeneticAlgorithm(states, seconds, population_size, crossover, mutate, inc_support, dec_support) ga.run() v += ga.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Genetic Algorithm ' + crossover + ' ' + mutate, str(seconds), str(population_size), str(v / REPEATS), str(tt / REPEATS)) for initial_temperature in [100, 500, 1000]: for cooling_coefficient in [0.9, 0.99, 0.999, 0.9999]: for minimal_temperature in [ initial_temperature * 0.25, initial_temperature * 0.5, initial_temperature * 0.75 ]: v = 0 time_s = datetime.now() for k in range(REPEATS): sa = SimulatedAnnealing(states, initial_temperature, cooling_coefficient, minimal_temperature, inc_support, dec_support) sa.run() v += sa.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Simulated Annealing', str(initial_temperature), str(cooling_coefficient), str(minimal_temperature), str(v / REPEATS), str(tt / REPEATS))
max_temp = settings.options.max_temp # initial temperature min_temp = settings.options.min_temp # final temperature eq_iter = settings.options.iters # iterations at same temperature temp_change = settings.options.temp_rate # temperature reduction factor # execute the algorithm filename = settings.options.data_filename if not filename: raise UserWarning("enter data filename through the -df flag.") constraints = [ SameRoomAndTime(), SameStudents(), DifferentTime(), Precedence(), SameInstructor(), Spread() ] soft_constraints = [RoomCost(), PreferenceRoom(), StudentsTakingClass()] solver = SimulatedAnnealing(TtDataReader(), H1()) plotter = TtPlotter() plotter.register_constraints(constraints) plotter.register_soft_constraints(soft_constraints) solver.register_plotter(plotter) solver.register_constraints(constraints) solver.register_soft_constraints(soft_constraints) best_solution = solver.solve(filename) # print(best_solution) # print(best_solution.cost())
from grammar.feature_table import FeatureTable from grammar.constraint_set import ConstraintSet from grammar.grammar import Grammar from traversable_grammar_hypothesis import TraversableGrammarHypothesis from corpus import Corpus from simulated_annealing import SimulatedAnnealing feature_table_file_path = "/Users/iddoberger/Documents/MercurialRepositories/otml/source/tests/fixtures/feature_table/french_deletion_feature_table.json" corpus_file_path = "/Users/iddoberger/Documents/MercurialRepositories/otml/source/tests/fixtures/corpora/french_deletion_corpus.txt" constraint_set_file_path = "/Users/iddoberger/Documents/MercurialRepositories/otml/source/tests/fixtures/constraint_sets/french_deletion_constraint_set.json" configuration_json_str = codecs.open(configuration_file_path, 'r').read() OtmlConfigurationManager(configuration_json_str) feature_table = FeatureTable.load(feature_table_file_path) corpus = Corpus.load(corpus_file_path) constraint_set = ConstraintSet.load(constraint_set_file_path, feature_table) lexicon = Lexicon(corpus.get_words(), feature_table) grammar = Grammar(feature_table, constraint_set, lexicon) data = corpus.get_words() traversable_hypothesis = TraversableGrammarHypothesis(grammar, data) simulated_annealing = SimulatedAnnealing(traversable_hypothesis) simulated_annealing.run()