From 59542928c866b0ae75b2d22444033befc748297e Mon Sep 17 00:00:00 2001 From: Zargham Date: Tue, 16 Oct 2018 15:33:35 -0700 Subject: [PATCH] mikes edits --- engine/__pycache__/__init__.cpython-36.pyc | Bin 146 -> 147 bytes .../configProcessor.cpython-36.pyc | Bin 726 -> 727 bytes .../mechanismExecutor.cpython-36.pyc | Bin 2498 -> 2499 bytes engine/__pycache__/run.cpython-36.pyc | Bin 763 -> 769 bytes engine/__pycache__/utils.cpython-36.pyc | Bin 2747 -> 2748 bytes engine/run.py | 7 +- notebooks/test.ipynb | 69 ++++++---- ui/__pycache__/config.cpython-36.pyc | Bin 3245 -> 3151 bytes ui/toyConfig.py | 122 ++++++++++++++++++ 9 files changed, 173 insertions(+), 25 deletions(-) create mode 100644 ui/toyConfig.py diff --git a/engine/__pycache__/__init__.cpython-36.pyc b/engine/__pycache__/__init__.cpython-36.pyc index 9fe048548927dd1802b900d01458dade5fdaab18..23735c920766f881a24777246f447f730ab31530 100644 GIT binary patch delta 100 zcmbQlIGK^%n3tC;)B4y%c8d@P{m|mnqGJ83#G>?!#9V!s{N&Qy)Vz{nefP`~kJ2Q4 zm&~-Z%0S)V%v@(j7yZ<{^vt|e{rLFIyv&mLc)fzkTO2mI`6;D2sdkJE3=G9U%m4s< Ch9Cj} delta 99 zcmbQtIEj(nn3tDJX2t%A>=wcH&Q>v@#i>QbF}X>JML976mB|^2MY#b*`B|ySCB-o= znQ3X2fx5w&xz3I*F{yd!nR%%(@$s2?nI-Y@dIgoYIBatBQ%ZAE?HCyt7>a?I0RWTL BAi@9u diff --git a/engine/__pycache__/configProcessor.cpython-36.pyc b/engine/__pycache__/configProcessor.cpython-36.pyc index b575caf1203a6b57feb1989f3f14bdea6b3c2e13..f6e95b3b98049a0a23b56068e09786a099d7e176 100644 GIT binary patch delta 77 zcmcb{dYzTin3tC;)B0HS!HJxY%-r=ui&Kk=^{Wz#(lZis^kd{~&%n3tC;)B0Gn(nd~RMl(sd`Otnn3tDJX2t&Kf{mQKjHVvWRxzQ)sYS&xxk-sdIWYm1$r*`7xdBD_S*gh- g#W60KX=#;#y1|*b&Wx z;g_|3XmM&$v3^xzQF=yVuD(lta%paAUP-aOduEA8X_CH6W?EWhpl)zxuCt?yerjHN zW?rg(QE8rDLFFx$+{Da0ZlE#60ziU+k&TgyiGz`cS%8s`k%PHN3@E0_AH`FesaKL; z>71XJmYH6}1QaY{1`?B_n9{BIKs=DTB9Lp42vH#S7Kcr4eoARhsvSsEF&B`KVd7x~ ILS_yo0FtdXxc~qF delta 214 zcmZo<`_0N}%*)H=viC?d&qhurMnXQd{W6vw1wrlnOD>K13_CMTxEq~@h(=B36I zmFDRcRNi9AP0Y;W1e#JT03;X~*%-N)I2bvY1Q_`kIhcz?fnu8cQJkfjddZUmnaZqq ofdXLBB9PTcgb0v(i^C>2KczG$)s7L!E9L?cGK@SR$jre60CiX~^#A|> diff --git a/engine/__pycache__/utils.cpython-36.pyc b/engine/__pycache__/utils.cpython-36.pyc index b98d7999c89c3ed06be6f26523365fe971fc7f19..f3da34e4b52d6e06759c5e7a5c660159d33d9f4e 100644 GIT binary patch delta 790 zcmZuvO>fgc5cS%%6T1m2g+SAfgs4)hNU2;XA)rDgcZZ|z1#XQM`dppeTjE>xH7z8ixZ#@X(Tl-y?CxbBIt~_DA zs-tO|DqfGg_{jJ6Ogsr(8kFTP)?<#mt1q!d8R*|FV#2&UFy2;F;dlgq4Zxyg4vze3 zynlV}-#MovRB#C$!5TB01vpQ&C4wpeT{A^{s4d0o|OOq delta 726 zcmZva&u-H|5XQZ6yvdqWN&&Y`^G}hgme3X|N)!YYP}&QZk_I6pW2thJbz)@4>Z}3v z0XQO6-7}oIat4Vzyn#;$@d8}9aAC(mB8fQcZ)ayde>*$!C+nldw&&)|%KOjH9)4hL zLTtH9O0Au}+s+fgK{(;D3xU%)?G0TBI}knRy;wN=zUQ4DZa((Iz1@9>j|TpTJMxTl zOH9+WB)=25;c?%+Yp9b@OM`;^O}d21gUk|{mxIiAib^o$BmIqK=Xx&y_$UU7$rMcf z)ZZ4Zf9J9MU3THY0)~r-B?M~h0`QlrUw$;?ZXZfhso3>{)U-)bF);ZnyGAOqX51-W zK#R$1eWOh3^0m=gt*Vmxq>ft#P?*rj^8}yn^P5p8jdL2P*@bkqZR zx?{%~v&k`jWsTNNr9V&;yoe6jbOWN|F*g32t;&YkzBP}k3IeAO4FnDj))8rQXg)Ek Kzdy~Hx$y`8?vOkH diff --git a/engine/run.py b/engine/run.py index 1adcca7..1c57cd7 100644 --- a/engine/run.py +++ b/engine/run.py @@ -1,4 +1,6 @@ -from ui.config import state_dict, mechanisms, exogenous_states, env_processes, sim_config +#from ui.config import state_dict, mechanisms, exogenous_states, env_processes, sim_config +from ui.toyConfig import state_dict, mechanisms, exogenous_states, env_processes, sim_config +#from ui. import state_dict, mechanisms, exogenous_states, env_processes, sim_config from engine.configProcessor import generate_config from engine.mechanismExecutor import simulation from engine.utils import flatten @@ -11,7 +13,8 @@ def main(): configs = generate_config(mechanisms, exogenous_states) # p = pipeline(states_list, configs, env_processes, range(10)) N = sim_config['N'] - r = range(5) + r = range(sim_config["R"]) + #r = range(5) # Dimensions: N x r x mechs s = simulation(states_list, configs, env_processes, r, N) result = pd.DataFrame(flatten(s)) diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb index 48c1228..98d21c7 100644 --- a/notebooks/test.ipynb +++ b/notebooks/test.ipynb @@ -2,45 +2,68 @@ "cells": [ { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "scrolled": false }, - "outputs": [ - { - "ename": "ImportError", - "evalue": "cannot import name 'run'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mImportError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mengine\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mrun\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mrun\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mImportError\u001b[0m: cannot import name 'run'" - ] - } - ], + "outputs": [], "source": [ "from engine import run\n", - "run.main()" + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test\n" + ] + } + ], + "source": [ + "d=run.main()" + ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 7, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "d.plot()" + ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [] @@ -69,7 +92,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.6.4" } }, "nbformat": 4, diff --git a/ui/__pycache__/config.cpython-36.pyc b/ui/__pycache__/config.cpython-36.pyc index 66450cbb60dfe66bb91997154518b07bdc19f1f6..d2090b07dc5d7dc92a64ea55abb4a3a05131de78 100644 GIT binary patch delta 604 zcmah_&1(};5Z`&5{YW;6)l_ZNYHUQg zy^P^eJjO3)jBk*yV0E6W;o?E=2rkTX$MMA99ItKC;PdL4SLJ*7(75K^ zOHd@<^FTZr2C;X0JV;|4O%m@;G}%tWFGKcGhYNDiOyQz@MeM$@QfSGk^%XjD%YFwv z`NO^sxm+#wH#gM5j7S5qN<0ANDU>SQA|wSO4zvT?*{5&Q@K!%$odMG^%0$(4e-QmiDgaEbI`vE)x~iv!r^MUkq^=Orx<#ax<9(6HHt^ zXEBw=T|zI19k(f4&hkobjM8{_FK46O+~PQh;^3(;Xi9F1V8q99E+0Fgqb?R|chQzV mohR^6ZkHP;b(`4=g#r|SlpMj5FUz&M&A`+dl#G9M!Tb$`YlLC| delta 682 zcmaKp&ubGw6vy|?{>Ub2YHZXR+t_Fn**0lRQfsXuf_M#r2r?c@l6lm`W>aT3l|ZpV z1o0?y5F~mR@#NK$|A3xz^(6Qgc+of8P~yc|-sgSyeP`a=VZWXJlr7X!sYLGgmxnLo zhVjFgS`O)36v4CCg`WqaC`vC3eimb5bqGf+N17-ui^|C6OPIwoxFD({ljqSCHC!CB zDCdSutc@5yhe@0fS4Iqv#f23TLBQ22UK-j$t~goy1dOVX{$dP~-FBny}lz z3xeG4Kziy)JQv$HXbRNT+ju^;IpwZs_h916S#ms(%akI0 zh&g&4+vx9YHE&EEEs|~lK`)*4z}pmoOV~FA%HRAj`ew4Eo+lqeQ~gTj?^rH#O$y5b d3n-I{XghHDxE2EjRE1fGfnzdA*#G9V^A~+~j+_7h diff --git a/ui/toyConfig.py b/ui/toyConfig.py new file mode 100644 index 0000000..cb2944c --- /dev/null +++ b/ui/toyConfig.py @@ -0,0 +1,122 @@ +from engine.utils import bound_norm_random, ep_time_step, env_proc + +import numpy as np +from decimal import Decimal + +seed = { + 'z': np.random.RandomState(1), + 'a': np.random.RandomState(2), + 'b': np.random.RandomState(3), + 'c': np.random.RandomState(3) +} + +# Behaviors per Mechanism +def b1m1(step, sL, s): + return s['s1'] + 1 +def b2m1(step, sL, s): + return s['s1'] + 1 + +def b1m2(step, sL, s): + return s['s1'] + 1 +def b2m2(step, sL, s): + return s['s1'] + 1 + +def b1m3(step, sL, s): + return s['s1'] + 1 +def b2m3(step, sL, s): + return s['s2'] + 1 + + +# Internal States per Mechanism +def s1m1(step, sL, s, _input): + s['s1'] = s['s1'] + _input +def s2m1(step, sL, s, _input): + s['s2'] = s['s2'] + _input + +def s1m2(step, sL, s, _input): + s['s1'] = s['s1'] + _input +def s2m2(step, sL, s, _input): + s['s2'] = s['s2'] + _input + +def s1m3(step, sL, s, _input): + s['s1'] = s['s1'] + _input +def s2m3(step, sL, s, _input): + s['s2'] = s['s2'] + _input + +# Exogenous States +proc_one_coef_A = 0.7 +proc_one_coef_B = 1.3 +def es3p1(step, sL, s, _input): + s['s3'] = s['s3'] * bound_norm_random(seed['a'], proc_one_coef_A, proc_one_coef_B) +def es4p2(step, sL, s, _input): + s['s4'] = s['s4'] * bound_norm_random(seed['b'], proc_one_coef_A, proc_one_coef_B) +def es5p2(step, sL, s, _input): # accept timedelta instead of timedelta params + s['timestamp'] = ep_time_step(s, s['timestamp'], seconds=1) + +# Environment States +def env_a(x): + return 10 +def env_b(x): + return 10 +# def what_ever(x): +# return x + 1 + +# Genesis States +state_dict = { + 's1': Decimal(0.0), + 's2': Decimal(0.0), + 's3': Decimal(1.0), + 's4': Decimal(1.0), + 'timestamp': '2018-10-01 15:16:24' +} + +exogenous_states = { + "s3": es3p1, + "s4": es4p2, + "timestamp": es5p2 +} + +env_processes = { + "s3": env_proc('2018-10-01 15:16:25', env_a), + "s4": env_proc('2018-10-01 15:16:25', env_b) +} + +# test return vs. non-return functions as lambdas +# test fully defined functions +mechanisms = { + "m1": { + "behaviors": { + "b1": b1m1, # lambda step, sL, s: s['s1'] + 1, + "b2": b2m1 + }, + "states": { + "s1": s1m1, + "s2": s2m1, + } + }, + "m2": { + "behaviors": { + "b1": b1m2, + "b2": b2m2 + }, + "states": { + "s1": s1m2, + "s2": s2m2, + } + }, + "m3": { + "behaviors": { + "b1": b1m3, + "b2": b2m3 + }, + "states": { + "s1": s1m3, + "s2": s2m3, + } + } +} + +sim_config = { + "N": 1, + "R": 100 +} \ No newline at end of file