def run_steepest_func_2(): csv_table = CSVFormatter() # x_0 * x_1 + (1-x_0)^2 + (2-x_1)^2+ (3-x_2)^2+ (4-x_3)^2+ (5-x_4)^2+ (6-x_5)^2+ (7-x_6)^2+ (8-x_7)^2+ (9-x_8)^2+ (10-x_9)^2 ## 10 Dimension test_func = lambda x: x[0] * x[1] + sum([(ele - x[ele - 1])**2 for ele in range(1, 11)]) fprime = lambda x: [x[1] + -2 * (1 - x[0]), x[0] + -2 * (2 - x[1])] + \ [-2*(ele - x[ele - 1]) for ele in range(3, 11)] csv_table.add_row(STEEP_HEADER) x0_param = [[random.gauss(-10, 10) for _ in range(10)] for _ in range(NUM_RUNS)] eps = 1e-14 for i in range(10): gc_iterations_param_dist = [10] * NUM_RUNS epsilon_abs_param_dist = [eps] * NUM_RUNS run_report_list = TestHarness.test_optimizer( alternate_method, test_func, x0_param, [fprime for _ in range(NUM_RUNS)], epsilon_abs_param_dist) stats = StatsGenerator.generate_stats(run_report_list, (1, 1), 1) print(stats) csv_table.add_row([ epsilon_abs_param_dist[i], CELL_FORMAT_STR.format(stats[0][0], stats[0][1]), CELL_FORMAT_STR.format(stats[1][0], stats[1][1]) ]) eps *= 10 csv_table.export_table("steepest_func2.csv") print("Finished steepest decent function 2") csv_table.clear_table()
def run_steepest_func_1(): csv_table = CSVFormatter() ## FIRST FUNCTION ## Rosenblock test_func = lambda x: (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2 + 1 fprime = lambda x: (2 * (200 * x[0]**3 - 200 * x[0] * x[1] + x[0] - 1), 200 * (x[1] - x[0]**2)) csv_table.add_row(STEEP_HEADER) # Func 1 epsilon variation x0_param = [(random.gauss(-10, 10), random.gauss(-10, 10)) for _ in range(NUM_RUNS)] eps = 1e-14 for i in range(10): gc_iterations_param_dist = [10] * NUM_RUNS epsilon_abs_param_dist = [eps] * NUM_RUNS run_report_list = TestHarness.test_optimizer( alternate_method, test_func, x0_param, [fprime for _ in range(NUM_RUNS)], epsilon_abs_param_dist) stats = StatsGenerator.generate_stats(run_report_list, (1, 1), 1) print(stats) csv_table.add_row([ epsilon_abs_param_dist[i], CELL_FORMAT_STR.format(stats[0][0], stats[0][1]), CELL_FORMAT_STR.format(stats[1][0], stats[1][1]) ]) eps *= 10 csv_table.export_table("steepest_func1.csv") print("Finished steepest decent function 1") csv_table.clear_table()
def setUp(self): DefaultTestFixture.setUp(self) self.data = _DataHolder() self.data.configure(['timestamp', 'column-A']) for x in range(1, 20): self.data.add_entry([time.time(), x]) exporters = _ParentHolder(self.data) exporter = _ParentHolder(exporters) exporter.log = self.data self.formatter = CSVFormatter() self.formatter.configure({'name': 'csvformatter', 'parent': exporter})
def problem_1_b(): csvf = CSVFormatter() csvf.add_row(["Time (ms)"]) color_set = range(3) problem_size = 10 num_runs = 100 cg = GraphColoring(color_set) harness_param_x0 = [[ random.choice(color_set) for _ in range(problem_size) ] for _ in range(num_runs)] harness_allowed = [[color_set for _ in range(problem_size)]] * num_runs harness_t0 = [25000] * num_runs harness_t_final = [0.1] * num_runs run_report_list = TestHarness.test_optimizer(simulated_annealing, cg.solve, harness_param_x0, harness_allowed, harness_t0, harness_t_final) print("Finished coloring graph runs") time_stats = StatsGenerator.stats_to_string( StatsGenerator.generate_stats( list(map(lambda x: x[0], run_report_list)))) completion_stats = StatsGenerator.stats_to_string( StatsGenerator.generate_stats( list(map(lambda x: x[2], run_report_list)))) print(time_stats, completion_stats) csvf.add_row([time_stats, completion_stats]) csvf.export_table("sa_graph_coloring")
def setUp(self): DefaultTestFixture.setUp(self) self.data = _DataHolder() self.data.configure(['timestamp','column-A']) for x in range(1,20): self.data.add_entry([time.time(),x]) exporters = _ParentHolder(self.data) exporter = _ParentHolder(exporters) exporter.log = self.data self.formatter = CSVFormatter() self.formatter.configure({'name':'csvformatter','parent':exporter})
class TestCase(DefaultTestFixture): def setUp(self): DefaultTestFixture.setUp(self) self.data = _DataHolder() self.data.configure(['timestamp', 'column-A']) for x in range(1, 20): self.data.add_entry([time.time(), x]) exporters = _ParentHolder(self.data) exporter = _ParentHolder(exporters) exporter.log = self.data self.formatter = CSVFormatter() self.formatter.configure({'name': 'csvformatter', 'parent': exporter}) def test_1(self): columns = '' formatter = self.formatter stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) list = string.split(csv) columns = string.split(list[0], ',') if 'timestamp' in columns: if len(columns) > 2: self.fail('first line has to much information:\n ' + string.join(columns, ',')) else: self.fail('timestamp column was not found on the first line') def test_2(self): columns = '' formatter = self.formatter stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) list = string.split(csv) values = string.split(list[1], ',') if len(values) == 2: t = time.strptime(values[0], '%Y-%m-%dT%H:%M:%S') else: self.fail('wrong number of values in line #2') def test_3(self): columns = '' formatter = self.formatter stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) list = string.split(csv) values = string.split(list[1], ',') for v in list[2:]: if len(string.split(v, ',')) != 2: self.fail('wrong number of values in line') def test_EInconsistantFormat(self): formatter = self.formatter data = self.data for x in range(1, 100): entry = {} entry['timestamp'] = time.time() entry['column-TEST'] = x data.append(entry) try: stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) raise 'test_2 failed, did not raise EBreakupTransfer' except EBreakupTransfer, e: pass except:
class TestCase(DefaultTestFixture): def setUp(self): DefaultTestFixture.setUp(self) self.data = _DataHolder() self.data.configure(['timestamp','column-A']) for x in range(1,20): self.data.add_entry([time.time(),x]) exporters = _ParentHolder(self.data) exporter = _ParentHolder(exporters) exporter.log = self.data self.formatter = CSVFormatter() self.formatter.configure({'name':'csvformatter','parent':exporter}) def test_1(self): columns = '' formatter = self.formatter stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) list = string.split(csv) columns = string.split(list[0],',') if 'timestamp' in columns: if len(columns) > 2: self.fail('first line has to much information:\n ' + string.join(columns,',')) else: self.fail('timestamp column was not found on the first line') def test_2(self): columns = '' formatter = self.formatter stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) list = string.split(csv) values = string.split(list[1],',') if len(values) == 2: t = time.strptime(values[0],'%Y-%m-%dT%H:%M:%S') else: self.fail('wrong number of values in line #2') def test_3(self): columns = '' formatter = self.formatter stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) list = string.split(csv) values = string.split(list[1],',') for v in list[2:]: if len(string.split(v,',')) != 2: self.fail('wrong number of values in line') def test_EInconsistantFormat(self): formatter = self.formatter data = self.data for x in range(1,100): entry = {} entry['timestamp'] = time.time() entry['column-TEST'] = x data.append(entry) try: stream = formatter.format(self.data) csv = '' data = stream.read(1024) while data: csv += data data = stream.read(1024) raise 'test_2 failed, did not raise EBreakupTransfer' except EBreakupTransfer,e: pass except:
def run_cg_func_2(): csv_table = CSVFormatter() test_func = lambda x: x[0] * x[1] + sum([(ele - x[ele - 1])**2 for ele in range(1, 11)]) fprime = lambda x: [x[1] + -2 * (1 - x[0]), x[0] + -2 * (2 - x[1])] + \ [-2*(ele - x[ele - 1]) for ele in range(3, 11)] x0_param = [[random.gauss(-10, 10) for _ in range(10)] for _ in range(NUM_RUNS)] epsilon_abs_param_dist = [1.14e-14] * NUM_RUNS csv_table.add_row(CG_HEADER) for i in range(NUM_VARIATIONS): gc_iterations_param_dist = [random.randint(2, NUM_VARIATIONS) ] * NUM_RUNS run_report_list = TestHarness.test_optimizer( conjugate_gradients, test_func, x0_param, [fprime for _ in range(NUM_RUNS)], gc_iterations_param_dist, epsilon_abs_param_dist) stats = StatsGenerator.generate_stats(run_report_list, (0, 2, 3, 4, 5, 6, 7, 8, 9, 10), 1) print(stats) csv_table.add_row([ gc_iterations_param_dist[i], epsilon_abs_param_dist[i], CELL_FORMAT_STR.format(stats[0][0], stats[0][1]), CELL_FORMAT_STR.format(stats[1][0], stats[1][1]), CELL_FORMAT_STR.format(stats[2][0], stats[2][1]) ]) csv_table.export_table("function2_gc_freq_variation.csv") csv_table.clear_table() print("Finished function 2 GC restart variation") csv_table.add_row(CG_HEADER) # Func 1 epsilon variation eps = 1e-14 for i in range(10): gc_iterations_param_dist = [10] * NUM_RUNS epsilon_abs_param_dist = [eps] * NUM_RUNS run_report_list = TestHarness.test_optimizer( conjugate_gradients, test_func, x0_param, [fprime for _ in range(NUM_RUNS)], gc_iterations_param_dist, epsilon_abs_param_dist) stats = StatsGenerator.generate_stats(run_report_list, (0, 2, 3, 4, 5, 6, 7, 8, 9, 10), 1) print(stats) csv_table.add_row([ gc_iterations_param_dist[i], epsilon_abs_param_dist[i], CELL_FORMAT_STR.format(stats[0][0], stats[0][1]), CELL_FORMAT_STR.format(stats[1][0], stats[1][1]), CELL_FORMAT_STR.format(stats[2][0], stats[2][1]) ]) eps *= 10 csv_table.export_table("function2_epsilon_variation.csv") print("Finished function 2 epsilon variation") csv_table.clear_table()
def run_cg_func_1(): csv_table = CSVFormatter() ## FIRST FUNCTION ## Rosenblock test_func = lambda x: (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2 + 1 fprime = lambda x: (2 * (200 * x[0]**3 - 200 * x[0] * x[1] + x[0] - 1), 200 * (x[1] - x[0]**2)) # Vary GC restart frequency (2->50 drawn from uniform distribution # Func 1 conj variation epsilon_abs_param_dist = [1.14e-14] * NUM_RUNS x0_param = [(random.gauss(-10, 10), random.gauss(-10, 10)) for _ in range(NUM_RUNS)] csv_table.add_row(CG_HEADER) for i in range(NUM_VARIATIONS): gc_iterations_param_dist = [random.randint(2, NUM_VARIATIONS) ] * NUM_RUNS run_report_list = TestHarness.test_optimizer( conjugate_gradients, test_func, x0_param, [fprime for _ in range(NUM_RUNS)], gc_iterations_param_dist, epsilon_abs_param_dist) stats = StatsGenerator.generate_stats(run_report_list, (1, 1), 1) print(stats) csv_table.add_row([ gc_iterations_param_dist[i], epsilon_abs_param_dist[i], CELL_FORMAT_STR.format(stats[0][0], stats[0][1]), CELL_FORMAT_STR.format(stats[1][0], stats[1][1]), CELL_FORMAT_STR.format(stats[2][0], stats[2][1]) ]) csv_table.export_table("function1_gc_freq_variation.csv") csv_table.clear_table() print("Finished function 1 GC restart variation") csv_table.add_row(CG_HEADER) # Func 1 epsilon variation eps = 1e-14 for i in range(10): gc_iterations_param_dist = [10] * NUM_RUNS epsilon_abs_param_dist = [eps] * NUM_RUNS run_report_list = TestHarness.test_optimizer( conjugate_gradients, test_func, x0_param, [fprime for _ in range(NUM_RUNS)], gc_iterations_param_dist, epsilon_abs_param_dist) stats = StatsGenerator.generate_stats(run_report_list, (1, 1), 1) print(stats) csv_table.add_row([ gc_iterations_param_dist[i], epsilon_abs_param_dist[i], CELL_FORMAT_STR.format(stats[0][0], stats[0][1]), CELL_FORMAT_STR.format(stats[1][0], stats[1][1]), CELL_FORMAT_STR.format(stats[2][0], stats[2][1]) ]) eps *= 10 csv_table.export_table("function1_epsilon_variation.csv") print("Finished function 1 epsilon variation") csv_table.clear_table()
def problem_1_a(): csvf = CSVFormatter() csvf.add_row(["Problem Size", "Time (ms)", "Profit"]) values = [ 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312, 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312, 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312, 360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147, 78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28, 87, 73, 78, 15, 26, 78, 210, 36, 85, 189, 274, 43, 33, 10, 19, 389, 276, 312 ] weights = [ 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13, 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13, 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13, 7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0, 42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71, 3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13 ] num_runs = 5 knapsack_problem_size_range = (5, 125, 5) max_weight_modifier = 37 harness_param_t0 = [25000] * num_runs harness_param_t_final = [0.1] * num_runs for problem_size in range(*knapsack_problem_size_range): # create knapsack problem for test kp = KnapsackProblem(max_weight=max_weight_modifier * problem_size, values=values[:problem_size], weights=weights[:problem_size]) harness_param_x0 = [[ round(random.uniform(0, 1)) for _ in range(problem_size) ] for _ in range(num_runs)] allowed = [[0, 1] for _ in range(problem_size)] harness_param_allowed = [allowed] * num_runs run_report_list = TestHarness.test_optimizer( simulated_annealing, kp.get_profit, harness_param_x0, harness_param_allowed, harness_param_t0, harness_param_t_final) time_stats = StatsGenerator.generate_stats( list(map(lambda x: x[0], run_report_list))) profit_stats = StatsGenerator.generate_stats( list(map(lambda x: x[2], run_report_list))) table_entry = [ problem_size, StatsGenerator.stats_to_string(time_stats), StatsGenerator.stats_to_string(profit_stats) ] csvf.add_row(table_entry) print("Finished problem size:", problem_size) print(table_entry) csvf.export_table("sa_knapsack_test.csv")
def problem_2(): nm_csvf = CSVFormatter() sa_csvf = CSVFormatter() nm_csvf.add_row(["Time (ms)", "Minimum"]) sa_csvf.add_row(["Time (ms)", "Minimum"]) nm_test_function = lambda x: x[0]**2 + 2 * x[1]**2 + 2 * x[0] * x[1] num_runs = 1000 harness_sa_allowed = [[[], []]] * num_runs harness_sa_t0 = [25000] * num_runs harness_sa_t_final = [0.1] * num_runs harness_x0 = [(random.uniform(-100, 100), random.uniform(-100, 100)) for _ in range(num_runs)] nm_run_report = TestHarness.test_optimizer(nelder_mead, nm_test_function, harness_x0) sa_run_report = TestHarness.test_optimizer(simulated_annealing, nm_test_function, harness_x0, harness_sa_allowed, harness_sa_t0, harness_sa_t_final) nm_time_stats = StatsGenerator.generate_stats( list(map(lambda x: x[0], nm_run_report))) nm_min_stats = StatsGenerator.generate_stats( list(map(lambda x: x[2], nm_run_report))) sa_time_stats = StatsGenerator.generate_stats( list(map(lambda x: x[0], sa_run_report))) sa_min_stats = StatsGenerator.generate_stats( list(map(lambda x: x[2], sa_run_report))) nm_csvf.add_row([ StatsGenerator.stats_to_string(nm_time_stats), StatsGenerator.stats_to_string(nm_min_stats) ]) sa_csvf.add_row([ StatsGenerator.stats_to_string(sa_time_stats), StatsGenerator.stats_to_string(sa_min_stats) ]) nm_csvf.export_table("tables/nelder_mead_stats.csv") sa_csvf.export_table("tables/continuous_simulated_annealing_stats.csv")