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

{mg_pso_gui-0.2.125.dist-info → mg_pso_gui-0.2.126.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mg-pso-gui
-Version: 0.2.125
+Version: 0.2.126
 Summary: GUI for MG-PSO
 Author: Robert Cordingly
 Author-email: <rcording@uw.ed>

{mg_pso_gui-0.2.125.dist-info → mg_pso_gui-0.2.126.dist-info}/RECORD

@@ -1,7 +1,7 @@
 mgpsogui/__init__.py,sha256=q7AfBjeJABnFtbsZnsObpUwaXKPDVYtz46G6MKXLF74,42
 mgpsogui/mgpsogui.py,sha256=NIZmyNcbwC8EgSwf1ubdMUSJscrIEgoD4jLYziqHQ-k,148
 mgpsogui/start.yaml,sha256=ZjCVLb-MLqAxrGRm9kA7_SDpa-45EuKIELNQ2QqCAiU,4713
-mgpsogui/gui/HomePage.py,sha256=N_0FGZ8R6fiMBHiNWYNMM8h3QvudteaJ_Fq5GDxoPug,26053
+mgpsogui/gui/HomePage.py,sha256=fTGAuCUBWaydSe0t7HO95snJ1B6j2xa5GJcEJSLymBA,25974
 mgpsogui/gui/OptionManager.py,sha256=t0aXOeBo48qQ-P8OykpP2v_3KJoaJtUPSkYtacjloCc,22844
 mgpsogui/gui/OptionManager_backup.py,sha256=TCWfPnHL2foN5id47jsi267lamRG6yGU6y_M29eOOJk,18530
 mgpsogui/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,7 +19,7 @@ mgpsogui/gui/SetupTab/CustomFunctionEditorWindow.py,sha256=lZ9a20YucwhCDiUN3eGA6
 mgpsogui/gui/SetupTab/CustomFunctionMetrics.py,sha256=vOJpElbTgz043m6JYwe9xz_2MBHg985S6KdbJkJERW4,5923
 mgpsogui/gui/SetupTab/FunctionsList.py,sha256=wmYmppyB5y8QADe3X_FQ5mAYVDC0HAPQgqtkegNwmLA,7007
 mgpsogui/gui/SetupTab/ListEditor.py,sha256=nin7Pl8z7d_yfKoAxM-yVS34uhj-LnprJ2mNRSB7Z0A,3197
-mgpsogui/gui/SetupTab/ListParametersView.py,sha256=mkGaC5cXhEOy5oD0MbTyK9z7VGZp019oK2Y8Ay-n05Q,7460
+mgpsogui/gui/SetupTab/ListParametersView.py,sha256=CdK7OVdccwk0_OLgrwwNFTHuV2hMvETsocQIKndZoV4,7459
 mgpsogui/gui/SetupTab/OverrideParameterMetrics.py,sha256=rBfaSitYDOajbHvyi2TfoXAHYlz1cCt028UVpIJ_Dc0,3369
 mgpsogui/gui/SetupTab/OverrideParameterWindow.py,sha256=1UJHel0BH4sYa5WQnuSaFd3cdpRwAIwOpFIbhDS30IY,1824
 mgpsogui/gui/SetupTab/SamplingListView.py,sha256=DhZBAhDcrqZn1XioCs1gTe_v-8W10C0UfPm0fLAbeXM,5260
@@ -58,7 +58,9 @@ mgpsogui/util/CTkToolTip/ctk_tooltip.py,sha256=SZMovpQIGvdpDRbqCKl9SHs92DrFCO2MO
 mgpsogui/util/recosu/__init__.py,sha256=pPR0lB6clIi6q73H1W8eT5u0dd3bIemwa9-XFmOaVVk,279
 mgpsogui/util/recosu/pso/__init__.py,sha256=PQ548aEKVOk6MMzxxDg7yMO_1hHfoEoYLLkGLeij73Y,247
 mgpsogui/util/recosu/pso/csip_access.py,sha256=_oA71d6CSwhKSa3pgywIW7mXRJtgJTNu1X2DiBkQkuA,4152
-mgpsogui/util/recosu/pso/pso.py,sha256=qUwpp6gjhCTXA6twKGAda84HIeQebKGB6MJ4K9GfcdM,23181
+mgpsogui/util/recosu/pso/pso modified.py,sha256=sFY1csASu5Os5SSheWWdpVcjpPwJeBqZKsv89DLXdxk,21648
+mgpsogui/util/recosu/pso/pso.py,sha256=iPqT6aI1vi8LYuWmtxuHkLEM9sQwhUznPInBgps7ANI,13708
+mgpsogui/util/recosu/pso/pso_new.py,sha256=qUwpp6gjhCTXA6twKGAda84HIeQebKGB6MJ4K9GfcdM,23181
 mgpsogui/util/recosu/sampling/__init__.py,sha256=dWs1MPx0o2UFmOmUfFaomQWBTIZAwALsVJzZQNZePZU,252
 mgpsogui/util/recosu/sampling/sample_trace_writer.py,sha256=M9w-POLlZgjL5a7J7yxr73OG6mCsS2aUuP9d3HKfkbA,1966
 mgpsogui/util/recosu/sampling/sampler_task.py,sha256=uZobpR83u6xEaUzIknvW9FbB84c2AL7T-5T8O8QIhzY,2776
@@ -73,8 +75,8 @@ mgpsogui/util/recosu/utils/trace_writer.py,sha256=V9BJlOjCbNYGoXGEk3CF5wjifBxvar
 mgpsogui/util/recosu/utils/utils.py,sha256=6MIoJb0nhIa4tNv7qhBfZi-AtL3L95CgJf6eAf12NQs,4140
 mgpsogui/util/recosu/utils/plot/__init__.py,sha256=h1KjM7_tNDv351pcwt8A6Ibb1jhwWyx5Gbu-zj-sI3Q,71
 mgpsogui/util/recosu/utils/plot/cost_steps.py,sha256=1Ce11AJyweWkmvjXPxEygzS-h8yVLmQEDLS53yjPLqQ,3779
-mg_pso_gui-0.2.125.dist-info/METADATA,sha256=1cfBNFu2xvNbvbzQQKz2JtmCFVC5Z49qKHPxNW0oWB4,9542
-mg_pso_gui-0.2.125.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-mg_pso_gui-0.2.125.dist-info/entry_points.txt,sha256=jg82VOFjR1XDGrchs1wJSCqKYE4Ozv12aBcCSp--koA,117
-mg_pso_gui-0.2.125.dist-info/top_level.txt,sha256=y7JuS9xJN5YdxUsQ3PSVjN8MzQAnR146bP3ZN3PYWdE,9
-mg_pso_gui-0.2.125.dist-info/RECORD,,
+mg_pso_gui-0.2.126.dist-info/METADATA,sha256=WoBCQFVK_l0TIamnui7_FpcDK8hr6Tc0-a5kYKXAQV0,9542
+mg_pso_gui-0.2.126.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+mg_pso_gui-0.2.126.dist-info/entry_points.txt,sha256=jg82VOFjR1XDGrchs1wJSCqKYE4Ozv12aBcCSp--koA,117
+mg_pso_gui-0.2.126.dist-info/top_level.txt,sha256=y7JuS9xJN5YdxUsQ3PSVjN8MzQAnR146bP3ZN3PYWdE,9
+mg_pso_gui-0.2.126.dist-info/RECORD,,

mgpsogui/gui/HomePage.py

@@ -145,7 +145,7 @@ class App(customtkinter.CTk):
 		self.sidebar_frame.grid_columnconfigure(4, weight=1)
 		self.logo_label = customtkinter.CTkLabel(self.sidebar_frame, text="COSU Manager (" + version + ")", font=customtkinter.CTkFont(size=20, weight="bold"))
 		self.logo_label.grid(row=0, column=0, padx=(20, 10), pady=header_padding_y)
-		self.save_button = customtkinter.CTkButton(self.sidebar_frame, text="Save", width=60, command=self.save_project)
+		self.save_button = customtkinter.CTkButton(self.sidebar_frame, text="Save As", width=60, command=self.save_project)
 		self.save_button.grid(row=0, column=1, padx=header_padding_x, pady=header_padding_y)
 		self.load_button = customtkinter.CTkButton(self.sidebar_frame, text="Load", width=60, command=self.load_project)
 		self.load_button.grid(row=0, column=2, padx=header_padding_x, pady=header_padding_y)
@@ -258,11 +258,11 @@ class App(customtkinter.CTk):
 				os.makedirs(os.path.join(folder, "results"))
 				
 			self.save_button.configure(text="Saved!")
-			self.after(3000, lambda: self.save_button.configure(text="Save"))
+			self.after(3000, lambda: self.save_button.configure(text="Save As"))
 		except Exception as e:
 			self.save_button.configure(text="Error!")
 			print(e)
-			self.after(3000, lambda: self.save_button.configure(text="Save"))
+			self.after(3000, lambda: self.save_button.configure(text="Save As"))
 
 	def auto_save_project(self):
 		data = self.option_manager.get_project_data()
@@ -281,8 +281,6 @@ class App(customtkinter.CTk):
 				if not os.path.exists(os.path.join(folder, "results")):
 					os.makedirs(os.path.join(folder, "results"))
 					
-				self.save_button.configure(text="Saved!")
-				self.after(1000, lambda: self.save_button.configure(text="Save"))
 			except Exception as e:
 				self.save_button.configure(text="Error!")
 				print(e)
@@ -445,6 +443,8 @@ class App(customtkinter.CTk):
 			NW(title="Error", message="A process is already running!", x = 400, y = 200)
 			return 0
 		
+		self.auto_save_project()
+
 		data = self.option_manager.get_all_data()
 		mode = self.option_manager.get_mode()
 		data = data[mode]

mgpsogui/gui/SetupTab/ListParametersView.py

@@ -138,7 +138,7 @@ class ListParametersView(CTkScrollableFrame):
         row += 1
         
         CTkButton(self.containerFrame, text="Open", command=self.open_csv).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
-        CTkButton(self.containerFrame, text="Import", command=self.import_csv).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+        CTkButton(self.containerFrame, text="Paste", command=self.import_csv).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
         row += 1
         
         

mgpsogui/util/recosu/pso/pso modified.py

@@ -0,0 +1,585 @@
+#
+# $Id:$
+#
+# This file is part of the Cloud Services Integration Platform (CSIP),
+# a Model-as-a-Service framework, API, and application suite.
+#
+# 2012-2020, OMSLab, Colorado State University.
+#
+# 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
+from pyswarms.single.global_best import GlobalBestPSO
+from os import path
+from threading import Thread
+from typing import Dict, List, Set, Tuple
+import numpy as np
+import copy
+import datetime
+import queue
+import json
+import os
+
+cost2 = {}
+
+
+def eval_cost(x, iteration, step_param, step_objfunc, calib_params, req_queue, files, url, param, conf: Dict, rnd,
+              step):
+    particles = len(x[:, 0])
+
+    pfail_count = conf.get('particles_fail', 1)  # Number of particles allowed to fail.
+    pfail_retry = conf.get('particles_retry', 3)  # retry number of times if more than allowed fail
+
+    while pfail_retry > 0:
+        cost = np.ones(particles)
+        res_queue = queue.Queue()
+
+        print('   ', end='', flush=True)
+
+        # 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((i_particle, x[i_particle,:], step_param_names, calib_params, step_objfunc, res_queue))
+
+        # wait for the cost value to come back
+        # for i, v in enumerate(x[:, 0]):
+        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()
+
+        # replace the 'nan' cost values (failed/missing runs) with the mean of the
+        # rest of the cost values, hence ignore it
+
+        # print("cost ", cost)
+        nan_idx = np.where(np.isnan(cost))
+        failed_particles = len(nan_idx[0])
+
+        # 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
+
+    if pfail_retry == 0:
+        print('Particle evaluation failed ', conf.get('particles_retry', 3), ' times. PSO stopped.')
+        return None
+
+    # print("mean ", mean)
+    # assign the mean value to all failed runs.
+    mean = np.nanmean(cost)
+    cost[nan_idx[0]] = mean
+
+    for key in cost2:
+        # print(key, ' - ', cost2[key])
+        cost2[key][iteration][1] = cost[key]
+        # 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,
+                conf: Dict = None, metainfo: Dict = None, cost_target: float = -np.inf) -> Tuple:
+    """Performs a 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)
+        oh_strategy : Dict
+            PSO Option handling strategy (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)
+        ftol_iter : float
+            number of iterations over which the relative error in
+            objective_func is acceptable for convergence. (default: 1)
+        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)
+        rtol_iter : int
+            the number of subsequent rounds with sum(best_cost) < rtol
+            (default: 1)
+        conf : Dict
+            configuration settings (default: {} )
+        metainfo : Dict
+             additional metainfo for the csip client (default: {} )
+        cost_target: float
+             the cost target (default: -np.inf)
+        Returns
+        -------
+        Tuple
+            optimizer: List, step_trace: Dict
+
+    """
+
+    utils.check_url(args['url'])
+
+    step_file = conf.get('step_trace', None)
+
+    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 rtol_iter < 1:
+        raise Exception('rtol_iter >= 1, was "{}"'.format(rtol_iter))
+
+    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)) * 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 = {}
+
+    step_trace['dir'] = os.getcwd()
+    step_trace['start'] = str(datetime.datetime.now())
+    step_trace['min_rounds'] = min_rounds
+    step_trace['max_rounds'] = max_rounds
+    step_trace['iters'] = iters
+    step_trace['ftol'] = ftol
+    step_trace['ftol_iter'] = ftol_iter
+    step_trace['rtol'] = rtol
+    step_trace['rtol_iter'] = rtol_iter
+    step_trace['n_threads'] = n_threads
+    step_trace['n_particles'] = n_particles
+    step_trace['n_steps'] = len(steps)
+    step_trace['steps'] = copy.deepcopy(steps)
+    step_trace['args'] = args
+
+    if step_file is not None:
+        with open(step_file, "w") as fo:
+            json.dump(step_trace, fo)
+
+    # best round cost
+    best_round_cost = np.inf
+
+    # request queue for worker
+    req_queue = queue.Queue()
+
+    conf = conf or {}
+    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.get('files', None), args['param'],
+                                                  conf, metainfo)
+                        )
+        thread_pool.append(worker)
+        worker.start()
+
+    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.
+            if path.exists("stop"):
+                print('\n>>>>> stop file found, exit now.')
+                early_exit = True
+                break
+
+            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_objfunc'] = objfunc
+            # get calibrated parameter from all other steps
+            args['calib_params'] = utils.get_calibrated_params(steps, s)
+
+            args['req_queue'] = req_queue
+            args['conf'] = conf
+
+            # 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:
+                # 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
+
+            # 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
+
+            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)
+
+            print('\n     Step summary, best particle values: {} '.format(pos))
+
+            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_cost
+            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)
+
+            # print(json.dumps(steps, sort_keys=False, indent=2))
+
+        if early_exit:
+            step_trace['exit'] = '1'
+            break
+
+        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))
+        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
+        if step_file is not None:
+            with open(step_file, "w") as fo:
+                json.dump(step_trace, fo)
+
+        if (r + 1 >= min_rounds) and 0 <= rel_round_tol < rtol:
+            r_below += 1
+            if r_below >= rtol_iter:
+                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['end'] = str(datetime.datetime.now())
+    step_trace['time'] = elapsed
+
+    if step_file is not None:
+        with open(step_file, "w") as fo:
+            json.dump(step_trace, fo)
+
+    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