diff --git a/grortir/main/model/stages/calls_stage.py b/grortir/main/model/stages/calls_stage.py index 327285c..91a6d70 100644 --- a/grortir/main/model/stages/calls_stage.py +++ b/grortir/main/model/stages/calls_stage.py @@ -1,4 +1,6 @@ """Module contains class CallsStage.""" +import math + from grortir.main.model.core.abstract_stage import AbstractStage @@ -17,7 +19,7 @@ class CallsStage(AbstractStage): """ def __init__(self, name, max_calls, input_vector=(), - maximum_acceptable_quality=0.01): + maximum_acceptable_quality=0.3): """Constructor.""" super().__init__(input_vector) self.max_calls = max_calls @@ -53,9 +55,8 @@ def calculate_quality(input_vector, control_params): """ assert len(control_params) == len(input_vector) quality = 0 - for i in enumerate(control_params): - quality += (control_params[i[0]] - input_vector[ - i[0]]) ** 2 + for i, param in enumerate(control_params): + quality += abs(10*input_vector[i] - 2.16) + math.cos(5 * math.pi * control_params[i]) * control_params[i] * (1 - control_params[i] * control_params[i]) + 0.4 return quality def get_cost(self): diff --git a/grortir/main/pso/pso_algorithm.py b/grortir/main/pso/pso_algorithm.py index 0fc2a20..0847214 100644 --- a/grortir/main/pso/pso_algorithm.py +++ b/grortir/main/pso/pso_algorithm.py @@ -18,7 +18,7 @@ def __init__(self, process, grouping_strategy, optimization_startegy, def run(self): """Run algorithm.""" self.process_validator.validate(self.process) - self.process.optimizationStatus = OptimizationStatus.in_progress + self.process.optimization_status = OptimizationStatus.in_progress number_of_groups = self.grouping_strategy.get_actual_numbers_of_groups() for current_group_number in range(number_of_groups): current_stages = self.grouping_strategy.get_items_from_group( @@ -27,3 +27,11 @@ def run(self): get_group_optimization_strategy(current_stages) self.whole_group_pso.optimize(current_stages, group_optimization_strategy) + self._post_processing() + + def _post_processing(self): + final_status = OptimizationStatus.success + for stage in self.grouping_strategy.ordered_stages: + if stage.optimization_status != OptimizationStatus.success: + final_status = OptimizationStatus.failed + self.process.optimization_status = final_status diff --git a/grortir/main/pso/velocity_calculator.py b/grortir/main/pso/velocity_calculator.py index ae43198..b44b38a 100644 --- a/grortir/main/pso/velocity_calculator.py +++ b/grortir/main/pso/velocity_calculator.py @@ -32,8 +32,6 @@ def calculate(self, current_velocities, particle_best_positions, """Calculate velocity.""" rand_1 = np.random.rand() rand_2 = np.random.rand() - print("rand_1 = " + str(rand_1)) - print("rand_2 = " + str(rand_2)) velocities = {} for stage in control_params: s_0 = self._s0(current_velocities[stage]) diff --git a/grortir/scripts/SEQ_diagram.png b/grortir/scripts/SEQ_diagram.png new file mode 100644 index 0000000..f851f7c Binary files /dev/null and b/grortir/scripts/SEQ_diagram.png differ diff --git a/grortir/scripts/SIM_diagram.png b/grortir/scripts/SIM_diagram.png new file mode 100644 index 0000000..64d3531 Binary files /dev/null and b/grortir/scripts/SIM_diagram.png differ diff --git a/grortir/scripts/case_when_sim_better_than_seq.py b/grortir/scripts/case_when_sim_better_than_seq.py new file mode 100644 index 0000000..16ad6a4 --- /dev/null +++ b/grortir/scripts/case_when_sim_better_than_seq.py @@ -0,0 +1,84 @@ +"""Example when Sim is better than sequential.""" +import matplotlib.pyplot as plt +import networkx as nx + +from grortir.main.model.core.optimization_status import OptimizationStatus +from grortir.main.model.processes.factories.calls_process_factory import \ + CallsProcessFactory +from grortir.main.optimizers.grouping_strategy import GroupingStrategy +from grortir.main.pso.calls_optimization_strategy import \ + CallsOptimizationStrategy +from grortir.main.pso.pso_algorithm import PsoAlgorithm + + +def optimization(max_calls, how_many_nodes, method_type): + factory = CallsProcessFactory("linear", how_many_nodes, max_calls, (0.216,)) + process = factory.construct_process() + ordered_stages = nx.topological_sort(process) + grouping_strategy = GroupingStrategy(ordered_stages) + # in sim all stages are in the sam group: + if method_type == "SIM": + grouping_strategy.define_group(ordered_stages) + elif method_type == "SEQ": + for stage in ordered_stages: + grouping_strategy.define_group([stage]) + else: + raise NotImplementedError + calls_optimization_strategy = CallsOptimizationStrategy() + pso_algorithm = PsoAlgorithm(process, grouping_strategy, + calls_optimization_strategy) + pso_algorithm.run() + return process + + +# sim_optimization(MAX_CALLS, HOW_MANY_NODES) +def calculate_probability_of_success(max_calls, number_of_nodes, + number_of_tries, method_type): + results = {} + for how_many_nodes in number_of_nodes: + how_many_success = 0.0 + how_many_failed = 0.0 + probability = -1 + for nr_proby in range(number_of_tries): + optimized_process = optimization(max_calls, how_many_nodes, + method_type) + if optimized_process.optimization_status == OptimizationStatus.success: + how_many_success += 1 + else: + how_many_failed += 1 + probability = how_many_success / number_of_tries + results[how_many_nodes] = probability + return results + + +NUMBER_OF_STAGES = [1, 2, 3, 5, 7, 10] +HOW_MANY_TRIES = 100 +MAX_CALLS = 1000 + + +def draw_from_dict(dict_with_results, name="Undefined"): + x = [] + y = [] + for key, value in dict_with_results.items(): + x.append(key) + y.append(value) + plt.plot(x, y, 'ro') + plt.savefig(name) + plt.show() + + +# key -dimension, value - probability of success +results_sim = calculate_probability_of_success(MAX_CALLS, NUMBER_OF_STAGES, + HOW_MANY_TRIES, + "SIM") +draw_from_dict(results_sim, "SIM_diagram.png") +# {1: 1.0, 2: 0.95, 3: 0.78, 5: 0.46, 7: 0.06, 10: 0.0} + + +results_seq = calculate_probability_of_success(MAX_CALLS, NUMBER_OF_STAGES, + HOW_MANY_TRIES, + "SEQ") +draw_from_dict(results_seq, "SEQ_diagram.png") +# {1: 1.0, 2: 0.0, 3: 0.0, 5: 0.0, 7: 0.0, 10: 0.0} + +print("The End")