mg-pso-gui 0.1.122__py3-none-any.whl → 0.1.123__py3-none-any.whl

{mg_pso_gui-0.1.122.dist-info → mg_pso_gui-0.1.123.dist-info}/METADATA

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

{mg_pso_gui-0.1.122.dist-info → mg_pso_gui-0.1.123.dist-info}/RECORD

@@ -44,13 +44,17 @@ mgpsogui/util/recosu/__init__.py,sha256=T7_iigIlowGbPOHLO3hwihjw2kbwIg6olOMhFhNi
 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/sampling/__init__.py,sha256=1rGd7ccgFRBwfWgyvkYAxzlGESGEvKX78LB84G9BfuQ,106
+mgpsogui/util/recosu/sampling/sample_trace_writer.py,sha256=M9w-POLlZgjL5a7J7yxr73OG6mCsS2aUuP9d3HKfkbA,1966
+mgpsogui/util/recosu/sampling/sampler.py,sha256=smwCtKdxGM3vU0SNb9DoPcBbNeEY9uaAkaU_DFye6Ew,4163
+mgpsogui/util/recosu/sampling/sampler_task.py,sha256=uZobpR83u6xEaUzIknvW9FbB84c2AL7T-5T8O8QIhzY,2776
 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/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.1.122.dist-info/METADATA,sha256=URzxA1kwKRyErmBgKMDlKqnVUxG9vMl0c_JGR4YV-4g,9460
-mg_pso_gui-0.1.122.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-mg_pso_gui-0.1.122.dist-info/entry_points.txt,sha256=jg82VOFjR1XDGrchs1wJSCqKYE4Ozv12aBcCSp--koA,117
-mg_pso_gui-0.1.122.dist-info/top_level.txt,sha256=y7JuS9xJN5YdxUsQ3PSVjN8MzQAnR146bP3ZN3PYWdE,9
-mg_pso_gui-0.1.122.dist-info/RECORD,,
+mg_pso_gui-0.1.123.dist-info/METADATA,sha256=eOXdqI0YHp-TbdJDhljn63KItB3ii3lJm6YQlhFv0mM,9460
+mg_pso_gui-0.1.123.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+mg_pso_gui-0.1.123.dist-info/entry_points.txt,sha256=jg82VOFjR1XDGrchs1wJSCqKYE4Ozv12aBcCSp--koA,117
+mg_pso_gui-0.1.123.dist-info/top_level.txt,sha256=y7JuS9xJN5YdxUsQ3PSVjN8MzQAnR146bP3ZN3PYWdE,9
+mg_pso_gui-0.1.123.dist-info/RECORD,,

mgpsogui/util/recosu/sampling/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+"""
+LUCA/PSO toolkit
+=========================================
+This is ...
+
+"""
+

mgpsogui/util/recosu/sampling/sample_trace_writer.py

@@ -0,0 +1,47 @@
+import threading
+
+
+class SampleTraceWriter:
+    trace_file: str
+    parameter_indices: dict[int, str]
+    objective_indices: dict[int, str]
+    write_lock: threading.Lock
+
+    def __init__(self, trace_file: str):
+        assert(trace_file is not None and len(trace_file) > 0)
+        self.trace_file = trace_file
+        self.parameter_indices = {}
+        self.objective_indices = {}
+        self.write_lock = threading.Lock()
+
+    def write_header(self, parameter_names: list[str], objective_names: list[str]) -> None:
+        with self.write_lock:
+            with open(self.trace_file, 'w') as writer:
+                writer.write("id")
+                self.parameter_indices = {}
+                index: int = 0
+                for name in parameter_names:
+                    writer.write(",{}".format(name))
+                    self.parameter_indices[index] = name
+                    index = index + 1
+                self.objective_indices = {}
+                index = 0
+                for name in objective_names:
+                    writer.write(",{}".format(name))
+                    self.objective_indices[index] = name
+                    index = index + 1
+                writer.write("\n")
+
+    def append_sample(self, sample_id: int, parameters: dict[str, any], objectives: dict[str, any]) -> None:
+        with self.write_lock:
+            with open(self.trace_file, 'a') as writer:
+                writer.write("{}".format(sample_id))
+                index: int = 0
+                while index < len(self.parameter_indices):
+                    writer.write(",{}".format(parameters[self.parameter_indices[index]]))
+                    index = index + 1
+                index = 0
+                while index < len(self.objective_indices):
+                    writer.write(",{}".format(objectives[self.objective_indices[index]]))
+                    index = index + 1
+                writer.write("\n")

mgpsogui/util/recosu/sampling/sampler.py

