mg-pso-gui 0.2.119__py3-none-any.whl → 0.2.122__py3-none-any.whl

{mg_pso_gui-0.2.119.dist-info → mg_pso_gui-0.2.122.dist-info}/METADATA

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

{mg_pso_gui-0.2.119.dist-info → mg_pso_gui-0.2.122.dist-info}/RECORD

@@ -1,11 +1,11 @@
 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=NiddhmNT9VXPl9s5ksFOkC6RHmTf5qQErQNeUuqJ9L8,25158
+mgpsogui/gui/HomePage.py,sha256=Lz0P7TgRwzvocxxNWr84d-LvMzdTs_VvwrNkxP28kuI,25155
 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
-mgpsogui/gui/General/NoticeWindow.py,sha256=bD5M5TXd4vaWwYw6nL0sGL072wqFTBdNTNtpwDuUyeY,1949
+mgpsogui/gui/General/NoticeWindow.py,sha256=uPOXXBhofvcPbaC8-VYyqy2_AtY_8-lcg5O6Rua_jcA,2466
 mgpsogui/gui/General/ParameterView.py,sha256=H7BqT1UiEYpGp8d6ycdKaKtuqY5IkrlHOXiiN_pgcMM,10059
 mgpsogui/gui/General/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mgpsogui/gui/PlatformTab/PlatformTab.py,sha256=8J2Aa3Zrh1q9x07zZ0Ap9PgwHjeSKOYyj6wlxx40udw,10985
@@ -13,17 +13,17 @@ mgpsogui/gui/PlatformTab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 mgpsogui/gui/RunTab/OptimalParameterView.py,sha256=nliUEWA840cPBQt7wjiZ-L7uBOp_ozzJhyBkL08fJzI,1752
 mgpsogui/gui/RunTab/RunTab.py,sha256=_JWzDx5LT_uISw0Vnv-W2ypIeuKgoWqBnvFnvrLhNQA,5917
 mgpsogui/gui/RunTab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mgpsogui/gui/SetupTab/BoundsEditorWindow.py,sha256=U64oaiDIOaimjbqKMz5rQNq2o1SrQtrRHDdTYQ9ux1s,2870
+mgpsogui/gui/SetupTab/BoundsEditorWindow.py,sha256=7Vic6AkBI2FStMlYyPH0-dNJJyqEckYJpwxknAqtp84,3403
 mgpsogui/gui/SetupTab/BoundsList.py,sha256=UHXVpofV1201udOsz_jCva-XktFVLBvlkeeR-eOQhUY,15515
-mgpsogui/gui/SetupTab/CustomFunctionEditorWindow.py,sha256=yx0dHSNa7fGy99Q6qFcI6j9r8p0DlV3iOBgyPMGd8pM,2884
+mgpsogui/gui/SetupTab/CustomFunctionEditorWindow.py,sha256=lZ9a20YucwhCDiUN3eGA6WXQK7laToB7FP4Zev4Zxnc,3417
 mgpsogui/gui/SetupTab/CustomFunctionMetrics.py,sha256=vOJpElbTgz043m6JYwe9xz_2MBHg985S6KdbJkJERW4,5923
 mgpsogui/gui/SetupTab/FunctionsList.py,sha256=6oFS8qKF3OCtxNi5aY5Rj_ovM9nv4-vh-oT_CbhVTj4,7043
 mgpsogui/gui/SetupTab/ListEditor.py,sha256=nin7Pl8z7d_yfKoAxM-yVS34uhj-LnprJ2mNRSB7Z0A,3197
 mgpsogui/gui/SetupTab/ListParametersView.py,sha256=mkGaC5cXhEOy5oD0MbTyK9z7VGZp019oK2Y8Ay-n05Q,7460
 mgpsogui/gui/SetupTab/OverrideParameterMetrics.py,sha256=rBfaSitYDOajbHvyi2TfoXAHYlz1cCt028UVpIJ_Dc0,3369
-mgpsogui/gui/SetupTab/OverrideParameterWindow.py,sha256=UpZDxTaFxee0BeviUYXeiIlMNYNy00qz3zlMlM5VcXE,1291
+mgpsogui/gui/SetupTab/OverrideParameterWindow.py,sha256=1UJHel0BH4sYa5WQnuSaFd3cdpRwAIwOpFIbhDS30IY,1824
 mgpsogui/gui/SetupTab/SamplingListView.py,sha256=DhZBAhDcrqZn1XioCs1gTe_v-8W10C0UfPm0fLAbeXM,5260
