def test_raise_exceptions_false(): initial_state = { 'state_a': 0 } state_update_blocks = [ { 'policies': {}, 'variables': { 'state_a': update_state_invalid_result } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulation) experiment.engine = Engine(raise_exceptions=False) results = experiment.run() _results = experiment.results assert len(results) > 0 assert results == _results exceptions = experiment.exceptions print(exceptions) assert any([True if isinstance(exception['exception'], Exception) else False for exception in exceptions]) assert isinstance(results, list)
def test_backend_single_process(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = 10 #basic.TIMESTEPS RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulation) processes = 1 experiment.engine = Engine(backend=Backend.MULTIPROCESSING, processes=processes) df_multiprocessing = pd.DataFrame(experiment.run()) if _has_ray_extension: experiment.engine = Engine(backend=Backend.RAY, processes=processes) df_ray = pd.DataFrame(experiment.run()) experiment.engine = Engine(backend=Backend.PATHOS, processes=processes) df_pathos = pd.DataFrame(experiment.run()) experiment.engine = Engine(backend=Backend.SINGLE_PROCESS) df_single_process = pd.DataFrame(experiment.run()) if _has_ray_extension: assert df_multiprocessing.equals(df_ray) assert df_multiprocessing.equals(df_pathos) assert df_multiprocessing.equals(df_single_process)
def test_basic_state_update(): initial_state = { 'a': a } state_update_blocks = [ { 'policies': {}, 'variables': { 'a': update_a } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulation) result = experiment.run() assert result[0]['a'] == 0 assert result[1]['a'] == 1 assert result[-2]['a'] == 9 assert result[-1]['a'] == 10
def test_policy_result_type_error(): initial_state = { 'state_a': 0 } state_update_blocks = [ { 'policies': { 'p1': policy_function_invalid_result }, 'variables': { 'state_a': update_state_a } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) with pytest.raises(Exception) as e: result = simulation.run() assert str(e.value) == "Failed to extract policy function result as dictionary"
def test_state_history(): initial_state = {'a': 1, 'b': 1} state_update_blocks = [ { 'policies': {}, 'variables': { 'a': update_a } }, { 'policies': {}, 'variables': { 'a': update_a } }, ] model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params={}) simulation = Simulation(model=model, timesteps=10) result = simulation.run() assert True
def test_to_HDF5(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) HDF5_store_file = 'experiment_results.hdf5' experiment = Experiment(simulations=[simulation]) experiment.after_experiment = lambda experiment: save_to_HDF5(experiment, HDF5_store_file, 'experiment_0') raw_result = experiment.run() df = pd.read_hdf(HDF5_store_file, 'experiment_0') assert df.equals(pd.DataFrame(raw_result)) experiment = Experiment(simulations=[simulation]) experiment.after_experiment = lambda experiment: save_to_HDF5(experiment, HDF5_store_file, 'experiment_1') raw_result = experiment.run() df = pd.read_hdf(HDF5_store_file, 'experiment_1') assert df.equals(pd.DataFrame(raw_result)) assert len(raw_result) > 0 assert raw_result == experiment.results assert simulation.run() == raw_result
def test_policy_exception(): initial_state = { 'state_a': 0 } state_update_blocks = [ { 'policies': { 'p1': policy_function_raises }, 'variables': { 'state_a': update_state_a } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) with pytest.raises(Exception) as e: result = simulation.run() assert str(e.value) == "Forced exception from policy function"
def test_regression_policy_names(): initial_state = {'a': 0} state_update_blocks = [ { 'policies': { 'policy': policy_a }, 'variables': { 'a': update_a } }, ] params = {'param_a': [0]} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulation) assert isinstance(experiment.run(), list)
def test_regression_policy_signals(): initial_state = {'a': 0, 'b': 0} state_update_blocks = [ { 'policies': {}, 'variables': { 'a': update_a_from_signal, 'b': update_b_from_signal } }, { 'policies': { 'policy': policy_two_signals }, 'variables': { 'a': update_a_from_signal, 'b': update_b_from_signal } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) result = simulation.run() df = pd.DataFrame(result) assert df.query('timestep == 10 and substep == 2')['a'].item() == 10
def test_regression_deepcopy(): initial_state = {'state_a': 0} state_update_blocks = [ { 'policies': {}, 'variables': { 'state_a': update_state_a } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model) experiment = Experiment(simulation) simulation.run() _ = copy.deepcopy(simulation)
def test_paralell_state_update(): def update_a(params, substep, state_history, previous_state, policy_input): if previous_state['timestep'] == 1: assert previous_state['b'] == 0 return 'a', previous_state['a'] + 1 def update_b(params, substep, state_history, previous_state, policy_input): if previous_state['timestep'] == 1: assert previous_state['a'] == 0 return 'b', previous_state['b'] + 1 initial_state = {'a': 0, 'b': 0} state_update_blocks = [ { 'policies': {}, 'variables': { 'a': update_a, 'b': update_b } }, ] params = {} TIMESTEPS = 1 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) result = simulation.run() df = pd.DataFrame(result)
def test_regression_state_names(): # Test that state names of more than one charachter don't fail! initial_state = {'state_a': 0} state_update_blocks = [ { 'policies': {}, 'variables': { 'state_a': update_state_a } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulation) assert isinstance(experiment.run(), list)
def test_run(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulations=[simulation]) experiment.run() assert True
def test_model_call_method(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) # Test Model __call__() method configuration model( drop_substeps=True, deepcopy=False, raise_exceptions=False, )
def test_simulation_init(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) with pytest.raises(Exception): Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS, invalid_arg=None)
def test_run(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulations=[simulation]) raw_result = experiment.run() assert len(raw_result) > 0 assert raw_result == experiment.results assert simulation.run() == raw_result
def test_base_results(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS 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_results = simulation.run() experiment_results = experiment.run() # Check Executable results & exceptions assert simulation_results == experiment_results assert simulation.results == experiment.results assert simulation.exceptions == experiment.exceptions
def test_initial_state_and_previous_state(): model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks) simulation = Simulation(model=model, timesteps=10, runs=1) simulation.engine = Engine(backend=Backend.SINGLE_PROCESS) result = simulation.run() df = pd.DataFrame(result) # Check that the initial state transition is correct assert timesteps[:4] == [ 0, # Timestep 1; substep 1 1, # Timestep 1; substep 2 1, # Timestep 1; substep 3 1 # Timestep 2; substep 1 ] assert substeps[:4] == [ 0, # Timestep 1; substep 1 1, # Timestep 1; substep 2 2, # Timestep 1; substep 3 3 # Timestep 2; substep 1 ] # Check that the previous state is correctly passed to next timestep/substep assert timesteps[len(timesteps) - 4:] == [ 9, # Timestep 9; substep 3 9, # Timestep 10; substep 1 10, # Timestep 10; substep 2 10 # Timestep 10; substep 3 ] assert substeps[len(substeps) - 4:] == [ 2, # Timestep 9; substep 3 3, # Timestep 10; substep 1 1, # Timestep 10; substep 2 2 # Timestep 10; substep 3 ] assert df.query("timestep == 0")["substep"].iloc[0] == 0 assert df.query("timestep == 1")["substep"].iloc[0] == df.query( "timestep == 2")["substep"].iloc[0] assert df.query("timestep == 9")["substep"].iloc[0] == df.query( "timestep == 10")["substep"].iloc[0]
def test_simulation_dataframe_structure(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS 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) 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) assert_frame_equal(df_radcad, df_cadcad) assert df_radcad.equals(df_cadcad)
def test_run_ray_remote(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) engine = Engine(backend=Backend.RAY_REMOTE) experiment = Experiment(simulation, engine=engine) if not RAY_ADDRESS or not RAY_REDIS_PASSWORD: assert False, "RAY_ADDRESS or RAY_REDIS_PASSWORD not set" ray.init(_redis_password=RAY_REDIS_PASSWORD) result = experiment.run() df = pd.DataFrame(result) print(df) assert True
def test_multiple_partial_state_updates(): initial_state = { 'a': 0 } state_update_blocks = [ { 'policies': {}, 'variables': { 'a': lambda params, substep, state_history, previous_state, policy_input: ('a', previous_state['a'] + 1), } }, { 'policies': {}, 'variables': { 'a': lambda params, substep, state_history, previous_state, policy_input: ('a', previous_state['a'] + 1), } }, { 'policies': {}, 'variables': { 'a': lambda params, substep, state_history, previous_state, policy_input: ('a', previous_state['a'] + 1), } }, ] params = {} TIMESTEPS = 10 RUNS = 1 model = Model(initial_state=initial_state, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulation) experiment.engine = Engine(backend=Backend.SINGLE_PROCESS) result = experiment.run() df = pd.DataFrame(result) assert df.query('timestep == 10 and substep == 3')['a'].item() == 30
def test_model_generator(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = 10 RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulations=[simulation]) raw_result_experiment = experiment.run() # The Model generator doesn't handle parameter sweeps, and only executes one run df_experiment = pd.DataFrame(raw_result_experiment).query( 'run == 1 and subset == 0') assert len(raw_result_experiment) > 0 assert raw_result_experiment == experiment.results assert simulation.run() == raw_result_experiment # Create a generator from the Model instance model_generator = iter(model) raw_result_model = [] # Set initial state raw_result_model.append(model.state) # Emulate the behaviour of the radCAD Engine for t in range(TIMESTEPS): _model = next(model_generator) raw_result_model.append(_model.substeps) # Flatten the results raw_result_model = utils.flatten(raw_result_model) df_model = pd.DataFrame(raw_result_model) assert_frame_equal(df_experiment, df_model)
def test_run(): states = basic.states state_update_blocks = basic.state_update_blocks params = basic.params TIMESTEPS = 10 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(simulations=[simulation]) experiment.engine = Engine(drop_substeps=True) drop_substeps_result = pd.DataFrame(experiment.run()) simulation_result = pd.DataFrame(simulation.run()) keep = (simulation_result.substep == simulation_result['substep'].max()) keep |= (simulation_result.substep == 0) simulation_result = simulation_result.loc[keep] assert simulation_result.reset_index(drop=True).equals( drop_substeps_result.reset_index(drop=True))
def test_invalid_state_update_function(): states = basic.states state_update_blocks = [ { 'policies': { 'p': basic.policy, }, 'variables': { 'a': basic.update_b } }, ] params = basic.params TIMESTEPS = basic.TIMESTEPS RUNS = basic.RUNS model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulation) with pytest.raises(KeyError) as err: experiment.run()
def execute(self, engine=Engine()): simulations = [] for config in self.configs: initial_state = config.initial_state state_update_blocks = config.partial_state_update_blocks timesteps = max(list(config.sim_config["T"])) + 1 runs = config.sim_config["N"] params = config.sim_config[ "M"] # {key: [value] for key, value in config.sim_config['M'].items()} model = Model( initial_state=initial_state, state_update_blocks=state_update_blocks, params=params, ) simulation = Simulation(model=model, timesteps=timesteps, runs=1) simulations.append(simulation) experiment = Experiment(simulations=simulations) experiment.engine = engine result = experiment.run() return result, None, None
import pytest import pandas as pd from radcad import Model, Simulation, Experiment from tests.test_cases import benchmark_model states = benchmark_model.states state_update_blocks = benchmark_model.state_update_blocks params = benchmark_model.params TIMESTEPS = 100_000 RUNS = 3 model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation_radcad = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment([simulation_radcad, simulation_radcad, simulation_radcad]) def test_benchmark_radcad(benchmark): benchmark.pedantic(radcad_simulation, iterations=1, rounds=3) def radcad_simulation(): data_radcad = experiment.run()
def test_hooks(capsys): states = basic.states state_update_blocks = basic.state_update_blocks params = params = {'a': [1, 2], 'b': [1]} TIMESTEPS = 1 RUNS = 2 model = Model(initial_state=states, state_update_blocks=state_update_blocks, params=params) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) experiment = Experiment(simulations=[simulation, simulation]) experiment.before_experiment = lambda experiment=None: print( f'before_experiment') experiment.before_simulation = lambda simulation=None: print( f'before_simulation {simulation.index}') experiment.before_run = lambda context=None: print( f'before_run {context.run}') experiment.before_subset = lambda context=None: print( f'before_subset {context.subset}') experiment.after_subset = lambda context=None: print( f'after_subset {context.subset}') experiment.after_run = lambda context=None: print( f'after_run {context.run}') experiment.after_simulation = lambda simulation=None: print( f'after_simulation {simulation.index}') experiment.after_experiment = lambda experiment=None: print( f'after_experiment') experiment.run() captured = capsys.readouterr() assert captured.out.replace('\n', '').replace(' ', '') == """ before_experiment before_simulation 0 before_run 0 before_subset 0 after_subset 0 before_subset 1 after_subset 1 after_run 0 before_run 1 before_subset 0 after_subset 0 before_subset 1 after_subset 1 after_run 1 after_simulation 0 before_simulation 1 before_run 0 before_subset 0 after_subset 0 before_subset 1 after_subset 1 after_run 0 before_run 1 before_subset 0 after_subset 0 before_subset 1 after_subset 1 after_run 1 after_simulation 1 after_experiment """.replace('\n', '').replace(' ', '')
state_update_blocks = [{ "policies": { "loop": loop }, "variables": { "full": state_update_full, "board": state_update_board }, }] TIMESTEPS = 100 RUNS = 1 model = Model( initial_state=initial_state, state_update_blocks=state_update_blocks, params=params, ) simulation = Simulation(model=model, timesteps=TIMESTEPS, runs=RUNS) full, board = generate_new_board() def cells_to_board(cells): string = io.StringIO(cells) for row, line in enumerate(string): for column, char in enumerate(line): if char == 'O': board[row, column] = 1