From d29658ecbe39a82396e2316446fe7139a2bd457f Mon Sep 17 00:00:00 2001 From: "Joshua E. Jodesty" Date: Thu, 15 Nov 2018 17:35:49 -0500 Subject: [PATCH] Reafactor Pt. 3: Improved Runtime Env / ui Pt.1 --- engine/__init__.py | 85 ++++++++++++++++++++------ engine/{mechanism.py => simulation.py} | 0 refactored_test.py | 7 +++ runtime/run.py | 6 +- utils/__init__.py | 4 ++ {engine => utils}/configProcessor.py | 0 utils/engine.py | 6 -- utils/ui.py | 2 +- 8 files changed, 82 insertions(+), 28 deletions(-) rename engine/{mechanism.py => simulation.py} (100%) create mode 100644 refactored_test.py create mode 100644 utils/__init__.py rename {engine => utils}/configProcessor.py (100%) diff --git a/engine/__init__.py b/engine/__init__.py index f5117de..bd3356d 100644 --- a/engine/__init__.py +++ b/engine/__init__.py @@ -1,18 +1,67 @@ -# from pathos.multiprocessing import ProcessingPool as Pool -# -# class Multiproc(object): -# -# def __init__(self, fs, states_list, configs, env_processes, Ts, Ns): -# self.fs = fs -# self.states_list = states_list -# self.configs = configs -# self.env_processes = env_processes -# self.Ts = Ts -# self.Ns = Ns -# -# def parallelize_simulations(self): -# l = list(zip(self.fs, self.states_list, self.configs, self.env_processes, self.Ts, self.Ns)) -# with Pool(len(self.configs)) as p: -# results = p.map(lambda t: t[0](t[1], t[2], t[3], t[4], t[5]), l) -# -# return results \ No newline at end of file + + +from pathos.multiprocessing import ProcessingPool as Pool + +import pandas as pd +from tabulate import tabulate + +from utils import flatten +from utils.ui import create_tensor_field +from utils.configProcessor import generate_config + +class ExecutionContext(object): + + def __init__(self): + def parallelize_simulations(fs, states_list, configs, env_processes, Ts, Ns): + l = list(zip(fs, states_list, configs, env_processes, Ts, Ns)) + with Pool(len(configs)) as p: + results = p.map(lambda t: t[0](t[1], t[2], t[3], t[4], t[5]), l) + + return results + + self.parallelize_simulations = parallelize_simulations + + +class Executor(object): + + def __init__(self, ExecutionContext, configs): + from engine.simulation import Executor + + def execute(): + ec = ExecutionContext() + print(configs) + states_lists, Ts, Ns, eps, configs_struct, env_processes, mechanisms, simulation_execs = \ + [], [], [], [], [], [], [], [] + config_idx = 0 + for x in configs: + states_lists.append([x.state_dict]) + Ts.append(x.sim_config['T']) + Ns.append(x.sim_config['N']) + eps.append(list(x.exogenous_states.values())) + configs_struct.append(generate_config(x.state_dict, x.mechanisms, eps[config_idx])) + env_processes.append(x.env_processes) + mechanisms.append(x.mechanisms) + simulation_execs.append(Executor(x.behavior_ops).simulation) + + config_idx += 1 + + # Dimensions: N x r x mechs + + if len(configs) > 1: + simulations = ec.parallelize_simulations(simulation_execs, states_lists, configs_struct, env_processes, Ts, Ns) + + for result, mechanism, ep in list(zip(simulations, mechanisms, eps)): + print(tabulate(create_tensor_field(mechanism, ep), headers='keys', tablefmt='psql')) + print(tabulate(pd.DataFrame(flatten(result)), headers='keys', tablefmt='psql')) + else: + print('single note') + simulation, states_list, config = simulation_execs.pop(), states_lists.pop(), configs_struct.pop() + env_process = env_processes.pop() + # simulations = [simulation(states_list, config, env_processes, T, N)] + + # behavior_ops, states_list, configs, env_processes, time_seq, runs + # result = simulation(states_list1, config1, conf1.env_processes, T, N) + # return pd.DataFrame(flatten(result)) + + self.ExecutionContext = ExecutionContext + self.main = execute \ No newline at end of file diff --git a/engine/mechanism.py b/engine/simulation.py similarity index 100% rename from engine/mechanism.py rename to engine/simulation.py diff --git a/refactored_test.py b/refactored_test.py new file mode 100644 index 0000000..8973217 --- /dev/null +++ b/refactored_test.py @@ -0,0 +1,7 @@ + +from engine import ExecutionContext, Executor +from ui import config1, config2 + +configs = [config1, config2] +run = Executor(ExecutionContext, configs) +result = run.main() \ No newline at end of file diff --git a/runtime/run.py b/runtime/run.py index b2420a5..b113a11 100644 --- a/runtime/run.py +++ b/runtime/run.py @@ -1,10 +1,10 @@ import pandas as pd from tabulate import tabulate from configuration import configs -from utils.engine import flatten +from utils import flatten from utils.ui import create_tensor_field -from engine.configProcessor import generate_config -from engine.mechanism import Executor +from utils.configProcessor import generate_config +from engine.simulation import Executor from runtime.multiproc import parallelize_simulations # from ui import config1, config2 diff --git a/utils/__init__.py b/utils/__init__.py new file mode 100644 index 0000000..71ebbdd --- /dev/null +++ b/utils/__init__.py @@ -0,0 +1,4 @@ +flatten = lambda l: [item for sublist in l for item in sublist] + +def flatmap(f, items): + return list(map(f, items)) \ No newline at end of file diff --git a/engine/configProcessor.py b/utils/configProcessor.py similarity index 100% rename from engine/configProcessor.py rename to utils/configProcessor.py diff --git a/utils/engine.py b/utils/engine.py index b5f3f7a..24e2089 100644 --- a/utils/engine.py +++ b/utils/engine.py @@ -1,11 +1,5 @@ from datetime import datetime -flatten = lambda l: [item for sublist in l for item in sublist] - -def flatmap(f, items): - return list(map(f, items)) - - def datetime_range(start, end, delta, dt_format='%Y-%m-%d %H:%M:%S'): reverse_head = end [start, end] = [datetime.strptime(x, dt_format) for x in [start, end]] diff --git a/utils/ui.py b/utils/ui.py index 467d4f2..1bcad4a 100644 --- a/utils/ui.py +++ b/utils/ui.py @@ -1,5 +1,5 @@ import pandas as pd -from engine.configProcessor import create_matrix_field +from utils.configProcessor import create_matrix_field def create_tensor_field(mechanisms, exo_proc, keys=['behaviors', 'states']): dfs = [ create_matrix_field(mechanisms, k) for k in keys ]