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 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)
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()
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 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()
# `N` is the number of times the simulation will be run (Monte Carlo runs) time_periods_per_run = 250 monte_carlo_runs = 1 simulation_parameters = { 'T': range(time_periods_per_run), 'N': monte_carlo_runs, 'M': params } from cadCAD.engine import ExecutionMode, ExecutionContext, Executor from cadCAD.configuration import append_configs from cadCAD import configs # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # The configurations above are then packaged into a `Configuration` object config = 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 ) exec_mode = ExecutionMode() exec_context = ExecutionContext(context=exec_mode.multi_proc) run = Executor(exec_context=exec_context, configs=configs) executor = Executor(exec_context, configs) # Pass the configuration object inside an array raw_result, tensor = executor.execute( ) # The `main()` method returns a tuple; its first elements contains the raw results
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()
'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: {},
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 policy_aggregation exec_mode = ExecutionMode() local_proc_ctx = ExecutionContext(context=exec_mode.local_mode) run = Executor(exec_context=local_proc_ctx, configs=policy_aggregation.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 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},
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'))