@@ -0,0 +1,99 @@
+from collections.abc import Iterable
+import math
+import asyncio
+import concurrent
+import datetime
+from recosu.utils import utils
+from recosu.sampling.halton.halton import HaltonSampleGenerator
+from recosu.sampling.random.random_sampler import RandomSampleGenerator
+from recosu.sampling.sampler_task import SamplerTask
+from recosu.sampling.sample_trace_writer import SampleTraceWriter
+
+
+def weighted_value(weight: float, lower: float, upper: float) -> float:
+    return lower + weight * (upper - lower)
+
+
+def get_static_parameters(args: dict[str, any]) -> dict[str, any]:
+    static_parameters: dict[str, any] = {}
+    for param in args["param"]:
+        static_parameters[param["name"]] = param["value"]
+    return static_parameters
+
+
+def get_objective_names(objfunc: dict[str, any]) -> list[str]:
+    objective_names: list[str] = []
+    for of in objfunc:
+        objective_names.append(of["name"])
+    return objective_names
+
+
+def thread_function(task: SamplerTask) -> tuple[bool, SamplerTask]:
+    return task.run_task(), task
+
+
+def create_generator(method: str, count: int, num_parameters: int, **kwargs) -> Iterable[tuple[int, list[float]]]:
+    if method == "halton":
+        offset: int = 0
+        if "offset" in kwargs:
+            offset = kwargs["offset"]
+        return HaltonSampleGenerator(count, offset, num_parameters)
+    elif method == "random":
+        return RandomSampleGenerator(count, num_parameters)
+
+    raise Exception("Sampling method is not recognized")
+
+
+def run_sampler(steps: list[dict[str, any]], args: dict[str, any], count: int, num_threads: int, method: str = "halton",
+                metainfo: dict[str, any] = None, conf: dict[str, any] = None, trace_file: str = "trace.csv",
+                **kwargs) -> dict[int, tuple[dict[str, any], dict[str, any]]]:
+    param_names, bounds, objfunc = utils.get_step_info(steps, 0)
+    generator: Iterable[tuple[int, list[float]]] = create_generator(method, count, len(param_names), **kwargs)
+    objective_names: list[str] = get_objective_names(objfunc)
+    static_parameters: dict[str, any] = get_static_parameters(args)
+    url: str = args["url"]
+    files: list[str] = args["files"]
+
+    trace: dict[int, tuple[dict[str, float], dict[str, float]]] = {}
+    trace_writer: SampleTraceWriter = SampleTraceWriter(trace_file)
+    trace_writer.write_header(param_names, objective_names)
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads) as executor:
+        futures = []
+        for sample_id, sample in generator:
+            params: dict[str, float] = {}
+            index: int = 0
+            while index < len(sample):
+                params[param_names[index]] = weighted_value(sample[index], bounds[0][index], bounds[1][index])
+                index += 1
+
+            task: SamplerTask = SamplerTask(sample_id, params, objfunc, static_parameters, url, files, metainfo, conf)
+            futures.append(executor.submit(thread_function, task))
+        # for future in concurrent.futures.as_completed(futures):
+        #     pass
+        num_finished: int = 0
+        percentage: float
+        last_percentage: float = 0
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                successful, task = future.result()
+
+                if successful:
+                    trace[task.task_id] = (task.parameters, task.result)
+                    trace_writer.append_sample(task.task_id, task.parameters, task.result)
+                else:
+                    print("Failed to successfully execute task: {}", task.task_id)
+            except asyncio.CancelledError as ce:
+                pass
+            except asyncio.InvalidStateError as ise:
+                pass
+            except Exception as ex:
+                print(ex)
+
+            num_finished = num_finished + 1
+            percentage = math.trunc(num_finished / count * 1000) / 10
+            if percentage > last_percentage:
+                last_percentage = percentage
+                print("{}% Done {}".format(percentage, datetime.datetime.now()))
+
+    return trace

mgpsogui/util/recosu/sampling/sampler_task.py

@@ -0,0 +1,75 @@
+import os
+from csip import Client
+
+
+class SamplerTask:
+    task_id: int
+    parameters: dict[str, any]
+    objectives: list[dict[str, any]]
+    static_parameters: dict[str, any]
+    url: str
+    files: list[str]
+    metainfo: dict[str, any]
+    conf: dict[str, any]
+    result: dict[str, any]
+
+    def __init__(self, task_id: int, parameters: dict[str, any], objectives: list[dict[str, any]],
+                 static_parameters: dict[str, any], url: str, files: list[str] = None, metainfo: dict[str, any] = None,
+                 conf: dict[str, any] = None):
+        self.task_id = task_id
+        assert (parameters is not None and len(parameters) > 0)
+        self.parameters = parameters
+        assert (objectives is not None and len(objectives) > 0)
+        self.objectives = objectives
+        self.static_parameters = static_parameters if static_parameters is not None else []
+        assert (url is not None and len(url) > 0)
+        self.url = url
+        self.files = files if files is not None else []
+        self.metainfo = metainfo
+        self.conf = conf
+
+    def create_request(self) -> Client:
+        request: Client = Client(metainfo=self.metainfo)
+
+        for key, value in self.static_parameters.items():
+            request.add_data(key, value)
+
+        for key, value in self.parameters.items():
+            request.add_data(key, value)
+
+        for of in self.objectives:
+            request.add_cosu(of['name'], of['of'], of['data'])
+
+        return request
+
+    def run_task(self) -> bool:
+        self.result = {}
+        request: Client = self.create_request()
+        async_call: bool = self.conf.get('async_call', True) if self.conf is not None else True
+        # save response, set it to a folder if responses should be saved.
+        save_resp = self.conf.get('save_response_to', None) if self.conf is not None else None
+        successful: bool = False
+
+        response: Client = None
+        try:
+            if async_call:
+                response = request.execute_async(self.url, files=self.files, conf=self.conf)
+            else:
+                response = request.execute(self.url, files=self.files, conf=self.conf)
+
+            successful = response.is_finished()
+            if not successful:
+                print(response)
+
+            if save_resp:
+                response.save_to(os.path.join(save_resp, 'task_{}.json'.format(self.task_id)))
+
+            objectives: list[dict[str, str]] = response.get_metainfo("cosu")
+            for of in objectives:
+                self.result[of["name"]] = of["value"]
+        except Exception as ex:
+            print(ex)
+            print(response)
+            successful = False
+
+        return successful