jeffemmett
/
cadCAD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Not producing multiple dicts

This commit is contained in:
Joshua E. Jodesty 2019-02-01 12:42:42 -05:00
parent 5729ffc0ed
commit eaf9cf21ff
5 changed files with 86 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
SimCAD/configuration/utils/__init__.py
View File

@ -5,8 +5,8 @@ from fn.func import curried
import pandas as pd import pandas as pd
from SimCAD.utils import rename from SimCAD.utils import rename
from SimCAD.utils import groupByKey, dict_filter, contains_type from SimCAD.utils import dict_filter, contains_type, curry_pot
from SimCAD.utils import flatMap
from funcy import curry from funcy import curry
@ -116,24 +116,11 @@ def sweep_states(state_type, states, in_config):
return configs return configs
def param_sweep(config, raw_exogenous_states):
return flatMap(
sweep_states('environmental', config.env_processes),
flatMap(
sweep_states('exogenous', raw_exogenous_states),
flatMap(
sweep_mechs('states'),
sweep_mechs('behaviors', config)
)
)
)
def exo_update_per_ts(ep): def exo_update_per_ts(ep):
@curried @curried
def ep_decorator(f, y, step, sL, s, _input): def ep_decorator(f, y, step, sL, s, _input):
if s['mech_step'] + 1 == 1: if s['mech_step'] + 1 == 1:
return f(step, sL, s, _input) return curry_pot(f, step, sL, s, _input)
else: else:
return (y, s[y]) return (y, s[y])
@ -143,6 +130,7 @@ def exo_update_per_ts(ep):
def sweep(params, sweep_f): def sweep(params, sweep_f):
return [rename("sweep_"+sweep_f.__name__+"_"+str(i), curry(sweep_f)(param)) for param, i in zip(params, range(len(params)))] return [rename("sweep_"+sweep_f.__name__+"_"+str(i), curry(sweep_f)(param)) for param, i in zip(params, range(len(params)))]
def zip_sweep_functions(sweep_lists): def zip_sweep_functions(sweep_lists):
zipped_sweep_lists = [] zipped_sweep_lists = []
it = iter(sweep_lists) it = iter(sweep_lists)
@ -157,7 +145,8 @@ def zip_sweep_functions(sweep_lists):
raise ValueError('lists have different lengths!') raise ValueError('lists have different lengths!')
def create_sweep_config_list(zipped_sweep_lists, states_dict, state_type_ind = 'mechs'): # ToDo: Not producing multiple dicts
def create_sweep_config_list(zipped_sweep_lists, states_dict, state_type_ind='mechs'):
configs = [] configs = []
for f_lists in zipped_sweep_lists: for f_lists in zipped_sweep_lists:
new_states_dict = deepcopy(states_dict) new_states_dict = deepcopy(states_dict)
@ -187,6 +176,8 @@ def create_sweep_config_list(zipped_sweep_lists, states_dict, state_type_ind = '
def parameterize_states(exo_states): def parameterize_states(exo_states):
pp.pprint(exo_states)
print()
sweep_lists = [] sweep_lists = []
for sk, vfs in exo_states.items(): for sk, vfs in exo_states.items():
id_sweep_lists = [] id_sweep_lists = []
@ -199,6 +190,9 @@ def parameterize_states(exo_states):
if len(sweep_lists) == 0: if len(sweep_lists) == 0:
return [exo_states] return [exo_states]
pp.pprint(sweep_lists)
print()
zipped_sweep_lists = zip_sweep_functions(sweep_lists) zipped_sweep_lists = zip_sweep_functions(sweep_lists)
states_configs = create_sweep_config_list(zipped_sweep_lists, exo_states, "exo_proc") states_configs = create_sweep_config_list(zipped_sweep_lists, exo_states, "exo_proc")

27
SimCAD/engine/simulation.py
View File

@ -1,5 +1,6 @@
from copy import deepcopy from copy import deepcopy
from fn.op import foldr, call from fn.op import foldr, call
from SimCAD.utils import curry_pot
from SimCAD.engine.utils import engine_exception from SimCAD.engine.utils import engine_exception
id_exception = engine_exception(KeyError, KeyError, None) id_exception = engine_exception(KeyError, KeyError, None)
@ -11,31 +12,14 @@ class Executor:
self.state_update_exception = state_update_exception self.state_update_exception = state_update_exception
self.behavior_update_exception = behavior_update_exception self.behavior_update_exception = behavior_update_exception
def curry_pot(self, f, *argv):
sweep_ind = f.__name__[0:5] == 'sweep'
arg_len = len(argv)
if sweep_ind == True and arg_len == 4:
return f(argv[0])(argv[1])(argv[2])(argv[3])
elif sweep_ind == False and arg_len == 4:
return f(argv[0], argv[1], argv[2], argv[3])
elif sweep_ind == True and arg_len == 3:
return f(argv[0])(argv[1])(argv[2])
elif sweep_ind == False and arg_len == 3:
return f(argv[0], argv[1], argv[2])
else:
raise TypeError('curry_pot() needs 3 or 4 positional arguments')
def get_behavior_input(self, step, sL, s, funcs): def get_behavior_input(self, step, sL, s, funcs):
ops = self.behavior_ops[::-1] ops = self.behavior_ops[::-1]
def get_col_results(step, sL, s, funcs): def get_col_results(step, sL, s, funcs):
return list(map(lambda f: self.curry_pot(f, step, sL, s), funcs)) return list(map(lambda f: curry_pot(f, step, sL, s), funcs))
return foldr(call, get_col_results(step, sL, s, funcs))(ops) return foldr(call, get_col_results(step, sL, s, funcs))(ops)
def apply_env_proc(self, env_processes, state_dict, step): def apply_env_proc(self, env_processes, state_dict, step):
for state in state_dict.keys(): for state in state_dict.keys():
if state in list(env_processes.keys()): if state in list(env_processes.keys()):
@ -45,7 +29,6 @@ class Executor:
else: else:
state_dict[state] = env_state(state_dict[state]) state_dict[state] = env_state(state_dict[state])
def mech_step(self, m_step, sL, state_funcs, behavior_funcs, env_processes, t_step, run): def mech_step(self, m_step, sL, state_funcs, behavior_funcs, env_processes, t_step, run):
last_in_obj = sL[-1] last_in_obj = sL[-1]
@ -53,14 +36,11 @@ class Executor:
# print(_input) # print(_input)
# ToDo: add env_proc generator to `last_in_copy` iterator as wrapper function # ToDo: add env_proc generator to `last_in_copy` iterator as wrapper function
# last_in_copy = [self.behavior_update_exception(f(m_step, sL, last_in_obj, _input)) for f in state_funcs]
last_in_copy = dict( last_in_copy = dict(
[ [
self.behavior_update_exception(self.curry_pot(f, m_step, sL, last_in_obj, _input)) for f in state_funcs self.behavior_update_exception(curry_pot(f, m_step, sL, last_in_obj, _input)) for f in state_funcs
] ]
) )
# print(last_in_copy)
for k in last_in_obj: for k in last_in_obj:
if k not in last_in_copy: if k not in last_in_copy:
@ -97,7 +77,6 @@ class Executor:
def block_pipeline(self, states_list, configs, env_processes, time_seq, run): def block_pipeline(self, states_list, configs, env_processes, time_seq, run):
time_seq = [x + 1 for x in time_seq] time_seq = [x + 1 for x in time_seq]
simulation_list = [states_list] simulation_list = [states_list]
# print(len(configs))
for time_step in time_seq: for time_step in time_seq:
pipe_run = self.mech_pipeline(simulation_list[-1], configs, env_processes, time_step, run) pipe_run = self.mech_pipeline(simulation_list[-1], configs, env_processes, time_step, run)
_, *pipe_run = pipe_run _, *pipe_run = pipe_run

19
SimCAD/utils/__init__.py
View File

@ -1,6 +1,5 @@
from collections import defaultdict from collections import defaultdict
from itertools import product from itertools import product
# from fn.func import curried
def pipe(x): def pipe(x):
@ -47,14 +46,13 @@ def contains_type(_collection, type):
def drop_right(l, n): def drop_right(l, n):
return l[:len(l)-n] return l[:len(l) - n]
def key_filter(l, keyname): def key_filter(l, keyname):
return [v[keyname] for k, v in l.items()] return [v[keyname] for k, v in l.items()]
def groupByKey(l): def groupByKey(l):
d = defaultdict(list) d = defaultdict(list)
for key, value in l: for key, value in l:
@ -67,6 +65,21 @@ def rename(new_name, f):
f.__name__ = new_name f.__name__ = new_name
return f return f
def curry_pot(f, *argv):
sweep_ind = f.__name__[0:5] == 'sweep'
arg_len = len(argv)
if sweep_ind is True and arg_len == 4:
return f(argv[0])(argv[1])(argv[2])(argv[3])
elif sweep_ind is False and arg_len == 4:
return f(argv[0], argv[1], argv[2], argv[3])
elif sweep_ind is True and arg_len == 3:
return f(argv[0])(argv[1])(argv[2])
elif sweep_ind is False and arg_len == 3:
return f(argv[0], argv[1], argv[2])
else:
raise TypeError('curry_pot() needs 3 or 4 positional arguments')
# def rename(newname): # def rename(newname):
# def decorator(f): # def decorator(f):
# f.__name__ = newname # f.__name__ = newname

48
simulations/example_run.py
View File

@ -8,28 +8,28 @@ from SimCAD import configs
exec_mode = ExecutionMode() exec_mode = ExecutionMode()
print("Simulation Execution 1") # print("Simulation Execution 1")
print() # print()
first_config = [configs[0]] # from config1 # first_config = [configs[0]] # from config1
single_proc_ctx = ExecutionContext(context=exec_mode.single_proc) # single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
run1 = Executor(exec_context=single_proc_ctx, configs=first_config) # run1 = Executor(exec_context=single_proc_ctx, configs=first_config)
run1_raw_result, tensor_field = run1.main() # run1_raw_result, tensor_field = run1.main()
result = pd.DataFrame(run1_raw_result) # result = pd.DataFrame(run1_raw_result)
print() # print()
print("Tensor Field:") # print("Tensor Field:")
print(tabulate(tensor_field, headers='keys', tablefmt='psql')) # print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
print("Output:") # print("Output:")
print(tabulate(result, headers='keys', tablefmt='psql')) # print(tabulate(result, headers='keys', tablefmt='psql'))
print() # print()
# print("Simulation Execution 2: Pairwise Execution") print("Simulation Execution 2: Pairwise Execution")
# multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc) multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
# run2 = Executor(exec_context=multi_proc_ctx, configs=configs) run2 = Executor(exec_context=multi_proc_ctx, configs=configs)
# for raw_result, tensor_field in run2.main(): for raw_result, tensor_field in run2.main():
# result = pd.DataFrame(raw_result) result = pd.DataFrame(raw_result)
# print() print()
# print("Tensor Field:") print("Tensor Field:")
# print(tabulate(tensor_field, headers='keys', tablefmt='psql')) print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
# print("Output:") print("Output:")
# print(tabulate(result, headers='keys', tablefmt='psql')) print(tabulate(result, headers='keys', tablefmt='psql'))
# print() print()

222
simulations/validation/config1.py
View File

@ -1,52 +1,18 @@
from decimal import Decimal from decimal import Decimal
import numpy as np import numpy as np
from datetime import timedelta from datetime import timedelta
from fn.func import curried
import pprint import pprint
from SimCAD import configs from SimCAD import configs
from SimCAD.utils import flatMap, rename
from SimCAD.configuration import Configuration from SimCAD.configuration import Configuration
from SimCAD.configuration.utils import exo_update_per_ts, proc_trigger, bound_norm_random, \ from SimCAD.configuration.utils import exo_update_per_ts, proc_trigger, bound_norm_random, \
ep_time_step, parameterize_mechanism, parameterize_states, sweep #parameterize_states ep_time_step, parameterize_mechanism, parameterize_states, sweep
from copy import deepcopy
pp = pprint.PrettyPrinter(indent=4) pp = pprint.PrettyPrinter(indent=4)
# ToDo: handle single param sweep # ToDo: handle single param sweep
beta = [Decimal(1), Decimal(2)] beta = [Decimal(1), Decimal(2)]
# # -------------
# var_a = [1,2,3]
# var_b = [1,2,3]
#
#
# # Internal States per Mechanism
# def s1m1(step, sL, s, _input):
# # __assumed__ = var_a
# # __handler__ = f
# y = 's1'
# x = _input['param1'] + 1 + var_a
# # example = [_input['param1'], 1, assumed].reduceLeft(_ + _)
#
# return (y, x)
#
# def s2m1(assumed, step, sL, s, _input):
# y = 's2'
# x = _input['param2'] + assumed
# return (y, x)
#
# def s1m3(unused_wildcard, step, sL, s, _input):
# y = 's1'
# x = _input['param1']
# return (y, x)
#
#
# middleware(beta, [s1m1, s2m2, b1m3, . . . ])
#
# # -------------
seed = { seed = {
'z': np.random.RandomState(1), 'z': np.random.RandomState(1),
'a': np.random.RandomState(2), 'a': np.random.RandomState(2),
@ -60,46 +26,35 @@ def b1m1(step, sL, s):
return {'param1': 1} return {'param1': 1}
def b2m1(step, sL, s): def b2m1(step, sL, s):
return {'param2': 4} return {'param2': 4}
# @curried # @curried
def b1m2(param, step, sL, s): def b1m2(param, step, sL, s):
return {'param1': 'a', 'param2': param} return {'param1': 'a', 'param2': param}
#
# def b1m2(step, sL, s):
# return {'param1': 'a', 'param2': 2}
def b2m2(step, sL, s): def b2m2(step, sL, s):
return {'param1': 'b', 'param2': 4} return {'param1': 'b', 'param2': 0}
def b1m3(step, sL, s): def b1m3(step, sL, s):
return {'param1': ['c'], 'param2': np.array([10, 100])} return {'param1': np.array([10, 100])}
def b2m3(step, sL, s): def b2m3(step, sL, s):
return {'param1': ['d'], 'param2': np.array([20, 200])} return {'param1': np.array([20, 200])}
# Internal States per Mechanism # Internal States per Mechanism
def s1m1(step, sL, s, _input): def s1m1(step, sL, s, _input):
y = 's1' y = 's1'
x = _input['param1'] x = 0
return (y, x) return (y, x)
# param = Decimal(11.0)
# def s2m1(step, sL, s, _input):
# y = 's2'
# x = _input['param2'] + param
# return (y, x)
# @curried # @curried
def s2m1(param, step, sL, s, _input): def s2m1(param, step, sL, s, _input):
y = 's2' y = 's2'
x = _input['param2'] + param x = param
return (y, x) return (y, x)
def s1m2(step, sL, s, _input): def s1m2(step, sL, s, _input):
y = 's1' y = 's1'
x = _input['param1'] x = _input['param2']
return (y, x) return (y, x)
def s2m2(step, sL, s, _input): def s2m2(step, sL, s, _input):
y = 's2' y = 's2'
@ -108,22 +63,17 @@ def s2m2(step, sL, s, _input):
def s1m3(step, sL, s, _input): def s1m3(step, sL, s, _input):
y = 's1' y = 's1'
x = _input['param1'] x = 0
return (y, x) return (y, x)
def s2m3(step, sL, s, _input): def s2m3(step, sL, s, _input):
y = 's2' y = 's2'
x = _input['param2'] x = 0
return (y, x) return (y, x)
# Exogenous States # Exogenous States
proc_one_coef_A = 0.7 proc_one_coef_A = 0.7
proc_one_coef_B = 1.3 proc_one_coef_B = 1.3
#
# def es3p1(step, sL, s, _input):
# y = 's3'
# x = s['s3'] * bound_norm_random(seed['a'], proc_one_coef_A, proc_one_coef_B)
# return (y, x)
# @curried # @curried
def es3p1(param, step, sL, s, _input): def es3p1(param, step, sL, s, _input):
@ -146,14 +96,10 @@ def es5p2(step, sL, s, _input):
# Environment States # Environment States
# @curried # @curried
# def env_a(param, x): def env_a(param, x):
# return x + param return x + param
def env_a(x):
return x
def env_b(x): def env_b(x):
return 10 return 10
# def what_ever(x):
# return x + 1
# Genesis States # Genesis States
@ -165,9 +111,6 @@ genesis_states = {
'timestamp': '2018-10-01 15:16:24' 'timestamp': '2018-10-01 15:16:24'
} }
# print(sweep(beta, es3p1))
# print()
# remove `exo_update_per_ts` to update every ts # remove `exo_update_per_ts` to update every ts
raw_exogenous_states = { raw_exogenous_states = {
@ -175,25 +118,22 @@ raw_exogenous_states = {
"s4": sweep(beta, es4p2), "s4": sweep(beta, es4p2),
"timestamp": es5p2 "timestamp": es5p2
} }
exogenous_states = exo_update_per_ts(raw_exogenous_states) # exogenous_states_list = list(map(exo_update_per_ts, parameterize_states(raw_exogenous_states)))
# pp.pprint(raw_exogenous_states)
# print()
# pp.pprint(parameterize_states(raw_exogenous_states))
# print()
# exogenous_states['s3'] = rename('parameterized', es3p1)
# ToDo: make env proc trigger field agnostic # ToDo: make env proc trigger field agnostic
# ToDo: input json into function renaming __name__ # ToDo: input json into function renaming __name__
triggered_env_b = proc_trigger('2018-10-01 15:16:25', env_b) triggered_env_b = proc_trigger('2018-10-01 15:16:25', env_b)
env_processes = { env_processes = {
"s3": env_a, #sweep(beta, env_a, 'env_a'), "s3": sweep(beta, env_a),
"s4": triggered_env_b #rename('parameterized', triggered_env_b) #sweep(beta, triggered_env_b) "s4": triggered_env_b #rename('parameterized', triggered_env_b) #sweep(beta, triggered_env_b)
} }
parameterized_env_processes = parameterize_states(env_processes)
pp.pprint(parameterized_env_processes)
exit()
# ToDo: The number of values enteren in sweep should be the # of config objs created, # ToDo: The number of values enteren in sweep should be the # of config objs created,
# not dependent on the # of times the sweep is applied # not dependent on the # of times the sweep is applied
@ -212,12 +152,12 @@ mechanisms = {
}, },
"states": { "states": {
"s1": s1m1, "s1": s1m1,
"s2": sweep(beta, s2m1) #rename('parameterized', s2m1) #s2m1(1) #sweep(beta, s2m1) "s2": sweep(beta, s2m1) #s2m1(1) #sweep(beta, s2m1)
} }
}, },
"m2": { "m2": {
"behaviors": { "behaviors": {
"b1": sweep(beta, b1m2), #rename('parameterized', b1m2), #b1m2(1) #sweep(beta, b1m2), "b1": sweep(beta, b1m2), #b1m2(1) #sweep(beta, b1m2),
"b2": b2m2 "b2": b2m2
}, },
"states": { "states": {
@ -236,119 +176,21 @@ mechanisms = {
} }
} }
} }
parameterized_mechanism = parameterize_mechanism(mechanisms)
# list(map(lambda x: list(map(lambda y: list(y.keys()).pop(), x)), zipped_sweep_lists))
# pp.pprint(parameterize_mechanism(mechanisms))
# print()
# pp.pprint(mechanisms)
sim_config = { sim_config = {
"N": 2, "N": 2,
"T": range(5) "T": range(5)
} }
# for mech_configs in parameterize_mechanism(mechanisms): for mechanisms, env_processes, exogenous_states in zip(parameterized_mechanism, parameterized_env_processes, exogenous_states_list):
configs.append( configs.append(
Configuration( Configuration(
sim_config=sim_config, sim_config=sim_config,
state_dict=genesis_states, state_dict=genesis_states,
seed=seed, seed=seed,
exogenous_states=parameterize_states(raw_exogenous_states)[1], exogenous_states=exogenous_states, #parameterize_states(raw_exogenous_states)[1],
env_processes=env_processes, env_processes=env_processes,
mechanisms=parameterize_mechanism(mechanisms)[1] mechanisms=mechanisms #parameterize_mechanism(mechanisms)[1]
)
) )
)
# # print(rename('new', b2m2).__name__)
#
# def parameterize_mechanism(mechanisms, param):
# new_mechanisms = deepcopy(mechanisms)
# for mech, update_types in new_mechanisms.items():
# for update_type, fkv in update_types.items():
# for sk, vf in fkv.items():
# if vf.__name__ == 'parameterized':
# # print(vf.__name__)
# new_mechanisms[mech][update_type][sk] = vf(param)
#
# del mechanisms
# return new_mechanisms
#
# def parameterize_states(states_dict, param):
# new_states_dict = deepcopy(states_dict)
# for sk, vf in new_states_dict.items():
# if vf.__name__ == 'parameterized':
# print(vf.__name__)
# new_states_dict[sk] = vf(param)
#
# del states_dict
# return new_states_dict
#
# # parameterize_mechanism(mechanisms, beta)
# @curried
# def s2m1(param, a, b, c, d):
# y = a
# x = b, + c + d + param
# return (y, x)
# print(s2m1(1)(1))
# pp.pprint(mechanisms)
# pp.pprint(parameterize_mechanism(mechanisms, 1))
# print(sweep(beta, s2m1))
# pp.pprint(parameterize_states(raw_exogenous_states, 1))
# pp.pprint(parameterize_states(env_processes, 1))
# configs.append(
# Configuration(
# sim_config=sim_config,
# state_dict=genesis_states,
# seed=seed,
# exogenous_states=exogenous_states,
# env_processes=env_processes,
# mechanisms=parameterize_mechanism(mechanisms, 1)
# )
# )
# def sweep_config(config, params):
# new_config = deepcopy(config)
# configs = []
# for param in params:
# new_config.mechanisms = parameterize_mechanism(config.mechanisms, param)
# # new_config.raw_exogenous_states = parameterize_states(config.exogenous_states, param)
# # new_config.env_processes = parameterize_states(config.env_processes, param)
# configs.append(new_config)
# del config
# return configs
# print(sweep_config(c, beta))
#
# for config in sweep_config(c, beta):
# configs.append(config)
# for config in param_sweep(c, raw_exogenous_states):
# configs.append(config)
# # configs = configs +
# #
# print()
# print(len(configs))
# print()
# for g in configs:
# print()
# print('Configuration')
# print()
# pp.pprint(g.env_processes)
# print()
# pp.pprint(g.exogenous_states)
# print()
# pp.pprint(g.mechanisms)
# print()