mg-pso-gui 0.2.125__py3-none-any.whl → 0.2.126__py3-none-any.whl

mgpsogui/util/recosu/pso/pso.py

@@ -9,7 +9,6 @@
 # OMSLab licenses this file to you under the MIT license.
 # See the LICENSE file in the project root for more information.
 #
-import numpy
 
 from ..utils import utils
 from .csip_access import csip_worker
@@ -25,9 +24,8 @@ import json
 import os
 from multiprocessing import Queue as MPQueue
 
-cost2 = {}
 
-def eval_cost(x, iteration, step_param, step_objfunc, calib_params, req_queue, files, url, param, conf: Dict, rnd,
+def eval_cost(x, iteration, step_param_names, step_objfunc, calib_params, req_queue, files, url, param, conf: Dict, rnd,
               step):
     particles = len(x[:, 0])
 
@@ -43,13 +41,7 @@ def eval_cost(x, iteration, step_param, step_objfunc, calib_params, req_queue, f
         # submit for processing
         # for i_particle, v in enumerate(x[:, 0]):
         for particle in range(particles):
-            req_queue.put((rnd, step, iteration, particle, x, step_param, calib_params, step_objfunc, res_queue))
-            # print(' rnd: ', rnd)
-            # print(' step: ', step)
-            # print(' interation: ', iteration)
-            # print(' particle: ', particle)
-            # print(' x[particle,:]: ', x[particle,:])
-
+            req_queue.put((rnd, step, iteration, particle, x, step_param_names, calib_params, step_objfunc, res_queue))
             # req_queue.put((i_particle, x[i_particle,:], step_param_names, calib_params, step_objfunc, res_queue))
 
         # wait for the cost value to come back
@@ -57,16 +49,6 @@ def eval_cost(x, iteration, step_param, step_objfunc, calib_params, req_queue, f
         for idx in range(particles):
             (particle, p_cost) = res_queue.get()
             cost[particle] = p_cost
-            cost1 = []
-            cost1.append(iteration)
-            cost1.append(p_cost)
-            cost1.append(str('r{}s{}i{}p{}.json'.format(rnd, step, iteration, particle)))
-
-            if particle not in cost2:
-                cost2[particle] = []
-
-            cost2[particle].append(cost1)
-
             res_queue.task_done()
 
         res_queue.join()
@@ -81,6 +63,7 @@ def eval_cost(x, iteration, step_param, step_objfunc, calib_params, req_queue, f
         # leave the loop if fails acceptable
         if failed_particles <= pfail_count:
             break
+        
         print("Re-running particles, since ", failed_particles, ' out of ', particles, ' particles failed.')
         pfail_retry -= 1
 
@@ -93,15 +76,9 @@ def eval_cost(x, iteration, step_param, step_objfunc, calib_params, req_queue, f
     mean = np.nanmean(cost)
     cost[nan_idx[0]] = mean
 
-    for key in cost2:
-        # print(key, ' - ', cost2[key])
-        cost2[key][iteration][1] = cost[key] # BUG LIST INDEX OUT OF RANGE?
-        # print(key, ' - ', cost2[key])
-
     print(flush=True)
     return cost
 
-
 def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters: int, options: Dict,
                 oh_strategy: Dict = None, n_threads: int = 4, rtol: float = 0.001, ftol: float = -np.inf,
                 ftol_iter: int = 1, full_trace: List = None, rtol_iter: int = 1,
@@ -183,22 +160,6 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
     best_cost = np.ones(len(steps)) * np.inf
     optimizer = np.empty(len(steps), dtype=object)
 
-    # best_pos = {}
-    #
-    # best_pos[0] = numpy.array([1.18792343e+02, 5.43472746e+01, 7.10091373e+01, 1.80144959e+00,
-    #                2.63979951e+00, 4.61775754e+00, 4.84808030e-01, 3.97179059e+00,
-    #                4.12612823e+00, 2.29275033e-01, 5.86661573e+01, 4.33933491e-01,
-    #                3.80515317e-01, 2.32299702e+01, 1.29697400e+01, 3.94149865e+01,
-    #                2.78110081e+01, 1.71484176e+01, 4.59081223e+01, 3.25059995e+01,
-    #                3.03662465e+01, 4.15040920e-01, 4.21613876e-01, 4.07747156e-01,
-    #                4.32604236e-01, 4.19428929e-01, 4.01926017e-01, 4.36295072e-01,
-    #                4.37658392e-01, 4.14423735e-01, 4.39537540e-01, 2.65952198e-01,
-    #                2.63096106e-01, 2.24934845e-01, 1.66953435e-01, 2.32302802e-01,
-    #                2.55939246e-01, 2.42916828e-01, 2.39205412e-01, 2.79600625e-01,
-    #                9.58733328e-02, 8.08481274e-02, 7.34124368e-02, 1.04667432e-01,
-    #                1.26246347e-01, 1.14700200e-01, 1.22694002e-01, 7.86003659e-02,
-    #                1.34393803e-01])
-
     # trace of steps info
     step_trace = {}
 
@@ -207,7 +168,7 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
     step_trace['min_rounds'] = min_rounds
     step_trace['max_rounds'] = max_rounds
     step_trace['iters'] = iters
-
+    
     # BUG If ftol is -inf set it to a string
     ftol_value = ftol
     if ftol == -np.inf:
@@ -216,7 +177,6 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
         ftol_value = 'inf'
     
     step_trace['ftol'] = ftol_value
-
     step_trace['ftol_iter'] = ftol_iter
     step_trace['rtol'] = rtol
     step_trace['rtol_iter'] = rtol_iter
@@ -224,14 +184,13 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
     step_trace['n_particles'] = n_particles
     step_trace['n_steps'] = len(steps)
     step_trace['steps'] = copy.deepcopy(steps)
-
-    #step_trace['args'] = str(args) BUG MUST BE REMOVED?
-    step_trace['args'] = args
+    step_trace['args'] = str(args) #BUG MUST BE REMOVED
 
     if step_file is not None:
         with open(step_file, "w") as fo:
             json.dump(step_trace, fo)
 
+    print("Wrote step trace")
 
     # best round cost
     best_round_cost = np.inf
@@ -239,6 +198,7 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
     # request queue for worker
     req_queue = queue.Queue()
     
+    print("Created queue")
 
     conf = conf or {}
     done = False
@@ -251,13 +211,13 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
         thread_pool.append(worker)
         worker.start()
 
+    print("Started worker threads")
 
     r_below = 0
     early_exit = False
     start_time = datetime.datetime.now()
     for r in range(max_rounds):
         no_improvement = np.full(len(steps), True)
-        best_step_request = None
         for s, step in enumerate(steps):
 
             # check if forced exit.
@@ -268,8 +228,7 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
 
             param_names, bounds, objfunc = utils.get_step_info(steps, s)
             # maybe clone args?
-            # args['step_param_names'] = param_names
-            args['step_param'] = step['param']
+            args['step_param_names'] = param_names
             args['step_objfunc'] = objfunc
             # get calibrated parameter from all other steps
             args['calib_params'] = utils.get_calibrated_params(steps, s)
@@ -278,30 +237,25 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
             args['conf'] = conf
 
             print("Calling global best..")
-            # if r < 1:
-            # best_pos[s] = np.full(len(param_names), True)
-            # best_pos[s] = np.empty(len(param_names), dtype=object)
-            # best_pos[s] = None
 
             # create optimizer in the first round.
+            if optimizer[s] is None:
+                optimizer[s] = GlobalBestPSO(step.get('n_particles', n_particles),
+                                             len(param_names),
+                                             oh_strategy=step.get('oh_strategy', oh_strategy),
+                                             options=step.get('options', options),
+                                             bounds=bounds,
+                                             ftol=step.get('ftol', ftol),
+                                             ftol_iter=step.get('ftol_iter', ftol_iter),
+                                             cost_target=step.get('cost_target', cost_target))
+                
+            print('\n>>>>> R{}/S{}  particle params: {}  calibrated params: {}\n'.format(r + 1, s + 1, param_names, args['calib_params']))
+
             #if result_queue is not None:
             #    result_queue.put('\n>>>>> R{}/S{}  particle params: {}  calibrated params: {}\n'.format(r + 1, s + 1, param_names, args['calib_params']))
             
             print("Filled request queue...")
             
-            if optimizer[s] is None:
-                # if r <= 1:
-                optimizer[s] = GlobalBestPSO(step.get('n_particles', n_particles),
-                                            len(param_names),
-                                            oh_strategy=step.get('oh_strategy', oh_strategy),
-                                            options=step.get('options', options),
-                                            bounds=bounds,
-                                            ftol=step.get('ftol', ftol),
-                                            ftol_iter=step.get('ftol_iter', ftol_iter),
-                                            cost_target=step.get('cost_target', cost_target),
-                                            init_pos=None)
-            print('\n>>>>> R{}/S{}  particle params: {}  calibrated params: {}\n'.format(r + 1, s + 1, param_names, args['calib_params']))
-
             args['rnd'] = r + 1
             args['step'] = s + 1
 
@@ -309,30 +263,18 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
 
             # perform optimization
             cost, pos = optimizer[s].optimize(eval_cost, iters=step.get('iters', iters), **args)
-
-            for key in cost2:
-                # print(key, ' - ', cost2[key])
-                inner_arrays = cost2[key]
-                for arrays_part in inner_arrays:
-                    if arrays_part[1] == cost:
-                        print(' best-file ', arrays_part[2])
-
-            cost2.clear()
-            print(' cost: ', cost, ' pos: ', pos)
             if cost is None:
                 early_exit = True
                 break
 
             print("Finished evaluation...")
-            if cost == best_cost[s]:
-                print(' !! equal cost !!!')
 
-            # # capture the best cost
-            # # if cost < best_cost[s] and np.abs(cost - best_cost[s]) > rtol:
-            # if cost < best_cost[s]:
-            #     best_cost[s] = cost
-            #     no_improvement[s] = False
-            #     utils.annotate_step(best_cost[s], pos, steps, s)
+            # capture the best cost
+            # if cost < best_cost[s] and np.abs(cost - best_cost[s]) > rtol:
+            if cost < best_cost[s]:
+                best_cost[s] = cost
+                no_improvement[s] = False
+                utils.annotate_step(best_cost[s], pos, steps, s)
 
             print('\n     Step summary, best particle values: {} '.format(pos))
             
@@ -342,20 +284,18 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
             key = "r{}s{}".format(r + 1, s + 1)
             step_trace[key] = {}
             step_trace[key]['time'] = str(datetime.datetime.now())
-
-            #step_trace[key]['best_costs'] = best_costs_list BUG
-            step_trace[key]['best_costs'] = best_cost
+            
+            best_costs_list = best_cost.tolist()
+            # If the cost is inf, set it to a string
+            for i, c in enumerate(best_costs_list):
+                if c == np.inf:
+                    best_costs_list[i] = 'inf'
+                elif c == -np.inf:
+                    best_costs_list[i] = '-inf'
+            
+            step_trace[key]['best_costs'] = best_costs_list # BUG
             step_trace[key]['steps'] = copy.deepcopy(steps)
 
-            # capture the best cost
-            # if cost < best_cost[s] and np.abs(cost - best_cost[s]) > rtol:
-            if cost < best_cost[s]:
-                best_cost[s] = cost
-                no_improvement[s] = False
-                utils.annotate_step(best_cost[s], pos, steps, s)
-                best_step_request = key
-                # best_pos[s] = pos
-
             if step_file is not None:
                 with open(step_file, "w") as fo:
                     json.dump(step_trace, fo)
@@ -385,14 +325,22 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
         if result_queue is not None:
             result_queue.put('\n  Progress -  best_round_cost:{}, rel_round_tol:{}, rtol:{}'
               .format(best_round_cost, rel_round_tol, rtol))
-        print('\n  Progress -  best_step_request:{}'.format(best_step_request))
 
         key = "r{}".format(r + 1)
         step_trace[key] = {}
         step_trace[key]['time'] = str(datetime.datetime.now())
         step_trace[key]['round_cost'] = round_cost
-        step_trace[key]['best_costs'] = best_cost
-        step_trace[key]['improvements'] = no_improvement
+        
+        best_costs_list = best_cost.tolist() #BUG
+        # If the cost is inf, set it to a string
+        for i, c in enumerate(best_costs_list):
+            if c == np.inf:
+                best_costs_list[i] = 'inf'
+            elif c == -np.inf:
+                best_costs_list[i] = '-inf'
+        
+        step_trace[key]['best_costs'] = best_costs_list
+        step_trace[key]['improvements'] = no_improvement.tolist()
         if step_file is not None:
             with open(step_file, "w") as fo:
                 json.dump(step_trace, fo)
@@ -433,195 +381,3 @@ def global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters:
         result_queue.put(step_trace)
 
     return optimizer, step_trace
-
-# def p_global_best(steps: Dict, rounds: Tuple, args: Dict, n_particles: int, iters: int, options: Dict,
-#                   n_threads: int = 4, rtol: float = 0.001, ftol: float = -np.inf,
-#                   full_trace: List = None, rounds_below: int = 1) -> Tuple:
-#     """Performs a parallel stepwise particle swarm optimization PSO using a global best approach.
-#
-#         Parameters
-#         ----------
-#         steps : Dict
-#             step definitions
-#         rounds : tuple
-#             round definition,  (min,max) or max
-#         args : Dict
-#             static service args
-#         n_particles : int
-#             number of particles
-#         iters : int
-#             number of iterations
-#         options : Dict
-#             PSO options (see pyswarms)
-#         n_threads : int
-#             size of thread pool (default: 4)
-#         rtol : float
-#             percentage of change of sum(best_cost) between rounds for
-#             convergence. (Default is 0.001 0.1%)
-#         ftol : float
-#             PSO tolerance (default: -np.inf)
-#         full_trace : List
-#             trace of all runs, list of tuples
-#             first is dictionary of parameter names to parameter values
-#             second is the cost value (default: None)
-#         rounds_below : int
-#             the number of subsequent rounds with sum(best_cost) < rtol
-#             (default: 1)
-#         Returns
-#         -------
-#         Tuple
-#             optimizer: List, step_trace: Dict
-#     """
-#
-#     utils.check_url(args['url'])
-#
-#     min_rounds = 1
-#     if type(rounds) == tuple:
-#         min_rounds = rounds[0]
-#         max_rounds = rounds[1]
-#     else:
-#         max_rounds = rounds
-#
-#     if min_rounds < 1:
-#         raise Exception('min rounds >= 1 expected, was "{}"'.format(min_rounds))
-#
-#     if max_rounds > 20:
-#         raise Exception('max rounds <= 20 expected, was "{}"'.format(max_rounds))
-#
-#     if n_threads < 1:
-#         raise Exception('n_threads >= 1, was "{}"'.format(n_threads))
-#
-#     if rounds_below < 1:
-#         raise Exception('rounds_below >= 1, was "{}"'.format(rounds_below))
-#
-#     if full_trace is not None and not isinstance(full_trace, list):
-#         raise Exception('full_trace must be of type, was "{}"'.format(type(full_trace)))
-#
-#     best_cost = np.ones(len(steps))
-#     cost = np.ones(len(steps))
-#     optimizer = np.empty(len(steps), dtype=object)
-#     pos = np.empty(len(steps), dtype=object)
-#     args_s = np.empty(len(steps), dtype=object)
-#
-#     # trace of steps info
-#     step_trace = {}
-#
-#     # best round cost
-#     best_round_cost = 1000
-#
-#     # request queue for worker
-#     req_queue = queue.Queue()
-#
-#     # Threadpool management
-#     done = False
-#     thread_pool = []
-#     for thread_no in range(n_threads):
-#         worker = Thread(target=csip_worker, args=(req_queue, thread_no, lambda: done,
-#                                                   full_trace, args['url'], args['files'], args['param']))
-#         thread_pool.append(worker)
-#         worker.start()
-#
-#     start_time = datetime.datetime.now()
-#
-#     # setup Step PSOs
-#     for s, step in enumerate(steps):
-#         param_names, bounds, objfunc = utils.get_step_info(steps, s)
-#         optimizer[s] = GlobalBestPSO(n_particles,
-#                                      len(param_names),
-#                                      options=options,
-#                                      bounds=bounds,
-#                                      ftol=ftol)
-#
-#     def step_thread(s, args):
-#         cost[s], pos[s] = optimizer[s].optimize(eval_cost, iters=iters, **args)
-#
-#     # Run PSOs in parallel
-#     r_below = 0
-#     for r in range(max_rounds):
-#         no_improvement = np.full(len(steps), True)
-#         # check if forced exit.
-#         if path.exists("stop"):
-#             print('\n>>>>> stop file found, exit now.')
-#             break
-#
-#         # cross copy calibrated parameter, setup the arguments
-#         for s, step in enumerate(steps):
-#             param_names, bounds, objfunc = utils.get_step_info(steps, s)
-#             # maybe clone args?
-#             args_s[s] = args
-#             args_s[s]['step_param_names'] = param_names
-#             args_s[s]['step_objfunc'] = objfunc
-#             # get calibrated parameter from all other steps
-#             args_s[s]['calib_params'] = utils.get_calibrated_params(steps, s)
-#
-#             args_s[s]['req_queue'] = req_queue
-#
-#             # create optimizer in the first round.
-#             print('\n>>>>> R{}/S{}  particle params: {} calibrated params: {}\n'.format(r + 1, s + 1, param_names,
-#                                                                                         args_s[s]['calib_params']))
-#
-#         # perform optimization
-#         s_threads = []
-#         for s, step in enumerate(steps):
-#             s_thread = threading.Thread(target=step_thread, args=(s, args_s[s]))
-#             s_threads.append(s_thread)
-#             s_thread.start()
-#
-#         for t in s_threads:
-#             t.join()
-#
-#         # eval cost
-#         for s, step in enumerate(steps):
-#             # capture the best cost
-#             # if cost < best_cost[s] and np.abs(cost - best_cost[s]) > rtol:
-#             if cost[s] < best_cost[s]:
-#                 best_cost[s] = cost[s]
-#                 no_improvement[s] = False
-#                 utils.annotate_step(best_cost[s], pos[s], steps, s)
-#
-#             print('\n     Step {} summary, best particle values: {} '.format(s, pos[s]))
-#
-#             key = "r{}s{}".format(r + 1, s + 1)
-#             step_trace[key] = copy.deepcopy(steps)
-#
-#             # print(json.dumps(steps, sort_keys=False, indent=2))
-#
-#         round_cost = np.sum(best_cost)
-#
-#         # if no improvement in all steps, break out of rounds prematurely
-#         # but start checking only after min_rounds
-#         # if (r + 1 >= min_rounds) and all(no_improvement):
-#         rel_round_tol = 1 - round_cost / best_round_cost
-#
-#         print('\n  Round summary - round_cost:{}, step_costs: {}, step improvement:{}'
-#               .format(round_cost, best_cost, np.invert(no_improvement)))
-#         print('\n  Progress -  best_round_cost:{}, rel_round_tol:{}, rtol:{}'
-#               .format(best_round_cost, rel_round_tol, rtol))
-#
-#         if (r + 1 >= min_rounds) and 0 <= rel_round_tol < rtol:
-#             r_below += 1
-#             if r_below == rounds_below:
-#                 break
-#         else:
-#             # reset
-#             r_below = 0
-#
-#         if round_cost < best_round_cost:
-#             best_round_cost = round_cost
-#
-#     end_time = datetime.datetime.now()
-#     elapsed = str(end_time - start_time)
-#
-#     print('Done in {} after {} out of {} rounds'.format(elapsed, r + 1, max_rounds))
-#
-#     done = True
-#     for worker in thread_pool:
-#         worker.join()
-#
-#     step_trace['rounds'] = r + 1
-#     step_trace['steps'] = len(steps)
-#     step_trace['iters'] = iters
-#     step_trace['particles'] = n_particles
-#     step_trace['time'] = elapsed
-#
-#     return optimizer, step_trace