-mgpsogui/gui/SetupTab/SamplingNameListWindow.py,sha256=QzVu8mSpFGy3mUlLonk94k5thDNdJzw2d3qmEq89RAQ,2866
+mgpsogui/gui/SetupTab/SamplingNameListWindow.py,sha256=XX9PPYZfhCnj7j-ZO8n1cGY-ANwEuw1ZjL0yeU18kgA,3399
 mgpsogui/gui/SetupTab/SetupTab.py,sha256=3V8LYvg5ulTll1hhguB_XpSoOR-w72vHh_Z3gw3nCxc,2758
 mgpsogui/gui/SetupTab/StepView.py,sha256=zogpFpGPRHrVZTADGGl6D5gHj0rfUmlTIJBxA50stbg,10399
 mgpsogui/gui/SetupTab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -57,8 +57,8 @@ mgpsogui/util/CTkToolTip/__init__.py,sha256=G1jxV55hGtGgwyC1sR-uUUdasDdh0XZgcI-a
 mgpsogui/util/CTkToolTip/ctk_tooltip.py,sha256=SZMovpQIGvdpDRbqCKl9SHs92DrFCO2MOYL2ifolvOE,6329
 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=jBli1MSShUUwQCMKOUvMaGuNwBViCrjXJi_FmSEJsZA,2721
-mgpsogui/util/recosu/pso/pso.py,sha256=iPqT6aI1vi8LYuWmtxuHkLEM9sQwhUznPInBgps7ANI,13708
+mgpsogui/util/recosu/pso/csip_access.py,sha256=_oA71d6CSwhKSa3pgywIW7mXRJtgJTNu1X2DiBkQkuA,4152
+mgpsogui/util/recosu/pso/pso.py,sha256=phW1kRsEp8h7bcgeqku-kWwnZsguDX53-F8HM7q40iE,23150
 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
@@ -70,11 +70,11 @@ mgpsogui/util/recosu/sampling/random/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 mgpsogui/util/recosu/sampling/random/random_sampler.py,sha256=cVF2VA40v9h0OSBgwXCKMw4wJGaQnUfBdwVPMffk_9U,905
 mgpsogui/util/recosu/utils/__init__.py,sha256=TXz_TpNif2GeGu22pzTnkUQvaP-PmLQ9Sz4BgMIS6ig,196
 mgpsogui/util/recosu/utils/trace_writer.py,sha256=V9BJlOjCbNYGoXGEk3CF5wjifBxvarrMRXJMbDBWqI8,3023
-mgpsogui/util/recosu/utils/utils.py,sha256=QB8vftq3142ekG0ORjz0ZBHU5YknXbR0oTsrxrPAsF0,3951
+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.119.dist-info/METADATA,sha256=iOIGUO0VDSt_trIKV4koEjhF56lr__R2IMXuwNT4qXc,9542
-mg_pso_gui-0.2.119.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-mg_pso_gui-0.2.119.dist-info/entry_points.txt,sha256=jg82VOFjR1XDGrchs1wJSCqKYE4Ozv12aBcCSp--koA,117
-mg_pso_gui-0.2.119.dist-info/top_level.txt,sha256=y7JuS9xJN5YdxUsQ3PSVjN8MzQAnR146bP3ZN3PYWdE,9
-mg_pso_gui-0.2.119.dist-info/RECORD,,
+mg_pso_gui-0.2.122.dist-info/METADATA,sha256=WUY3YFL6zE3UtSJcK-KNT7BOkNAb7fiNxCsa3Jl-mSI,9542
+mg_pso_gui-0.2.122.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+mg_pso_gui-0.2.122.dist-info/entry_points.txt,sha256=jg82VOFjR1XDGrchs1wJSCqKYE4Ozv12aBcCSp--koA,117
+mg_pso_gui-0.2.122.dist-info/top_level.txt,sha256=y7JuS9xJN5YdxUsQ3PSVjN8MzQAnR146bP3ZN3PYWdE,9
+mg_pso_gui-0.2.122.dist-info/RECORD,,

