def run_simulation(config_path): path = os.path.join(os.path.dirname(__file__), '..', config_path) with open(path) as simulation_data: data = json.loads(simulation_data.read()) simulation_config = simulation.Config(data) simulator = simulation.Simulator(simulation_config) return simulator.simulate()
def run_sims(switch_time, nruns, setup, model, params): """Run simulations and extract objective values.""" def controller(time): if time < switch_time: return [1.0, 0.0] else: return [0.0, 1.0] params["controller_args"] = {"oc_model": model, "policy": controller} simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.RiskPolicyController) run_data = simulator.run_simulation(nruns=nruns, verbose=False) return [np.sum(x.objective) for x in run_data]
def create_simulator(): sim = simulation.Simulator() sim.add_polygon( simulation.Polygon(geo.Point(-3, 2), 30 * 3.14 / 180, [ geo.Point(1, 1), geo.Point(-1, 1), geo.Point(-1, -1), geo.Point(1, -1) ], 1, 2.0 / 3.0, geo.Vector(4, 0), geo.Vector(0, 0, 2 * 3.14))) sim.add_polygon( simulation.Polygon(geo.Point(5, 0), 90 * 3.14 / 180, [ geo.Point(3, 1), geo.Point(-3, 1), geo.Point(-3, -1), geo.Point(3, -1) ], 3, 10, geo.Vector(0, 0), geo.Vector(0, 0, 3.14))) return sim
def main(_): config = cf.CustomConfig() sim = simulation.Simulator() sim.fillStupid() raw_data = sim.getAllData() metagraphs = [] current_time = 6 with tf.Graph().as_default(): initializer = tf.random_uniform_initializer(-config.init_scale, config.init_scale) with tf.name_scope("Input"): train_input = mod.PflanzInput(config=config, data=raw_data, name="input") train_input.make_batches() train_input.input_is_one_batch(0) with tf.variable_scope("Model", reuse=None, initializer=initializer): m = mod.PflanzModel(current_time, is_training=True, config=config, input_=train_input) with tf.Session() as session: session.run(tf.global_variables_initializer()) state = session.run(m.initial_state) session.run([m.final_state]) m.save(session, config, 6) actions = get_params(current_time, config, sim) for i in actions: for j in i: for k in j: print(k) print("oneplant") print("onebatch")
def get_objective_set(fitter, setup, state_init, high_prop, nruns): """Get objective values from a number of simulation runs using given control proportion.""" params = { "birth_rate": setup['birth_rate'], "death_rate": setup['death_rate'], "removal_rate": setup['removal_rate'], "recov_rate": setup['recov_rate'], "end_time": setup['end_time'], "update_control_on_all_events": True, "control_update_freq": np.inf, "return_event_data": False, } model_params = { 'birth_rate': setup['birth_rate'], 'death_rate': setup['death_rate'], 'removal_rate': setup['removal_rate'], 'recov_rate': setup['recov_rate'], 'state_init': state_init, 'times': np.linspace(0, setup['end_time'], 101), 'max_control_rate': setup['max_control_rate'], 'high_alloc_cost': 0.0, 'low_alloc_cost': 0.0 } model = risk_model.RiskModel(model_params, fitter.get_fit()) def controller(time): return [high_prop, 1.0 - high_prop] params["controller_args"] = {"oc_model": model, "policy": controller} simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.RiskPolicyController) run_data = simulator.run_simulation(nruns=nruns, verbose=False) print("Done high proportion {}".format(high_prop)) return [np.sum(x.objective) for x in run_data]
def get_data(self, ninits=20, nrepeats=10, initial_nodes=None): """Run simulations and extract data for fitting. Arguments: ninits Number of distinct initialisations (potentially changing initial conds. nrepeats Number of simulation realisations for each initialisation. initial_nodes Starting conditions for simulation realisations. If None then conditions are randomised, otherwise must be a list of simulation.Node objects. """ print("Generating training set...") self.data['dpc_times'] = np.linspace(0, self.sim_params['end_time'], 51) self.data['dpc_sus'] = np.empty((3, 2, len(self.data['dpc_times']), 0)) self.data['dpc_inf'] = np.empty((3, 2, len(self.data['dpc_times']), 0)) self.data['init_state'] = np.empty((0, 18)) input_events = [] for _ in range(ninits): if initial_nodes is None: nlow = np.random.randint(0, 3) nhigh = 2 - nlow nodes_init = randomise_infection(self.nodes, nhigh=nhigh, nlow=nlow) else: nodes_init = copy.deepcopy(initial_nodes) simulator = simulation.Simulator( nodes_init, self.risk_coupling, self.dist_coupling, self.sim_params) all_runs = simulator.run_simulation(nruns=nrepeats, verbose=False) if nrepeats == 1: all_runs = [all_runs] self._store_dpc_data(all_runs) input_events += self._extract_event_data(all_runs) self.data['input_events'] = input_events
def main(): parser = argparse.ArgumentParser( description='Run simulation on JSON file.') parser.add_argument('--json', '-j', action='store', dest='json_file_name', help='Use network stored in json file', required=True) #option for tcp reno or tcp fast tcp_type = parser.add_mutually_exclusive_group(required=True) tcp_type.add_argument('--Reno', dest='tcp_type', action='store_const', const='Reno', help='Use the TCP-Reno congestion control algorithm') tcp_type.add_argument("--FAST", dest='tcp_type', action='store_const', const='FAST', help='Use the TCP-FAST congestion control algorithm') # options for graphing metrics metrics = parser.add_argument_group() metrics.add_argument('-m', dest='metrics', action='store_true', help='Print graphs for metrics.\ Requires the following subarguments:') metricType = metrics.add_mutually_exclusive_group() metricType.add_argument('--more', dest='log', action='store_const', const='more', help='Prints a timetrace from collecting\ all data.\ Requires the -m argument.') metricType.add_argument('--less', dest='log', action='store_const', const='less', help='Prints a timetrace from collecting\ a single datum per discrete time interval. \ Subargument for the -m argument.') metricType.add_argument('--avg', dest='log', action='store_const', const='avg', help='Prints an approximate (average) timetrace\ by collecting data over a discrete time interval. \ Subargument for the -m argument.') metrics.add_argument('-l', '--links', nargs='+', type=str, action='store', dest='links', metavar='LinkID', help='Specify which\ links are to be logged. LinkID must given in the form\ \'L1\', \'L2\', etc. Subargument for the -m argument.') metrics.add_argument('-f', '--flows', nargs='+', type=str, action='store', dest='flows', metavar='FlowID', help='Specify which\ flows are to be logged. FlowID must given in the form\ \'F1\', \'F2\', etc. Subargument for the -m argument.') parser.add_argument('-v', action='store_true', dest='verbose', help='verbose: prints out information about events,\ event time, and number of elements in priority queue') args = parser.parse_args() # All subargs must be present if --m is invoked if not args.metrics and (args.log is not None or args.links is not None or args.flows is not None): parser.print_usage() print "Error: -m argument is required." return # All subargs must be present if --m is invoked elif args.metrics and (args.log is None or args.links is None or args.flows is None): parser.print_usage() print "Error: All of --m's subargments required." return f = open(args.json_file_name) parsed_data = json.loads(f.read()) if args.verbose: print "JSON DATA:" pprint.pprint(parsed_data) devices = {} links = {} flows = {} print "\n\n" # Parse json data into data structures print "Iterating over hosts:" for host_name in parsed_data['hosts']: print "Host ", host_name, "has data: ", parsed_data['hosts'][host_name] host = classes.Host(str(host_name)) devices[str(host_name)] = host print "Iterating over routers:" for router_name in parsed_data['routers']: print "Router ", router_name, "has data: ", parsed_data['routers'][ router_name] router = classes.Router(str(router_name)) devices[str(router_name)] = router print "Hosts and routers instantiated. ", "\n\n" print "Iterating over links and adding to hosts/routers:" for link_name in parsed_data['links']: link_data = parsed_data['links'][link_name] print "Link ", link_name, "has data: ", link_data link = classes.Link(str(link_name), link_data['link_rate'], link_data['link_delay'], link_data['link_buffer'], devices[link_data['devices'][0]], devices[link_data['devices'][1]]) links[str(link_name)] = link print "Links instantiated.", "\n\n" print "Iterating over flows:" for flow_name in parsed_data['flows']: flow_data = parsed_data['flows'][flow_name] print "Flow ", flow_name, "has data: ", flow_data flow = classes.Flow(str(flow_name), devices[flow_data['flow_src']], devices[flow_data['flow_dest']], flow_data['data_amt'], flow_data['flow_start'], flow_data['theoRTT']) flows[str(flow_name)] = flow print "Flows instantiated.", "\n\n" # Verifying metric inputs from command line are correct if args.metrics: for flowID in args.flows: if flowID not in flows.keys(): print "Bad flowID in argument list." return for linkID in args.links: if linkID not in links.keys(): print "Bad linkID in argument list." return network = classes.Network(devices, links, flows) met = None if args.metrics: met = m.Metrics(args.log, args.flows, args.links) simulator = simulation.Simulator(network, args.tcp_type, met) # Generate initial routing table print "Running..." if args.verbose: print "Static routing:" simulator.staticRouting() while not simulator.q.empty(): result = simulator.processEvent() if args.verbose: print "processing one event\n" + str(result) if args.verbose: print "------------NETWORK------------" print "----------DEVICE DETAILS----------" for device_name in devices: print devices[device_name] print "----------LINK DETAILS----------" for link_name in links: print links[link_name] print "----------FLOW DETAILS----------" for flow_name in flows: print flows[flow_name] print "----------STARTING SIMULATION------------" # Flows begin: for flow_name in flows: flow = flows[flow_name] counter = 0 timer = flow.flow_start newGenEvent = simulation.Event(None, None, "INITIALIZEFLOW", timer, flow) simulator.insertEvent(newGenEvent) newDynamicRoutingEvent = simulation.Event(None, None, "REROUT", constants.REROUT_TIME, None) simulator.insertEvent(newDynamicRoutingEvent) while not simulator.q.empty(): result = simulator.processEvent() if args.verbose: print "QUEUE SIZE: " + str( simulator.q.qsize()) + "\n" + str(result) for flow_name in flows: flow = flows[flow_name] print "DATA ACKNOWLEDGED: " + str(flow.data_acknowledged) print "DATA MADE: " + str(flow.data_amt) print "Simulation for ", args.json_file_name[: -4], args.tcp_type, args.log, " done!" simulator.done()
def _get_sim_dpcs(self, model, opt_control, initial_nodes=None): """Run simulations with and without control for assessment DPCs.""" sim_params = copy.deepcopy(self.parent_fitter.sim_params) # Run no control sims print("Generating risk testing set...") stored_data = {} input_events = [] for _ in range(10): if initial_nodes is None: nodes_init = fitting.randomise_infection( self.parent_fitter.nodes, nhigh=self.data['init_conds'][1], nlow=self.data['init_conds'][4]) else: nodes_init = copy.deepcopy(initial_nodes) simulator = simulation.Simulator(nodes_init, self.parent_fitter.risk_coupling, self.parent_fitter.dist_coupling, sim_params, controller=None) all_runs = simulator.run_simulation(nruns=10, verbose=False) self.parent_fitter._store_dpc_data(all_runs, data_store=stored_data, include_vac=False) input_events += self.parent_fitter._extract_event_data(all_runs) # Convert to risk based format risk_events = [] for run in input_events: risk_run = np.zeros((len(run), 7)) for i in range(4): risk_run[:, i] = np.sum(run[:, i:12:4], axis=1) risk_run[:, 4:] = run[:, 12:15] risk_events.append(risk_run) for key, val in stored_data.items(): self.data[key] = val self.data["assessment_events"] = risk_events sim_params['update_control_on_all_events'] = True sim_params['vac_rate'] = 1.0 sim_params["controller_args"] = { "oc_model": model, "policy": opt_control } # Run controlled simulations print("Generating controlled risk testing set...") stored_data = {} input_events = [] for i in range(10): if initial_nodes is None: nodes_init = fitting.randomise_infection( self.parent_fitter.nodes, nhigh=self.data['init_conds'][1], nlow=self.data['init_conds'][4]) else: nodes_init = copy.deepcopy(initial_nodes) simulator = simulation.Simulator(nodes_init, self.parent_fitter.risk_coupling, self.parent_fitter.dist_coupling, sim_params, controller=control_tools.RiskPolicyController) all_runs = simulator.run_simulation(nruns=10, verbose=False) self.parent_fitter._store_dpc_data(all_runs, data_store=stored_data, include_vac=True) input_events += self.parent_fitter._extract_event_data(all_runs) # Convert to risk based format risk_events = [] for run in input_events: risk_run = np.zeros((len(run), 7)) for i in range(4): risk_run[:, i] = np.sum(run[:, i:12:4], axis=1) risk_run[:, 4:] = run[:, 12:15] risk_events.append(risk_run) for key, val in stored_data.items(): self.data["controlled_" + key] = val self.data["controlled_assessment_events"] = risk_events
def main(): simulator = simulation.Simulator() simulator.simulate() """
from Sensors import * import simulation # simulation object sim = simulation.Simulator() # get robots from sim robot1 = sim.robot1 robot2 = sim.robot2 # add sensors to robot 1 sensor1 = Debug_Sensor() # debug sensor is ground truth, can't be used in official run robot1.add_sensor(sensor1) # add sensors to robot 2 sensor2 = IMU_Sensor() sensor3 = Stereo_Camera() robot2.add_sensor(sensor2) robot2.add_sensor(sensor3) # start simulation (ensure to add sensors before calling this) sim.start_simulation() x1 = sensor1.x y1 = sensor1.y # round float to int for path planning grid_x1, grid_y1 = simulation.to_grid(x1, y1) # get obstacle map ob_map = sim.obstacle_map
def __init__(self, config, transform=None): self.transform = transform self.min_len_wav = (config["data_config"]["seg_len"] - 1) * config[ "data_config"]["frame_shift"] + config["data_config"]["frame_len"] self.sequence_mode = config["data_config"]["sequence_mode"] # IO layer: set up the data sources # load the three types of source data dir_noise_streams = None rir_streams = None source_streams = None if "dir_noise_paths" in config: dir_noise_streams = self.load_streams(config["dir_noise_paths"], config['data_path'], is_speech=False) if "rir_paths" in config: rir_streams = self.load_streams(config["rir_paths"], config['data_path'], is_speech=False, is_rir=True) source_streams = self.load_streams(config["source_paths"], config['data_path'], is_speech=True) self.source_stream_sizes = [ i.get_number_of_data() for i in source_streams ] if self.sequence_mode: self.source_stream_cum_sizes = [self.source_stream_sizes[0]] for i in range(1, len(self.source_stream_sizes)): self.source_stream_cum_sizes.append( self.source_stream_cum_sizes[-1] + self.source_stream_sizes[i]) # Simulation layer: set up the simulator # get the single channel single source simulation configuration use_reverb = config["data_config"]["use_reverb"] use_noise = config["data_config"]["use_dir_noise"] snr_range = [ config["data_config"]["snr_min"], config["data_config"]["snr_max"] ] t60_range = [ config["data_config"]["t60_min"], config["data_config"]["t60_max"] ] cfg_simu = simu.config.single_channel_single_source_config( use_reverb=use_reverb, use_noise=use_noise, snr_range=snr_range, t60_range=t60_range) #print("data simulation config{}".format(json.dumps(cfg_simu, sort_keys=True, indent=4))) # single source simulation shares the input streams with multi-source simulation, but uses different configurations simulator_ss = simu.Simulator(cfg_simu, source_streams, noise_streams=dir_noise_streams, rir_streams=rir_streams, iso_noise_streams=None) generator_config = DataGeneratorSequenceConfig( n_hour_per_epoch=config["sweep_size"], sequence_mode=self.sequence_mode, load_label=config["data_config"]["load_label"], seglen=config["data_config"]["seg_len"], segshift=config["data_config"]["seg_shift"], ) data_generator = DataGeneratorTrain(simulator_ss, generator_config, DEBUG=False) if self.sequence_mode: self.data_buffer = data_generator else: self.data_buffer = feature.data_generation.DataBuffer( data_generator, buffer_size=200, preload_size=200, randomize=True) # self.data_buffer = feature.data_generation.DataBuffer(data_generator) self.use_cmn = config["data_config"]["use_cmn"] self.sample_len_seconds = config["data_config"][ "seg_len"] * 0.01 # default sampling rate: 100Hz self.stream_idx_for_transform = [0]
allocators = {'best_fit': best_fit, 'first_fit': first_fit} if not os.path.exists('output'): os.mkdir('output') for name, allocator in allocators.items(): print(f'Allocator: {name}') for t in thresholds: print(f'Threshold: {t}') file = f"output\\{name}-{str(t).replace('.', '')}.txt" recorder = recording.Recorder(memory, file=file) defragmentor = storage.ThresholdDefragmentor(memory, threshold=t) simulator = simulation.Simulator( stream=stream, allocator=allocator, defragmentor=defragmentor, recorder=recorder, std_out=std_out) simulator.run(num_steps) memory.reset() groups = get_allocator_files() for group in groups: fig, ax = plt.subplots() summaries = ((a, s) for a, s in group if 'summary' in f) allocator_name = None str_thresh = None for allocator, summary in summaries: allocator_name = allocator
def _get_sim_dpcs(self, model, opt_control, initial_nodes=None): """Run simulations with and without control for assessment DPCs.""" sim_params = copy.deepcopy(self.parent_fitter.sim_params) # Run no control sims print("Generating space testing set...") stored_data = {} input_events = [] for _ in range(10): if initial_nodes is None: region_init = { "A": (self.data['init_conds'][1], self.data['init_conds'][4]), "B": (self.data['init_conds'][7], self.data['init_conds'][10]), "C": (self.data['init_conds'][13], self.data['init_conds'][16]) } nodes_init = fitting.randomise_init_infs( self.parent_fitter.nodes, region_init) else: nodes_init = copy.deepcopy(initial_nodes) simulator = simulation.Simulator(nodes_init, self.parent_fitter.risk_coupling, self.parent_fitter.dist_coupling, sim_params, controller=None) all_runs = simulator.run_simulation(nruns=10, verbose=False) self.parent_fitter._store_dpc_data(all_runs, data_store=stored_data, include_vac=False) input_events += self.parent_fitter._extract_event_data(all_runs) for key, val in stored_data.items(): self.data[key] = val self.data["assessment_events"] = input_events sim_params['update_control_on_all_events'] = True sim_params['vac_rate'] = 1.0 sim_params["controller_args"] = { "oc_model": model, "policy": opt_control } # Run simulations with control stored_data = {} input_events = [] for _ in range(10): if initial_nodes is None: region_init = { "A": (self.data['init_conds'][1], self.data['init_conds'][4]), "B": (self.data['init_conds'][7], self.data['init_conds'][10]), "C": (self.data['init_conds'][13], self.data['init_conds'][16]) } nodes_init = fitting.randomise_init_infs( self.parent_fitter.nodes, region_init) else: nodes_init = copy.deepcopy(initial_nodes) simulator = simulation.Simulator( nodes_init, self.parent_fitter.risk_coupling, self.parent_fitter.dist_coupling, sim_params, controller=control_tools.SpacePolicyController) all_runs = simulator.run_simulation(nruns=10, verbose=False) self.parent_fitter._store_dpc_data(all_runs, data_store=stored_data, include_vac=True) input_events += self.parent_fitter._extract_event_data(all_runs) for key, val in stored_data.items(): self.data["controlled_" + key] = val self.data["controlled_assessment_events"] = input_events
def make_data(nruns=10, reuse_fitter=False, skip_risk_mpc=False, skip_space_mpc=False, check_data=None): """Generate all data for figures. Arguments: nruns Number of simulation runs for each control strategy reuse_fitter Whether to reuse previous fits. If so take from Data/Fit/FitData.pickle skip_risk_mpc If True do not run risk based MPC simulations skip_space_mpc If True do not run space based MPC simulations check_data If not None this is filepath for existing data that this new data will be appended to. Setup in each will be checked to ensure parameters have not been changed. """ plt.style.use("seaborn-whitegrid") if check_data is not None: with open(check_data, "rb") as infile: setup_check = pickle.load(infile)['setup'] all_data = {} # Setup initial network structure and state from node file node_file = "node_file.txt" nodes = simulation.initialise_nodes(node_file) nodes = fitting.randomise_infection(nodes, nlow=3, nhigh=0, node_choice=0) # Setup spatial and risk coupling beta = 2.5 scale = 0.2 risk_coupling = np.array([[1, 0.008], [0.008, 0.016]]) dist_coupling = np.zeros((len(nodes), len(nodes))) np.fill_diagonal(dist_coupling, 1.0) for i, node1 in enumerate(nodes): for j, node2 in enumerate(nodes): if node1.region == node2.region: # within region connections dist = np.linalg.norm(node1.position - node2.position) dist_coupling[i, j] = np.exp(-dist / scale) for k, l in [(17, 20), (18, 21), (19, 22), (32, 52), (33, 53), (34, 54)]: # between region connections dist_coupling[l, k] = 0.1 dist_coupling[k, l] = 0.1 for i, node1 in enumerate(nodes): dist_coupling[:, i] *= beta # Setup required parameters for simulations and fitting setup = { 'nodes': nodes, 'dist_coupling': dist_coupling, 'risk_coupling': risk_coupling, 'birth_rate': 0.01, 'death_rate': 0.01, 'removal_rate': 0.5, 'recov_rate': 0.25, 'end_time': 5, 'max_control_rate': 200, 'mpc_update_freq': 0.5, 'bounds': { 'beta': np.array([[(0, 1), (0, 1)], [(0, 1), (0, 1)]]), 'coef': np.full((4, 2, 2), (0, 3), dtype=np.float), 'sigma': np.array([[(0, 1), (0, 1), (0, 1)], [(0, 1), (0, 1), (0, 1)], [(0, 1), (0, 1), (0, 1)]]), 'rho': np.array([[(0, 1), (0, 1)], [(0, 1), (0, 1)]]) }, 'start': { 'beta': np.array([[8.8e-3, 5.8e-5], [7.7e-4, 6.2e-4]]), 'coef': np.array([[1.9, 1.0], [1.5, 1.0], [2.4, 1.0], [1.9, 1.1]]), 'sigma': np.array([[5.4e-2, 4.9e-5, 0], [7.7e-5, 5.3e-2, 1.5e-4], [0, 1.5e-4, 5.5e-2]]), 'rho': np.array([[1, 0.03], [0.03, 0.05]]) }, } all_data['setup'] = setup params = { "birth_rate": setup['birth_rate'], "death_rate": setup['death_rate'], "removal_rate": setup['removal_rate'], "recov_rate": setup['recov_rate'], "end_time": setup['end_time'], "update_control_on_all_events": True, "control_update_freq": None, "return_event_data": True } os.makedirs(os.path.join("Data", "Fit"), exist_ok=True) # Test run and show sample no control simulations simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, None) no_control_run_data = simulator.run_simulation(nruns=5) visualisation.plot_dpc_data(nodes, no_control_run_data, {}, nruns=5) plt.show() # Run fitting of approximate models if reuse_fitter: fitter = fitting.Fitter.from_file( os.path.join("Data", "Fit", "FitData.pickle")) else: fitter = fitting.Fitter(nodes, risk_coupling, dist_coupling, params) fitter.get_data(initial_nodes=nodes) fitter.fit_risk(setup['bounds'], setup['start']) fitter.fit_space(setup['bounds'], setup['start']) fitter.save(filename=os.path.join("Data", "Fit", "FitData.pickle")) print(fitter) fitter.assess(save_folder=os.path.join("Data", "Fit"), initial_nodes=nodes, max_control_rate=setup['max_control_rate']) fitter.save(filename=os.path.join("Data", "Fit", "FitData.pickle")) params['return_event_data'] = False # No control simulation results print("No control simulation runs") simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, None) no_control_run_data = simulator.run_simulation(nruns=nruns) all_data['sim_no_control'] = no_control_run_data # Scenario testing runs model_params = { 'birth_rate': setup['birth_rate'], 'death_rate': setup['death_rate'], 'removal_rate': setup['removal_rate'], 'recov_rate': setup['recov_rate'], 'state_init': np.array(no_control_run_data[0][0]['Global'][0])[[1, 2, 3, 5, 6, 7]], 'times': np.linspace(0, setup['end_time'], 101), 'max_control_rate': setup['max_control_rate'], 'high_alloc_cost': 0.0, 'low_alloc_cost': 0.0 } space_model_params = copy.deepcopy(model_params) state = np.zeros(18) state[0:6] = np.array( no_control_run_data[0][0]["RegionA"][0])[[1, 2, 3, 5, 6, 7]] state[6:12] = np.array( no_control_run_data[0][0]["RegionB"][0])[[1, 2, 3, 5, 6, 7]] state[12:18] = np.array( no_control_run_data[0][0]["RegionC"][0])[[1, 2, 3, 5, 6, 7]] space_model_params['state_init'] = state if check_data is None: # Get optimal constant split strategy balancing high and low control print("Optimising constant risk split strategy") min_prop = risk_split_scan.make_data(fitter, setup, model_params['state_init'], num_props=101, nruns=1000) setup['risk_min_prop'] = min_prop else: setup['risk_min_prop'] = setup_check['risk_min_prop'] # Check setup is same as any previous data if check_data is not None: for key, val in setup.items(): if isinstance(val, dict): for key2 in val.keys(): if np.any(val[key2] != setup_check[key][key2]): raise ValueError( "Setup parameters do not match in {0}!".format( key)) else: if np.any(val != setup_check[key]): raise ValueError( "Setup parameters do not match in {0}!".format(key)) # Approximate models model = risk_model.RiskModel(model_params, fitter.get_fit()) model_space = space_model.SpaceModel(space_model_params, fitter.get_fit(space=True)) def high_prio_controller(time): return [1.0, 0.0] def split_prio_controller(time): return [setup['risk_min_prop'], 1.0 - setup['risk_min_prop']] params["controller_args"] = { "oc_model": model, "policy": high_prio_controller } # Prioritise high risk population print("High risk prioritisation simulation runs") simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.RiskPolicyController) high_run_data = simulator.run_simulation(nruns=nruns) all_data['sim_high'] = high_run_data # Constant optimal risk split population print("Constant risk split simulation runs") params["controller_args"]["policy"] = split_prio_controller simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.RiskPolicyController) split_run_data = simulator.run_simulation(nruns=nruns) all_data['sim_split'] = split_run_data # Risk based model - no control DPC no_control_risk_run = model.run_policy(risk_model.no_control_policy) all_data['risk_model_no_control'] = no_control_risk_run # Risk based model - optimal control print("Risk model open loop simulation runs") bocop_run = model.run_bocop(verbose=True, init_policy=risk_model.even_control_policy) if bocop_run.exit_code != "Optimal Solution Found.": raise RuntimeError("Convergence Failure!") params["controller_args"]["policy"] = bocop_run.control simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.RiskPolicyController) risk_opt_run_data = simulator.run_simulation(nruns=nruns) all_data['sim_risk_opt'] = risk_opt_run_data all_data['risk_model_opt'] = bocop_run # Space based model - no control DPC no_control_space_run = model_space.run_policy( space_model.no_control_policy) all_data['space_model_no_control'] = no_control_space_run # Space based model - optimal control print("Space model open loop simulation runs") params['vac_rate'] = 1.0 bocop_run = model_space.run_bocop(verbose=True, sol_file="InitSol0.sol") if bocop_run.exit_code != "Optimal Solution Found.": raise RuntimeError("Convergence Failure!") params["controller_args"]["policy"] = bocop_run.control params["controller_args"]["oc_model"] = model_space simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.SpacePolicyController) space_opt_run_data = simulator.run_simulation(nruns=nruns) all_data['sim_space_opt'] = space_opt_run_data all_data['space_model_opt'] = bocop_run if not skip_risk_mpc: # Risk based MPC runs print("Risk model MPC simulation runs") params['controller_args'] = { 'oc_model': model, 'mpc_params': { 'update_freq': setup['mpc_update_freq'], 'model_horizon': model_params['times'][-1], 'rolling_horizon': False, 'init_policy': all_data['risk_model_opt'].control, 'initial_control_func': None }, 'verbose': True } params['control_update_freq'] = setup['mpc_update_freq'] simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.MPCRiskController) mpc_run_data = simulator.run_simulation(nruns=nruns) all_data['sim_risk_mpc'] = mpc_run_data if not skip_space_mpc: # Setup cold start intialisation files update_times = np.arange(0, setup['end_time'], setup['mpc_update_freq']) sol_file_names = [ "InitSol" + str(i) + ".sol" for i in range(len(update_times)) ] if not reuse_fitter: for i, (sol_file, start_time) in enumerate( zip(sol_file_names[1:], update_times[1:])): model_space.params['state_init'] = all_data[ 'space_model_opt'].state(start_time)[:-1] # model_space.params['times'] = np.linspace(start_time, setup['end_time'], 101) model_space.params['times'] = np.arange( start_time, setup['end_time'], setup['end_time'] / 100) bocop_run = model_space.run_bocop( verbose=True, sol_file=sol_file, init_policy=space_model.even_control_policy) if bocop_run.exit_code != "Optimal Solution Found.": raise RuntimeError("Convergence Failure!") # Space based MPC runs print("Space model MPC simulation runs") params['controller_args'] = { 'oc_model': model_space, 'mpc_params': { 'update_freq': setup['mpc_update_freq'], 'model_horizon': space_model_params['times'][-1], 'rolling_horizon': False, 'cold_start_files': sol_file_names, 'init_policy': all_data['space_model_opt'].control, 'initial_control_func': None }, 'verbose': True } params['control_update_freq'] = setup['mpc_update_freq'] simulator = simulation.Simulator(setup['nodes'], setup['risk_coupling'], setup['dist_coupling'], params, control_tools.MPCSpaceController) mpc_run_data = simulator.run_simulation(nruns=nruns) all_data['sim_space_mpc'] = mpc_run_data params["controller_args"] = None return all_data
def __init__(self, config): self.transform = None self.sequence_mode = config["data_config"]["sequence_mode"] # load the three types of source data dir_noise_streams = None if "dir_noise_paths" in config: dir_noise_streams = self.load_streams(config["dir_noise_paths"], config['data_path'], is_speech=False) rir_streams = None if "rir_paths" in config: rir_streams = self.load_streams(config["rir_paths"], config['data_path'], is_speech=False, is_rir=True) source_streams = self.load_streams(config["source_paths"], config['data_path'], is_speech=True) self.source_stream_sizes = [ i.get_number_of_data() for i in source_streams ] if self.sequence_mode: self.source_stream_cum_sizes = [self.source_stream_sizes[0]] for i in range(1, len(self.source_stream_sizes)): self.source_stream_cum_sizes.append( self.source_stream_cum_sizes[-1] + self.source_stream_sizes[i]) # Simulation layer: set up the simulator # get the single channel single source simulation configuration use_reverb = config["data_config"]["use_reverb"] use_noise = config["data_config"]["use_dir_noise"] snr_range = [ config["data_config"]["snr_min"], config["data_config"]["snr_max"] ] cfg_simu = simu.config.single_channel_single_source_config( use_reverb=use_reverb, use_noise=use_noise, snr_range=snr_range) simulator = simu.Simulator(cfg_simu, source_streams, noise_streams=dir_noise_streams, rir_streams=rir_streams) generator_config = DataGeneratorSequenceConfig( n_hour_per_epoch=config["sweep_size"], sequence_mode=self.sequence_mode, load_label=config["data_config"]["load_label"], seglen=config["data_config"]["seg_len"], segshift=config["data_config"]["seg_shift"], use_cmn=config["data_config"]["use_cmn"]) data_generator = DataGeneratorTrain(simulator, generator_config, DEBUG=False) if self.sequence_mode: self.data_buffer = data_generator else: self.data_buffer = DataBuffer(data_generator, buffer_size=20000, preload_size=200, randomize=True) self.sample_len_seconds = config["data_config"][ "seg_len"] * 0.01 # default sampling rate: 100Hz self.stream_idx_for_transform = [0]
def get_lag_times(coupling, nruns=1000, keep_sims=False): """Setup stochastic and deterministic analogues and evaluate lag times to regions B and C. keep_sims: If True then all simulation data and deterministic run data is returned also. """ initial_state_a = [495, 5, 0, 0, 0, 0, 0, 0] initial_state_b = [500, 0, 0, 0, 0, 0, 0, 0] initial_state_c = [500, 0, 0, 0, 0, 0, 0, 0] ###################### ## STOCHASTIC MODEL ## ###################### nodes = [] nodes.append(simulation.Node((0, 0), "A", initial_state_a, 0)) nodes.append(simulation.Node((0, 0), "B", initial_state_b, 1)) nodes.append(simulation.Node((0, 0), "C", initial_state_c, 2)) beta = 0.03 risk_coupling = np.ones((2, 2)) dist_coupling = np.array([[beta, coupling, 0], [coupling, beta, coupling], [0, coupling, beta]]) # Setup required parameters params = { "birth_rate": 0.0, "death_rate": 0.0, "removal_rate": 1.0, "recov_rate": 0.0, "end_time": 50.0, "update_control_on_all_events": True, "control_update_freq": np.inf, "return_event_data": False } simulator = simulation.Simulator(nodes, risk_coupling, dist_coupling, params, None) stoch_run_data = simulator.run_simulation(nruns=nruns, verbose=False) stoch_time_max = np.zeros((nruns, 3)) for j, run in enumerate(stoch_run_data): stoch_time_max[j, 0] = run.run_data["RegionA"][np.argmax( np.array(run.run_data["RegionA"])[:, 2])][0] arg_b = np.argmax(np.array(run.run_data["RegionB"])[:, 2]) if run.run_data["RegionB"][arg_b][2] > 5: stoch_time_max[j, 1] = run.run_data["RegionB"][arg_b][0] else: stoch_time_max[j, 1] = np.nan arg_c = np.argmax(np.array(run.run_data["RegionC"])[:, 2]) if run.run_data["RegionC"][arg_c][2] > 5: stoch_time_max[j, 2] = run.run_data["RegionC"][arg_c][0] else: stoch_time_max[j, 2] = np.nan ######################### ## DETERMINISTIC MODEL ## ######################### model_params = { "birth_rate": 0.0, "death_rate": 0.0, "removal_rate": 1.0, "recov_rate": 0.0, "state_init": np.array([495, 5, 0, 0, 0, 0, 500, 0, 0, 0, 0, 0, 500, 0, 0, 0, 0, 0], dtype=float), 'times': np.linspace(0.0, params['end_time'], 2001), 'max_control_rate': 0.0, 'high_alloc_cost': 0.0, 'low_alloc_cost': 0.0 } space_fitter = fit_space_model.SpaceFitterLikelihood(None) space_fitter.data['sigma'] = dist_coupling space_fitter.data['rho'] = risk_coupling determ_model = space_model.SpaceModel(model_params, space_fitter) determ_run_data = determ_model.run_policy(space_model.no_control_policy) determ_time_max = np.array([ model_params['times'][np.argmax([ determ_run_data.state(t)[6 * x + 1] for t in model_params['times'] ])] for x in range(3) ]) lag_times = stoch_time_max - determ_time_max if keep_sims: return (lag_times, [run.run_data for run in stoch_run_data], determ_run_data) return (lag_times, )