def run_simulation(c: CommonsSimulationConfiguration):
initial_conditions, simulation_parameters = bootstrap_simulation(c)
exp = Experiment()
exp.append_configs(
initial_state=initial_conditions,
partial_state_update_blocks=partial_state_update_blocks,
sim_configs=simulation_parameters
)
# Do not use multi_proc, breaks ipdb.set_trace()
exec_mode = ExecutionMode()
single_proc_context = ExecutionContext(exec_mode.local_mode)
executor = Executor(single_proc_context, configs)
raw_system_events, tensor_field, sessions = executor.execute()
df = pd.DataFrame(raw_system_events)
df_final = df[df.substep.eq(2)]
result = {
"timestep": list(df_final["timestep"]),
"funding_pool": list(df_final["funding_pool"]),
"token_supply": list(df_final["token_supply"]),
"collateral": list(df_final["collateral_pool"]),
"sentiment": list(df_final["sentiment"])
}
return result, df_final
def run(drop_midsteps: bool = True) -> pd.DataFrame:
"""
Run all experiments and return their output on the dataset column.
Each line represents an iteration of the parameter-sweep combinations.
"""
exec_mode = ExecutionMode()
multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
run = Executor(exec_context=multi_proc_ctx, configs=configs)
results = pd.DataFrame()
i = 0
for raw_result, _ in run.execute():
params = configs[i].sim_config['M']
result_record = pd.DataFrame.from_records(
[tuple([i for i in params.values()])], columns=list(params.keys()))
df = pd.DataFrame(raw_result)
# keep only last substep of each timestep
if drop_midsteps:
max_substep = max(df.substep)
is_droppable = (df.substep != max_substep) & (df.substep != 0)
df.drop(df[is_droppable].index, inplace=True)
result_record['dataset'] = [df]
results = results.append(result_record)
i += 1
return results.reset_index()
def run(drop_midsteps=True):
'''
Definition:
Run simulation
'''
exec_mode = ExecutionMode()
local_mode_ctx = ExecutionContext(context=exec_mode.local_mode)
simulation = Executor(exec_context=local_mode_ctx, configs=configs)
raw_system_events, tensor_field, sessions = simulation.execute()
# Result System Events DataFrame
df = pd.DataFrame(raw_system_events)
config_ids = [
dict(
get_M(k, v) for k, v in config.__dict__.items()
if k in ['simulation_id', 'run_id', 'sim_config', 'subset_id'])
for config in configs
]
results = pd.DataFrame()
for i, config_id in enumerate(config_ids):
params = config_id['M']
result_record = pd.DataFrame.from_records(
[tuple([i for i in params.values()])], columns=list(params.keys()))
sub_df = df[df.subset == config_id['subset_id']]
max_substep = max(sub_df.substep)
is_droppable = (sub_df.substep != max_substep) & (sub_df.substep != 0)
sub_df.drop(sub_df[is_droppable].index, inplace=True)
result_record['dataset'] = [sub_df]
results = results.append(result_record)
return results.reset_index()
def run(drop_midsteps: bool = True) -> pd.DataFrame:
"""
Run all experiments and return their output on the dataset column.
Each line represents an iteration of the parameter-sweep combinations.
"""
exec_mode = ExecutionMode()
exec_context = ExecutionContext(exec_mode.local_mode)
run = Executor(exec_context=exec_context, configs=configs)
results = pd.DataFrame()
(system_events, tensor_field, sessions) = run.execute()
df = pd.DataFrame(system_events)
results = []
for i, (_, subset_df) in enumerate(df.groupby(["simulation", "subset"])):
params = configs[i].sim_config['M']
result_record = pd.DataFrame.from_records(
[tuple([i for i in params.values()])], columns=list(params.keys()))
# keep only last substep of each timestep
if drop_midsteps:
max_substep = max(subset_df.substep)
is_droppable = (subset_df.substep != max_substep)
is_droppable &= (subset_df.substep != 0)
subset_df = subset_df.loc[~is_droppable]
result_record['dataset'] = [subset_df]
results.append(result_record)
return pd.concat(results).reset_index()
def run():
exec_mode = ExecutionMode()
multi_mode_ctx = ExecutionContext(context=exec_mode.multi_proc)
simulation = Executor(exec_context=multi_mode_ctx, configs=configs)
raw_system_events, tensor_field, sessions = simulation.execute()
# Result System Events DataFrame
df = pd.DataFrame(raw_system_events)
return df
def run(drop_midsteps: bool=True) -> pd.DataFrame:
"""
Run all experiments and return their output on the dataset column.
Each line represents an iteration of the parameter-sweep combinations.
"""
exec_mode = ExecutionMode()
local_proc_ctx = ExecutionContext(context=exec_mode.multi_mode)
simulation = Executor(exec_context=local_proc_ctx, configs=configs)
raw_system_events, tensor_field, sessions = simulation.execute()
simulation_result = pd.DataFrame(raw_system_events)
return simulation_result
def run(drop_midsteps: bool = True) -> pd.DataFrame:
"""
Run all experiments and return their output on the dataset column.
Each line represents an iteration of the parameter-sweep combinations.
"""
exec_mode = ExecutionMode()
multi_mode_ctx = ExecutionContext(context=exec_mode.multi_mode)
run = Executor(exec_context=multi_mode_ctx, configs=configs)
raw_result, tensor_field, sessions = run.execute()
results = pd.DataFrame(raw_result)
return results
def run():
'''
Definition:
Run simulation
'''
exec_mode = ExecutionMode()
local_mode_ctx = ExecutionContext(context=exec_mode.local_mode)
simulation = Executor(exec_context=local_mode_ctx, configs=configs)
raw_system_events, tensor_field, sessions = simulation.execute()
# Result System Events DataFrame
df = pd.DataFrame(raw_system_events)
return df
def temp_run(drop_midsteps=True):
exec_mode = ExecutionMode()
multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
run = Executor(exec_context=multi_proc_ctx, configs=configs)
i = 0
results = {}
for raw_result, tensor_field in run.execute():
result = pd.DataFrame(raw_result)
results[i] = {}
results[i]['result'] = result
i += 1
return results
def main():
c = Central(300)
params = Parameters(c)
config = Configuration(
initial_state=params.initial_state(),
partial_state_update_blocks=params.partial_state_update_blocks,
sim_config=simulation_parameters)
exec_mode = ExecutionMode()
exec_context = ExecutionContext(exec_mode.single_proc)
executor = Executor(exec_context, [config])
raw_result, tensor = executor.execute()
raw_result = [d for d in raw_result]
plot_results(raw_result)
def run(input_config=configs):
'''
Definition:
Run simulation
Parameters:
input_config: Optional way to pass in system configuration
'''
exec_mode = ExecutionMode()
local_mode_ctx = ExecutionContext(context=exec_mode.local_mode)
simulation = Executor(exec_context=local_mode_ctx, configs=input_config)
raw_system_events, tensor_field, sessions = simulation.execute()
# Result System Events DataFrame
df = pd.DataFrame(raw_system_events)
return df
def run(initial_state, partial_state_update_block, sim_configs):
exp = Experiment()
exp.append_configs(initial_state=initial_state,
partial_state_update_blocks=partial_state_update_block,
sim_configs=sim_configs)
# Do not use multi_proc, breaks ipdb.set_trace()
exec_mode = ExecutionMode()
single_proc_context = ExecutionContext(exec_mode.single_proc)
executor = Executor(single_proc_context, configs)
raw_system_events, tensor_field, sessions = executor.execute()
df = pd.DataFrame(raw_system_events)
return df
def run_simulation(c: CommonsSimulationConfiguration):
initial_conditions, simulation_parameters = bootstrap_simulation(c)
exp = Experiment()
exp.append_configs(initial_state=initial_conditions,
partial_state_update_blocks=partial_state_update_blocks,
sim_configs=simulation_parameters)
# Do not use multi_proc, breaks ipdb.set_trace()
exec_mode = ExecutionMode()
single_proc_context = ExecutionContext(exec_mode.local_mode)
executor = Executor(single_proc_context, configs)
raw_system_events, tensor_field, sessions = executor.execute()
df = pd.DataFrame(raw_system_events)
return df
def run():
'''
Definition:
Run simulation
'''
# Single
exec_mode = ExecutionMode()
local_mode_ctx = ExecutionContext(context=exec_mode.local_mode)
simulation = Executor(exec_context=local_mode_ctx, configs=exp.configs)
raw_system_events, tensor_field, sessions = simulation.execute()
# Result System Events DataFrame
df = pd.DataFrame(raw_system_events)
# subset to last substep
df = df[df['substep'] == df.substep.max()]
return df
def run():
'''
Definition:
Run simulation
Parameters:
input_config: Optional way to pass in system configuration
'''
exec_mode = ExecutionMode()
local_mode_ctx = ExecutionContext(context=exec_mode.local_mode)
simulation = Executor(exec_context=local_mode_ctx, configs=configs)
raw_system_events, tensor_field, sessions = simulation.execute()
df = (pd.DataFrame(raw_system_events))
# Clean substeps
first_ind = (df.substep == 0) & (df.timestep == 0)
last_ind = df.substep == max(df.substep)
inds_to_drop = (first_ind | last_ind)
df = df.loc[inds_to_drop].drop(columns=['substep'])
# Set indexes
df = df.set_index(['simulation', 'subset', 'run', 'timestep'])
return df
def run_3(drop_midsteps=True):
exec_mode = ExecutionMode()
multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
run = Executor(exec_context=multi_proc_ctx, configs=configs)
results = pd.DataFrame()
i = 0
for raw_result, _ in run.execute():
params = configs[i].sim_config['M']
result_record = pd.DataFrame.from_records(
[tuple([i for i in params.values()])], columns=list(params.keys()))
df = pd.DataFrame(raw_result)
# keep only last substep of each timestep
if drop_midsteps:
max_substep = max(df.substep)
is_droppable = (df.substep != max_substep) & (df.substep != 0)
df.drop(df[is_droppable].index, inplace=True)
result_record['dataset'] = [df]
results = results.append(result_record)
i += 1
return results.reset_index()
def test_simulation_dataframe_structure():
states = basic.states
state_update_blocks = basic.state_update_blocks
params = basic.params
TIMESTEPS = 1000
RUNS = 1
model = Model(initial_state=states,
state_update_blocks=state_update_blocks,
params=params)
simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS)
experiment = Experiment([simulation, simulation, simulation])
data_radcad = experiment.run()
df_radcad = pd.DataFrame(data_radcad).drop(['run'], axis=1)
c = config_sim({"N": RUNS, "T": range(TIMESTEPS), "M": params})
exp = cadCADExperiment()
exp.append_configs(model_id='a',
initial_state=states,
partial_state_update_blocks=state_update_blocks,
sim_configs=c)
exp.append_configs(model_id='b',
initial_state=states,
partial_state_update_blocks=state_update_blocks,
sim_configs=c)
exp.append_configs(model_id='c',
initial_state=states,
partial_state_update_blocks=state_update_blocks,
sim_configs=c)
exec_mode = ExecutionMode()
local_mode_ctx = ExecutionContext(context=exec_mode.local_mode)
simulation = Executor(exec_context=local_mode_ctx, configs=exp.configs)
data_cadcad, tensor_field, sessions = simulation.execute()
df_cadcad = pd.DataFrame(data_cadcad).drop(['run'], axis=1)
assert_frame_equal(df_radcad, df_cadcad)
assert df_radcad.equals(df_cadcad)
from pprint import pprint import pandas as pd from tabulate import tabulate from cadCAD.engine import ExecutionMode, ExecutionContext, Executor from simulations.regression_tests.models import sweep_config exec_mode = ExecutionMode() local_proc_ctx = ExecutionContext(context=exec_mode.local_mode) run = Executor(exec_context=local_proc_ctx, configs=sweep_config.exp.configs) raw_result, tensor_fields, _ = run.execute() result = pd.DataFrame(raw_result) print(tabulate(tensor_fields[0], headers='keys', tablefmt='psql')) print(tabulate(result, headers='keys', tablefmt='psql'))
import pandas as pd
from tabulate import tabulate
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from documentation.examples import sys_model_A, sys_model_B
from cadCAD import configs
exec_mode = ExecutionMode()
# Multiple Processes Execution using Multiple System Model Configurations:
local_proc_ctx = ExecutionContext(context=exec_mode.local_mode)
sys_model_AB_simulation = Executor(exec_context=local_proc_ctx, configs=configs)
i = 0
config_names = ['sys_model_A', 'sys_model_B']
sys_model_AB_raw_result, sys_model_AB_tensor_field, sessions = sys_model_AB_simulation.execute()
sys_model_AB_result = pd.DataFrame(sys_model_AB_raw_result)
print()
print(f"Tensor Field:")
print(tabulate(sys_model_AB_tensor_field, headers='keys', tablefmt='psql'))
print("Result: System Events DataFrame:")
print(tabulate(sys_model_AB_result, headers='keys', tablefmt='psql'))
print()
from cadCAD.configuration import append_configs
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# The configurations above are then packaged into a `Configuration` object
append_configs(
initial_state=
initial_conditions, #dict containing variable names and initial values
partial_state_update_blocks=
partial_state_update_blocks, #dict containing state update functions
sim_configs=simulation_parameters #dict containing simulation parameters
)
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from cadCAD import configs
import pandas as pd
exec_mode = ExecutionMode()
multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
run = Executor(exec_context=multi_proc_ctx, configs=configs)
i = 0
for raw_result, tensor_field in run.execute():
result = pd.DataFrame(raw_result)
print()
print(f"Tensor Field: {type(tensor_field)}")
print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
print(f"Output: {type(result)}")
print(tabulate(result, headers='keys', tablefmt='psql'))
print()
i += 1
import pandas as pd
from tabulate import tabulate
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from documentation.examples import sys_model_A, sys_model_B
from cadCAD import configs
exec_mode = ExecutionMode()
# # Multiple Processes Execution using Multiple System Model Configurations:
# # sys_model_A & sys_model_B
multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
sys_model_AB_simulation = Executor(exec_context=multi_proc_ctx,
configs=configs)
i = 0
config_names = ['sys_model_A', 'sys_model_B']
for sys_model_AB_raw_result, sys_model_AB_tensor_field in sys_model_AB_simulation.execute(
):
sys_model_AB_result = pd.DataFrame(sys_model_AB_raw_result)
print()
print(f"Tensor Field: {config_names[i]}")
print(tabulate(sys_model_AB_tensor_field, headers='keys', tablefmt='psql'))
print("Result: System Events DataFrame:")
print(tabulate(sys_model_AB_result, headers='keys', tablefmt='psql'))
print()
i += 1
import pandas as pd
from tabulate import tabulate
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from documentation.examples import sys_model_A
from cadCAD import configs
exec_mode = ExecutionMode()
# Single Process Execution using a Single System Model Configuration:
# sys_model_A
sys_model_A = [configs[0]] # sys_model_A
single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
sys_model_A_simulation = Executor(exec_context=single_proc_ctx, configs=sys_model_A)
sys_model_A_raw_result, sys_model_A_tensor_field = sys_model_A_simulation.execute()
sys_model_A_result = pd.DataFrame(sys_model_A_raw_result)
print()
print("Tensor Field: sys_model_A")
print(tabulate(sys_model_A_tensor_field, headers='keys', tablefmt='psql'))
print("Result: System Events DataFrame")
print(tabulate(sys_model_A_result, headers='keys', tablefmt='psql'))
print()
exp = Experiment()
exp.append_configs(
initial_state = states,
partial_state_update_blocks = psubs,
sim_configs = c
)
exp.append_configs(
initial_state = states,
partial_state_update_blocks = psubs,
sim_configs = c
)
exec_mode = ExecutionMode()
local_mode_ctx = ExecutionContext(context=exec_mode.local_mode)
simulation = Executor(exec_context=local_mode_ctx, configs=configs)
start = time.time()
data, tensor_field, sessions = simulation.execute()
end = time.time()
duration_cadcad = end - start
print(duration_cadcad)
df_cadcad = pd.DataFrame(data)
print(df_cadcad)
from pandas.testing import assert_frame_equal
assert_frame_equal(df_radcad.drop(['run'], axis=1), df_cadcad.drop(['run'], axis=1))
print()
import unittest
import pandas as pd
from cadCAD import configs
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from testing.generic_test import make_generic_test
exec_mode = ExecutionMode()
single_proc_ctx = ExecutionContext(context=exec_mode.single_mode)
run = Executor(exec_context=single_proc_ctx, configs=configs)
raw_result, tensor_field, _ = run.execute()
result = pd.DataFrame(raw_result)
expected_results = {
(0, 1, 0, 0): {
'x': 0,
'nonexsistant': [],
'last_x': [],
'2nd_to_last_x': [],
'3rd_to_last_x': [],
'4th_to_last_x': []
},
(0, 1, 1, 1): {
'x':
1,
'nonexsistant': [],
'last_x': [{
'simulation': 0,
'x': 0,
'run': 1,
'substep': 0,
from pprint import pprint
import pandas as pd
from tabulate import tabulate
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from simulations.regression_tests.models import udo_inter_substep_update
from cadCAD import configs
exec_mode = ExecutionMode()
local_proc_ctx = ExecutionContext(context=exec_mode.local_mode)
run = Executor(exec_context=local_proc_ctx, configs=configs)
raw_result, tensor_fields, sessions = run.execute()
# cols = configs[0].initial_state.keys()
cols = [
'increment',
'state_udo_tracker_a', 'state_udo', 'state_udo_perception_tracker', 'state_udo_tracker_b',
'udo_policy_tracker_a', 'udo_policies', 'udo_policy_tracker_b',
'timestamp'
]
result = pd.DataFrame(raw_result)[['run', 'substep', 'timestep'] + cols]
print(tabulate(tensor_fields[0], headers='keys', tablefmt='psql'))
pprint(sessions)
print(tabulate(result, headers='keys', tablefmt='psql'))
import pandas as pd
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from simulations.regression_tests.models import policy_aggregation
from cadCAD.utils.sys_exec import to_spark_df, to_pandas_df
from cadCAD.configuration.utils import configs_as_dataframe #, configs_as_objs, configs_as_dicts
from distroduce.engine.execution import transform, distributed_simulations
from distroduce.session import sc_alt as sc
from distroduce.session import spark_alt as spark
exec_mode = ExecutionMode()
distributed_sims = distributed_simulations(transform(publish=False))
distributed_ctx = ExecutionContext(context=exec_mode.distributed, method=distributed_sims)
run = Executor(exec_context=distributed_ctx, configs=configs, spark_context=sc)
raw_result, tensor_fields, sessions = run.execute()
print(tabulate(tensor_fields[0], headers='keys', tablefmt='psql'))
pprint(sessions)
print("Configuration Data:")
configs_df = configs_as_dataframe(configs)
print(tabulate(configs_df, headers='keys', tablefmt='psql'))
print("Tensor Field:")
print(tabulate(tensor_fields[0], headers='keys', tablefmt='psql'))
print("Output:")
# RDD:
print()
print("RDD:")
def run_simulation():
def update_collateral_pool(params, step, sL, s, _input):
commons = s["commons"]
s["collateral_pool"] = commons._collateral_pool
return "collateral_pool", commons._collateral_pool
def update_token_supply(params, step, sL, s, _input):
commons = s["commons"]
s["token_supply"] = commons._token_supply
return "token_supply", commons._token_supply
def update_funding_pool(params, step, sL, s, _input):
commons = s["commons"]
s["funding_pool"] = commons._funding_pool
return "funding_pool", commons._funding_pool
# In[3]:
# contributions = [5e5, 5e5, 2.5e5]
contributions = [np.random.rand() * 10e5 for i in range(60)]
token_batches, initial_token_supply = create_token_batches(
contributions, 0.1, 60)
commons = Commons(sum(contributions),
initial_token_supply,
exit_tribute=0.35)
network = bootstrap_network(token_batches, 3, commons._funding_pool,
commons._token_supply)
initial_conditions = {
"network": network,
"commons": commons,
"funding_pool": commons._funding_pool,
"collateral_pool": commons._collateral_pool,
"token_supply": commons._token_supply,
"sentiment": 0.5,
}
partial_state_update_blocks = [
{
"policies": {
"generate_new_participants": GenerateNewParticipant.p_randomly,
},
'variables': {
'network': GenerateNewParticipant.su_add_to_network,
'commons': GenerateNewParticipant.su_add_investment_to_commons,
}
},
{
"policies": {},
"variables": {
"funding_pool": update_funding_pool,
"collateral_pool": update_collateral_pool,
"token_supply": update_token_supply,
}
},
{
"policies": {
"generate_new_proposals": GenerateNewProposal.p_randomly,
},
"variables": {
"network": GenerateNewProposal.su_add_to_network,
}
},
{
"policies": {
"generate_new_funding":
GenerateNewFunding.
p_exit_tribute_of_average_speculator_position_size,
},
"variables": {
"network": GenerateNewFunding.su_add_funding,
}
},
]
# In[4]:
# TODO: make it explicit that 1 timestep is 1 day
simulation_parameters = {
'T': range(150),
'N': 1,
'M': {
"sentiment_decay": 0.01, # termed mu in the state update function
"trigger_threshold": trigger_threshold,
"min_proposal_age_days":
7, # minimum periods passed before a proposal can pass,
"sentiment_sensitivity": 0.75,
"alpha": 0.5, # conviction voting parameter
'min_supp':
50, # number of tokens that must be stake for a proposal to be a candidate
}
}
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# The configurations above are then packaged into a `Configuration` object
config = Configuration(
initial_state=
initial_conditions, # dict containing variable names and initial values
# dict containing state update functions
partial_state_update_blocks=partial_state_update_blocks,
sim_config=simulation_parameters # dict containing simulation parameters
)
exec_mode = ExecutionMode()
# Do not use multi_proc, breaks ipdb.set_trace()
exec_context = ExecutionContext(exec_mode.single_proc)
# Pass the configuration object inside an array
executor = Executor(exec_context, [config])
# The `execute()` method returns a tuple; its first elements contains the raw results
raw_result, tensor = executor.execute()
# In[5]:
df = pd.DataFrame(raw_result)
df_final = df[df.substep.eq(2)]
# In[6]:
df_final.plot("timestep", "collateral_pool", grid=True)
df_final.plot("timestep", "token_supply", grid=True)
df_final.plot("timestep", "funding_pool", grid=True)
import unittest, pandas as pd
from tabulate import tabulate
from testing.models import policy_aggregation as policy_agg
from testing.results_comparison import dataframe_difference, compare_results
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
exec_mode = ExecutionMode()
exec_ctx = ExecutionContext(context=exec_mode.local_mode)
run = Executor(exec_context=exec_ctx, configs=policy_agg.exp.configs)
raw_result, _, _ = run.execute()
result_df = pd.DataFrame(raw_result)
expected_df = pd.read_pickle("expected_results/policy_agg_4.pkl")
result_diff = dataframe_difference(result_df, expected_df)
print(tabulate(result_diff, headers='keys', tablefmt='psql'))
class PolicyAggTest(compare_results(result_diff)):
pass
if __name__ == '__main__':
unittest.main()
import unittest
import pandas as pd
from cadCAD import configs
from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
from testing.generic_test import make_generic_test
exec_mode = ExecutionMode()
first_config = configs
single_proc_ctx = ExecutionContext(context=exec_mode.local_mode)
run = Executor(exec_context=single_proc_ctx, configs=first_config)
raw_result, tensor_field, sessions = run.execute()
result = pd.DataFrame(raw_result)
def get_expected_results(run):
return {
(0, run, 0, 0): {
'external_data': {'ds1': None, 'ds2': None, 'ds3': None},
'increment': 0,
'policies': {'ds1': None, 'ds2': None, 'ds3': None}
},
(0, run, 1, 1): {
'external_data': {'ds1': 0, 'ds2': 0, 'ds3': 1},
'increment': 1,
'policies': {'ds1': 0, 'ds2': 0, 'ds3': 1}
},
(0, run, 1, 2): {
'external_data': {'ds1': 1, 'ds2': 40, 'ds3': 5},
'create_pat': create_pat,
},
'variables': {
PATS: add_pat,
}
},
]
config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values
partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions
sim_config=simulation_parameters #dict containing simulation parameters
)
exec_mode = ExecutionMode()
exec_context = ExecutionContext(exec_mode.single_proc)
executor = Executor(exec_context, [config]) # Pass the configuration object inside an array
raw_result, tensor = executor.execute()
df = pd.DataFrame(raw_result)
print(df)
# # Initial design V0
# In[34]:
initial_conditions = {
USERS: {0:{}}, # users are numerical ids and a dictionary of their current wallet
PATS: [0], # pats are currently simply numerical ids
CLAIMS: {},
