mg-pso-gui 0.1.122__tar.gz → 0.1.124__tar.gz

{mg-pso-gui-0.1.122 → mg-pso-gui-0.1.124}/PKG-INFO

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

{mg-pso-gui-0.1.122 → mg-pso-gui-0.1.124}/mg_pso_gui.egg-info/PKG-INFO

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

{mg-pso-gui-0.1.122 → mg-pso-gui-0.1.124}/mg_pso_gui.egg-info/SOURCES.txt

@@ -51,6 +51,10 @@ mgpsogui/util/recosu/__init__.py
 mgpsogui/util/recosu/pso/__init__.py
 mgpsogui/util/recosu/pso/csip_access.py
 mgpsogui/util/recosu/pso/pso.py
+mgpsogui/util/recosu/sampling/__init__.py
+mgpsogui/util/recosu/sampling/sample_trace_writer.py
+mgpsogui/util/recosu/sampling/sampler.py
+mgpsogui/util/recosu/sampling/sampler_task.py
 mgpsogui/util/recosu/utils/__init__.py
 mgpsogui/util/recosu/utils/trace_writer.py
 mgpsogui/util/recosu/utils/utils.py

mg-pso-gui-0.1.124/mgpsogui/util/recosu/sampling/__init__.py

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

mg-pso-gui-0.1.124/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")

mg-pso-gui-0.1.124/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

mg-pso-gui-0.1.124/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

{mg-pso-gui-0.1.122 → mg-pso-gui-0.1.124}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 import codecs
 import os
 
-VERSION = '0.1.122'
+VERSION = '0.1.124'
 DESCRIPTION = 'GUI for MG-PSO'
 LONG_DESCRIPTION = open('../README.md').read()