[Example] Example with new function

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):

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

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])

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")