mgpsogui/gui/General/NoticeWindow.py

@@ -20,7 +20,21 @@ class NoticeWindow(CTkInputDialog):
                  **kwargs):
         super().__init__(*args, **kwargs)
         
-        self.geometry(str(x) + "x" + str(y))
+        screen_width = self.winfo_screenwidth()
+        screen_height = self.winfo_screenheight()
+        win_width = x
+        win_height = y
+        if screen_width < win_width:
+            win_width = screen_width * 0.9
+
+        if screen_height < win_height:
+            win_height = screen_height * 0.9
+
+        # Calculate the x and y coordinates to center the window
+        x_coord = (screen_width // 2) - (win_width // 2)
+        y_coord = (screen_height // 2) - (win_height // 2)
+
+        self.geometry(f"{win_width}x{win_height}+{x_coord}+{y_coord}")
 
         self.message = message
 

mgpsogui/gui/HomePage.py

@@ -114,7 +114,8 @@ class App(customtkinter.CTk):
 		self.testing = False
 
 		# Configure window
-		self.title("COSU Manager (v0.2.120)")
+		version = "v0.2.120"
+		self.title("COSU Manager (" + version + ")")
 
 		screen_width = self.winfo_screenwidth()
 		screen_height = self.winfo_screenheight()
@@ -130,9 +131,6 @@ class App(customtkinter.CTk):
 
 		self.geometry(f"{win_width}x{win_height}+{x_coord}+{y_coord}")
 
-		# Center the Window on the screen
-		
-
 		# configure grid layout (4x4)
 		self.grid_columnconfigure(0, weight=1)
 		self.grid_rowconfigure(1, weight=1)
@@ -143,7 +141,7 @@ class App(customtkinter.CTk):
 		self.sidebar_frame = customtkinter.CTkFrame(self, width=140, corner_radius=0)
 		self.sidebar_frame.grid(row=0, column=0, sticky="nsew")
 		self.sidebar_frame.grid_columnconfigure(4, weight=1)
-		self.logo_label = customtkinter.CTkLabel(self.sidebar_frame, text="COSU Manager (v0.2.112)", font=customtkinter.CTkFont(size=20, weight="bold"))
+		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.grid(row=0, column=1, padx=header_padding_x, pady=header_padding_y)

mgpsogui/gui/SetupTab/BoundsEditorWindow.py

@@ -19,7 +19,21 @@ class BoundsEditorWindow(CTkInputDialog):
                  **kwargs):
         super().__init__(*args, **kwargs)
         
-        self.geometry("400x800")
+        screen_width = self.winfo_screenwidth()
+        screen_height = self.winfo_screenheight()
+        win_width = 400
+        win_height = 800
+        if screen_width < win_width:
+            win_width = screen_width * 0.9
+
+        if screen_height < win_height:
+            win_height = screen_height * 0.9
+
+        # Calculate the x and y coordinates to center the window
+        x_coord = (screen_width // 2) - (win_width // 2)
+        y_coord = (screen_height // 2) - (win_height // 2)
+
+        self.geometry(f"{win_width}x{win_height}+{x_coord}+{y_coord}")
         
         self.step_index = step_index
         self.bound_index = bound_index  

mgpsogui/gui/SetupTab/CustomFunctionEditorWindow.py

@@ -19,7 +19,21 @@ class CustomFunctionEditorWindow(CTkInputDialog):
                  **kwargs):
         super().__init__(*args, **kwargs)
         
-        self.geometry("400x800")
+        screen_width = self.winfo_screenwidth()
+        screen_height = self.winfo_screenheight()
+        win_width = 400
+        win_height = 800
+        if screen_width < win_width:
+            win_width = screen_width * 0.9
+
+        if screen_height < win_height:
+            win_height = screen_height * 0.9
+
+        # Calculate the x and y coordinates to center the window
+        x_coord = (screen_width // 2) - (win_width // 2)
+        y_coord = (screen_height // 2) - (win_height // 2)
+
+        self.geometry(f"{win_width}x{win_height}+{x_coord}+{y_coord}")
         
         self.step_index = step_index
         self.function_index = function_index  

mgpsogui/gui/SetupTab/OverrideParameterWindow.py

@@ -18,7 +18,21 @@ class OverrideParameterWindow(CTkInputDialog):
                  **kwargs):
         super().__init__(*args, **kwargs)
         
-        self.geometry("400x800")
+        screen_width = self.winfo_screenwidth()
+        screen_height = self.winfo_screenheight()
+        win_width = 400
+        win_height = 800
+        if screen_width < win_width:
+            win_width = screen_width * 0.9
+
+        if screen_height < win_height:
+            win_height = screen_height * 0.9
+
+        # Calculate the x and y coordinates to center the window
+        x_coord = (screen_width // 2) - (win_width // 2)
+        y_coord = (screen_height // 2) - (win_height // 2)
+
+        self.geometry(f"{win_width}x{win_height}+{x_coord}+{y_coord}")
         
         self.step_index = step_index
         self.option_manager = option_manager

mgpsogui/gui/SetupTab/SamplingNameListWindow.py

@@ -19,7 +19,21 @@ class SamplingNameListWindow(CTkInputDialog):
                  **kwargs):
         super().__init__(*args, **kwargs)
         
-        self.geometry("400x800")
+        screen_width = self.winfo_screenwidth()
+        screen_height = self.winfo_screenheight()
+        win_width = 400
+        win_height = 800
+        if screen_width < win_width:
+            win_width = screen_width * 0.9
+
+        if screen_height < win_height:
+            win_height = screen_height * 0.9
+
+        # Calculate the x and y coordinates to center the window
+        x_coord = (screen_width // 2) - (win_width // 2)
+        y_coord = (screen_height // 2) - (win_height // 2)
+
+        self.geometry(f"{win_width}x{win_height}+{x_coord}+{y_coord}")
         
         self.step_index = step_index
         self.bound_index = bound_index  

mgpsogui/util/recosu/pso/csip_access.py

@@ -10,25 +10,56 @@ def csip_worker(reqq: queue.Queue, thread_no: int, stop, full_trace,
     save_resp = conf.get('save_response_to', None)  # save response, set it to a folder if responses should be saved.
 
     while not stop():
-        
         try:
-            (rnd, step, iteration, particle, x, step_param_names, calib_params, objfunc, resq) = reqq.get(True, 0.5)
+            (rnd, step, iteration, particle, x, step_param, calib_params, objfunc, resq) = reqq.get(True, 0.5)
             # print(thread_no, particle)
-    
+
             c = Client(metainfo=metainfo)
 
+            all_params = {}
+
             # static params (from args)
             for param in arg_params:
                 c.add_data(param['name'], param['value'])
 
             # particle params  (generated from steps)
             # for i, value in enumerate(x):
-            for idx, value in enumerate(x[particle, :]):
-                c.add_data(step_param_names[idx], value)
+            # for idx, value in enumerate(x[particle, :]):
+            #     c.add_data(step_param_names[idx], value)
+            values = x[particle]
+            idx = 0
+            for p in step_param:
+                value_type = p.get('type', 'float')
+                if 'float' == value_type:
+                    c.add_data(p['name'], values[idx])
+                    all_params[p['name']] = values[idx]
+                    idx = idx + 1
+                elif 'list' == value_type:
+                    base_name = p['name']
+                    calibration_strategy = p.get('calibration_strategy', 'mean')
+
+                    if 'mean' == calibration_strategy:
+                        mean = values[idx]
+                        default_value = p['default_value']
+                        value = [(1 + mean) * x for x in default_value]
+                        c.add_data(base_name, value)
+                        all_params[base_name] = value
+                        idx = idx + 1
+                    elif 'single' == calibration_strategy:
+                        default_value = p['default_value']
+                        sub_index = 0
+                        value = default_value.copy()
+                        while sub_index < len(default_value):
+                            value[sub_index] = values[idx]
+                            idx = idx + 1
+                            sub_index = sub_index + 1
+                        c.add_data(base_name, value)
+                        all_params[base_name] = value
 
             # other, previously calibrated params (other steps)
             for name, value in calib_params.items():
                 c.add_data(name, value)
+                all_params[name] = value
 
             # objective function info
             for of in objfunc:
@@ -44,31 +75,31 @@ def csip_worker(reqq: queue.Queue, thread_no: int, stop, full_trace,
                 else:
                     res = c.execute(url, files=files, conf=conf)
 
-                if res.is_failed():
-                    print(res)
+                # run_string = 'r{}s{}i{}p{}.json'.format(rnd, step, iteration, particle)
 
                 if save_resp:
                     res.save_to(os.path.join(save_resp, 'r{}s{}i{}p{}.json'.format(rnd, step, iteration, particle)))
-                    
-                # print(res)
-                print('O', end='', flush=True)
-                
-                cost = utils.calc_cost(res, objfunc)
+
+                if res.is_failed():
+                    print(u'F')
+                    # print(res)
+                    resq.put((particle, 100))
+                else:
+                    # print(res)
+                    # print(u'\u2714', end='', flush=True)
+                    print(u'O', end='', flush=True)
+                    cost = utils.calc_cost(res, objfunc)
+                    resq.put((particle, cost))
+                    # break
 
                 if full_trace is not None:
-                    all_params = {}
-                    # for i, value in enumerate(x):
-                    for idx, value in enumerate(x[particle, :]):
-                        all_params[step_param_names[idx]] = value
-                        
-                    for name, value in calib_params.items():
-                        all_params[name] = value
                     full_trace.append((all_params, cost))
 
                 resq.put((particle, cost))
-            except Exception as e:
-                print(res)
-                print(e)
+            except:
+                print(u'sF')
+                resq.put((particle, 100))
+                continue
 
             reqq.task_done()
         except queue.Empty:

mgpsogui/util/recosu/pso/pso.py

@@ -9,6 +9,7 @@
 # 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
@@ -24,8 +25,9 @@ import json
 import os
 from multiprocessing import Queue as MPQueue
 
+cost2 = {}
 
-def eval_cost(x, iteration, step_param_names, step_objfunc, calib_params, req_queue, files, url, param, conf: Dict, rnd,
+def eval_cost(x, iteration, step_param, step_objfunc, calib_params, req_queue, files, url, param, conf: Dict, rnd,
               step):
     particles = len(x[:, 0])
 
@@ -41,7 +43,13 @@ def eval_cost(x, iteration, step_param_names, step_objfunc, calib_params, req_qu
         # 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_names, calib_params, step_objfunc, res_queue))
+            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
@@ -49,6 +57,16 @@ def eval_cost(x, iteration, step_param_names, step_objfunc, calib_params, req_qu
         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()
@@ -63,7 +81,6 @@ def eval_cost(x, iteration, step_param_names, step_objfunc, calib_params, req_qu
         # 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
 
@@ -76,9 +93,15 @@ def eval_cost(x, iteration, step_param_names, step_objfunc, calib_params, req_qu
     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,
@@ -160,6 +183,22 @@ 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 = {}
 
@@ -168,7 +207,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:
@@ -177,6 +216,7 @@ 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
@@ -184,13 +224,14 @@ 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'] = str(args) BUG MUST BE REMOVED?
+    step_trace['args'] = args
 
     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
@@ -198,7 +239,6 @@ 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
@@ -211,13 +251,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.
@@ -228,7 +268,8 @@ 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_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)
@@ -237,25 +278,30 @@ 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
 
@@ -263,18 +309,30 @@ 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))
             
@@ -284,18 +342,20 @@ 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())
-            
-            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]['best_costs'] = best_costs_list BUG
+            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)
@@ -325,22 +385,14 @@ 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
-        
-        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()
+        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)
@@ -381,3 +433,195 @@ 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

mgpsogui/util/recosu/utils/utils.py

@@ -18,12 +18,17 @@ from csip import Client
 
 NORM = {
     'kge': lambda x: 1 - x,
+    'absdiff': lambda x: x,
+    'kge09': lambda x: 1 - x,
     'nslog': lambda x: 1 - x,
     'nslog1p': lambda x: 1 - x,
+    'nslog2': lambda x: 1 - x,  # the good one???
     'ns': lambda x: 1 - x,
+    'mns': lambda x: 1 - x,
     'rmse': lambda x: x,
     'trmse': lambda x: x,
-    'pbias': lambda x: abs(x)
+    'pbias': lambda x: abs(x)  # correct one
+    # 'pbias': lambda x: abs(2.5 - x)
 }